bmad-method 4.43.0 → 4.44.0

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

@@ -0,0 +1,149 @@
+<!-- Powered by BMAD™ Core -->
+
+# Create Brownfield Story Task
+
+## Purpose
+
+Create a single user story for very small brownfield enhancements that can be completed in one focused development session. This task is for minimal additions or bug fixes that require existing system integration awareness.
+
+## When to Use This Task
+
+**Use this task when:**
+
+- The enhancement can be completed in a single story
+- No new architecture or significant design is required
+- The change follows existing patterns exactly
+- Integration is straightforward with minimal risk
+- Change is isolated with clear boundaries
+
+**Use brownfield-create-epic when:**
+
+- The enhancement requires 2-3 coordinated stories
+- Some design work is needed
+- Multiple integration points are involved
+
+**Use the full brownfield PRD/Architecture process when:**
+
+- The enhancement requires multiple coordinated stories
+- Architectural planning is needed
+- Significant integration work is required
+
+## Instructions
+
+### 1. Quick Project Assessment
+
+Gather minimal but essential context about the existing project:
+
+**Current System Context:**
+
+- [ ] Relevant existing functionality identified
+- [ ] Technology stack for this area noted
+- [ ] Integration point(s) clearly understood
+- [ ] Existing patterns for similar work identified
+
+**Change Scope:**
+
+- [ ] Specific change clearly defined
+- [ ] Impact boundaries identified
+- [ ] Success criteria established
+
+### 2. Story Creation
+
+Create a single focused story following this structure:
+
+#### Story Title
+
+{{Specific Enhancement}} - Brownfield Addition
+
+#### User Story
+
+As a {{user type}},
+I want {{specific action/capability}},
+So that {{clear benefit/value}}.
+
+#### Story Context
+
+**Existing System Integration:**
+
+- Integrates with: {{existing component/system}}
+- Technology: {{relevant tech stack}}
+- Follows pattern: {{existing pattern to follow}}
+- Touch points: {{specific integration points}}
+
+#### Acceptance Criteria
+
+**Functional Requirements:**
+
+1. {{Primary functional requirement}}
+2. {{Secondary functional requirement (if any)}}
+3. {{Integration requirement}}
+
+**Integration Requirements:** 4. Existing {{relevant functionality}} continues to work unchanged 5. New functionality follows existing {{pattern}} pattern 6. Integration with {{system/component}} maintains current behavior
+
+**Quality Requirements:** 7. Change is covered by appropriate tests 8. Documentation is updated if needed 9. No regression in existing functionality verified
+
+#### Technical Notes
+
+- **Integration Approach:** {{how it connects to existing system}}
+- **Existing Pattern Reference:** {{link or description of pattern to follow}}
+- **Key Constraints:** {{any important limitations or requirements}}
+
+#### Definition of Done
+
+- [ ] Functional requirements met
+- [ ] Integration requirements verified
+- [ ] Existing functionality regression tested
+- [ ] Code follows existing patterns and standards
+- [ ] Tests pass (existing and new)
+- [ ] Documentation updated if applicable
+
+### 3. Risk and Compatibility Check
+
+**Minimal Risk Assessment:**
+
+- **Primary Risk:** {{main risk to existing system}}
+- **Mitigation:** {{simple mitigation approach}}
+- **Rollback:** {{how to undo if needed}}
+
+**Compatibility Verification:**
+
+- [ ] No breaking changes to existing APIs
+- [ ] Database changes (if any) are additive only
+- [ ] UI changes follow existing design patterns
+- [ ] Performance impact is negligible
+
+### 4. Validation Checklist
+
+Before finalizing the story, confirm:
+
+**Scope Validation:**
+
+- [ ] Story can be completed in one development session
+- [ ] Integration approach is straightforward
+- [ ] Follows existing patterns exactly
+- [ ] No design or architecture work required
+
+**Clarity Check:**
+
+- [ ] Story requirements are unambiguous
+- [ ] Integration points are clearly specified
+- [ ] Success criteria are testable
+- [ ] Rollback approach is simple
+
+## Success Criteria
+
+The story creation is successful when:
+
+1. Enhancement is clearly defined and appropriately scoped for single session
+2. Integration approach is straightforward and low-risk
+3. Existing system patterns are identified and will be followed
+4. Rollback plan is simple and feasible
+5. Acceptance criteria include existing functionality verification
+
+## Important Notes
+
+- This task is for VERY SMALL brownfield changes only
+- If complexity grows during analysis, escalate to brownfield-create-epic
+- Always prioritize existing system integrity
+- When in doubt about integration complexity, use brownfield-create-epic instead
+- Stories should take no more than 4 hours of focused development work

