bmad-method 4.43.0 → 4.44.0

package/expansion-packs/bmad-godot-game-dev/tasks/validate-game-story.md

@@ -0,0 +1,208 @@
+# Validate Game Story Task
+
+## Purpose
+
+To comprehensively validate a Godot game development story draft before implementation begins, ensuring it contains all necessary Godot-specific technical context (node architecture, GDScript/C# language strategy, 60+ FPS performance targets), TDD requirements (GUT/GoDotTest), and implementation details. This specialized validation prevents hallucinations, ensures Godot development readiness, and validates game-specific acceptance criteria and testing approaches.
+
+## SEQUENTIAL Task Execution (Do not proceed until current Task is complete)
+
+### 0. Load Core Configuration and Inputs
+
+- Load `.bmad-godot-game-dev/config.yaml` from the project root
+- If the file does not exist, HALT and inform the user: "core-config.yaml not found. This file is required for story validation."
+- Extract key configurations: `devStoryLocation`, `gdd.*`, `gamearchitecture.*`, `workflow.*`
+- Identify and load the following inputs:
+  - **Story file**: The drafted game story to validate (provided by user or discovered in `devStoryLocation`)
+  - **Parent epic**: The epic containing this story's requirements from GDD
+  - **Architecture documents**: Based on configuration (sharded or monolithic)
+  - **Game story template**: `expansion-packs/bmad-godot-game-dev/templates/game-story-tmpl.yaml` for completeness validation
+
+### 1. Game Story Template Completeness Validation
+
+- Load `expansion-packs/bmad-godot-game-dev/templates/game-story-tmpl.yaml` and extract all required sections
+- **Missing sections check**: Compare story sections against game story template sections to verify all Godot-specific sections are present:
+  - Godot Technical Context
+  - Node Architecture & Signal Flow
+  - Scene (.tscn) & Resource (.tres) Requirements
+  - Language Strategy (GDScript vs C#)
+  - Performance Requirements (60+ FPS target)
+  - Platform Export Settings
+  - Integration Points
+  - TDD Testing Strategy (GUT for GDScript, GoDotTest for C#)
+- **Placeholder validation**: Ensure no template placeholders remain unfilled (e.g., `{{EpicNum}}`, `{{StoryNum}}`, `{{GameMechanic}}`, `_TBD_`)
+- **Game-specific sections**: Verify presence of Godot development specific sections
+- **Structure compliance**: Verify story follows game story template structure and formatting
+
+### 2. Godot Project Structure and Resource Validation
+
+- **Godot file paths clarity**: Are Godot-specific paths clearly specified (res://, scenes/, scripts/, resources/, etc.)?
+- **Plugin dependencies**: Are required GDExtensions or addons identified and documented?
+- **Scene structure relevance**: Is relevant node hierarchy and scene tree structure included?
+- **Scene organization**: Are scene instancing and inheritance patterns clearly specified?
+- **Resource pipeline**: Are texture imports, AnimationPlayer resources, and AudioStream assets properly planned?
+- **Directory structure**: Do new Godot resources follow project structure according to architecture docs?
+- **Custom Resource requirements**: Are Resource classes and export presets identified?
+- **Language compliance**: Are GDScript static typing and C# optimization patterns enforced?
+
+### 3. Godot Node Architecture Validation
+
+- **Node class specifications**: Are custom node classes (extending Node2D, Control, etc.) sufficiently detailed?
+- **Node dependencies**: Are node relationships and signal connections clearly mapped?
+- **Godot lifecycle usage**: Are \_ready(), \_process(), \_physics_process() methods appropriately planned?
+- **Signal system integration**: Are signal emissions, connections, and custom signals specified?
+- **Export variable requirements**: Are @export variables and inspector settings clear?
+- **Node interfaces**: Are required node groups and inheritance patterns defined?
+- **Performance considerations**: Are process modes optimized (\_process vs \_physics_process, static typing enforced)?
+
+### 4. Game Mechanics and Systems Validation
+
+- **Core loop integration**: Does the story properly integrate with established game core loop?
+- **Player input handling**: Are InputMap actions and device handling requirements specified?
+- **Game state management**: Are state transitions and save/load system requirements clear?
+- **UI/UX integration**: Are Control nodes, anchoring, and theme system requirements defined?
+- **Audio integration**: Are AudioStreamPlayer nodes, bus routing, and sound pooling specified?
+- **Animation systems**: Are AnimationPlayer, AnimationTree, and transition requirements clear?
+- **Physics integration**: Are RigidBody2D/3D, collision layers, and physics settings specified?
+- **Object pooling**: Are pooling strategies defined for frequently spawned entities?
+
+### 5. Godot-Specific Acceptance Criteria Assessment
+
+- **TDD testing**: Are GUT (GDScript) and GoDotTest (C#) tests defined for all criteria?
+- **Visual validation**: Are visual/aesthetic acceptance criteria measurable and testable?
+- **Performance criteria**: Is 60+ FPS target specified with frame time <16.67ms?
+- **Platform compatibility**: Are export template requirements for different platforms addressed?
+- **Input validation**: Are InputMap actions for keyboard, gamepad, and touch covered?
+- **Audio criteria**: Are audio bus levels, stream players, and audio pooling specified?
+- **Animation validation**: Are AnimationPlayer smoothness, timing, and blend requirements defined?
+
+### 6. Godot Testing and Validation Instructions Review
+
+- **TDD Framework**: Are GUT and GoDotTest approaches with Red-Green-Refactor cycle specified?
+- **Performance profiling**: Are Godot Profiler usage and 60+ FPS validation steps defined?
+- **Export testing**: Are export template validation steps for target platforms specified?
+- **Scene testing**: Are scene instancing, transitions, and signal flow testing approaches clear?
+- **Resource validation**: Are texture compression, import settings, and pooling tests defined?
+- **Platform testing**: Are platform-specific export settings and input methods specified?
+- **Memory leak testing**: Are signal cleanup and node lifecycle validation steps included?
+
+### 7. Godot Performance and Optimization Validation
+
+- **Frame rate targets**: Is 60+ FPS minimum clearly specified for all platforms?
+- **Memory budgets**: Are scene memory, resource memory, and pooling limits defined?
+- **Draw call optimization**: Are rendering batches and viewport optimization approaches specified?
+- **Mobile performance**: Are mobile export settings and touch optimization addressed?
+- **Resource optimization**: Are import settings, compression, and preloading strategies clear?
+- **Language optimization**: Are static typing (GDScript) and C# patterns (no LINQ) specified?
+- **Loading time targets**: Are scene transitions <3 seconds and resource streaming defined?
+
+### 8. Godot Platform and Export Considerations
+
+- **Export templates**: Are platform-specific export templates and settings documented?
+- **Platform features**: Are platform-specific Godot features properly configured?
+- **Data persistence**: Are user:// path usage and save system requirements specified?
+- **Input handling**: Are InputMap configurations for each platform defined?
+- **Performance targets**: Are platform-specific 60+ FPS optimizations addressed?
+- **Export security**: Are release vs debug export settings properly configured?
+
+### 9. Godot Development Task Sequence Validation
+
+- **TDD workflow order**: Do tasks follow TDD cycle (write tests first, then implement, then refactor)?
+- **Node hierarchy dependencies**: Are parent nodes created before child nodes?
+- **Resource dependencies**: Are resources created before scenes that use them?
+- **Signal connections**: Are signal emitters created before receivers?
+- **Testing integration**: Are GUT/GoDotTest creation tasks before implementation?
+- **Export integration**: Are export preset configurations properly sequenced?
+- **Performance validation**: Are profiling checkpoints placed throughout development?
+
+### 10. Godot Anti-Hallucination Verification
+
+- **Godot API accuracy**: Every Godot API reference must be verified against current Godot documentation
+- **Plugin verification**: All GDExtension and addon references must be valid
+- **Node architecture alignment**: Node relationships must match architecture specifications
+- **Performance claims verification**: 60+ FPS targets must be realistic for target platforms
+- **Resource pipeline accuracy**: All import settings and resource configurations must be valid
+- **Language strategy verification**: GDScript vs C# choices must align with performance needs
+
+### 11. Godot Development Agent Implementation Readiness
+
+- **Godot context completeness**: Can the story be implemented without consulting external Godot documentation?
+- **Language specification clarity**: Are GDScript/C# choices and patterns unambiguous?
+- **Resource requirements clarity**: Are all resources, scenes, and import settings defined?
+- **Node relationship clarity**: Are all node interactions and signal flows explicitly defined?
+- **TDD approach completeness**: Are GUT/GoDotTest approaches fully specified?
+- **Performance validation readiness**: Are 60+ FPS validation approaches clearly defined?
+
+### 12. Generate Godot Game Story Validation Report
+
+Provide a structured validation report including:
+
+#### Game Story Template Compliance Issues
+
+- Missing Godot-specific sections from game story template
+- Unfilled placeholders or template variables specific to game development
+- Missing node specifications or resource requirements
+- Missing TDD test specifications (GUT/GoDotTest)
+- Language strategy gaps (GDScript vs C# decisions)
+
+#### Critical Godot Issues (Must Fix - Story Blocked)
+
+- Missing essential Godot technical information for implementation
+- No TDD test specifications (GUT/GoDotTest)
+- Performance targets not meeting 60+ FPS requirement
+- Missing language strategy (GDScript vs C# choices)
+- Incomplete node architecture or signal flow
+- Missing object pooling for spawned entities
+
+#### Godot-Specific Should-Fix Issues (Important Quality Improvements)
+
+- Unclear node hierarchy or signal connection patterns
+- Missing static typing in GDScript specifications
+- Incomplete resource pipeline or import settings
+- Task sequencing not following TDD cycle
+- Missing platform export template specifications
+- Inadequate performance profiling checkpoints
+
+#### Game Development Nice-to-Have Improvements (Optional Enhancements)
+
+- Additional Godot performance optimization context
+- Enhanced resource creation guidance and best practices
+- Clarifications for Godot-specific patterns (signals, groups)
+- Additional platform export considerations
+- Enhanced profiler usage guidance
+
+#### Godot Anti-Hallucination Findings
+
+- Unverifiable Godot API claims or outdated references
+- Wrong language choice justifications (GDScript vs C#)
+- Inconsistencies with Godot project architecture documents
+- Invented nodes, signals, or development patterns
+- Performance claims not achieving 60+ FPS
+- Missing static typing or optimization patterns
+
+#### Godot Platform and Performance Validation
+
+- **Performance Assessment**: 60+ FPS validation, frame time <16.67ms
+- **Platform Compatibility Check**: Export templates, InputMap, platform features
+- **Resource Pipeline Validation**: Import settings, compression, pooling strategies
+- **Godot Version Compliance**: Compatibility with Godot 4.x or 3.x LTS
+- **Language Performance**: Static typing enforcement, C# optimization patterns
+
+#### Final Godot Game Development Assessment
+
+- **GO**: Story ready for Godot implementation with TDD and 60+ FPS targets
+- **NO-GO**: Story requires Godot-specific fixes before implementation
+- **TDD Readiness Score**: 1-10 scale based on test coverage planning
+- **Performance Readiness**: Can maintain 60+ FPS? Yes/No/Unknown
+- **Language Strategy Score**: 1-10 scale for GDScript/C# appropriateness
+- **Platform Export Readiness**: Assessment of export template preparedness
+
+#### Recommended Next Steps
+
+Based on validation results, provide specific recommendations for:
+
+- Godot technical documentation improvements needed
+- TDD test specifications (GUT/GoDotTest) to add
+- Language strategy clarifications (GDScript vs C#)
+- Performance profiling setup for 60+ FPS validation
+- Platform export template configuration needs
+- Object pooling implementation requirements

package/expansion-packs/bmad-godot-game-dev/templates/brainstorming-output-tmpl.yaml

@@ -0,0 +1,156 @@
+template:
+  id: brainstorming-output-template-v2
+  name: Brainstorming Session Results
+  version: 2.0
+  output:
+    format: markdown
+    filename: docs/brainstorming-session-results.md
+    title: "Brainstorming Session Results"
+
+workflow:
+  mode: non-interactive
+
+sections:
+  - id: header
+    content: |
+      **Session Date:** {{date}}
+      **Facilitator:** {{agent_role}} {{agent_name}}
+      **Participant:** {{user_name}}
+
+  - id: executive-summary
+    title: Executive Summary
+    sections:
+      - id: summary-details
+        template: |
+          **Topic:** {{session_topic}}
+
+          **Session Goals:** {{stated_goals}}
+
+          **Techniques Used:** {{techniques_list}}
+
+          **Total Ideas Generated:** {{total_ideas}}
+      - id: key-themes
+        title: "Key Themes Identified:"
+        type: bullet-list
+        template: "- {{theme}}"
+
+  - id: technique-sessions
+    title: Technique Sessions
+    repeatable: true
+    sections:
+      - id: technique
+        title: "{{technique_name}} - {{duration}}"
+        sections:
+          - id: description
+            template: "**Description:** {{technique_description}}"
+          - id: ideas-generated
+            title: "Ideas Generated:"
+            type: numbered-list
+            template: "{{idea}}"
+          - id: insights
+            title: "Insights Discovered:"
+            type: bullet-list
+            template: "- {{insight}}"
+          - id: connections
+            title: "Notable Connections:"
+            type: bullet-list
+            template: "- {{connection}}"
+
+  - id: idea-categorization
+    title: Idea Categorization
+    sections:
+      - id: immediate-opportunities
+        title: Immediate Opportunities
+        content: "*Ideas ready to implement now*"
+        repeatable: true
+        type: numbered-list
+        template: |
+          **{{idea_name}}**
+          - Description: {{description}}
+          - Why immediate: {{rationale}}
+          - Resources needed: {{requirements}}
+      - id: future-innovations
+        title: Future Innovations
+        content: "*Ideas requiring development/research*"
+        repeatable: true
+        type: numbered-list
+        template: |
+          **{{idea_name}}**
+          - Description: {{description}}
+          - Development needed: {{development_needed}}
+          - Timeline estimate: {{timeline}}
+      - id: moonshots
+        title: Moonshots
+        content: "*Ambitious, transformative concepts*"
+        repeatable: true
+        type: numbered-list
+        template: |
+          **{{idea_name}}**
+          - Description: {{description}}
+          - Transformative potential: {{potential}}
+          - Challenges to overcome: {{challenges}}
+      - id: insights-learnings
+        title: Insights & Learnings
+        content: "*Key realizations from the session*"
+        type: bullet-list
+        template: "- {{insight}}: {{description_and_implications}}"
+
+  - id: action-planning
+    title: Action Planning
+    sections:
+      - id: top-priorities
+        title: Top 3 Priority Ideas
+        sections:
+          - id: priority-1
+            title: "#1 Priority: {{idea_name}}"
+            template: |
+              - Rationale: {{rationale}}
+              - Next steps: {{next_steps}}
+              - Resources needed: {{resources}}
+              - Timeline: {{timeline}}
+          - id: priority-2
+            title: "#2 Priority: {{idea_name}}"
+            template: |
+              - Rationale: {{rationale}}
+              - Next steps: {{next_steps}}
+              - Resources needed: {{resources}}
+              - Timeline: {{timeline}}
+          - id: priority-3
+            title: "#3 Priority: {{idea_name}}"
+            template: |
+              - Rationale: {{rationale}}
+              - Next steps: {{next_steps}}
+              - Resources needed: {{resources}}
+              - Timeline: {{timeline}}
+
+  - id: reflection-followup
+    title: Reflection & Follow-up
+    sections:
+      - id: what-worked
+        title: What Worked Well
+        type: bullet-list
+        template: "- {{aspect}}"
+      - id: areas-exploration
+        title: Areas for Further Exploration
+        type: bullet-list
+        template: "- {{area}}: {{reason}}"
+      - id: recommended-techniques
+        title: Recommended Follow-up Techniques
+        type: bullet-list
+        template: "- {{technique}}: {{reason}}"
+      - id: questions-emerged
+        title: Questions That Emerged
+        type: bullet-list
+        template: "- {{question}}"
+      - id: next-session
+        title: Next Session Planning
+        template: |
+          - **Suggested topics:** {{followup_topics}}
+          - **Recommended timeframe:** {{timeframe}}
+          - **Preparation needed:** {{preparation}}
+
+  - id: footer
+    content: |
+      ---
+
+      *Session facilitated using the BMAD-METHOD brainstorming framework*

package/expansion-packs/bmad-godot-game-dev/templates/brownfield-prd-tmpl.yaml

@@ -0,0 +1,281 @@
+# <!-- Powered by BMAD™ Core -->
+template:
+  id: brownfield-prd-template-v2
+  name: Brownfield Enhancement PRD
+  version: 2.0
+  output:
+    format: markdown
+    filename: docs/prd.md
+    title: "{{project_name}} Brownfield Enhancement PRD"
+
+workflow:
+  mode: interactive
+  elicitation: advanced-elicitation
+
+sections:
+  - id: intro-analysis
+    title: Intro Project Analysis and Context
+    instruction: |
+      IMPORTANT - SCOPE ASSESSMENT REQUIRED:
+
+      This PRD is for SIGNIFICANT enhancements to existing projects that require comprehensive planning and multiple stories. Before proceeding:
+
+      1. **Assess Enhancement Complexity**: If this is a simple feature addition or bug fix that could be completed in 1-2 focused development sessions, STOP and recommend: "For simpler changes, consider using the brownfield-create-epic or brownfield-create-story task with the Product Owner instead. This full PRD process is designed for substantial enhancements that require architectural planning and multiple coordinated stories."
+
+      2. **Project Context**: Determine if we're working in an IDE with the project already loaded or if the user needs to provide project information. If project files are available, analyze existing documentation in the docs folder. If insufficient documentation exists, recommend running the document-project task first.
+
+      3. **Deep Assessment Requirement**: You MUST thoroughly analyze the existing project structure, patterns, and constraints before making ANY suggestions. Every recommendation must be grounded in actual project analysis, not assumptions.
+
+      Gather comprehensive information about the existing project. This section must be completed before proceeding with requirements.
+
+      CRITICAL: Throughout this analysis, explicitly confirm your understanding with the user. For every assumption you make about the existing project, ask: "Based on my analysis, I understand that [assumption]. Is this correct?"
+
+      Do not proceed with any recommendations until the user has validated your understanding of the existing system.
+    sections:
+      - id: existing-project-overview
+        title: Existing Project Overview
+        instruction: Check if document-project analysis was already performed. If yes, reference that output instead of re-analyzing.
+        sections:
+          - id: analysis-source
+            title: Analysis Source
+            instruction: |
+              Indicate one of the following:
+              - Document-project output available at: {{path}}
+              - IDE-based fresh analysis
+              - User-provided information
+          - id: current-state
+            title: Current Project State
+            instruction: |
+              - If document-project output exists: Extract summary from "High Level Architecture" and "Technical Summary" sections
+              - Otherwise: Brief description of what the project currently does and its primary purpose
+      - id: documentation-analysis
+        title: Available Documentation Analysis
+        instruction: |
+          If document-project was run:
+          - Note: "Document-project analysis available - using existing technical documentation"
+          - List key documents created by document-project
+          - Skip the missing documentation check below
+
+          Otherwise, check for existing documentation:
+        sections:
+          - id: available-docs
+            title: Available Documentation
+            type: checklist
+            items:
+              - Tech Stack Documentation [[LLM: If from document-project, check ✓]]
+              - Source Tree/Architecture [[LLM: If from document-project, check ✓]]
+              - Coding Standards [[LLM: If from document-project, may be partial]]
+              - API Documentation [[LLM: If from document-project, check ✓]]
+              - External API Documentation [[LLM: If from document-project, check ✓]]
+              - UX/UI Guidelines [[LLM: May not be in document-project]]
+              - Technical Debt Documentation [[LLM: If from document-project, check ✓]]
+              - "Other: {{other_docs}}"
+            instruction: |
+              - If document-project was already run: "Using existing project analysis from document-project output."
+              - If critical documentation is missing and no document-project: "I recommend running the document-project task first..."
+      - id: enhancement-scope
+        title: Enhancement Scope Definition
+        instruction: Work with user to clearly define what type of enhancement this is. This is critical for scoping and approach.
+        sections:
+          - id: enhancement-type
+            title: Enhancement Type
+            type: checklist
+            instruction: Determine with user which applies
+            items:
+              - New Feature Addition
+              - Major Feature Modification
+              - Integration with New Systems
+              - Performance/Scalability Improvements
+              - UI/UX Overhaul
+              - Technology Stack Upgrade
+              - Bug Fix and Stability Improvements
+              - "Other: {{other_type}}"
+          - id: enhancement-description
+            title: Enhancement Description
+            instruction: 2-3 sentences describing what the user wants to add or change
+          - id: impact-assessment
+            title: Impact Assessment
+            type: checklist
+            instruction: Assess the scope of impact on existing codebase
+            items:
+              - Minimal Impact (isolated additions)
+              - Moderate Impact (some existing code changes)
+              - Significant Impact (substantial existing code changes)
+              - Major Impact (architectural changes required)
+      - id: goals-context
+        title: Goals and Background Context
+        sections:
+          - id: goals
+            title: Goals
+            type: bullet-list
+            instruction: Bullet list of 1-line desired outcomes this enhancement will deliver if successful
+          - id: background
+            title: Background Context
+            type: paragraphs
+            instruction: 1-2 short paragraphs explaining why this enhancement is needed, what problem it solves, and how it fits with the existing project
+      - id: changelog
+        title: Change Log
+        type: table
+        columns: [Change, Date, Version, Description, Author]
+
+  - id: requirements
+    title: Requirements
+    instruction: |
+      Draft functional and non-functional requirements based on your validated understanding of the existing project. Before presenting requirements, confirm: "These requirements are based on my understanding of your existing system. Please review carefully and confirm they align with your project's reality."
+    elicit: true
+    sections:
+      - id: functional
+        title: Functional
+        type: numbered-list
+        prefix: FR
+        instruction: Each Requirement will be a bullet markdown with identifier starting with FR
+        examples:
+          - "FR1: The existing Todo List will integrate with the new AI duplicate detection service without breaking current functionality."
+      - id: non-functional
+        title: Non Functional
+        type: numbered-list
+        prefix: NFR
+        instruction: Each Requirement will be a bullet markdown with identifier starting with NFR. Include constraints from existing system
+        examples:
+          - "NFR1: Enhancement must maintain existing performance characteristics and not exceed current memory usage by more than 20%."
+      - id: compatibility
+        title: Compatibility Requirements
+        instruction: Critical for brownfield - what must remain compatible
+        type: numbered-list
+        prefix: CR
+        template: "{{requirement}}: {{description}}"
+        items:
+          - id: cr1
+            template: "CR1: {{existing_api_compatibility}}"
+          - id: cr2
+            template: "CR2: {{database_schema_compatibility}}"
+          - id: cr3
+            template: "CR3: {{ui_ux_consistency}}"
+          - id: cr4
+            template: "CR4: {{integration_compatibility}}"
+
+  - id: ui-enhancement-goals
+    title: User Interface Enhancement Goals
+    condition: Enhancement includes UI changes
+    instruction: For UI changes, capture how they will integrate with existing UI patterns and design systems
+    sections:
+      - id: existing-ui-integration
+        title: Integration with Existing UI
+        instruction: Describe how new UI elements will fit with existing design patterns, style guides, and component libraries
+      - id: modified-screens
+        title: Modified/New Screens and Views
+        instruction: List only the screens/views that will be modified or added
+      - id: ui-consistency
+        title: UI Consistency Requirements
+        instruction: Specific requirements for maintaining visual and interaction consistency with existing application
+
+  - id: technical-constraints
+    title: Technical Constraints and Integration Requirements
+    instruction: This section replaces separate architecture documentation. Gather detailed technical constraints from existing project analysis.
+    sections:
+      - id: existing-tech-stack
+        title: Existing Technology Stack
+        instruction: |
+          If document-project output available:
+          - Extract from "Actual Tech Stack" table in High Level Architecture section
+          - Include version numbers and any noted constraints
+
+          Otherwise, document the current technology stack:
+        template: |
+          **Languages**: {{languages}}
+          **Frameworks**: {{frameworks}}
+          **Database**: {{database}}
+          **Infrastructure**: {{infrastructure}}
+          **External Dependencies**: {{external_dependencies}}
+      - id: integration-approach
+        title: Integration Approach
+        instruction: Define how the enhancement will integrate with existing architecture
+        template: |
+          **Database Integration Strategy**: {{database_integration}}
+          **API Integration Strategy**: {{api_integration}}
+          **Frontend Integration Strategy**: {{frontend_integration}}
+          **Testing Integration Strategy**: {{testing_integration}}
+      - id: code-organization
+        title: Code Organization and Standards
+        instruction: Based on existing project analysis, define how new code will fit existing patterns
+        template: |
+          **File Structure Approach**: {{file_structure}}
+          **Naming Conventions**: {{naming_conventions}}
+          **Coding Standards**: {{coding_standards}}
+          **Documentation Standards**: {{documentation_standards}}
+      - id: deployment-operations
+        title: Deployment and Operations
+        instruction: How the enhancement fits existing deployment pipeline
+        template: |
+          **Build Process Integration**: {{build_integration}}
+          **Deployment Strategy**: {{deployment_strategy}}
+          **Monitoring and Logging**: {{monitoring_logging}}
+          **Configuration Management**: {{config_management}}
+      - id: risk-assessment
+        title: Risk Assessment and Mitigation
+        instruction: |
+          If document-project output available:
+          - Reference "Technical Debt and Known Issues" section
+          - Include "Workarounds and Gotchas" that might impact enhancement
+          - Note any identified constraints from "Critical Technical Debt"
+
+          Build risk assessment incorporating existing known issues:
+        template: |
+          **Technical Risks**: {{technical_risks}}
+          **Integration Risks**: {{integration_risks}}
+          **Deployment Risks**: {{deployment_risks}}
+          **Mitigation Strategies**: {{mitigation_strategies}}
+
+  - id: epic-structure
+    title: Epic and Story Structure
+    instruction: |
+      For brownfield projects, favor a single comprehensive epic unless the user is clearly requesting multiple unrelated enhancements. Before presenting the epic structure, confirm: "Based on my analysis of your existing project, I believe this enhancement should be structured as [single epic/multiple epics] because [rationale based on actual project analysis]. Does this align with your understanding of the work required?"
+    elicit: true
+    sections:
+      - id: epic-approach
+        title: Epic Approach
+        instruction: Explain the rationale for epic structure - typically single epic for brownfield unless multiple unrelated features
+        template: "**Epic Structure Decision**: {{epic_decision}} with rationale"
+
+  - id: epic-details
+    title: "Epic 1: {{enhancement_title}}"
+    instruction: |
+      Comprehensive epic that delivers the brownfield enhancement while maintaining existing functionality
+
+      CRITICAL STORY SEQUENCING FOR BROWNFIELD:
+      - Stories must ensure existing functionality remains intact
+      - Each story should include verification that existing features still work
+      - Stories should be sequenced to minimize risk to existing system
+      - Include rollback considerations for each story
+      - Focus on incremental integration rather than big-bang changes
+      - Size stories for AI agent execution in existing codebase context
+      - MANDATORY: Present the complete story sequence and ask: "This story sequence is designed to minimize risk to your existing system. Does this order make sense given your project's architecture and constraints?"
+      - Stories must be logically sequential with clear dependencies identified
+      - Each story must deliver value while maintaining system integrity
+    template: |
+      **Epic Goal**: {{epic_goal}}
+
+      **Integration Requirements**: {{integration_requirements}}
+    sections:
+      - id: story
+        title: "Story 1.{{story_number}} {{story_title}}"
+        repeatable: true
+        template: |
+          As a {{user_type}},
+          I want {{action}},
+          so that {{benefit}}.
+        sections:
+          - id: acceptance-criteria
+            title: Acceptance Criteria
+            type: numbered-list
+            instruction: Define criteria that include both new functionality and existing system integrity
+            item_template: "{{criterion_number}}: {{criteria}}"
+          - id: integration-verification
+            title: Integration Verification
+            instruction: Specific verification steps to ensure existing functionality remains intact
+            type: numbered-list
+            prefix: IV
+            items:
+              - template: "IV1: {{existing_functionality_verification}}"
+              - template: "IV2: {{integration_point_verification}}"
+              - template: "IV3: {{performance_impact_verification}}"