feat: security overhaul (proxy ssrf fix, streaming sanitization, docker optimization)

2026-10-23 23:18:06 +02:00 · 2026-01-07 08:43:33 +01:00
1 parent 6d87ada2b8
commit 8df9a37baa
@@ -0,0 +1,249 @@
+---
+name: 'step-01-init'
+description: 'Initialize the GDD workflow by detecting continuation state and setting up the document'
+
+# Path Definitions
+workflow_path: '{project-root}/_bmad/bmgd/workflows/2-design/gdd'
+
+# File References
+thisStepFile: '{workflow_path}/steps/step-01-init.md'
+nextStepFile: '{workflow_path}/steps/step-02-context.md'
+continueStepFile: '{workflow_path}/steps/step-01b-continue.md'
+workflowFile: '{workflow_path}/workflow.md'
+outputFile: '{output_folder}/gdd.md'
+
+# Template References
+gddTemplate: '{workflow_path}/templates/gdd-template.md'
+
+# Data Files
+gameTypesCSV: '{workflow_path}/game-types.csv'
+---
+
+# Step 1: Workflow Initialization
+
+**Progress: Step 1 of 14** - Next: Game Context & Type
+
+## STEP GOAL:
+
+Initialize the GDD workflow by detecting continuation state, discovering input documents (game brief, research), and setting up the document structure for collaborative game design discovery.
+
+## 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
+- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}`
+
+### Role Reinforcement:
+
+- You are a veteran game designer facilitator collaborating with a creative peer
+- If you already have been given a name, communication_style and persona, continue to use those while playing this new role
+- We engage in collaborative dialogue, not command-response
+- You bring structured game design thinking and facilitation skills, while the user brings their game vision
+
+### Step-Specific Rules:
+
+- Focus only on initialization and setup - no content generation yet
+- FORBIDDEN to look ahead to future steps or assume knowledge from them
+- Approach: Systematic setup with clear reporting to user
+- Detect existing workflow state and handle continuation properly
+
+## EXECUTION PROTOCOLS:
+
+- Show your analysis of current state before taking any action
+- Initialize document structure and update frontmatter appropriately
+- Set up frontmatter `stepsCompleted: [1]` before loading next step
+- FORBIDDEN to load next step until user selects 'C' (Continue)
+
+## CONTEXT BOUNDARIES:
+
+- Available context: Variables from workflow.md are available in memory
+- Focus: Workflow initialization and document setup only
+- Limits: Don't assume knowledge from other steps or create content yet
+- Dependencies: Configuration loaded from workflow.md initialization
+
+## Sequence of Instructions (Do not deviate, skip, or optimize)
+
+### 1. Check for Existing Workflow State
+
+First, check if the output document already exists:
+
+**Workflow State Detection:**
+
+- Look for file at `{outputFile}`
+- If exists, read the complete file including frontmatter
+- If not exists, this is a fresh workflow
+
+### 2. Handle Continuation (If Document Exists)
+
+If the document exists and has frontmatter with `stepsCompleted`:
+
+**Continuation Protocol:**
+
+- **STOP immediately** and load `{continueStepFile}`
+- Do not proceed with any initialization tasks
+- Let step-01b handle all continuation logic
+- This is an auto-proceed situation - no user choice needed
+
+### 3. Fresh Workflow Setup (If No Document)
+
+If no document exists or no `stepsCompleted` in frontmatter:
+
+#### A. Input Document Discovery
+
+Discover and load context documents using smart discovery.
+
+**IMPORTANT: Track document counts as you discover files.**
+
+Initialize counters:
+
+```
+briefCount = 0
+researchCount = 0
+brainstormingCount = 0
+projectDocsCount = 0
+```
+
+**Game Brief (Priority: Analysis -> Main -> Sharded -> Whole):**
+
+1. Check analysis folder: `{output_folder}/analysis/*game-brief*.md`
+2. If no analysis files: Try main folder: `{output_folder}/*game-brief*.md`
+3. If no main files: Check for sharded brief folder: `{output_folder}/*game-brief*/**/*.md`
+4. If sharded folder exists: Load EVERY file in that folder completely
+5. Add discovered files to `inputDocuments` frontmatter
+6. **Update briefCount with number of files found**
+
+**Research Documents (Priority: Analysis -> Main -> Sharded -> Whole):**
+
+1. Check analysis folder: `{output_folder}/analysis/research/*research*.md`
+2. If no analysis files: Try main folder: `{output_folder}/*research*.md`
+3. If no main files: Check for sharded research folder: `{output_folder}/*research*/**/*.md`
+4. Load useful research files completely
+5. Add discovered files to `inputDocuments` frontmatter
+6. **Update researchCount with number of files found**
+
+**Brainstorming Documents (Priority: Analysis -> Main):**
+
+1. Check analysis folder: `{output_folder}/analysis/brainstorming/*brainstorm*.md`
+2. If no analysis files: Try main folder: `{output_folder}/*brainstorm*.md`
+3. Add discovered files to `inputDocuments` frontmatter
+4. **Update brainstormingCount with number of files found**
+
+**Project Documentation (Existing Projects - Brownfield):**
+
+1. Look for index file: `{output_folder}/index.md`
+2. CRITICAL: Load index.md to understand what project files are available
+3. Read available files from index to understand existing project context
+4. This provides essential context for extending existing game with new features
+5. Add discovered files to `inputDocuments` frontmatter
+6. **Update projectDocsCount with number of files found (including index.md)**
+
+**Loading Rules:**
+
+- Load ALL discovered files completely (no offset/limit)
+- For sharded folders, load ALL files to get complete picture
+- For existing projects, use index.md as guide to what's relevant
+- Track all successfully loaded files in frontmatter `inputDocuments` array
+
+#### B. Create Initial Document
+
+**Document Setup:**
+
+- Copy the template from `{gddTemplate}` to `{outputFile}`
+- Initialize frontmatter with proper structure including document counts:
+
+```yaml
+---
+stepsCompleted: []
+inputDocuments: []
+documentCounts:
+  briefs: { { briefCount } }
+  research: { { researchCount } }
+  brainstorming: { { brainstormingCount } }
+  projectDocs: { { projectDocsCount } }
+workflowType: 'gdd'
+lastStep: 0
+project_name: '{{project_name}}'
+user_name: '{{user_name}}'
+date: '{{date}}'
+game_type: ''
+game_name: ''
+---
+```
+
+#### C. Present Initialization Results
+
+**Setup Report to User:**
+
+"Welcome {{user_name}}! I've set up your GDD workspace for {{project_name}}.
+
+**Document Setup:**
+
+- Created: `{outputFile}` from template
+- Initialized frontmatter with workflow state
+
+**Input Documents Discovered:**
+
+- Game briefs: {{briefCount}} files {if briefCount > 0}loaded{else}(none found){/if}
+- Research: {{researchCount}} files {if researchCount > 0}loaded{else}(none found){/if}
+- Brainstorming: {{brainstormingCount}} files {if brainstormingCount > 0}loaded{else}(none found){/if}
+- Project docs: {{projectDocsCount}} files {if projectDocsCount > 0}loaded (brownfield project){else}(none found - greenfield project){/if}
+
+**Files loaded:** {list of specific file names or "No additional documents found"}
+
+{if projectDocsCount > 0}
+**Note:** This is a **brownfield project**. Your existing project documentation has been loaded. In the next step, I'll ask specifically about what new features or changes you want to add to your existing game.
+{/if}
+
+Do you have any other documents you'd like me to include, or shall we continue to the next step?"
+
+### 4. Present MENU OPTIONS
+
+Display menu after setup report:
+
+"[C] Continue - Save this and move to Game Context & Type (Step 2 of 14)"
+
+#### Menu Handling Logic:
+
+- IF C: Update frontmatter with `stepsCompleted: [1]`, then load, read entire file, then execute {nextStepFile}
+- IF user provides additional files: Load them, update inputDocuments and documentCounts, redisplay report
+- IF user asks questions: Answer and redisplay menu
+
+#### EXECUTION RULES:
+
+- ALWAYS halt and wait for user input after presenting menu
+- ONLY proceed to next step when user selects 'C'
+
+## CRITICAL STEP COMPLETION NOTE
+
+ONLY WHEN [C continue option] is selected and [frontmatter properly updated with stepsCompleted: [1] and documentCounts], will you then load and read fully `{nextStepFile}` to execute and begin game context discovery.
+
+---
+
+## SYSTEM SUCCESS/FAILURE METRICS
+
+### SUCCESS:
+
+- Existing workflow detected and properly handed off to step-01b
+- Fresh workflow initialized with template and proper frontmatter
+- Input documents discovered and loaded using sharded-first logic
+- All discovered files tracked in frontmatter `inputDocuments`
+- **Document counts stored in frontmatter `documentCounts`**
+- User clearly informed of brownfield vs greenfield status
+- Menu presented and user input handled correctly
+- Frontmatter updated with `stepsCompleted: [1]` before proceeding
+
+### SYSTEM FAILURE:
+
+- Proceeding with fresh initialization when existing workflow exists
+- Not updating frontmatter with discovered input documents
+- **Not storing document counts in frontmatter**
+- Creating document without proper template structure
+- Not checking sharded folders first before whole files
+- Not reporting discovered documents to user clearly
+- Proceeding without user selecting 'C' (Continue)
+
+**Master Rule:** Skipping steps, optimizing sequences, or not following exact instructions is FORBIDDEN and constitutes SYSTEM FAILURE.
@@ -0,0 +1,174 @@
+---
+name: 'step-01b-continue'
+description: 'Resume an interrupted GDD workflow from the last completed step'
+
+# Path Definitions
+workflow_path: '{project-root}/_bmad/bmgd/workflows/2-design/gdd'
+
+# File References
+thisStepFile: '{workflow_path}/steps/step-01b-continue.md'
+workflowFile: '{workflow_path}/workflow.md'
+outputFile: '{output_folder}/gdd.md'
+---
+
+# Step 1B: Workflow Continuation
+
+## STEP GOAL:
+
+Resume the GDD workflow from where it was left off, ensuring smooth continuation with full context restoration.
+
+## 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
+- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}`
+
+### Role Reinforcement:
+
+- You are a veteran game designer facilitator collaborating with a creative peer
+- We engage in collaborative dialogue, not command-response
+- Resume workflow from exact point where it was interrupted
+
+### Step-Specific Rules:
+
+- FOCUS on understanding where we left off and continuing appropriately
+- FORBIDDEN to modify content completed in previous steps
+- Only reload documents that were already tracked in `inputDocuments`
+
+## EXECUTION PROTOCOLS:
+
+- Show your analysis of current state before taking action
+- Keep existing frontmatter `stepsCompleted` values
+- Only load documents that were already tracked in `inputDocuments`
+- FORBIDDEN to discover new input documents during continuation
+
+## CONTEXT BOUNDARIES:
+
+- Available context: Current document and frontmatter are already loaded
+- Focus: Workflow state analysis and continuation logic only
+- Limits: Don't assume knowledge beyond what's in the document
+- Dependencies: Existing workflow state from previous session
+
+## Sequence of Instructions (Do not deviate, skip, or optimize)
+
+### 1. Analyze Current State
+
+**State Assessment:**
+Review the frontmatter to understand:
+
+- `stepsCompleted`: Which steps are already done
+- `lastStep`: The most recently completed step number
+- `inputDocuments`: What context was already loaded
+- `documentCounts`: briefs, research, brainstorming, projectDocs counts
+- `game_type`: The identified game type (if set)
+- `game_name`: The game name (if set)
+- All other frontmatter variables
+
+### 2. Restore Context Documents
+
+**Context Reloading:**
+
+- For each document in `inputDocuments`, load the complete file
+- This ensures you have full context for continuation
+- Don't discover new documents - only reload what was previously processed
+- If `game_type` is set, also reload the corresponding game type guide from `{workflow_path}/game-types/{game_type}.md`
+
+### 3. Present Current Progress
+
+**Progress Report to User:**
+"Welcome back {{user_name}}! I'm resuming our GDD collaboration for {{game_name or project_name}}.
+
+**Current Progress:**
+
+- Steps completed: {stepsCompleted}
+- Last worked on: Step {lastStep}
+- Game type: {game_type or 'Not yet determined'}
+- Context documents available: {len(inputDocuments)} files
+
+**Document Status:**
+
+- Current GDD document is ready with all completed sections
+- Ready to continue from where we left off
+
+Does this look right, or do you want to make any adjustments before we proceed?"
+
+### 4. Determine Continuation Path
+
+**Next Step Logic:**
+Based on `lastStep` value, determine which step to load next:
+
+- If `lastStep = 1` -> Load `./step-02-context.md`
+- If `lastStep = 2` -> Load `./step-03-platforms.md`
+- If `lastStep = 3` -> Load `./step-04-vision.md`
+- If `lastStep = 4` -> Load `./step-05-core-gameplay.md`
+- If `lastStep = 5` -> Load `./step-06-mechanics.md`
+- If `lastStep = 6` -> Load `./step-07-game-type.md`
+- If `lastStep = 7` -> Load `./step-08-progression.md`
+- If `lastStep = 8` -> Load `./step-09-levels.md`
+- If `lastStep = 9` -> Load `./step-10-art-audio.md`
+- If `lastStep = 10` -> Load `./step-11-technical.md`
+- If `lastStep = 11` -> Load `./step-12-epics.md`
+- If `lastStep = 12` -> Load `./step-13-metrics.md`
+- If `lastStep = 13` -> Load `./step-14-complete.md`
+- If `lastStep = 14` -> Workflow already complete
+
+### 5. Handle Workflow Completion
+
+**If workflow already complete (`lastStep = 14`):**
+"Great news! It looks like we've already completed the GDD workflow for {{game_name}}.
+
+The final document is ready at `{outputFile}` with all sections completed through step 14.
+
+Would you like me to:
+
+- Review the completed GDD with you
+- Suggest next workflow steps (like architecture or epic creation)
+- Start a new GDD revision
+
+What would be most helpful?"
+
+### 6. Present MENU OPTIONS
+
+**If workflow not complete:**
+Display: "Ready to continue with Step {nextStepNumber}?
+
+**Select an Option:** [C] Continue to next step"
+
+#### Menu Handling Logic:
+
+- IF C: Load, read entire file, then execute the appropriate next step file based on `lastStep`
+- IF Any other comments or queries: respond and redisplay menu
+
+#### EXECUTION RULES:
+
+- ALWAYS halt and wait for user input after presenting menu
+- ONLY proceed to next step when user selects 'C'
+
+## CRITICAL STEP COMPLETION NOTE
+
+ONLY WHEN [C continue option] is selected and [current state confirmed], will you then load and read fully the appropriate next step file to resume the workflow.
+
+---
+
+## SYSTEM SUCCESS/FAILURE METRICS
+
+### SUCCESS:
+
+- All previous input documents successfully reloaded
+- Game type guide reloaded if game_type was set
+- Current workflow state accurately analyzed and presented
+- User confirms understanding of progress before continuation
+- Correct next step identified and prepared for loading
+
+### SYSTEM FAILURE:
+
+- Discovering new input documents instead of reloading existing ones
+- Modifying content from already completed steps
+- Loading wrong next step based on `lastStep` value
+- Proceeding without user confirmation of current state
+
+**Master Rule:** Skipping steps, optimizing sequences, or not following exact instructions is FORBIDDEN and constitutes SYSTEM FAILURE.
@@ -0,0 +1,333 @@
+---
+name: 'step-02-context'
+description: 'Load game context from brief and determine the game type'
+
+# Path Definitions
+workflow_path: '{project-root}/_bmad/bmgd/workflows/2-design/gdd'
+
+# File References
+thisStepFile: '{workflow_path}/steps/step-02-context.md'
+nextStepFile: '{workflow_path}/steps/step-03-platforms.md'
+workflowFile: '{workflow_path}/workflow.md'
+outputFile: '{output_folder}/gdd.md'
+
+# Data Files
+gameTypesCSV: '{workflow_path}/game-types.csv'
+gameTypesFolder: '{workflow_path}/game-types'
+
+# Task References
+advancedElicitationTask: '{project-root}/_bmad/core/workflows/advanced-elicitation/workflow.xml'
+partyModeWorkflow: '{project-root}/_bmad/core/workflows/party-mode/workflow.md'
+---
+
+# Step 2: Game Context & Type
+
+**Progress: Step 2 of 14** - Next: Platforms & Audience
+
+## STEP GOAL:
+
+Load and analyze the game brief (if available), determine the game type from game-types.csv, load the corresponding game type guide, and capture the core game concept that will drive the entire GDD.
+
+## 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
+- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}`
+
+### Role Reinforcement:
+
+- You are a veteran game designer facilitator collaborating with a creative peer
+- We engage in collaborative dialogue, not command-response
+- You bring structured game design thinking and facilitation skills, while the user brings their game vision
+
+### Step-Specific Rules:
+
+- Focus on understanding the game concept and determining the correct game type
+- CRITICAL: Load game-types.csv to understand available game types
+- FORBIDDEN to generate detailed content without real user input
+- Approach: Leverage existing documents while validating with user
+
+## EXECUTION PROTOCOLS:
+
+- Show your analysis before taking any action
+- Present A/P/C menu after generating core concept content
+- ONLY save when user chooses C (Continue)
+- Update frontmatter `stepsCompleted: [1, 2]` before loading next step
+- FORBIDDEN to load next step until C is selected
+
+## COLLABORATION MENUS (A/P/C):
+
+This step will generate content and present choices:
+
+- **A (Advanced Elicitation)**: Use discovery protocols to develop deeper insights about the game concept
+- **P (Party Mode)**: Bring multiple perspectives to discuss and improve the game concept
+- **C (Continue)**: Save the content to the document and proceed to next step
+
+## PROTOCOL INTEGRATION:
+
+- When 'A' selected: Execute {advancedElicitationTask}
+- When 'P' selected: Execute {partyModeWorkflow}
+- PROTOCOLS always return to this step's A/P/C menu
+- User accepts/rejects protocol changes before proceeding
+
+## CONTEXT BOUNDARIES:
+
+- Current document and frontmatter from step 1 are available
+- Input documents already loaded are in memory (game briefs, research, brainstorming)
+- **Document counts available in frontmatter `documentCounts`**
+- Game types CSV data will be loaded in this step
+- This will be the first content section appended to the document
+
+## Sequence of Instructions (Do not deviate, skip, or optimize)
+
+### 1. Read Document State from Frontmatter
+
+**CRITICAL FIRST ACTION:** Read the frontmatter from `{outputFile}` to get document counts.
+
+```
+Read documentCounts from gdd.md frontmatter:
+- briefCount = documentCounts.briefs
+- researchCount = documentCounts.research
+- brainstormingCount = documentCounts.brainstorming
+- projectDocsCount = documentCounts.projectDocs
+```
+
+**ANNOUNCE your understanding:**
+
+"From step 1, I have loaded:
+
+- Game briefs: {{briefCount}} files
+- Research: {{researchCount}} files
+- Brainstorming: {{brainstormingCount}} files
+- Project docs: {{projectDocsCount}} files
+
+{if projectDocsCount > 0}This is a **brownfield project** - I'll focus on understanding what you want to add or change.{else}This is a **greenfield project** - I'll help you define the full game vision.{/if}"
+
+### 2. Load Game Types Data
+
+Load and prepare CSV data for intelligent game type classification:
+
+- Load `{gameTypesCSV}` completely
+- Parse columns: id, name, description, key_mechanics, detection_signals
+- Store in memory for classification matching
+
+### 3. Begin Discovery Conversation
+
+**SELECT EXACTLY ONE DISCOVERY PATH based on document state:**
+
+---
+
+#### PATH A: Has Game Brief (briefCount > 0)
+
+**Use this path when:** `briefCount > 0`
+
+"As your game design peer, I've reviewed your game brief and have a great starting point. Let me share what I understand and you can refine or correct as needed.
+
+**Based on your game brief:**
+
+**Game Name:**
+{{extracted_name_from_brief}}
+
+**Core Concept:**
+{{extracted_concept_from_brief}}
+
+**Genre/Type:**
+{{extracted_genre_from_brief}}
+
+**Target Experience:**
+{{extracted_experience_from_brief}}
+
+{if projectDocsCount > 0}I also see you have existing project documentation. This GDD will define how new features integrate with your existing game.{/if}
+
+**How does this align with your vision?** Should we refine any of these points or are there important aspects I'm missing?"
+
+**AFTER this message, SKIP to Section 4.**
+
+---
+
+#### PATH B: No Brief but Has Brainstorming (briefCount == 0 AND brainstormingCount > 0)
+
+**Use this path when:** `briefCount == 0 AND brainstormingCount > 0`
+
+"As your game design peer, I've reviewed your brainstorming documents.
+
+**Ideas I've extracted:**
+{{summarize key concepts from brainstorming}}
+
+Let's crystallize these ideas into a clear game concept:
+
+- What's the core gameplay experience you want to create?
+- What genre or type of game is this?
+- What's the one thing that makes this game special?
+
+I'll use this to identify the right game type framework for our GDD."
+
+**AFTER this message, SKIP to Section 4.**
+
+---
+
+#### PATH C: No Documents - Greenfield (briefCount == 0 AND brainstormingCount == 0)
+
+**Use this path when:** `briefCount == 0 AND brainstormingCount == 0`
+
+"Let's start by understanding your game vision!
+
+**Tell me about what you want to create:**
+
+- What kind of game is it? (genre, style, references)
+- What does the player do? (core actions, moment-to-moment gameplay)
+- What makes it special or different?
+- What experience or feeling do you want players to have?
+
+I'll be listening for signals to help us identify the right game type framework."
+
+**AFTER this message, SKIP to Section 4.**
+
+---
+
+### 4. Determine Game Type
+
+As the user describes their game, match against `detection_signals` from `game-types.csv`:
+
+#### Game Type Detection Logic
+
+Compare user description against game-types.csv entries:
+
+- Look for keyword matches from semicolon-separated detection_signals
+- Examples: "platform;jump;run;2D;side-scroll" -> action-platformer
+- Examples: "RPG;level;quest;stats;inventory" -> rpg
+- Examples: "story;choices;narrative;dialogue" -> visual-novel
+
+Store the best matching `game_type` id.
+
+### 5. Present Classification for Validation
+
+**Present to user:**
+
+"Based on our conversation, I'm classifying this as:
+
+**Game Type:** {matched_game_type_name} ({matched_game_type_id})
+
+**Why this type:**
+{explain the detection signals that matched}
+
+**This game type includes these focus areas:**
+{key_mechanics from game-types.csv}
+
+Does this sound right? If not, tell me what type better fits your vision and I'll adjust."
+
+### 6. Load Game Type Guide
+
+**After user confirms game type:**
+
+- Load the corresponding game type guide: `{gameTypesFolder}/{game_type}.md`
+- Store the guide content for use in step-07 (game-type specific sections)
+- Update frontmatter: `game_type: '{game_type}'`
+
+### 7. Capture Game Name
+
+"What would you like to call this game? (Working title is fine)"
+
+- Store in frontmatter: `game_name: '{user_provided_name}'`
+
+### 8. Generate Core Concept Content
+
+Based on the conversation, prepare the content to append to the document:
+
+#### Content Structure:
+
+```markdown
+## Executive Summary
+
+### Game Name
+
+{{game_name}}
+
+### Core Concept
+
+{{description - 2-3 paragraphs describing the game concept}}
+
+### Game Type
+
+**Type:** {{game_type_name}}
+**Framework:** This GDD uses the {{game_type}} template with type-specific sections for {{key_mechanics}}
+```
+
+### 9. Present Content and Menu
+
+Show the generated content to the user and present:
+
+"I've drafted the Executive Summary based on our conversation. This will be the opening section of your GDD.
+
+**Here's what I'll add to the document:**
+
+[Show the complete markdown content from step 8]
+
+**Select an Option:**
+[A] Advanced Elicitation - Let's dive deeper and refine this content
+[P] Party Mode - Bring in different perspectives to improve this
+[C] Continue - Save this and move to Platforms & Audience (Step 3 of 14)"
+
+### 10. Handle Menu Selection
+
+#### IF A (Advanced Elicitation):
+
+- Execute {advancedElicitationTask} with the current content
+- Process the enhanced content that comes back
+- Ask user: "Accept these changes to the Core Concept? (y/n)"
+- If yes: Update the content with improvements, then return to A/P/C menu
+- If no: Keep original content, then return to A/P/C menu
+
+#### IF P (Party Mode):
+
+- Execute {partyModeWorkflow} with the current content
+- Process the collaborative improvements that come back
+- Ask user: "Accept these changes to the Core Concept? (y/n)"
+- If yes: Update the content with improvements, then return to A/P/C menu
+- If no: Keep original content, then return to A/P/C menu
+
+#### IF C (Continue):
+
+- Append the final content to `{outputFile}`
+- Update frontmatter: `stepsCompleted: [1, 2]`, `game_type: '{game_type}'`, `game_name: '{game_name}'`
+- Load `{nextStepFile}`
+
+## CRITICAL STEP COMPLETION NOTE
+
+ONLY WHEN [C continue option] is selected and [core concept content finalized and saved to document with frontmatter updated including game_type and game_name], will you then load and read fully `{nextStepFile}` to execute and begin platforms definition.
+
+---
+
+## SYSTEM SUCCESS/FAILURE METRICS
+
+### SUCCESS:
+
+- Document counts read from frontmatter and announced
+- Game types CSV loaded and used effectively
+- **Correct discovery path selected based on document counts**
+- Input documents analyzed and leveraged for head start
+- Game type identified and validated with user
+- Game type guide loaded and stored for later use
+- Game name captured and stored in frontmatter
+- Core concept content generated collaboratively
+- A/P/C menu presented and handled correctly
+- Content properly appended to document when C selected
+- Frontmatter updated with stepsCompleted: [1, 2], game_type, game_name
+
+### SYSTEM FAILURE:
+
+- **Not reading documentCounts from frontmatter first**
+- **Executing multiple discovery paths instead of exactly one**
+- Not loading game-types.csv for classification
+- Not validating game type with user before proceeding
+- Generating detailed content without real user input
+- Not loading the game type guide file
+- Not capturing game name
+- Not presenting A/P/C menu after content generation
+- Appending content without user selecting 'C'
+
+**Master Rule:** Skipping steps, optimizing sequences, or not following exact instructions is FORBIDDEN and constitutes SYSTEM FAILURE.
@@ -0,0 +1,246 @@
+---
+name: 'step-03-platforms'
+description: 'Define target platforms and target audience for the game'
+
+# Path Definitions
+workflow_path: '{project-root}/_bmad/bmgd/workflows/2-design/gdd'
+
+# File References
+thisStepFile: '{workflow_path}/steps/step-03-platforms.md'
+nextStepFile: '{workflow_path}/steps/step-04-vision.md'
+workflowFile: '{workflow_path}/workflow.md'
+outputFile: '{output_folder}/gdd.md'
+
+# Task References
+advancedElicitationTask: '{project-root}/_bmad/core/workflows/advanced-elicitation/workflow.xml'
+partyModeWorkflow: '{project-root}/_bmad/core/workflows/party-mode/workflow.md'
+---
+
+# Step 3: Platforms & Audience
+
+**Progress: Step 3 of 14** - Next: Goals & Vision
+
+## STEP GOAL:
+
+Define the target platform(s) for the game and establish a clear picture of the target audience, including demographics, gaming experience level, and preferred play patterns.
+
+## 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
+- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}`
+
+### Role Reinforcement:
+
+- You are a veteran game designer facilitator collaborating with a creative peer
+- We engage in collaborative dialogue, not command-response
+- Platform and audience decisions drive many downstream choices - take this seriously
+
+### Step-Specific Rules:
+
+- Focus on platform capabilities and audience characteristics
+- FORBIDDEN to generate detailed content without real user input
+- Consider platform-specific constraints (controls, performance, monetization)
+- Approach: Guide user through considerations they may not have thought about
+
+## EXECUTION PROTOCOLS:
+
+- Show your analysis before taking any action
+- Present A/P/C menu after generating content for each section
+- ONLY save when user chooses C (Continue)
+- Update frontmatter `stepsCompleted: [1, 2, 3]` before loading next step
+- FORBIDDEN to load next step until C is selected
+
+## COLLABORATION MENUS (A/P/C):
+
+- **A (Advanced Elicitation)**: Explore platform constraints and audience nuances deeper
+- **P (Party Mode)**: Get multiple perspectives on platform/audience decisions
+- **C (Continue)**: Save the content to the document and proceed to next step
+
+## CONTEXT BOUNDARIES:
+
+- Game type and core concept from step 2 are available
+- Platform choice affects many downstream decisions
+- Audience definition affects tone, complexity, and accessibility
+
+## Sequence of Instructions (Do not deviate, skip, or optimize)
+
+### 1. Platform Discovery
+
+**Guide user through platform selection:**
+
+"Now let's talk about where players will experience {{game_name}}.
+
+**Platform Options to Consider:**
+
+| Platform                     | Considerations                                                           |
+| ---------------------------- | ------------------------------------------------------------------------ |
+| **PC (Steam/Epic)**          | Full keyboard/mouse, highest specs, Steam achievements, workshop support |
+| **Web Browser**              | Instant access, limited performance, broad reach, touch/mouse hybrid     |
+| **Mobile (iOS/Android)**     | Touch controls, short sessions, IAP monetization, battery/thermal limits |
+| **Console (Switch/PS/Xbox)** | Controller-first, certification requirements, couch multiplayer          |
+| **VR (Quest/PCVR)**          | Motion controls, comfort considerations, presence                        |
+
+**For {{game_type}} games, common platform choices include:** {platform_suggestions_from_game_type}
+
+**Questions to consider:**
+
+1. Where do your target players primarily game?
+2. Does your core gameplay work well with {platform} input methods?
+3. Are you targeting a primary platform with potential ports later?
+
+What platform(s) are you targeting?"
+
+### 2. Capture Platform Details
+
+**After user responds:**
+
+Document:
+
+- Primary platform (if multiple)
+- Platform-specific control schemes
+- Performance considerations (60fps target, resolution, etc.)
+- Platform-specific features to leverage (achievements, cloud saves, etc.)
+
+### 3. Audience Discovery
+
+**Guide user through audience definition:**
+
+"Now let's define who {{game_name}} is for.
+
+**Demographics to Consider:**
+
+- **Age Range:** What ages are you designing for? (affects content, complexity, monetization)
+- **Gaming Experience:** Casual, core, or hardcore gamers?
+- **Genre Familiarity:** Do they know {{game_type}} conventions, or are they new to the genre?
+- **Session Length:** Quick mobile sessions (5-15 min) or deep PC sessions (1+ hour)?
+
+**For {{game_type}} games, typical audiences include:**
+{audience_suggestions_from_game_type}
+
+Tell me about your ideal player. Who is this game for?"
+
+### 4. Capture Audience Details
+
+**After user responds:**
+
+Document:
+
+- Primary demographic
+- Gaming experience level
+- Genre familiarity expectations
+- Preferred session lengths
+- Secondary audiences (if any)
+
+### 5. Generate Platforms & Audience Content
+
+Based on the conversation, prepare the content:
+
+```markdown
+## Target Platform(s)
+
+### Primary Platform
+
+{{primary_platform}}
+
+### Platform Considerations
+
+{{platform_specific_details}}
+
+### Control Scheme
+
+{{control_scheme_for_platform}}
+
+---
+
+## Target Audience
+
+### Demographics
+
+{{target_demographics}}
+
+### Gaming Experience
+
+{{experience_level}} - {{experience_description}}
+
+### Genre Familiarity
+
+{{genre_familiarity_description}}
+
+### Session Length
+
+{{typical_session_length}} - {{session_description}}
+
+### Player Motivations
+
+{{what_draws_this_audience_to_this_game}}
+```
+
+### 6. Present Content and Menu
+
+Show the generated content to the user and present:
+
+"I've drafted the Platforms & Audience sections based on our conversation.
+
+**Here's what I'll add to the document:**
+
+[Show the complete markdown content from step 5]
+
+**Select an Option:**
+[A] Advanced Elicitation - Explore platform/audience deeper
+[P] Party Mode - Get other perspectives on these decisions
+[C] Continue - Save this and move to Goals & Vision (Step 4 of 14)"
+
+### 7. 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, 3]`
+- Load `{nextStepFile}`
+
+## CRITICAL STEP COMPLETION NOTE
+
+ONLY WHEN [C continue option] is selected and [platforms and audience content saved with frontmatter updated], will you then load and read fully `{nextStepFile}`.
+
+---
+
+## SYSTEM SUCCESS/FAILURE METRICS
+
+### SUCCESS:
+
+- Platform(s) clearly identified with rationale
+- Platform-specific considerations documented
+- Target audience demographics defined
+- Gaming experience level captured
+- Session length expectations established
+- A/P/C menu presented and handled correctly
+- Frontmatter updated with stepsCompleted: [1, 2, 3]
+
+### SYSTEM FAILURE:
+
+- Assuming platform without user confirmation
+- Generating audience profile without user input
+- Not considering platform-specific constraints
+- Not presenting A/P/C menu after content generation
+- Proceeding without user selecting 'C'
+
+**Master Rule:** Skipping steps, optimizing sequences, or not following exact instructions is FORBIDDEN and constitutes SYSTEM FAILURE.
@@ -0,0 +1,230 @@
+---
+name: 'step-04-vision'
+description: 'Define project goals, context, and unique selling points'
+
+# Path Definitions
+workflow_path: '{project-root}/_bmad/bmgd/workflows/2-design/gdd'
+
+# File References
+thisStepFile: '{workflow_path}/steps/step-04-vision.md'
+nextStepFile: '{workflow_path}/steps/step-05-core-gameplay.md'
+workflowFile: '{workflow_path}/workflow.md'
+outputFile: '{output_folder}/gdd.md'
+
+# Task References
+advancedElicitationTask: '{project-root}/_bmad/core/workflows/advanced-elicitation/workflow.xml'
+partyModeWorkflow: '{project-root}/_bmad/core/workflows/party-mode/workflow.md'
+---
+
+# Step 4: Goals & Vision
+
+**Progress: Step 4 of 14** - Next: Core Gameplay
+
+## STEP GOAL:
+
+Define the project goals, background context for why this game matters now, and the unique selling points that differentiate this game from others in the market.
+
+## 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
+- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}`
+
+### Role Reinforcement:
+
+- You are a veteran game designer facilitator collaborating with a creative peer
+- We engage in collaborative dialogue, not command-response
+- Vision and USPs are critical for maintaining focus throughout development
+
+### Step-Specific Rules:
+
+- Focus on the "why" behind this game project
+- FORBIDDEN to generate goals/USPs without real user input
+- Help user articulate what makes their game worth making
+- Approach: Challenge assumptions about differentiation
+
+## EXECUTION PROTOCOLS:
+
+- Show your analysis before taking any action
+- Present A/P/C menu after generating content
+- ONLY save when user chooses C (Continue)
+- Update frontmatter `stepsCompleted: [1, 2, 3, 4]` before loading next step
+- FORBIDDEN to load next step until C is selected
+
+## COLLABORATION MENUS (A/P/C):
+
+- **A (Advanced Elicitation)**: Dig deeper into goals and differentiation
+- **P (Party Mode)**: Challenge and strengthen the vision with multiple perspectives
+- **C (Continue)**: Save the content to the document and proceed to next step
+
+## CONTEXT BOUNDARIES:
+
+- Game type, platform, and audience from previous steps are available
+- Goals should be achievable and measurable where possible
+- USPs must be genuinely differentiating, not just features
+
+## Sequence of Instructions (Do not deviate, skip, or optimize)
+
+### 1. Goals Discovery
+
+**Guide user through goal definition:**
+
+"Let's define what success looks like for {{game_name}}.
+
+**Types of Goals to Consider:**
+
+| Goal Type         | Examples                                             |
+| ----------------- | ---------------------------------------------------- |
+| **Creative**      | "Create a game that makes players feel powerful"     |
+| **Technical**     | "Ship a stable 60fps experience on target platforms" |
+| **Business**      | "Achieve 10,000 wishlists before launch"             |
+| **Personal**      | "Learn Godot through this project"                   |
+| **Player Impact** | "Create a speedrunning community"                    |
+
+**Questions to consider:**
+
+1. What does success look like for this project?
+2. What would make you proud to have shipped this?
+3. Are there specific metrics you want to hit?
+
+What are your 2-4 main goals for {{game_name}}?"
+
+### 2. Context Discovery
+
+**Guide user through background context:**
+
+"Now let's capture why this game matters right now.
+
+**Context Questions:**
+
+- **Motivation:** What inspired you to make this game?
+- **Timing:** Why is now the right time for this game?
+- **Gap:** What's missing in the market that this fills?
+- **Personal:** What unique perspective or experience do you bring?
+
+Tell me the story behind {{game_name}}. Why are you making this?"
+
+### 3. USP Discovery
+
+**Guide user through unique selling points:**
+
+"Now for the critical question: What makes {{game_name}} different?
+
+**USP Framework:**
+
+A strong USP answers: "Why would someone play THIS game instead of the alternatives?"
+
+**Categories of Differentiation:**
+
+- **Mechanical Innovation:** New gameplay systems or combinations
+- **Narrative/World:** Unique setting, story, or characters
+- **Art/Audio:** Distinctive aesthetic or soundscape
+- **Audience Focus:** Serving an underserved player segment
+- **Technical:** Performance, accessibility, or platform features
+
+**For {{game_type}} games, common USPs include:**
+{typical_usps_for_game_type}
+
+But what's YOUR unique angle?
+
+**Challenge Questions:**
+
+1. If I removed your USP, would the game still be interesting?
+2. Can another developer easily copy this USP?
+3. Does this USP matter to your target audience?
+
+What 2-4 things make {{game_name}} genuinely different?"
+
+### 4. Generate Vision Content
+
+Based on the conversation, prepare the content:
+
+```markdown
+## Goals and Context
+
+### Project Goals
+
+{{goals_list_with_descriptions}}
+
+### Background and Rationale
+
+{{context_narrative}}
+
+---
+
+## Unique Selling Points (USPs)
+
+{{usps_with_descriptions}}
+
+### Competitive Positioning
+
+{{how_this_game_stands_out_in_the_market}}
+```
+
+### 5. Present Content and Menu
+
+Show the generated content to the user and present:
+
+"I've drafted the Goals & Vision sections based on our conversation.
+
+**Here's what I'll add to the document:**
+
+[Show the complete markdown content from step 4]
+
+**Select an Option:**
+[A] Advanced Elicitation - Challenge and strengthen these points
+[P] Party Mode - Get other perspectives on differentiation
+[C] Continue - Save this and move to Core Gameplay (Step 5 of 14)"
+
+### 6. 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, 3, 4]`
+- Load `{nextStepFile}`
+
+## CRITICAL STEP COMPLETION NOTE
+
+ONLY WHEN [C continue option] is selected and [vision content saved with frontmatter updated], will you then load and read fully `{nextStepFile}`.
+
+---
+
+## SYSTEM SUCCESS/FAILURE METRICS
+
+### SUCCESS:
+
+- 2-4 clear, achievable goals defined
+- Background context captures the "why"
+- USPs are genuinely differentiating, not just features
+- Competitive positioning is clear
+- A/P/C menu presented and handled correctly
+- Frontmatter updated with stepsCompleted: [1, 2, 3, 4]
+
+### SYSTEM FAILURE:
+
+- Generating generic goals without user input
+- USPs that are just feature lists, not differentiation
+- Not challenging weak USPs
+- Not presenting A/P/C menu after content generation
+- Proceeding without user selecting 'C'
+
+**Master Rule:** Skipping steps, optimizing sequences, or not following exact instructions is FORBIDDEN and constitutes SYSTEM FAILURE.
@@ -0,0 +1,259 @@
+---
+name: 'step-05-core-gameplay'
+description: 'Define game pillars, core gameplay loop, and win/loss conditions'
+
+# Path Definitions
+workflow_path: '{project-root}/_bmad/bmgd/workflows/2-design/gdd'
+
+# File References
+thisStepFile: '{workflow_path}/steps/step-05-core-gameplay.md'
+nextStepFile: '{workflow_path}/steps/step-06-mechanics.md'
+workflowFile: '{workflow_path}/workflow.md'
+outputFile: '{output_folder}/gdd.md'
+
+# Task References
+advancedElicitationTask: '{project-root}/_bmad/core/workflows/advanced-elicitation/workflow.xml'
+partyModeWorkflow: '{project-root}/_bmad/core/workflows/party-mode/workflow.md'
+---
+
+# Step 5: Core Gameplay
+
+**Progress: Step 5 of 14** - Next: Game Mechanics
+
+## STEP GOAL:
+
+Define the fundamental gameplay elements: game pillars (core design tenets), the core gameplay loop (what players repeatedly do), and win/loss conditions (how players succeed or fail).
+
+## 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
+- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}`
+
+### Role Reinforcement:
+
+- You are a veteran game designer facilitator collaborating with a creative peer
+- These are GAME-DEFINING decisions - treat them with appropriate weight
+- Every future decision should serve these pillars and loop
+
+### Step-Specific Rules:
+
+- Focus on the heart of the gameplay experience
+- FORBIDDEN to generate pillars/loops without real user input
+- Challenge: Do these pillars and loop serve the stated USPs?
+- Approach: Help user think through the player experience
+
+## EXECUTION PROTOCOLS:
+
+- Show your analysis before taking any action
+- Present A/P/C menu after generating content
+- ONLY save when user chooses C (Continue)
+- Update frontmatter `stepsCompleted: [1, 2, 3, 4, 5]` before loading next step
+- FORBIDDEN to load next step until C is selected
+
+## COLLABORATION MENUS (A/P/C):
+
+- **A (Advanced Elicitation)**: Deep dive into the player experience
+- **P (Party Mode)**: Test these fundamentals with multiple perspectives
+- **C (Continue)**: Save the content to the document and proceed to next step
+
+## CONTEXT BOUNDARIES:
+
+- All previous context (type, platform, audience, goals, USPs) available
+- Pillars are the "constitution" that guides all design decisions
+- Core loop is what players do 80% of the time
+- Win/loss conditions provide motivation and stakes
+
+## Sequence of Instructions (Do not deviate, skip, or optimize)
+
+### 1. Game Pillars Discovery
+
+**Guide user through pillar definition:**
+
+"Now we define the core pillars - the fundamental design principles that every feature must serve.
+
+**What are Game Pillars?**
+
+Pillars are 2-4 non-negotiable design tenets. Every mechanic, system, and feature should support at least one pillar. If something doesn't serve a pillar, question whether it belongs.
+
+**Examples of Pillars:**
+
+| Game           | Pillars                                            |
+| -------------- | -------------------------------------------------- |
+| **Dark Souls** | Challenge, Discovery, Consequence                  |
+| **Celeste**    | Tight Controls, Accessibility, Emotional Narrative |
+| **Minecraft**  | Creativity, Exploration, Player Agency             |
+| **Dead Cells** | Mastery, Variety, Momentum                         |
+
+**For your {{game_type}} with USPs of {{usps}}:**
+
+What 2-4 pillars will define every design decision in {{game_name}}?"
+
+### 2. Core Loop Discovery
+
+**Guide user through loop definition:**
+
+"Now let's define the core gameplay loop - the cycle of actions players repeat throughout the game.
+
+**Core Loop Structure:**
+
+A good loop has: **Action -> Feedback -> Reward -> Motivation to repeat**
+
+**Examples:**
+
+| Game          | Core Loop                                                              |
+| ------------- | ---------------------------------------------------------------------- |
+| **Roguelike** | Enter dungeon -> Fight/loot -> Die/extract -> Upgrade -> Enter dungeon |
+| **Puzzle**    | See puzzle -> Analyze -> Attempt -> Succeed/fail -> Next puzzle        |
+| **FPS**       | Engage enemy -> Shoot -> Kill/die -> Respawn/proceed -> Engage         |
+
+**For {{game_type}} games, typical loops include:**
+{typical_loops_for_game_type}
+
+**Questions to consider:**
+
+1. What does the player do most of the time?
+2. What makes each loop iteration feel different from the last?
+3. How long is one loop cycle? (seconds, minutes, hours?)
+
+Describe the core loop for {{game_name}}."
+
+### 3. Win/Loss Conditions Discovery
+
+**Guide user through win/loss definition:**
+
+"Finally, let's define how players succeed and fail.
+
+**Win/Loss Framework:**
+
+| Condition Type | Examples                                                        |
+| -------------- | --------------------------------------------------------------- |
+| **Victory**    | Beat final boss, reach score, complete story, survive time      |
+| **Failure**    | Run out of lives, time expires, resources depleted, story fails |
+| **Soft Fail**  | Lose progress, restart level, dropped loot                      |
+| **No Failure** | Sandbox games, creative tools, walking sims                     |
+
+**Questions to consider:**
+
+1. Is there a definitive "win state" or is success ongoing?
+2. What happens when players fail? How punishing is it?
+3. Are there multiple win/lose conditions (lives AND time)?
+4. Does failure teach the player something?
+
+How do players win and lose in {{game_name}}?"
+
+### 4. Generate Core Gameplay Content
+
+Based on the conversation, prepare the content:
+
+```markdown
+## Core Gameplay
+
+### Game Pillars
+
+{{pillar_list_with_descriptions}}
+
+**Pillar Prioritization:** When pillars conflict, prioritize in this order:
+{{pillar_priority_order}}
+
+### Core Gameplay Loop
+
+{{loop_description}}
+
+**Loop Diagram:**
+{{text_based_loop_visualization}}
+
+**Loop Timing:** {{typical_loop_duration}}
+
+**Loop Variation:** {{what_makes_each_iteration_different}}
+
+### Win/Loss Conditions
+
+#### Victory Conditions
+
+{{win_conditions}}
+
+#### Failure Conditions
+
+{{loss_conditions}}
+
+#### Failure Recovery
+
+{{what_happens_on_failure}}
+```
+
+### 5. Present Content and Menu
+
+Show the generated content to the user and present:
+
+"I've drafted the Core Gameplay sections based on our conversation.
+
+**Here's what I'll add to the document:**
+
+[Show the complete markdown content from step 4]
+
+**Validation Check:**
+
+- Do all pillars support your USPs?
+- Does the core loop deliver on your pillars?
+- Do win/loss conditions create appropriate stakes?
+
+**Select an Option:**
+[A] Advanced Elicitation - Stress test these fundamentals
+[P] Party Mode - Get other perspectives on the core design
+[C] Continue - Save this and move to Game Mechanics (Step 6 of 14)"
+
+### 6. 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, 3, 4, 5]`
+- Load `{nextStepFile}`
+
+## CRITICAL STEP COMPLETION NOTE
+
+ONLY WHEN [C continue option] is selected and [core gameplay content saved with frontmatter updated], will you then load and read fully `{nextStepFile}`.
+
+---
+
+## SYSTEM SUCCESS/FAILURE METRICS
+
+### SUCCESS:
+
+- 2-4 clear, actionable pillars defined
+- Pillar prioritization established for conflicts
+- Core loop clearly described with timing and variation
+- Win/loss conditions appropriate for game type
+- Failure recovery explained
+- A/P/C menu presented and handled correctly
+- Frontmatter updated with stepsCompleted: [1, 2, 3, 4, 5]
+
+### SYSTEM FAILURE:
+
+- Generic pillars that don't guide decisions
+- Core loop that doesn't match the game type
+- Generating content without real user input
+- Win/loss conditions misaligned with stated goals
+- Not presenting A/P/C menu after content generation
+- Proceeding without user selecting 'C'
+
+**Master Rule:** Skipping steps, optimizing sequences, or not following exact instructions is FORBIDDEN and constitutes SYSTEM FAILURE.
@@ -0,0 +1,250 @@
+---
+name: 'step-06-mechanics'
+description: 'Define primary game mechanics and control schemes'
+
+# Path Definitions
+workflow_path: '{project-root}/_bmad/bmgd/workflows/2-design/gdd'
+
+# File References
+thisStepFile: '{workflow_path}/steps/step-06-mechanics.md'
+nextStepFile: '{workflow_path}/steps/step-07-game-type.md'
+workflowFile: '{workflow_path}/workflow.md'
+outputFile: '{output_folder}/gdd.md'
+
+# Task References
+advancedElicitationTask: '{project-root}/_bmad/core/workflows/advanced-elicitation/workflow.xml'
+partyModeWorkflow: '{project-root}/_bmad/core/workflows/party-mode/workflow.md'
+---
+
+# Step 6: Game Mechanics
+
+**Progress: Step 6 of 14** - Next: Game Type Specifics
+
+## STEP GOAL:
+
+Define the primary game mechanics that players interact with and the control scheme/input methods for the target platform(s).
+
+## 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
+- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}`
+
+### Role Reinforcement:
+
+- You are a veteran game designer facilitator collaborating with a creative peer
+- Mechanics must serve the pillars and core loop defined in step 5
+- Controls must work for the target platform defined in step 3
+
+### Step-Specific Rules:
+
+- Focus on moment-to-moment player interactions
+- FORBIDDEN to generate mechanics without real user input
+- Challenge: Does each mechanic serve a pillar?
+- Approach: Start with verbs - what does the player DO?
+
+## EXECUTION PROTOCOLS:
+
+- Show your analysis before taking any action
+- Present A/P/C menu after generating content
+- ONLY save when user chooses C (Continue)
+- Update frontmatter `stepsCompleted: [1, 2, 3, 4, 5, 6]` before loading next step
+- FORBIDDEN to load next step until C is selected
+
+## COLLABORATION MENUS (A/P/C):
+
+- **A (Advanced Elicitation)**: Deep dive into mechanic interactions and edge cases
+- **P (Party Mode)**: Test mechanic clarity with multiple perspectives
+- **C (Continue)**: Save the content to the document and proceed to next step
+
+## CONTEXT BOUNDARIES:
+
+- All previous context available (especially pillars and platform)
+- Mechanics are the building blocks of gameplay
+- Controls must feel good on target platform(s)
+
+## Sequence of Instructions (Do not deviate, skip, or optimize)
+
+### 1. Primary Mechanics Discovery
+
+**Guide user through mechanics definition:**
+
+"Let's define the primary mechanics - the core actions players perform to engage with your game.
+
+**Mechanics Framework:**
+
+Think in terms of VERBS - what does the player DO?
+
+| Mechanic Category | Example Verbs                            |
+| ----------------- | ---------------------------------------- |
+| **Movement**      | Run, jump, dash, climb, swim, fly        |
+| **Combat**        | Attack, block, dodge, parry, aim, shoot  |
+| **Interaction**   | Talk, pickup, use, craft, build, destroy |
+| **Resource**      | Collect, spend, trade, manage, invest    |
+| **Information**   | Discover, read, scan, analyze, remember  |
+| **Social**        | Cooperate, compete, trade, communicate   |
+
+**For {{game_type}} games, key mechanics typically include:**
+{typical_mechanics_for_game_type}
+
+**Your core loop is:** {{core_loop}}
+**Your pillars are:** {{pillars}}
+
+**Questions to consider:**
+
+1. What are the 3-5 most important things players do?
+2. Which mechanics support which pillars?
+3. How do mechanics combine or interact?
+
+What are the primary mechanics in {{game_name}}?"
+
+### 2. Mechanics Deep Dive
+
+**For each mechanic identified, ask:**
+
+"Let's detail **{{mechanic_name}}**:
+
+- **When does the player use this?** (constantly, situationally, rarely)
+- **What skill does it test?** (timing, positioning, strategy, knowledge)
+- **How does it feel?** (snappy, weighty, floaty, precise)
+- **How does it progress?** (unlocks, upgrades, mastery)
+- **How does it interact with other mechanics?**"
+
+### 3. Controls Discovery
+
+**Guide user through control scheme definition:**
+
+"Now let's map these mechanics to controls for {{primary_platform}}.
+
+**Control Considerations:**
+
+| Platform    | Key Considerations                                                 |
+| ----------- | ------------------------------------------------------------------ |
+| **PC**      | Keyboard/mouse precision, rebindable keys, many available inputs   |
+| **Console** | Limited buttons, shoulder triggers, stick deadzone, rumble         |
+| **Mobile**  | Touch targets, gesture clarity, screen real estate, one-hand play? |
+| **VR**      | Motion control, tracked hands, comfort, physical space             |
+
+**Control Design Principles:**
+
+1. **Frequency = Accessibility:** Common actions get easy-to-reach inputs
+2. **Similar actions, similar buttons:** Jump/interact shouldn't be opposite hands
+3. **No hand gymnastics:** Avoid requiring uncomfortable button combos
+4. **Platform conventions:** Use expected mappings where appropriate
+
+**For {{game_type}} on {{platform}}, typical control schemes include:**
+{typical_controls_for_game_type_and_platform}
+
+How do you want controls to work in {{game_name}}?"
+
+### 4. Generate Mechanics Content
+
+Based on the conversation, prepare the content:
+
+```markdown
+## Game Mechanics
+
+### Primary Mechanics
+
+{{mechanics_list_with_details}}
+
+### Mechanic Interactions
+
+{{how_mechanics_combine}}
+
+### Mechanic Progression
+
+{{how_mechanics_evolve_or_unlock}}
+
+---
+
+## Controls and Input
+
+### Control Scheme ({{primary_platform}})
+
+{{control_mapping_table_or_description}}
+
+### Input Feel
+
+{{how_controls_should_feel}}
+
+### Accessibility Controls
+
+{{planned_accessibility_options}}
+```
+
+### 5. Present Content and Menu
+
+Show the generated content to the user and present:
+
+"I've drafted the Mechanics & Controls sections based on our conversation.
+
+**Here's what I'll add to the document:**
+
+[Show the complete markdown content from step 4]
+
+**Validation Check:**
+
+- Does each mechanic serve at least one pillar?
+- Do controls feel natural for the platform?
+- Are common actions easily accessible?
+
+**Select an Option:**
+[A] Advanced Elicitation - Deep dive into mechanic feel and edge cases
+[P] Party Mode - Test these mechanics with other perspectives
+[C] Continue - Save this and move to Game Type Specifics (Step 7 of 14)"
+
+### 6. 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, 3, 4, 5, 6]`
+- Load `{nextStepFile}`
+
+## CRITICAL STEP COMPLETION NOTE
+
+ONLY WHEN [C continue option] is selected and [mechanics content saved with frontmatter updated], will you then load and read fully `{nextStepFile}`.
+
+---
+
+## SYSTEM SUCCESS/FAILURE METRICS
+
+### SUCCESS:
+
+- 3-5 primary mechanics clearly defined
+- Each mechanic linked to pillars
+- Mechanic interactions described
+- Control scheme appropriate for platform
+- Input feel considerations captured
+- A/P/C menu presented and handled correctly
+- Frontmatter updated with stepsCompleted: [1, 2, 3, 4, 5, 6]
+
+### SYSTEM FAILURE:
+
+- Mechanics that don't serve pillars
+- Controls inappropriate for target platform
+- Generating content without real user input
+- Missing mechanic interactions
+- Not presenting A/P/C menu after content generation
+- Proceeding without user selecting 'C'
+
+**Master Rule:** Skipping steps, optimizing sequences, or not following exact instructions is FORBIDDEN and constitutes SYSTEM FAILURE.
@@ -0,0 +1,267 @@
+---
+name: 'step-07-game-type'
+description: 'Process game-type specific sections from the loaded game type guide'
+
+# Path Definitions
+workflow_path: '{project-root}/_bmad/bmgd/workflows/2-design/gdd'
+
+# File References
+thisStepFile: '{workflow_path}/steps/step-07-game-type.md'
+nextStepFile: '{workflow_path}/steps/step-08-progression.md'
+workflowFile: '{workflow_path}/workflow.md'
+outputFile: '{output_folder}/gdd.md'
+
+# Game Type Resources
+gameTypesFolder: '{workflow_path}/game-types'
+
+# Task References
+advancedElicitationTask: '{project-root}/_bmad/core/workflows/advanced-elicitation/workflow.xml'
+partyModeWorkflow: '{project-root}/_bmad/core/workflows/party-mode/workflow.md'
+---
+
+# Step 7: Game Type Specifics
+
+**Progress: Step 7 of 14** - Next: Progression & Balance
+
+## STEP GOAL:
+
+Process the game-type specific sections from the loaded game type guide ({game_type}.md). Each game type has unique sections that must be addressed (e.g., RPGs need character systems, platformers need movement feel, etc.).
+
+## 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
+- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}`
+
+### Role Reinforcement:
+
+- You are a veteran game designer facilitator collaborating with a creative peer
+- Game type guides contain expert knowledge for specific genres
+- This step varies significantly based on game type
+
+### Step-Specific Rules:
+
+- CRITICAL: Load and process the game type guide file
+- Each section in the guide should be elicited from user
+- FORBIDDEN to generate type-specific content without user input
+- Some game types have optional sections - respect them
+
+## EXECUTION PROTOCOLS:
+
+- Load the game type guide from `{gameTypesFolder}/{game_type}.md`
+- Process each section in the guide sequentially
+- Present A/P/C menu after completing all type-specific sections
+- ONLY save when user chooses C (Continue)
+- Update frontmatter `stepsCompleted: [1, 2, 3, 4, 5, 6, 7]` before loading next step
+
+## COLLABORATION MENUS (A/P/C):
+
+- **A (Advanced Elicitation)**: Deep dive into genre-specific elements
+- **P (Party Mode)**: Get genre expert perspectives
+- **C (Continue)**: Save the content to the document and proceed to next step
+
+## CONTEXT BOUNDARIES:
+
+- Game type was determined in step 2 and stored in frontmatter
+- Game type guide should already be loaded in memory from step 2
+- All previous context (pillars, mechanics, etc.) available
+- Type-specific content goes in the {{GAME_TYPE_SPECIFIC_SECTIONS}} placeholder
+
+## Sequence of Instructions (Do not deviate, skip, or optimize)
+
+### 1. Load Game Type Guide
+
+**CRITICAL FIRST ACTION:**
+
+- Read `game_type` from frontmatter
+- If not already loaded, load `{gameTypesFolder}/{game_type}.md`
+- Parse the guide to identify all sections that need elicitation
+
+**Announce to user:**
+
+"Now we'll work through the **{{game_type}}** specific sections. This game type has unique design elements that we need to define.
+
+**{{game_type}} requires these specific sections:**
+{list_sections_from_game_type_guide}
+
+Let's work through each one."
+
+### 2. Process Each Section from Guide
+
+**For each section defined in the game type guide:**
+
+The game type guide will have sections marked with placeholders like `{{section_name}}`. For each:
+
+1. **Read the guidance** in the guide for this section
+2. **Present the guidance and questions** to the user
+3. **Elicit user input** for this specific section
+4. **Store the content** for final assembly
+
+**Example flow for an RPG game type:**
+
+"**Character System**
+
+Your game type guide suggests addressing:
+
+- Character creation options
+- Attribute/stat system
+- Class or build system
+- Character progression path
+
+{guidance_from_guide}
+
+How do you want the character system to work in {{game_name}}?"
+
+### 3. Handle Optional Sections
+
+Some game type guides have optional sections marked with `[optional]` or similar:
+
+- Present optional sections to user
+- Ask: "This section is optional for {{game_type}}. Would you like to define {{section_name}}?"
+- If yes: elicit content
+- If no: skip and note as "Not applicable for this game"
+
+### 4. Handle Narrative Flags
+
+Some game type guides include narrative flags:
+
+- `<narrative-workflow-critical>` - Story is essential for this game type
+- `<narrative-workflow-recommended>` - Story would enhance this game type
+
+If flag found:
+
+- Store `needs_narrative = true` for use in step 14
+- Note to user: "This game type typically benefits from dedicated narrative design. We'll address this in the final step."
+
+### 5. Generate Game Type Content
+
+Based on all elicited sections, prepare the content:
+
+```markdown
+## {{game_type_name}} Specific Design
+
+{{assembled_sections_from_guide_elicitation}}
+```
+
+The content structure will vary based on game type:
+
+**Example for RPG:**
+
+```markdown
+## RPG Specific Design
+
+### Character System
+
+{{character_system_content}}
+
+### Combat System
+
+{{combat_system_content}}
+
+### Inventory & Equipment
+
+{{inventory_content}}
+
+### Quest System
+
+{{quest_system_content}}
+```
+
+**Example for Platformer:**
+
+```markdown
+## Platformer Specific Design
+
+### Movement Feel
+
+{{movement_feel_content}}
+
+### Jump Mechanics
+
+{{jump_mechanics_content}}
+
+### Hazards & Enemies
+
+{{hazards_content}}
+
+### Collectibles
+
+{{collectibles_content}}
+```
+
+### 6. Present Content and Menu
+
+Show the generated content to the user and present:
+
+"I've drafted the {{game_type}} Specific Design sections based on our conversation.
+
+**Here's what I'll add to the document:**
+
+[Show the complete markdown content from step 5]
+
+**Validation Check:**
+
+- Does each section align with your core pillars?
+- Have we covered all required elements for {{game_type}}?
+- Any genre conventions you want to subvert?
+
+**Select an Option:**
+[A] Advanced Elicitation - Deep dive into genre specifics
+[P] Party Mode - Get genre expert perspectives
+[C] Continue - Save this and move to Progression & Balance (Step 8 of 14)"
+
+### 7. 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}` in place of {{GAME_TYPE_SPECIFIC_SECTIONS}}
+- Update frontmatter: `stepsCompleted: [1, 2, 3, 4, 5, 6, 7]`
+- If `needs_narrative` flag was set, store in frontmatter
+- Load `{nextStepFile}`
+
+## CRITICAL STEP COMPLETION NOTE
+
+ONLY WHEN [C continue option] is selected and [game type content saved with frontmatter updated], will you then load and read fully `{nextStepFile}`.
+
+---
+
+## SYSTEM SUCCESS/FAILURE METRICS
+
+### SUCCESS:
+
+- Game type guide loaded and parsed
+- All required sections elicited from user
+- Optional sections offered and handled appropriately
+- Narrative flags detected and stored
+- Content matches game type guide structure
+- A/P/C menu presented and handled correctly
+- Frontmatter updated with stepsCompleted: [1, 2, 3, 4, 5, 6, 7]
+
+### SYSTEM FAILURE:
+
+- Not loading the game type guide file
+- Generating type-specific content without user input
+- Missing required sections from the guide
+- Ignoring narrative flags
+- Not presenting A/P/C menu after content generation
+- Proceeding without user selecting 'C'
+
+**Master Rule:** Skipping steps, optimizing sequences, or not following exact instructions is FORBIDDEN and constitutes SYSTEM FAILURE.
@@ -0,0 +1,273 @@
+---
+name: 'step-08-progression'
+description: 'Define player progression systems and game balance'
+
+# Path Definitions
+workflow_path: '{project-root}/_bmad/bmgd/workflows/2-design/gdd'
+
+# File References
+thisStepFile: '{workflow_path}/steps/step-08-progression.md'
+nextStepFile: '{workflow_path}/steps/step-09-levels.md'
+workflowFile: '{workflow_path}/workflow.md'
+outputFile: '{output_folder}/gdd.md'
+
+# Task References
+advancedElicitationTask: '{project-root}/_bmad/core/workflows/advanced-elicitation/workflow.xml'
+partyModeWorkflow: '{project-root}/_bmad/core/workflows/party-mode/workflow.md'
+---
+
+# Step 8: Progression & Balance
+
+**Progress: Step 8 of 14** - Next: Level Design
+
+## STEP GOAL:
+
+Define how players progress through the game (skill, power, narrative, etc.), the difficulty curve, and any economy or resource systems.
+
+## 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
+- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}`
+
+### Role Reinforcement:
+
+- You are a veteran game designer facilitator collaborating with a creative peer
+- Progression is what keeps players engaged over time
+- Balance determines if the game feels fair and fun
+
+### Step-Specific Rules:
+
+- Focus on player growth and challenge scaling
+- FORBIDDEN to generate progression systems without user input
+- Some games have no explicit progression - that's valid
+- Economy/resources are optional - ask before including
+
+## EXECUTION PROTOCOLS:
+
+- Show your analysis before taking any action
+- Present A/P/C menu after generating content
+- ONLY save when user chooses C (Continue)
+- Update frontmatter `stepsCompleted: [1, 2, 3, 4, 5, 6, 7, 8]` before loading next step
+- FORBIDDEN to load next step until C is selected
+
+## COLLABORATION MENUS (A/P/C):
+
+- **A (Advanced Elicitation)**: Deep dive into progression curves and balance
+- **P (Party Mode)**: Test progression ideas with multiple perspectives
+- **C (Continue)**: Save the content to the document and proceed to next step
+
+## CONTEXT BOUNDARIES:
+
+- All previous context available (especially core loop and mechanics)
+- Progression should reinforce the core loop
+- Balance affects all previously defined mechanics
+
+## Sequence of Instructions (Do not deviate, skip, or optimize)
+
+### 1. Player Progression Discovery
+
+**Guide user through progression definition:**
+
+"Let's define how players grow and progress through {{game_name}}.
+
+**Types of Progression:**
+
+| Type           | Description                                | Examples                  |
+| -------------- | ------------------------------------------ | ------------------------- |
+| **Skill**      | Player gets better at the game             | Dark Souls, Celeste       |
+| **Power**      | Character gets stronger (stats, abilities) | RPGs, Metroidvanias       |
+| **Narrative**  | Story unfolds and advances                 | Visual novels, adventures |
+| **Content**    | New levels, areas, or modes unlock         | Most games                |
+| **Collection** | Gathering items, achievements              | Completionist games       |
+| **Social**     | Rank, reputation, community status         | Competitive games         |
+
+**For {{game_type}} games, typical progression includes:**
+{typical_progression_for_game_type}
+
+**Questions to consider:**
+
+1. What type(s) of progression does {{game_name}} have?
+2. How long until players feel meaningful progress?
+3. Is there a "meta" progression (between runs/sessions)?
+
+How do players progress in {{game_name}}?"
+
+### 2. Difficulty Curve Discovery
+
+**Guide user through difficulty design:**
+
+"Now let's design the difficulty curve.
+
+**Difficulty Curve Patterns:**
+
+| Pattern               | Description                             | Best For                       |
+| --------------------- | --------------------------------------- | ------------------------------ |
+| **Linear**            | Steady increase in challenge            | Story games, first playthrough |
+| **Sawtooth**          | Build-release pattern (easy after hard) | Level-based games              |
+| **Exponential**       | Gentle start, steep late-game           | RPGs, incremental games        |
+| **Flat**              | Consistent challenge throughout         | Roguelikes, skill games        |
+| **Player-controlled** | User selects difficulty                 | Accessibility-focused          |
+
+**Questions to consider:**
+
+1. How does challenge increase over time?
+2. Are there difficulty spikes (bosses, skill checks)?
+3. Can players adjust difficulty? How?
+4. How do you handle players who are stuck?
+
+Describe the difficulty curve for {{game_name}}."
+
+### 3. Economy/Resources Discovery (Optional)
+
+**Ask first:**
+
+"Does {{game_name}} have an in-game economy or resource system?
+
+Examples:
+
+- Currency (gold, coins, gems)
+- Crafting materials
+- Energy/stamina systems
+- Ammunition or consumables
+
+If yes, we'll define it. If no, we'll skip this section."
+
+**If yes:**
+
+"Let's define the economy/resources:
+
+**Economy Questions:**
+
+1. What resources exist?
+2. How are resources earned?
+3. How are resources spent?
+4. Is there inflation/scarcity design?
+5. Are there sinks to remove resources?
+6. Premium currency? (if F2P)
+
+Describe the economy in {{game_name}}."
+
+### 4. Generate Progression Content
+
+Based on the conversation, prepare the content:
+
+```markdown
+## Progression and Balance
+
+### Player Progression
+
+{{progression_system_description}}
+
+#### Progression Types
+
+{{progression_types_used}}
+
+#### Progression Pacing
+
+{{how_fast_players_progress}}
+
+### Difficulty Curve
+
+{{difficulty_curve_description}}
+
+#### Challenge Scaling
+
+{{how_difficulty_increases}}
+
+#### Difficulty Options
+
+{{accessibility_and_difficulty_settings}}
+
+### Economy and Resources
+
+{{if_has_economy}}
+{{economy_system_description}}
+
+#### Resources
+
+{{resource_types_and_purposes}}
+
+#### Economy Flow
+
+{{earn_and_spend_loop}}
+{{/if_has_economy}}
+
+{{if_no_economy}}
+_This game does not feature an in-game economy or resource system._
+{{/if_no_economy}}
+```
+
+### 5. Present Content and Menu
+
+Show the generated content to the user and present:
+
+"I've drafted the Progression & Balance sections based on our conversation.
+
+**Here's what I'll add to the document:**
+
+[Show the complete markdown content from step 4]
+
+**Validation Check:**
+
+- Does progression reinforce your core loop?
+- Is the difficulty curve appropriate for your audience?
+- Does the economy (if any) feel fair?
+
+**Select an Option:**
+[A] Advanced Elicitation - Deep dive into balance and pacing
+[P] Party Mode - Test these systems with other perspectives
+[C] Continue - Save this and move to Level Design (Step 9 of 14)"
+
+### 6. 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, 3, 4, 5, 6, 7, 8]`
+- Load `{nextStepFile}`
+
+## CRITICAL STEP COMPLETION NOTE
+
+ONLY WHEN [C continue option] is selected and [progression content saved with frontmatter updated], will you then load and read fully `{nextStepFile}`.
+
+---
+
+## SYSTEM SUCCESS/FAILURE METRICS
+
+### SUCCESS:
+
+- Progression system clearly defined
+- Difficulty curve appropriate for game type and audience
+- Economy handled correctly (defined or explicitly skipped)
+- Balance considerations documented
+- A/P/C menu presented and handled correctly
+- Frontmatter updated with stepsCompleted: [1, 2, 3, 4, 5, 6, 7, 8]
+
+### SYSTEM FAILURE:
+
+- Generating progression without user input
+- Assuming economy exists without asking
+- Difficulty curve mismatched with audience
+- Not presenting A/P/C menu after content generation
+- Proceeding without user selecting 'C'
+
+**Master Rule:** Skipping steps, optimizing sequences, or not following exact instructions is FORBIDDEN and constitutes SYSTEM FAILURE.
@@ -0,0 +1,265 @@
+---
+name: 'step-09-levels'
+description: 'Define level design framework and level progression'
+
+# Path Definitions
+workflow_path: '{project-root}/_bmad/bmgd/workflows/2-design/gdd'
+
+# File References
+thisStepFile: '{workflow_path}/steps/step-09-levels.md'
+nextStepFile: '{workflow_path}/steps/step-10-art-audio.md'
+workflowFile: '{workflow_path}/workflow.md'
+outputFile: '{output_folder}/gdd.md'
+
+# Task References
+advancedElicitationTask: '{project-root}/_bmad/core/workflows/advanced-elicitation/workflow.xml'
+partyModeWorkflow: '{project-root}/_bmad/core/workflows/party-mode/workflow.md'
+---
+
+# Step 9: Level Design
+
+**Progress: Step 9 of 14** - Next: Art & Audio
+
+## STEP GOAL:
+
+Define the level design framework including level types, structure, and how levels progress or unlock throughout the game.
+
+## 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
+- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}`
+
+### Role Reinforcement:
+
+- You are a veteran game designer facilitator collaborating with a creative peer
+- Level design is where mechanics meet content
+- Not all games have "levels" - some have open worlds, others are endless
+
+### Step-Specific Rules:
+
+- Focus on spatial design and content structure
+- FORBIDDEN to generate level designs without user input
+- Adapt terminology to game type (levels, stages, areas, dungeons, etc.)
+- Some games have no level structure - that's valid
+
+## EXECUTION PROTOCOLS:
+
+- Show your analysis before taking any action
+- Present A/P/C menu after generating content
+- ONLY save when user chooses C (Continue)
+- Update frontmatter `stepsCompleted: [1, 2, 3, 4, 5, 6, 7, 8, 9]` before loading next step
+- FORBIDDEN to load next step until C is selected
+
+## COLLABORATION MENUS (A/P/C):
+
+- **A (Advanced Elicitation)**: Deep dive into level design principles
+- **P (Party Mode)**: Get perspectives on level structure
+- **C (Continue)**: Save the content to the document and proceed to next step
+
+## CONTEXT BOUNDARIES:
+
+- All previous context available (especially mechanics and progression)
+- Level design should teach and challenge using defined mechanics
+- Structure should support defined progression system
+
+## Sequence of Instructions (Do not deviate, skip, or optimize)
+
+### 1. Determine Level Structure Type
+
+**First, establish the structural approach:**
+
+"Let's define how {{game_name}} structures its playable content.
+
+**Structure Types:**
+
+| Type                 | Description                       | Examples                    |
+| -------------------- | --------------------------------- | --------------------------- |
+| **Linear Levels**    | Distinct stages played in order   | Mario, Celeste              |
+| **Hub-Based**        | Central area connecting levels    | Mario 64, Hollow Knight     |
+| **Open World**       | Large continuous space            | Breath of the Wild, GTA     |
+| **Procedural**       | Generated levels each playthrough | Spelunky, Dead Cells        |
+| **Arena/Match**      | Self-contained competitive spaces | Fighting games, MOBAs       |
+| **Puzzle Sets**      | Collections of puzzles            | Portal, The Witness         |
+| **Narrative Scenes** | Story-driven segments             | Visual novels, adventures   |
+| **Endless**          | Infinite generated content        | Endless runners, idle games |
+
+**For {{game_type}} games, typical structures include:**
+{typical_structures_for_game_type}
+
+What structure best fits {{game_name}}?"
+
+### 2. Level Types Discovery
+
+**Based on structure choice, elicit level types:**
+
+"Now let's define the types of {levels/areas/stages} in {{game_name}}.
+
+**Questions to consider:**
+
+1. What different environments or settings exist?
+2. Are there tutorial levels? How are they integrated?
+3. Are there boss levels or climax moments?
+4. What's the shortest level? Longest?
+5. Any special or secret levels?
+
+Describe the types of {levels/areas/stages} in {{game_name}}."
+
+### 3. Level Progression Discovery
+
+**Guide user through progression structure:**
+
+"Now let's define how players progress through {levels/areas/content}.
+
+**Progression Models:**
+
+| Model                 | Description                      | Best For               |
+| --------------------- | -------------------------------- | ---------------------- |
+| **Linear Sequence**   | 1 -> 2 -> 3 -> ...               | Story games, tutorials |
+| **Branching Paths**   | Choices lead to different levels | Replayability          |
+| **Open Selection**    | Player chooses order             | Mega Man style         |
+| **Gated Progress**    | Abilities unlock new areas       | Metroidvania           |
+| **Score/Star Unlock** | Performance unlocks levels       | Angry Birds style      |
+| **Story Unlock**      | Narrative triggers unlock        | Adventure games        |
+
+**Questions to consider:**
+
+1. How do players unlock new {levels/areas}?
+2. Can players replay previous {levels/areas}?
+3. Is there a "world map" or selection screen?
+4. How is the final {level/area} unlocked?
+
+How do players progress through {{game_name}}'s content?"
+
+### 4. Level Design Principles (Optional)
+
+"Would you like to establish specific level design principles or guidelines for {{game_name}}?
+
+Examples:
+
+- 'Teach through play, never through text'
+- 'Every room has one new idea'
+- '30 second rule - something interesting every 30 seconds'
+- 'Left is safety, right is danger'
+
+These can guide consistent level design throughout development."
+
+### 5. Generate Level Design Content
+
+Based on the conversation, prepare the content:
+
+```markdown
+## Level Design Framework
+
+### Structure Type
+
+{{structure_type_description}}
+
+### Level Types
+
+{{level_types_list}}
+
+#### Tutorial Integration
+
+{{how_tutorials_work}}
+
+#### Special Levels
+
+{{boss_levels_secret_levels_etc}}
+
+### Level Progression
+
+{{progression_model_description}}
+
+#### Unlock System
+
+{{how_levels_unlock}}
+
+#### Replayability
+
+{{replay_and_revisit_mechanics}}
+
+### Level Design Principles
+
+{{if_has_principles}}
+{{level_design_guidelines}}
+{{/if_has_principles}}
+
+{{if_no_principles}}
+_Level design principles will be established during production._
+{{/if_no_principles}}
+```
+
+### 6. Present Content and Menu
+
+Show the generated content to the user and present:
+
+"I've drafted the Level Design Framework based on our conversation.
+
+**Here's what I'll add to the document:**
+
+[Show the complete markdown content from step 5]
+
+**Validation Check:**
+
+- Does the structure support your core loop?
+- Does progression feel rewarding?
+- Are level types varied enough to maintain interest?
+
+**Select an Option:**
+[A] Advanced Elicitation - Deep dive into level design specifics
+[P] Party Mode - Get other perspectives on level structure
+[C] Continue - Save this and move to Art & Audio (Step 10 of 14)"
+
+### 7. 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, 3, 4, 5, 6, 7, 8, 9]`
+- Load `{nextStepFile}`
+
+## CRITICAL STEP COMPLETION NOTE
+
+ONLY WHEN [C continue option] is selected and [level design content saved with frontmatter updated], will you then load and read fully `{nextStepFile}`.
+
+---
+
+## SYSTEM SUCCESS/FAILURE METRICS
+
+### SUCCESS:
+
+- Level structure type clearly identified
+- Level types defined with variety
+- Progression model documented
+- Tutorial integration addressed
+- A/P/C menu presented and handled correctly
+- Frontmatter updated with stepsCompleted: [1, 2, 3, 4, 5, 6, 7, 8, 9]
+
+### SYSTEM FAILURE:
+
+- Generating level designs without user input
+- Using wrong terminology for game type
+- Structure doesn't support core loop
+- Not presenting A/P/C menu after content generation
+- Proceeding without user selecting 'C'
+
+**Master Rule:** Skipping steps, optimizing sequences, or not following exact instructions is FORBIDDEN and constitutes SYSTEM FAILURE.
@@ -0,0 +1,256 @@
+---
+name: 'step-10-art-audio'
+description: 'Define art style and audio direction'
+
+# Path Definitions
+workflow_path: '{project-root}/_bmad/bmgd/workflows/2-design/gdd'
+
+# File References
+thisStepFile: '{workflow_path}/steps/step-10-art-audio.md'
+nextStepFile: '{workflow_path}/steps/step-11-technical.md'
+workflowFile: '{workflow_path}/workflow.md'
+outputFile: '{output_folder}/gdd.md'
+
+# Task References
+advancedElicitationTask: '{project-root}/_bmad/core/workflows/advanced-elicitation/workflow.xml'
+partyModeWorkflow: '{project-root}/_bmad/core/workflows/party-mode/workflow.md'
+---
+
+# Step 10: Art & Audio
+
+**Progress: Step 10 of 14** - Next: Technical Specs
+
+## STEP GOAL:
+
+Define the visual art style and audio/music direction for the game, establishing the aesthetic identity that will guide all asset creation.
+
+## 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
+- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}`
+
+### Role Reinforcement:
+
+- You are a veteran game designer facilitator collaborating with a creative peer
+- Art and audio define the player's emotional experience
+- These decisions heavily impact scope and team requirements
+
+### Step-Specific Rules:
+
+- Focus on direction and mood, not specific asset lists
+- FORBIDDEN to generate art/audio direction without user input
+- Reference games or other media when helpful
+- Consider platform constraints on art complexity
+
+## EXECUTION PROTOCOLS:
+
+- Show your analysis before taking any action
+- Present A/P/C menu after generating content
+- ONLY save when user chooses C (Continue)
+- Update frontmatter `stepsCompleted: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]` before loading next step
+- FORBIDDEN to load next step until C is selected
+
+## COLLABORATION MENUS (A/P/C):
+
+- **A (Advanced Elicitation)**: Deep dive into aesthetic choices
+- **P (Party Mode)**: Get artistic perspectives
+- **C (Continue)**: Save the content to the document and proceed to next step
+
+## CONTEXT BOUNDARIES:
+
+- All previous context available (especially platform and audience)
+- Art style should match game pillars and tone
+- Audio must work on target platform(s)
+
+## Sequence of Instructions (Do not deviate, skip, or optimize)
+
+### 1. Art Style Discovery
+
+**Guide user through visual direction:**
+
+"Let's define the visual identity of {{game_name}}.
+
+**Art Style Categories:**
+
+| Style           | Description                  | Examples                  |
+| --------------- | ---------------------------- | ------------------------- |
+| **Pixel Art**   | Retro-styled discrete pixels | Celeste, Shovel Knight    |
+| **Low-Poly**    | Simple 3D geometry           | Superhot, Monument Valley |
+| **Hand-Drawn**  | Illustration-like visuals    | Cuphead, Hollow Knight    |
+| **Realistic**   | Photorealistic graphics      | AAA titles                |
+| **Stylized 3D** | Non-realistic 3D             | Fortnite, Zelda: BotW     |
+| **Vector/Flat** | Clean shapes, minimal        | Thomas Was Alone          |
+| **Mixed Media** | Combining multiple styles    | Paper Mario               |
+
+**Visual Elements to Consider:**
+
+- **Color Palette:** Vibrant, muted, monochromatic, complementary?
+- **Lighting:** Dramatic, soft, realistic, stylized?
+- **Camera:** 2D side, top-down, isometric, 3D third/first person?
+- **Character Design:** Cute, realistic, abstract, iconic?
+
+**For {{game_type}} on {{platform}}, common art styles include:**
+{typical_art_styles_for_game_type}
+
+What visual style do you envision for {{game_name}}?"
+
+### 2. Art Reference Gathering
+
+"Are there any games, films, or art that inspire the look of {{game_name}}?
+
+Examples help communicate the vision:
+
+- 'The lighting of Limbo with the colors of Journey'
+- 'Pixel art like Hyper Light Drifter but with a warmer palette'
+- 'Studio Ghibli-inspired environments'
+
+What references capture the visual feel you want?"
+
+### 3. Audio Direction Discovery
+
+**Guide user through audio/music direction:**
+
+"Now let's define the audio identity of {{game_name}}.
+
+**Music Style Considerations:**
+
+| Style              | Mood                | Examples              |
+| ------------------ | ------------------- | --------------------- |
+| **Chiptune/8-bit** | Retro, energetic    | Shovel Knight         |
+| **Orchestral**     | Epic, emotional     | Zelda, Final Fantasy  |
+| **Electronic**     | Modern, driving     | Hotline Miami, FURI   |
+| **Ambient**        | Atmospheric, subtle | Journey, INSIDE       |
+| **Rock/Metal**     | Intense, aggressive | DOOM, Devil May Cry   |
+| **Jazz/Lo-fi**     | Chill, stylish      | Persona, VA-11 Hall-A |
+| **Dynamic**        | Adapts to gameplay  | DOOM, Ape Out         |
+
+**Sound Design Considerations:**
+
+- **Feedback Sounds:** How responsive and punchy?
+- **Environmental Audio:** How immersive?
+- **Voice/Dialogue:** None, grunts, partial, full VO?
+- **Accessibility:** Audio cues for visual elements?
+
+**For {{game_type}} games, typical audio approaches include:**
+{typical_audio_for_game_type}
+
+What audio direction fits {{game_name}}?"
+
+### 4. Generate Art & Audio Content
+
+Based on the conversation, prepare the content:
+
+```markdown
+## Art and Audio Direction
+
+### Art Style
+
+{{art_style_description}}
+
+#### Visual References
+
+{{reference_games_and_media}}
+
+#### Color Palette
+
+{{color_direction}}
+
+#### Camera and Perspective
+
+{{camera_style}}
+
+### Audio and Music
+
+{{audio_direction_description}}
+
+#### Music Style
+
+{{music_genre_and_mood}}
+
+#### Sound Design
+
+{{sound_design_approach}}
+
+#### Voice/Dialogue
+
+{{voice_approach}}
+
+### Aesthetic Goals
+
+{{how_art_and_audio_support_game_pillars}}
+```
+
+### 5. Present Content and Menu
+
+Show the generated content to the user and present:
+
+"I've drafted the Art & Audio Direction based on our conversation.
+
+**Here's what I'll add to the document:**
+
+[Show the complete markdown content from step 4]
+
+**Validation Check:**
+
+- Does the art style support your game pillars?
+- Is the audio direction achievable for your scope?
+- Do art and audio work together cohesively?
+
+**Select an Option:**
+[A] Advanced Elicitation - Deep dive into aesthetic details
+[P] Party Mode - Get artistic perspectives
+[C] Continue - Save this and move to Technical Specs (Step 11 of 14)"
+
+### 6. 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, 3, 4, 5, 6, 7, 8, 9, 10]`
+- Load `{nextStepFile}`
+
+## CRITICAL STEP COMPLETION NOTE
+
+ONLY WHEN [C continue option] is selected and [art/audio content saved with frontmatter updated], will you then load and read fully `{nextStepFile}`.
+
+---
+
+## SYSTEM SUCCESS/FAILURE METRICS
+
+### SUCCESS:
+
+- Art style clearly defined with references
+- Audio direction documented
+- Aesthetic supports game pillars and tone
+- Platform constraints considered
+- A/P/C menu presented and handled correctly
+- Frontmatter updated with stepsCompleted: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+
+### SYSTEM FAILURE:
+
+- Generating art/audio direction without user input
+- Art style inappropriate for target platform
+- Missing references that help communicate vision
+- Not presenting A/P/C menu after content generation
+- Proceeding without user selecting 'C'
+
+**Master Rule:** Skipping steps, optimizing sequences, or not following exact instructions is FORBIDDEN and constitutes SYSTEM FAILURE.
@@ -0,0 +1,276 @@
+---
+name: 'step-11-technical'
+description: 'Define technical specifications and requirements'
+
+# Path Definitions
+workflow_path: '{project-root}/_bmad/bmgd/workflows/2-design/gdd'
+
+# File References
+thisStepFile: '{workflow_path}/steps/step-11-technical.md'
+nextStepFile: '{workflow_path}/steps/step-12-epics.md'
+workflowFile: '{workflow_path}/workflow.md'
+outputFile: '{output_folder}/gdd.md'
+
+# Task References
+advancedElicitationTask: '{project-root}/_bmad/core/workflows/advanced-elicitation/workflow.xml'
+partyModeWorkflow: '{project-root}/_bmad/core/workflows/party-mode/workflow.md'
+---
+
+# Step 11: Technical Specifications
+
+**Progress: Step 11 of 14** - Next: Epic Structure
+
+## STEP GOAL:
+
+Define technical requirements including performance targets, platform-specific details, and asset requirements. This provides a bridge to the architecture workflow.
+
+## 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
+- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}`
+
+### Role Reinforcement:
+
+- You are a veteran game designer facilitator collaborating with a creative peer
+- Technical specs inform the architecture workflow
+- Not all technical decisions are made here - architecture comes later
+
+### Step-Specific Rules:
+
+- Focus on requirements, not implementation details
+- FORBIDDEN to generate tech specs without user input
+- Keep scope appropriate - detailed architecture comes in a separate workflow
+- Reference target platform(s) from step 3
+
+## EXECUTION PROTOCOLS:
+
+- Show your analysis before taking any action
+- Present A/P/C menu after generating content
+- ONLY save when user chooses C (Continue)
+- Update frontmatter `stepsCompleted: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]` before loading next step
+- FORBIDDEN to load next step until C is selected
+
+## COLLABORATION MENUS (A/P/C):
+
+- **A (Advanced Elicitation)**: Deep dive into technical requirements
+- **P (Party Mode)**: Get technical perspectives
+- **C (Continue)**: Save the content to the document and proceed to next step
+
+## CONTEXT BOUNDARIES:
+
+- All previous context available (especially platform from step 3)
+- This is GDD-level specs, not architecture-level details
+- Engine/framework selection happens in architecture workflow
+
+## Sequence of Instructions (Do not deviate, skip, or optimize)
+
+### 1. Performance Requirements Discovery
+
+**Guide user through performance targets:**
+
+"Let's define the technical requirements for {{game_name}}.
+
+**Performance Targets:**
+
+| Platform    | Typical Targets                             |
+| ----------- | ------------------------------------------- |
+| **PC**      | 60fps @ 1080p minimum, 4K optional          |
+| **Console** | 30fps or 60fps depending on visual fidelity |
+| **Mobile**  | 30fps, thermal management, battery life     |
+| **Web**     | 30-60fps, file size under 50MB              |
+| **VR**      | 72-90fps minimum, latency critical          |
+
+**For {{game_type}} on {{platform}}:**
+
+**Questions to consider:**
+
+1. What frame rate are you targeting?
+2. What resolutions should be supported?
+3. What's the acceptable load time?
+4. Any specific performance priorities? (visuals vs frame rate)
+
+What are your performance targets for {{game_name}}?"
+
+### 2. Platform-Specific Requirements
+
+**Guide user through platform details:**
+
+"Now let's capture platform-specific considerations for {{platform}}.
+
+**Platform-Specific Questions:**
+
+**PC:**
+
+- Minimum and recommended specs?
+- Steam/Epic/itch.io features to support?
+- Mod support planned?
+- Cloud saves?
+
+**Console:**
+
+- Certification requirements awareness?
+- Controller-only or hybrid input?
+- Achievement/trophy integration?
+
+**Mobile:**
+
+- iOS minimum version? Android API level?
+- Portrait, landscape, or both?
+- Offline play required?
+- In-app purchases planned?
+
+**Web:**
+
+- Target browsers?
+- WebGL version?
+- Maximum build size?
+
+What platform-specific requirements matter for {{game_name}}?"
+
+### 3. Asset Requirements Discovery
+
+**Guide user through asset considerations:**
+
+"Finally, let's document asset requirements and constraints.
+
+**Asset Categories:**
+
+| Category             | Considerations                        |
+| -------------------- | ------------------------------------- |
+| **Sprites/Textures** | Resolution, count estimates, atlasing |
+| **3D Models**        | Poly budgets, LOD levels, rigging     |
+| **Animations**       | Frame counts, skeletal vs sprite      |
+| **Audio**            | Music tracks, SFX count, voice lines  |
+| **UI**               | Resolution scaling, localization      |
+
+**Questions to consider:**
+
+1. What are the major asset categories you'll need?
+2. Any rough estimates on asset counts?
+3. What quality level are you targeting?
+4. Any external assets planned (asset store, licensed content)?
+
+What are the key asset requirements for {{game_name}}?"
+
+### 4. Generate Technical Content
+
+Based on the conversation, prepare the content:
+
+```markdown
+## Technical Specifications
+
+### Performance Requirements
+
+{{performance_targets_description}}
+
+#### Frame Rate Target
+
+{{target_fps}}
+
+#### Resolution Support
+
+{{resolution_targets}}
+
+#### Load Times
+
+{{load_time_requirements}}
+
+### Platform-Specific Details
+
+{{platform_specific_requirements}}
+
+#### {{platform}} Requirements
+
+{{platform_details}}
+
+### Asset Requirements
+
+{{asset_requirements_overview}}
+
+#### Art Assets
+
+{{art_asset_requirements}}
+
+#### Audio Assets
+
+{{audio_asset_requirements}}
+
+#### External Assets
+
+{{third_party_asset_plans}}
+
+### Technical Constraints
+
+{{any_known_limitations_or_requirements}}
+```
+
+### 5. Present Content and Menu
+
+Show the generated content to the user and present:
+
+"I've drafted the Technical Specifications based on our conversation.
+
+**Here's what I'll add to the document:**
+
+[Show the complete markdown content from step 4]
+
+**Note:** This is GDD-level technical planning. Detailed architecture decisions (engine selection, specific technologies, system design) will be addressed in the Architecture workflow after the GDD is complete.
+
+**Select an Option:**
+[A] Advanced Elicitation - Deep dive into technical requirements
+[P] Party Mode - Get technical perspectives
+[C] Continue - Save this and move to Epic Structure (Step 12 of 14)"
+
+### 6. 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, 3, 4, 5, 6, 7, 8, 9, 10, 11]`
+- Load `{nextStepFile}`
+
+## CRITICAL STEP COMPLETION NOTE
+
+ONLY WHEN [C continue option] is selected and [technical content saved with frontmatter updated], will you then load and read fully `{nextStepFile}`.
+
+---
+
+## SYSTEM SUCCESS/FAILURE METRICS
+
+### SUCCESS:
+
+- Performance targets clearly defined
+- Platform-specific requirements documented
+- Asset requirements outlined
+- Scope appropriate for GDD (not architecture-level detail)
+- A/P/C menu presented and handled correctly
+- Frontmatter updated with stepsCompleted: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]
+
+### SYSTEM FAILURE:
+
+- Generating tech specs without user input
+- Going too deep into architecture details
+- Missing key platform requirements
+- Not presenting A/P/C menu after content generation
+- Proceeding without user selecting 'C'
+
+**Master Rule:** Skipping steps, optimizing sequences, or not following exact instructions is FORBIDDEN and constitutes SYSTEM FAILURE.
@@ -0,0 +1,285 @@
+---
+name: 'step-12-epics'
+description: 'Define development epics and high-level story breakdown'
+
+# Path Definitions
+workflow_path: '{project-root}/_bmad/bmgd/workflows/2-design/gdd'
+
+# File References
+thisStepFile: '{workflow_path}/steps/step-12-epics.md'
+nextStepFile: '{workflow_path}/steps/step-13-metrics.md'
+workflowFile: '{workflow_path}/workflow.md'
+outputFile: '{output_folder}/gdd.md'
+epicsOutputFile: '{output_folder}/epics.md'
+
+# Task References
+advancedElicitationTask: '{project-root}/_bmad/core/workflows/advanced-elicitation/workflow.xml'
+partyModeWorkflow: '{project-root}/_bmad/core/workflows/party-mode/workflow.md'
+---
+
+# Step 12: Epic Structure
+
+**Progress: Step 12 of 14** - Next: Success Metrics
+
+## STEP GOAL:
+
+Translate the game features defined throughout the GDD into development epics, each with a clear scope and list of high-level stories. This provides the foundation for sprint planning.
+
+## 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
+- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}`
+
+### Role Reinforcement:
+
+- You are a veteran game designer facilitator collaborating with a creative peer
+- Epics bridge design (GDD) to implementation (sprints)
+- Epic scope should be completable in 1-4 sprints
+
+### Step-Specific Rules:
+
+- Focus on feature groupings, not detailed task breakdowns
+- FORBIDDEN to generate epics without user input
+- Each epic should deliver playable value
+- Stories are high-level here - detailed stories come in sprint planning
+
+## EXECUTION PROTOCOLS:
+
+- Show your analysis before taking any action
+- Present A/P/C menu after generating content
+- ONLY save when user chooses C (Continue)
+- Update frontmatter `stepsCompleted: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]` before loading next step
+- FORBIDDEN to load next step until C is selected
+
+## COLLABORATION MENUS (A/P/C):
+
+- **A (Advanced Elicitation)**: Refine epic scopes and boundaries
+- **P (Party Mode)**: Get perspectives on epic organization
+- **C (Continue)**: Save the content to the document and proceed to next step
+
+## CONTEXT BOUNDARIES:
+
+- All GDD content from previous steps available
+- Epics should map to game pillars and features
+- This creates both GDD epic summary and detailed epics.md file
+
+## Sequence of Instructions (Do not deviate, skip, or optimize)
+
+### 1. Review Game Features for Epic Candidates
+
+**Analyze the GDD content:**
+
+"Let's organize {{game_name}}'s features into development epics.
+
+Based on everything we've defined, here are the major feature areas I've identified:
+
+**From Core Gameplay:** {{core_loop_features}}
+**From Mechanics:** {{mechanics_features}}
+**From Game Type Specifics:** {{game_type_features}}
+**From Progression:** {{progression_features}}
+**From Level Design:** {{level_features}}
+**From Art/Audio:** {{art_audio_features}}
+**From Technical:** {{technical_features}}
+
+**Epic Organization Principles:**
+
+1. **Playable Milestones:** Each epic should result in something playable
+2. **Dependency Awareness:** Some epics must come before others
+3. **Vertical Slices:** Early epics often prove core gameplay
+4. **Scope Control:** 1-4 sprints per epic is ideal
+
+How would you like to group these features into epics?"
+
+### 2. Define Epic Structure
+
+**For each epic, elicit:**
+
+"Let's define **Epic {{number}}: {{epic_name}}**
+
+**Epic Definition Questions:**
+
+1. **Goal:** What does completing this epic achieve?
+2. **Includes:** What features/systems are in this epic?
+3. **Excludes:** What specifically is NOT in this epic?
+4. **Dependencies:** What epics must come before this?
+5. **Deliverable:** What's the playable result?
+
+Describe this epic."
+
+### 3. Generate High-Level Stories
+
+**For each epic, generate story candidates:**
+
+"For **Epic {{number}}: {{epic_name}}**, let's identify high-level stories.
+
+**Story Principles:**
+
+- Each story is independently valuable
+- Stories should be completable in 1-3 days
+- Use format: 'As a [player], I can [action] so that [benefit]'
+
+What are the main stories in this epic?"
+
+### 4. Determine Epic Order and Dependencies
+
+**Guide user through sequencing:**
+
+"Now let's determine the order for these epics.
+
+**Common Epic Sequences:**
+
+1. **Foundation First:** Core systems before content
+2. **Vertical Slice Early:** Prove gameplay ASAP
+3. **Polish Last:** Visual/audio polish after mechanics solid
+
+**Your epics:**
+{{list_of_epics}}
+
+What order makes sense for {{game_name}}?"
+
+### 5. Generate Epic Content
+
+Based on the conversation, prepare two outputs:
+
+**A. GDD Epic Summary (goes in gdd.md):**
+
+```markdown
+## Development Epics
+
+### Epic Overview
+
+| #   | Epic Name | Scope | Dependencies | Est. Stories |
+| --- | --------- | ----- | ------------ | ------------ |
+
+{{epic_table}}
+
+### Recommended Sequence
+
+{{epic_sequence_with_rationale}}
+
+### Vertical Slice
+
+**The first playable milestone:** {{vertical_slice_description}}
+```
+
+**B. Detailed Epics File (goes in epics.md):**
+
+```markdown
+# {{game_name}} - Development Epics
+
+## Epic Overview
+
+{{epic_overview_table}}
+
+---
+
+## Epic 1: {{epic_1_name}}
+
+### Goal
+
+{{epic_1_goal}}
+
+### Scope
+
+**Includes:**
+{{epic_1_includes}}
+
+**Excludes:**
+{{epic_1_excludes}}
+
+### Dependencies
+
+{{epic_1_dependencies}}
+
+### Deliverable
+
+{{epic_1_deliverable}}
+
+### Stories
+
+{{epic_1_stories_list}}
+
+---
+
+{{repeat_for_each_epic}}
+```
+
+### 6. Present Content and Menu
+
+Show the generated content to the user and present:
+
+"I've drafted the Epic Structure based on our conversation.
+
+**For the GDD (gdd.md):**
+[Show GDD epic summary]
+
+**For the Epics file (epics.md):**
+[Show detailed epics structure]
+
+**Validation Check:**
+
+- Does each epic deliver playable value?
+- Is the sequence achievable?
+- Are dependencies clear?
+
+**Select an Option:**
+[A] Advanced Elicitation - Refine epic organization
+[P] Party Mode - Get perspectives on epic structure
+[C] Continue - Save this and move to Success Metrics (Step 13 of 14)"
+
+### 7. 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 epic summary to `{outputFile}`
+- Write detailed epics to `{epicsOutputFile}`
+- Update frontmatter: `stepsCompleted: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]`
+- Load `{nextStepFile}`
+
+## CRITICAL STEP COMPLETION NOTE
+
+ONLY WHEN [C continue option] is selected and [both epic content files saved with frontmatter updated], will you then load and read fully `{nextStepFile}`.
+
+---
+
+## SYSTEM SUCCESS/FAILURE METRICS
+
+### SUCCESS:
+
+- Epics cover all major game features
+- Each epic has clear scope and deliverable
+- Dependencies identified and sequenced
+- Both gdd.md and epics.md updated
+- High-level stories drafted for each epic
+- A/P/C menu presented and handled correctly
+- Frontmatter updated with stepsCompleted
+
+### SYSTEM FAILURE:
+
+- Generating epics without user input
+- Epics that don't deliver playable value
+- Missing key features from GDD
+- Not creating separate epics.md file
+- Not presenting A/P/C menu after content generation
+- Proceeding without user selecting 'C'
+
+**Master Rule:** Skipping steps, optimizing sequences, or not following exact instructions is FORBIDDEN and constitutes SYSTEM FAILURE.
@@ -0,0 +1,251 @@
+---
+name: 'step-13-metrics'
+description: 'Define success metrics for technical and gameplay evaluation'
+
+# Path Definitions
+workflow_path: '{project-root}/_bmad/bmgd/workflows/2-design/gdd'
+
+# File References
+thisStepFile: '{workflow_path}/steps/step-13-metrics.md'
+nextStepFile: '{workflow_path}/steps/step-14-complete.md'
+workflowFile: '{workflow_path}/workflow.md'
+outputFile: '{output_folder}/gdd.md'
+
+# Task References
+advancedElicitationTask: '{project-root}/_bmad/core/workflows/advanced-elicitation/workflow.xml'
+partyModeWorkflow: '{project-root}/_bmad/core/workflows/party-mode/workflow.md'
+---
+
+# Step 13: Success Metrics
+
+**Progress: Step 13 of 14** - Next: Final Steps
+
+## STEP GOAL:
+
+Define measurable success metrics for both technical performance and gameplay quality. These metrics help evaluate whether the game meets its design goals.
+
+## 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
+- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}`
+
+### Role Reinforcement:
+
+- You are a veteran game designer facilitator collaborating with a creative peer
+- Metrics should be measurable and actionable
+- Focus on metrics that indicate design success, not just technical success
+
+### Step-Specific Rules:
+
+- Focus on defining what success looks like
+- FORBIDDEN to generate metrics without user input
+- Metrics should relate back to game pillars and goals
+- Include both quantitative and qualitative measures
+
+## EXECUTION PROTOCOLS:
+
+- Show your analysis before taking any action
+- Present A/P/C menu after generating content
+- ONLY save when user chooses C (Continue)
+- Update frontmatter `stepsCompleted: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13]` before loading next step
+- FORBIDDEN to load next step until C is selected
+
+## COLLABORATION MENUS (A/P/C):
+
+- **A (Advanced Elicitation)**: Deep dive into metric selection
+- **P (Party Mode)**: Get perspectives on success criteria
+- **C (Continue)**: Save the content to the document and proceed to next step
+
+## CONTEXT BOUNDARIES:
+
+- All GDD content from previous steps available
+- Metrics should map to stated goals and pillars
+- Technical metrics from performance requirements
+
+## Sequence of Instructions (Do not deviate, skip, or optimize)
+
+### 1. Technical Metrics Discovery
+
+**Guide user through technical success criteria:**
+
+"Let's define how we'll measure technical success for {{game_name}}.
+
+**Technical Metric Categories:**
+
+| Category        | Example Metrics                                  |
+| --------------- | ------------------------------------------------ |
+| **Performance** | Frame rate consistency, load times, memory usage |
+| **Stability**   | Crash rate, bug severity distribution            |
+| **Platform**    | Certification pass rate, store review score      |
+| **Build**       | Build time, test coverage, asset size            |
+
+**Your performance targets from earlier:**
+
+- Frame rate: {{target_fps}}
+- Platform: {{platform}}
+
+**Questions to consider:**
+
+1. What technical metrics matter most for {{game_type}}?
+2. How will you measure performance in the field?
+3. What's an acceptable crash rate?
+4. Are there platform-specific metrics to track?
+
+What technical metrics will indicate success for {{game_name}}?"
+
+### 2. Gameplay Metrics Discovery
+
+**Guide user through gameplay success criteria:**
+
+"Now let's define gameplay metrics - how we know the design is working.
+
+**Gameplay Metric Categories:**
+
+| Category                | Example Metrics                                   |
+| ----------------------- | ------------------------------------------------- |
+| **Engagement**          | Session length, sessions per week, retention      |
+| **Progression**         | Completion rates, time-to-milestone, churn points |
+| **Difficulty**          | Death/retry rates, difficulty setting usage       |
+| **Feature Usage**       | Which mechanics are used, feature discovery       |
+| **Player Satisfaction** | Ratings, reviews, NPS                             |
+
+**Your game pillars are:** {{pillars}}
+**Your goals are:** {{goals}}
+
+**Questions to consider:**
+
+1. How will you know if players are having the intended experience?
+2. What retention rates would indicate success?
+3. How will you identify frustration points?
+4. What playtesting metrics will you track?
+
+What gameplay metrics will indicate success for {{game_name}}?"
+
+### 3. Qualitative Success Criteria
+
+**Guide user through qualitative measures:**
+
+"Finally, let's define qualitative success criteria - things that are harder to measure but equally important.
+
+**Qualitative Criteria Examples:**
+
+- 'Players describe the game using our pillar words'
+- 'Streamers enjoy playing without instruction'
+- 'Community creates fan content'
+- 'Players recommend to friends'
+- 'Reviews mention the unique selling points'
+
+What qualitative signs would tell you {{game_name}} is successful?"
+
+### 4. Generate Metrics Content
+
+Based on the conversation, prepare the content:
+
+```markdown
+## Success Metrics
+
+### Technical Metrics
+
+{{technical_metrics_list}}
+
+#### Key Technical KPIs
+
+| Metric | Target | Measurement Method |
+| ------ | ------ | ------------------ |
+
+{{technical_kpi_table}}
+
+### Gameplay Metrics
+
+{{gameplay_metrics_list}}
+
+#### Key Gameplay KPIs
+
+| Metric | Target | Measurement Method |
+| ------ | ------ | ------------------ |
+
+{{gameplay_kpi_table}}
+
+### Qualitative Success Criteria
+
+{{qualitative_criteria_list}}
+
+### Metric Review Cadence
+
+{{when_and_how_metrics_will_be_reviewed}}
+```
+
+### 5. Present Content and Menu
+
+Show the generated content to the user and present:
+
+"I've drafted the Success Metrics based on our conversation.
+
+**Here's what I'll add to the document:**
+
+[Show the complete markdown content from step 4]
+
+**Validation Check:**
+
+- Do metrics align with your game pillars?
+- Are targets achievable and measurable?
+- Can you actually collect this data?
+
+**Select an Option:**
+[A] Advanced Elicitation - Refine metric selection
+[P] Party Mode - Get perspectives on success criteria
+[C] Continue - Save this and move to Final Steps (Step 14 of 14)"
+
+### 6. 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, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13]`
+- Load `{nextStepFile}`
+
+## CRITICAL STEP COMPLETION NOTE
+
+ONLY WHEN [C continue option] is selected and [metrics content saved with frontmatter updated], will you then load and read fully `{nextStepFile}`.
+
+---
+
+## SYSTEM SUCCESS/FAILURE METRICS
+
+### SUCCESS:
+
+- Technical metrics defined with targets
+- Gameplay metrics tied to pillars and goals
+- Qualitative criteria documented
+- Metrics are actually measurable
+- A/P/C menu presented and handled correctly
+- Frontmatter updated with stepsCompleted
+
+### SYSTEM FAILURE:
+
+- Generating metrics without user input
+- Metrics that can't be measured
+- Missing connection to game pillars/goals
+- Not presenting A/P/C menu after content generation
+- Proceeding without user selecting 'C'
+
+**Master Rule:** Skipping steps, optimizing sequences, or not following exact instructions is FORBIDDEN and constitutes SYSTEM FAILURE.
@@ -0,0 +1,336 @@
+---
+name: 'step-14-complete'
+description: 'Document out of scope items, capture assumptions, and provide handoff guidance'
+
+# Path Definitions
+workflow_path: '{project-root}/_bmad/bmgd/workflows/2-design/gdd'
+
+# File References
+thisStepFile: '{workflow_path}/steps/step-14-complete.md'
+workflowFile: '{workflow_path}/workflow.md'
+outputFile: '{output_folder}/gdd.md'
+epicsFile: '{output_folder}/epics.md'
+
+# Workflow References
+narrativeWorkflow: '{project-root}/_bmad/bmgd/workflows/2-design/narrative/workflow.yaml'
+architectureWorkflow: '{project-root}/_bmad/bmgd/workflows/3-technical/game-architecture/workflow.yaml'
+---
+
+# Step 14: Complete & Handoff
+
+**Progress: Step 14 of 14** - GDD Complete!
+
+## STEP GOAL:
+
+Document what is explicitly out of scope, capture key assumptions and dependencies, and provide clear next steps for the game development process.
+
+## 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
+- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}`
+
+### Role Reinforcement:
+
+- You are a veteran game designer facilitator collaborating with a creative peer
+- This is the final step - ensure completeness
+- Provide clear actionable next steps
+
+### Step-Specific Rules:
+
+- Focus on scope boundaries and assumptions
+- Check if narrative workflow is recommended
+- Provide concrete next steps based on workflow status
+
+## EXECUTION PROTOCOLS:
+
+- Show your analysis before taking any action
+- Generate final sections without A/P/C menu (just confirmation)
+- Update frontmatter `stepsCompleted: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]`
+- Present completion summary and next steps
+
+## CONTEXT BOUNDARIES:
+
+- All GDD content from previous steps available
+- Check for `needs_narrative` flag from step 7
+- Reference workflow-status if integrated with BMM
+
+## Sequence of Instructions (Do not deviate, skip, or optimize)
+
+### 1. Out of Scope Discovery
+
+**Guide user through scope boundaries:**
+
+"Let's document what is explicitly NOT in scope for {{game_name}} v1.0.
+
+**Out of Scope Categories:**
+
+| Category         | Examples                               |
+| ---------------- | -------------------------------------- |
+| **Features**     | Multiplayer, level editor, mod support |
+| **Content**      | Additional game modes, DLC areas       |
+| **Platforms**    | Console ports, VR version              |
+| **Polish**       | Full voice acting, orchestral score    |
+| **Localization** | Additional languages                   |
+
+**Questions to consider:**
+
+1. What features have you intentionally cut for v1.0?
+2. What platforms are NOT in initial scope?
+3. What post-launch content are you deferring?
+4. What's 'nice to have' vs 'required for launch'?
+
+What's explicitly out of scope for {{game_name}} v1.0?"
+
+### 2. Assumptions and Dependencies Discovery
+
+**Guide user through assumptions:**
+
+"Now let's document key assumptions and dependencies.
+
+**Assumption Categories:**
+
+| Category      | Examples                                                          |
+| ------------- | ----------------------------------------------------------------- |
+| **Technical** | 'Unity LTS will remain stable', 'Players have controllers'        |
+| **Team**      | 'Art contractor available Q2', 'Solo developer capacity'          |
+| **External**  | 'Steam review approval in 2 weeks', 'Asset store assets licensed' |
+| **Market**    | 'Genre remains popular', 'Pricing assumptions'                    |
+
+**Dependency Categories:**
+
+| Category        | Examples                                  |
+| --------------- | ----------------------------------------- |
+| **Third-party** | Middleware, plugins, asset licenses       |
+| **Services**    | Backend providers, analytics, multiplayer |
+| **Content**     | External art, music, voice acting         |
+| **Platform**    | SDK versions, certification requirements  |
+
+What assumptions is {{game_name}} built on? What external dependencies exist?"
+
+### 3. Check Narrative Workflow Recommendation
+
+**Check if game type suggested narrative:**
+
+If `needs_narrative` flag is true (from step 7):
+
+"**Narrative Recommendation:**
+
+Based on your game type ({{game_type}}), a dedicated Narrative Design Document would benefit {{game_name}}. This covers:
+
+- Story structure and arcs
+- Character development
+- World lore and history
+- Dialogue framework
+- Environmental storytelling
+
+Would you like to create a Narrative Design Document as your next step?"
+
+Store user response for next steps.
+
+### 4. Generate Completion Content
+
+Based on the conversation, prepare the content:
+
+```markdown
+## Out of Scope
+
+{{out_of_scope_items}}
+
+### Deferred to Post-Launch
+
+{{post_launch_items}}
+
+---
+
+## Assumptions and Dependencies
+
+### Key Assumptions
+
+{{assumptions_list}}
+
+### External Dependencies
+
+{{dependencies_list}}
+
+### Risk Factors
+
+{{risks_based_on_assumptions}}
+
+---
+
+## Document Information
+
+**Document:** {{game_name}} - Game Design Document
+**Version:** 1.0
+**Created:** {{date}}
+**Author:** {{user_name}}
+**Status:** Complete
+
+### Change Log
+
+| Version | Date     | Changes              |
+| ------- | -------- | -------------------- |
+| 1.0     | {{date}} | Initial GDD complete |
+```
+
+### 5. Present Completion Summary
+
+"**GDD Complete!**
+
+{{user_name}}, the Game Design Document for **{{game_name}}** is now complete!
+
+**Document Summary:**
+
+- **Game Type:** {{game_type}}
+- **Platform:** {{platform}}
+- **Epics:** {{epic_count}} development epics
+- **Estimated Stories:** {{story_estimate}}
+
+**Files Created:**
+
+- `gdd.md` - Full Game Design Document
+- `epics.md` - Detailed epic and story breakdown
+
+**GDD Sections Completed:**
+
+1. Executive Summary & Game Type
+2. Platforms & Target Audience
+3. Goals & Unique Selling Points
+4. Core Gameplay (Pillars, Loop, Win/Loss)
+5. Game Mechanics & Controls
+6. {{game_type}} Specific Design
+7. Progression & Balance
+8. Level Design Framework
+9. Art & Audio Direction
+10. Technical Specifications
+11. Development Epics
+12. Success Metrics
+13. Out of Scope & Assumptions
+
+Do you want me to add or modify anything before we finalize?"
+
+### 6. Present Next Steps
+
+**After user confirms completion:**
+
+"**Next Steps for {{game_name}}:**
+
+{{if needs_narrative and user_wants_narrative}}
+**Immediate Next Step:**
+
+1. **Narrative Design Document** - Create story, characters, and world lore
+   - Command: `narrative` (Game Designer agent)
+   - Input: This GDD
+   - Output: narrative-design.md
+     {{/if}}
+
+**Required Next Steps:**
+
+1. **Game Architecture** - Define engine, tech stack, and system design
+   - Command: `create-architecture` (Game Architect agent)
+   - Input: This GDD
+   - Output: architecture.md
+
+2. **Sprint Planning** - Set up your first development sprint
+   - Command: `sprint-planning` (Scrum Master agent)
+   - Input: GDD + epics.md
+   - Output: sprint-status.yaml
+
+**Recommended Actions:**
+
+- [ ] Review GDD with any team members or stakeholders
+- [ ] Create a prototype for core gameplay validation
+- [ ] Set up project repository and dev environment
+- [ ] Gather reference materials for art direction
+
+**Which would you like to do next?**
+
+1. {{if needs_narrative}}Create Narrative Design Document{{else}}Create Game Architecture{{/if}}
+2. Start Sprint Planning
+3. Review the completed GDD
+4. Exit workflow"
+
+### 7. Handle User Selection
+
+Based on user choice:
+
+**If 1 (Narrative or Architecture):**
+
+- Update frontmatter with final `stepsCompleted: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]`
+- Provide handoff guidance for next workflow
+
+**If 2 (Sprint Planning):**
+
+- Update frontmatter with final stepsCompleted
+- Provide handoff guidance for sprint planning
+
+**If 3 (Review):**
+
+- Present document summary
+- Offer to highlight any sections
+- Return to next steps menu
+
+**If 4 (Exit):**
+
+- Update frontmatter with final stepsCompleted
+- Confirm GDD is saved
+- Exit workflow gracefully
+
+## CRITICAL STEP COMPLETION NOTE
+
+This is the final step. Ensure:
+
+- All content is saved to gdd.md
+- Frontmatter shows all 14 steps completed
+- User has clear actionable next steps
+- Handoff to next workflow is smooth
+
+---
+
+## SYSTEM SUCCESS/FAILURE METRICS
+
+### SUCCESS:
+
+- Out of scope clearly documented
+- Assumptions and dependencies captured
+- Narrative workflow recommendation handled
+- Final document status updated
+- Clear next steps provided
+- Smooth handoff to next workflow
+
+### SYSTEM FAILURE:
+
+- Missing out of scope documentation
+- Not checking for narrative flag
+- No clear next steps provided
+- Frontmatter not updated to show completion
+- User left without actionable guidance
+
+**Master Rule:** Skipping steps, optimizing sequences, or not following exact instructions is FORBIDDEN and constitutes SYSTEM FAILURE.
+
+---
+
+## GDD Workflow Complete
+
+The GDD workflow transforms a game concept into a comprehensive design document through 14 collaborative steps:
+
+1. **Initialize** - Set up workflow and discover input documents
+2. **Context** - Determine game type and load relevant guide
+3. **Platforms** - Define target platforms and audience
+4. **Vision** - Establish goals, context, and USPs
+5. **Core Gameplay** - Define pillars, loop, and win/loss
+6. **Mechanics** - Detail player actions and controls
+7. **Game Type** - Process genre-specific sections
+8. **Progression** - Design player growth and balance
+9. **Levels** - Structure playable content
+10. **Art & Audio** - Establish aesthetic direction
+11. **Technical** - Define performance requirements
+12. **Epics** - Organize features into development units
+13. **Metrics** - Define success criteria
+14. **Complete** - Document scope and hand off
+
+This step-file architecture ensures consistent, thorough GDD creation with user collaboration at every step.