package/expansion-packs/bmad-godot-game-dev/tasks/correct-course-game.md

@@ -0,0 +1,159 @@
+# Correct Course Task - Godot Game Development
+
+## Purpose
+
+- Guide a structured response to Godot game development change triggers using the `.bmad-godot-game-dev/checklists/game-change-checklist`.
+- Analyze the impacts of changes on game features, node systems, and performance targets (60+ FPS).
+- Explore Godot-specific solutions (e.g., GDScript vs C# optimization, scene restructuring, platform export adjustments).
+- Draft specific, actionable proposed updates to affected game artifacts (e.g., GDD sections, technical specs, Godot project settings).
+- Produce a consolidated "Godot Game Development Change Proposal" document for review and approval.
+- Ensure clear handoff path for changes requiring fundamental redesign, language migration, or architecture updates.
+
+## Instructions
+
+### 1. Initial Setup & Mode Selection
+
+- **Acknowledge Task & Inputs:**
+  - Confirm with the user that the "Godot Game Development Correct Course Task" is being initiated.
+  - Verify the change trigger (e.g., 60+ FPS performance issue, GDScript/C# migration need, node system refactor, platform export problem).
+  - Confirm access to relevant game artifacts:
+    - Game Design Document (GDD)
+    - Technical Design Documents
+    - Godot Architecture specifications (node hierarchy, signal flow)
+    - Performance budgets (60+ FPS minimum) and platform requirements
+    - Current sprint's game stories with TDD test coverage
+    - Asset import settings and resource management
+    - Language strategy documentation (GDScript vs C#)
+  - Confirm access to `.bmad-godot-game-dev/checklists/game-change-checklist`.
+
+- **Establish Interaction Mode:**
+  - Ask the user their preferred interaction mode:
+    - **"Incrementally (Default & Recommended):** Work through the game-change-checklist section by section, discussing findings and drafting changes collaboratively. Best for complex node restructuring, language migrations, or performance optimizations."
+    - **"YOLO Mode (Batch Processing):** Conduct batched analysis and present consolidated findings. Suitable for straightforward scene optimizations or export setting adjustments."
+  - Confirm the selected mode and inform: "We will now use the game-change-checklist to analyze the change and draft proposed updates specific to our Godot game development context with 60+ FPS targets and TDD practices."
+
+### 2. Execute Game Development Checklist Analysis
+
+- Systematically work through the game-change-checklist sections:
+  1. **Change Context & Game Impact**
+  2. **Feature/System Impact Analysis**
+  3. **Technical Artifact Conflict Resolution**
+  4. **Performance & Platform Evaluation**
+  5. **Path Forward Recommendation**
+
+- For each checklist section:
+  - Present Godot-specific prompts and considerations
+  - Analyze impacts on:
+    - Godot scenes and node hierarchies
+    - Signal connections and dependencies
+    - Performance metrics (60+ FPS requirement, frame time, draw calls)
+    - GDScript vs C# language boundaries
+    - Resource loading and object pooling
+    - Platform export templates and settings
+    - TDD test coverage (GUT for GDScript, GoDotTest for C#)
+  - Discuss findings with performance profiler data
+  - Record status: `[x] Addressed`, `[N/A]`, `[!] Further Action Needed`
+  - Document Godot-specific decisions and language choices
+
+### 3. Draft Game-Specific Proposed Changes
+
+Based on the analysis and agreed path forward:
+
+- **Identify affected game artifacts requiring updates:**
+  - GDD sections (mechanics, systems, progression)
+  - Technical specifications (node architecture, 60+ FPS targets)
+  - Godot-specific configurations (project settings, export presets)
+  - Game story modifications (TDD requirements, language choices)
+  - Resource import settings and compression
+  - Platform export template configurations
+  - Test suite updates (GUT/GoDotTest coverage)
+
+- **Draft explicit changes for each artifact:**
+  - **Game Stories:** Revise story text, TDD test requirements, GDScript/C# language selection
+  - **Technical Specs:** Update node hierarchies, signal architectures, 60+ FPS validation
+  - **Godot Configurations:** Propose project settings, rendering options, export templates
+  - **GDD Updates:** Modify feature descriptions, balance parameters, progression systems
+  - **Resource Specifications:** Adjust import settings, compression, pooling strategies
+  - **Performance Targets:** Ensure 60+ FPS minimum, frame time <16.67ms, draw call budgets
+  - **Test Coverage:** Update GUT tests for GDScript, GoDotTest for C# components
+
+- **Include Godot-specific details:**
+  - Scene tree structure changes
+  - Node composition updates
+  - Signal refactoring needs
+  - Shader/material optimizations
+  - Language migration paths (GDScript ↔ C#)
+  - Object pooling implementations
+  - Export preset modifications
+
+### 4. Generate "Godot Game Development Change Proposal"
+
+- Create a comprehensive proposal document containing:
+
+  **A. Change Summary:**
+  - Original issue (60+ FPS violation, language inefficiency, node bottleneck)
+  - Godot systems affected (scenes, nodes, signals)
+  - Platform/performance implications (frame time impact)
+  - Chosen solution approach (GDScript optimization, C# migration, pooling)
+
+  **B. Technical Impact Analysis:**
+  - Godot node architecture changes needed
+  - Performance implications (profiler metrics, FPS measurements)
+  - Language strategy adjustments (GDScript vs C# boundaries)
+  - Resource loading and pooling modifications
+  - Platform export compatibility effects
+  - TDD test suite impacts (GUT/GoDotTest coverage)
+
+  **C. Specific Proposed Edits:**
+  - For each game story: "Change Story GS-X.Y from: [old] To: [new with TDD requirements]"
+  - For technical specs: "Update Godot Architecture Section X: [node/signal changes]"
+  - For GDD: "Modify [Feature] in Section Y: [updates with performance targets]"
+  - For project.godot: "Change [Setting] from [old_value] to [new_value]"
+  - For language strategy: "Migrate [System] from GDScript to C# for performance"
+
+  **D. Implementation Considerations:**
+  - Required Godot version (4.x vs 3.x LTS)
+  - Resource reimport with optimized settings
+  - Scene and node refactoring requirements
+  - GDScript static typing enforcement
+  - C# performance optimization needs
+  - Object pooling implementation
+  - Platform export template testing
+  - TDD test updates (Red-Green-Refactor cycle)
+
+### 5. Finalize & Determine Next Steps
+
+- Obtain explicit approval for the "Godot Game Development Change Proposal"
+- Verify 60+ FPS targets are maintained post-change
+- Provide the finalized document to the user
+
+- **Based on change scope:**
+  - **Minor adjustments (can be handled in current sprint):**
+    - Confirm task completion
+    - Verify TDD tests are updated
+    - Suggest handoff to game-developer agent for implementation
+    - Note required performance profiling validation
+  - **Major changes (require replanning):**
+    - Clearly state need for deeper technical review
+    - Recommend engaging Game Architect for node restructuring
+    - Evaluate language migration complexity (GDScript ↔ C#)
+    - Provide proposal as input for architecture revision
+    - Flag any 60+ FPS risks or TDD coverage gaps
+
+## Output Deliverables
+
+- **Primary:** "Godot Game Development Change Proposal" document containing:
+  - Godot-specific change analysis
+  - Technical impact assessment with node/signal context
+  - Language strategy implications (GDScript vs C#)
+  - Performance validation against 60+ FPS target
+  - Clearly drafted updates for all affected game artifacts
+  - TDD test coverage requirements
+  - Implementation guidance following Carmack's optimization principles
+
+- **Secondary:** Annotated game-change-checklist showing:
+  - Technical decisions made (node architecture, language choices)
+  - Performance trade-offs considered (profiler data)
+  - Platform export accommodations
+  - Godot-specific implementation notes
+  - Required test updates (GUT/GoDotTest)

package/expansion-packs/bmad-godot-game-dev/tasks/create-deep-research-prompt.md

@@ -0,0 +1,278 @@
+# Create Deep Research Prompt Task
+
+This task helps create comprehensive research prompts for various types of deep analysis. It can process inputs from brainstorming sessions, project briefs, market research, or specific research questions to generate targeted prompts for deeper investigation.
+
+## Purpose
+
+Generate well-structured research prompts that:
+
+- Define clear research objectives and scope
+- Specify appropriate research methodologies
+- Outline expected deliverables and formats
+- Guide systematic investigation of complex topics
+- Ensure actionable insights are captured
+
+## Research Type Selection
+
+CRITICAL: First, help the user select the most appropriate research focus based on their needs and any input documents they've provided.
+
+### 1. Research Focus Options
+
+Present these numbered options to the user:
+
+1. **Product Validation Research**
+   - Validate product hypotheses and market fit
+   - Test assumptions about user needs and solutions
+   - Assess technical and business feasibility
+   - Identify risks and mitigation strategies
+
+2. **Market Opportunity Research**
+   - Analyze market size and growth potential
+   - Identify market segments and dynamics
+   - Assess market entry strategies
+   - Evaluate timing and market readiness
+
+3. **User & Customer Research**
+   - Deep dive into user personas and behaviors
+   - Understand jobs-to-be-done and pain points
+   - Map customer journeys and touchpoints
+   - Analyze willingness to pay and value perception
+
+4. **Competitive Intelligence Research**
+   - Detailed competitor analysis and positioning
+   - Feature and capability comparisons
+   - Business model and strategy analysis
+   - Identify competitive advantages and gaps
+
+5. **Technology & Innovation Research**
+   - Assess technology trends and possibilities
+   - Evaluate technical approaches and architectures
+   - Identify emerging technologies and disruptions
+   - Analyze build vs. buy vs. partner options
+
+6. **Industry & Ecosystem Research**
+   - Map industry value chains and dynamics
+   - Identify key players and relationships
+   - Analyze regulatory and compliance factors
+   - Understand partnership opportunities
+
+7. **Strategic Options Research**
+   - Evaluate different strategic directions
+   - Assess business model alternatives
+   - Analyze go-to-market strategies
+   - Consider expansion and scaling paths
+
+8. **Risk & Feasibility Research**
+   - Identify and assess various risk factors
+   - Evaluate implementation challenges
+   - Analyze resource requirements
+   - Consider regulatory and legal implications
+
+9. **Custom Research Focus**
+   - User-defined research objectives
+   - Specialized domain investigation
+   - Cross-functional research needs
+
+### 2. Input Processing
+
+**If Project Brief provided:**
+
+- Extract key product concepts and goals
+- Identify target users and use cases
+- Note technical constraints and preferences
+- Highlight uncertainties and assumptions
+
+**If Brainstorming Results provided:**
+
+- Synthesize main ideas and themes
+- Identify areas needing validation
+- Extract hypotheses to test
+- Note creative directions to explore
+
+**If Market Research provided:**
+
+- Build on identified opportunities
+- Deepen specific market insights
+- Validate initial findings
+- Explore adjacent possibilities
+
+**If Starting Fresh:**
+
+- Gather essential context through questions
+- Define the problem space
+- Clarify research objectives
+- Establish success criteria
+
+## Process
+
+### 3. Research Prompt Structure
+
+CRITICAL: collaboratively develop a comprehensive research prompt with these components.
+
+#### A. Research Objectives
+
+CRITICAL: collaborate with the user to articulate clear, specific objectives for the research.
+
+- Primary research goal and purpose
+- Key decisions the research will inform
+- Success criteria for the research
+- Constraints and boundaries
+
+#### B. Research Questions
+
+CRITICAL: collaborate with the user to develop specific, actionable research questions organized by theme.
+
+**Core Questions:**
+
+- Central questions that must be answered
+- Priority ranking of questions
+- Dependencies between questions
+
+**Supporting Questions:**
+
+- Additional context-building questions
+- Nice-to-have insights
+- Future-looking considerations
+
+#### C. Research Methodology
+
+**Data Collection Methods:**
+
+- Secondary research sources
+- Primary research approaches (if applicable)
+- Data quality requirements
+- Source credibility criteria
+
+**Analysis Frameworks:**
+
+- Specific frameworks to apply
+- Comparison criteria
+- Evaluation methodologies
+- Synthesis approaches
+
+#### D. Output Requirements
+
+**Format Specifications:**
+
+- Executive summary requirements
+- Detailed findings structure
+- Visual/tabular presentations
+- Supporting documentation
+
+**Key Deliverables:**
+
+- Must-have sections and insights
+- Decision-support elements
+- Action-oriented recommendations
+- Risk and uncertainty documentation
+
+### 4. Prompt Generation
+
+**Research Prompt Template:**
+
+```markdown
+## Research Objective
+
+[Clear statement of what this research aims to achieve]
+
+## Background Context
+
+[Relevant information from project brief, brainstorming, or other inputs]
+
+## Research Questions
+
+### Primary Questions (Must Answer)
+
+1. [Specific, actionable question]
+2. [Specific, actionable question]
+   ...
+
+### Secondary Questions (Nice to Have)
+
+1. [Supporting question]
+2. [Supporting question]
+   ...
+
+## Research Methodology
+
+### Information Sources
+
+- [Specific source types and priorities]
+
+### Analysis Frameworks
+
+- [Specific frameworks to apply]
+
+### Data Requirements
+
+- [Quality, recency, credibility needs]
+
+## Expected Deliverables
+
+### Executive Summary
+
+- Key findings and insights
+- Critical implications
+- Recommended actions
+
+### Detailed Analysis
+
+[Specific sections needed based on research type]
+
+### Supporting Materials
+
+- Data tables
+- Comparison matrices
+- Source documentation
+
+## Success Criteria
+
+[How to evaluate if research achieved its objectives]
+
+## Timeline and Priority
+
+[If applicable, any time constraints or phasing]
+```
+
+### 5. Review and Refinement
+
+1. **Present Complete Prompt**
+   - Show the full research prompt
+   - Explain key elements and rationale
+   - Highlight any assumptions made
+
+2. **Gather Feedback**
+   - Are the objectives clear and correct?
+   - Do the questions address all concerns?
+   - Is the scope appropriate?
+   - Are output requirements sufficient?
+
+3. **Refine as Needed**
+   - Incorporate user feedback
+   - Adjust scope or focus
+   - Add missing elements
+   - Clarify ambiguities
+
+### 6. Next Steps Guidance
+
+**Execution Options:**
+
+1. **Use with AI Research Assistant**: Provide this prompt to an AI model with research capabilities
+2. **Guide Human Research**: Use as a framework for manual research efforts
+3. **Hybrid Approach**: Combine AI and human research using this structure
+
+**Integration Points:**
+
+- How findings will feed into next phases
+- Which team members should review results
+- How to validate findings
+- When to revisit or expand research
+
+## Important Notes
+
+- The quality of the research prompt directly impacts the quality of insights gathered
+- Be specific rather than general in research questions
+- Consider both current state and future implications
+- Balance comprehensiveness with focus
+- Document assumptions and limitations clearly
+- Plan for iterative refinement based on initial findings

package/expansion-packs/bmad-godot-game-dev/tasks/create-doc.md

@@ -0,0 +1,103 @@
+<!-- Powered by BMAD™ Core -->
+
+# Create Document from Template (YAML Driven)
+
+## ⚠️ CRITICAL EXECUTION NOTICE ⚠️
+
+**THIS IS AN EXECUTABLE WORKFLOW - NOT REFERENCE MATERIAL**
+
+When this task is invoked:
+
+1. **DISABLE ALL EFFICIENCY OPTIMIZATIONS** - This workflow requires full user interaction
+2. **MANDATORY STEP-BY-STEP EXECUTION** - Each section must be processed sequentially with user feedback
+3. **ELICITATION IS REQUIRED** - When `elicit: true`, you MUST use the 1-9 format and wait for user response
+4. **NO SHORTCUTS ALLOWED** - Complete documents cannot be created without following this workflow
+
+**VIOLATION INDICATOR:** If you create a complete document without user interaction, you have violated this workflow.
+
+## Critical: Template Discovery
+
+If a YAML Template has not been provided, list all templates from .bmad-core/templates or ask the user to provide another.
+
+## CRITICAL: Mandatory Elicitation Format
+
+**When `elicit: true`, this is a HARD STOP requiring user interaction:**
+
+**YOU MUST:**
+
+1. Present section content
+2. Provide detailed rationale (explain trade-offs, assumptions, decisions made)
+3. **STOP and present numbered options 1-9:**
+   - **Option 1:** Always "Proceed to next section"
+   - **Options 2-9:** Select 8 methods from data/elicitation-methods
+   - End with: "Select 1-9 or just type your question/feedback:"
+4. **WAIT FOR USER RESPONSE** - Do not proceed until user selects option or provides feedback
+
+**WORKFLOW VIOLATION:** Creating content for elicit=true sections without user interaction violates this task.
+
+**NEVER ask yes/no questions or use any other format.**
+
+## Processing Flow
+
+1. **Parse YAML template** - Load template metadata and sections
+2. **Set preferences** - Show current mode (Interactive), confirm output file
+3. **Process each section:**
+   - Skip if condition unmet
+   - Check agent permissions (owner/editors) - note if section is restricted to specific agents
+   - Draft content using section instruction
+   - Present content + detailed rationale
+   - **IF elicit: true** → MANDATORY 1-9 options format
+   - Save to file if possible
+4. **Continue until complete**
+
+## Detailed Rationale Requirements
+
+When presenting section content, ALWAYS include rationale that explains:
+
+- Trade-offs and choices made (what was chosen over alternatives and why)
+- Key assumptions made during drafting
+- Interesting or questionable decisions that need user attention
+- Areas that might need validation
+
+## Elicitation Results Flow
+
+After user selects elicitation method (2-9):
+
+1. Execute method from data/elicitation-methods
+2. Present results with insights
+3. Offer options:
+   - **1. Apply changes and update section**
+   - **2. Return to elicitation menu**
+   - **3. Ask any questions or engage further with this elicitation**
+
+## Agent Permissions
+
+When processing sections with agent permission fields:
+
+- **owner**: Note which agent role initially creates/populates the section
+- **editors**: List agent roles allowed to modify the section
+- **readonly**: Mark sections that cannot be modified after creation
+
+**For sections with restricted access:**
+
+- Include a note in the generated document indicating the responsible agent
+- Example: "_(This section is owned by dev-agent and can only be modified by dev-agent)_"
+
+## YOLO Mode
+
+User can type `#yolo` to toggle to YOLO mode (process all sections at once).
+
+## CRITICAL REMINDERS
+
+**❌ NEVER:**
+
+- Ask yes/no questions for elicitation
+- Use any format other than 1-9 numbered options
+- Create new elicitation methods
+
+**✅ ALWAYS:**
+
+- Use exact 1-9 format when elicit: true
+- Select options 2-9 from data/elicitation-methods only
+- Provide detailed rationale explaining decisions
+- End with "Select 1-9 or just type your question/feedback:"