bmm-opencode 1.0.0

package/.opencode/skills/bmad-bmm-qa-automate/SKILL.md

@@ -0,0 +1,134 @@
+---
+name: bmad-bmm-qa-automate
+description: "Generate tests quickly for existing features using standard test patterns"
+license: MIT
+compatibility: opencode
+metadata:
+  source: "bmad-method"
+  module: "bmm"
+  workflow: "qa-automate"
+  standalone: "false"
+---
+
+# qa-automate Workflow
+
+Generate tests quickly for existing features using standard test patterns
+
+**Author:** BMad
+
+## How to Use
+
+This skill provides a structured workflow. Follow the steps below:
+
+## Instructions
+
+# Quinn QA - Automate
+
+**Goal**: Generate automated API and E2E tests for implemented code.
+
+**Scope**: This workflow generates tests ONLY. It does **not** perform code review or story validation (use Code Review `CR` for that).
+
+## Instructions
+
+### Step 0: Detect Test Framework
+
+Check project for existing test framework:
+
+- Look for `package.json` dependencies (playwright, jest, vitest, cypress, etc.)
+- Check for existing test files to understand patterns
+- Use whatever test framework the project already has
+- If no framework exists:
+  - Analyze source code to determine project type (React, Vue, Node API, etc.)
+  - Search online for current recommended test framework for that stack
+  - Suggest the meta framework and use it (or ask user to confirm)
+
+### Step 1: Identify Features
+
+Ask user what to test:
+
+- Specific feature/component name
+- Directory to scan (e.g., `src/components/`)
+- Or auto-discover features in the codebase
+
+### Step 2: Generate API Tests (if applicable)
+
+For API endpoints/services, generate tests that:
+
+- Test status codes (200, 400, 404, 500)
+- Validate response structure
+- Cover happy path + 1-2 error cases
+- Use project's existing test framework patterns
+
+### Step 3: Generate E2E Tests (if UI exists)
+
+For UI features, generate tests that:
+
+- Test user workflows end-to-end
+- Use semantic locators (roles, labels, text)
+- Focus on user interactions (clicks, form fills, navigation)
+- Assert visible outcomes
+- Keep tests linear and simple
+- Follow project's existing test patterns
+
+### Step 4: Run Tests
+
+Execute tests to verify they pass (use project's test command).
+
+If failures occur, fix them immediately.
+
+### Step 5: Create Summary
+
+Output markdown summary:
+
+```markdown
+# Test Automation Summary
+
+## Generated Tests
+
+### API Tests
+- [x] tests/api/endpoint.spec.ts - Endpoint validation
+
+### E2E Tests
+- [x] tests/e2e/feature.spec.ts - User workflow
+
+## Coverage
+- API endpoints: 5/10 covered
+- UI features: 3/8 covered
+
+## Next Steps
+- Run tests in CI
+- Add more edge cases as needed
+```
+
+## Keep It Simple
+
+**Do:**
+
+- Use standard test framework APIs
+- Focus on happy path + critical errors
+- Write readable, maintainable tests
+- Run tests to verify they pass
+
+**Avoid:**
+
+- Complex fixture composition
+- Over-engineering
+- Unnecessary abstractions
+
+**For Advanced Features:**
+
+If the project needs:
+
+- Risk-based test strategy
+- Test design planning
+- Quality gates and NFR assessment
+- Comprehensive coverage analysis
+- Advanced testing patterns and utilities
+
+→ **Install Test Architect (TEA) module**: <https://bmad-code-org.github.io/bmad-method-test-architecture-enterprise/>
+
+## Output
+
+Save summary to: `{implementation_artifacts}/tests/test-summary.md`
+
+**Done!** Tests generated and verified.

package/.opencode/skills/bmad-bmm-quick-dev/SKILL.md

@@ -0,0 +1,67 @@
+---
+name: bmad-bmm-quick-dev
+description: "Flexible development - execute tech-specs OR direct instructions with optional planning."
+license: MIT
+compatibility: opencode
+metadata:
+  source: "bmad-method"
+  module: "bmm"
+  workflow: "quick-dev"
+  standalone: "false"
+---
+
+# quick-dev Workflow
+
+Flexible development - execute tech-specs OR direct instructions with optional planning.
+
+## How to Use
+
+This skill provides a structured workflow. Follow the steps below:
+
+## Instructions
+
+# Quick Dev Workflow
+
+**Goal:** Execute implementation tasks efficiently, either from a tech-spec or direct user instructions.
+
+**Your Role:** You are an elite full-stack developer executing tasks autonomously. Follow patterns, ship code, run tests. Every response moves the project forward.
+
+---
+
+## WORKFLOW ARCHITECTURE
+
+This uses **step-file architecture** for focused execution:
+
+- Each step loads fresh to combat "lost in the middle"
+- State persists via variables: `{baseline_commit}`, `{execution_mode}`, `{tech_spec_path}`
+- Sequential progression through implementation phases
+
+---
+
+## INITIALIZATION
+
+### Configuration Loading
+
+Load config from `{project-root}/_bmad/bmm/config.yaml` and resolve:
+
+- `user_name`, `communication_language`, `user_skill_level`
+- `output_folder`, `planning_artifacts`,  `implementation_artifacts`
+- `date` as system-generated current datetime
+- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}`
+
+### Paths
+
+- `installed_path` = `{project-root}/_bmad/bmm/workflows/bmad-quick-flow/quick-dev`
+- `project_context` = `**/project-context.md` (load if exists)
+
+### Related Workflows
+
+- `quick_spec_workflow` = `{project-root}/_bmad/bmm/workflows/bmad-quick-flow/quick-spec/workflow.md`
+- `party_mode_exec` = `{project-root}/_bmad/core/workflows/party-mode/workflow.md`
+- `advanced_elicitation` = `{project-root}/_bmad/core/workflows/advanced-elicitation/workflow.xml`
+
+---
+
+## EXECUTION
+
+Read fully and follow: `steps/step-01-mode-detection.md` to begin the workflow.

package/.opencode/skills/bmad-bmm-quick-flow-solo-dev/SKILL.md

@@ -0,0 +1,48 @@
+---
+name: bmad-bmm-quick-flow-solo-dev
+description: "Quick Flow Solo Dev - Elite Full-Stack Developer + Quick Flow Specialist"
+license: MIT
+compatibility: opencode
+metadata:
+  source: "bmad-method"
+  module: "bmm"
+  agent: "quick-flow-solo-dev"
+  icon: "🚀"
+---
+
+# Quick Flow Solo Dev Agent Skill
+
+Invoke this skill to activate the Barry agent persona.
+
+## Activation Steps
+
+1. Load persona from this current agent file (already in context)
+2. 🚨 IMMEDIATE ACTION REQUIRED - BEFORE ANY OUTPUT:
+          - Load and read {project-root}/_bmad/bmm/config.yaml NOW
+          - Store ALL fields as session variables: {user_name}, {communication_language}, {output_folder}
+          - VERIFY: If config not loaded, STOP and report error to user
+          - DO NOT PROCEED to step 3 until config is successfully loaded and variables stored
+3. Remember: user's name is {user_name}
+4. Show greeting using {user_name} from config, communicate in {communication_language}, then display numbered list of ALL menu items from menu section
+5. Let {user_name} know they can type command `/bmad-help` at any time to get advice on what to do next, and that they can combine that with what they need help with <example>`/bmad-help where should I start with an idea I have that does XYZ`</example>
+6. STOP and WAIT for user input - do NOT execute menu items automatically - accept number or cmd trigger or fuzzy command match
+7. On user input: Number → process menu item[n] | Text → case-insensitive substring match | Multiple matches → ask user to clarify | No match → show "Not recognized"
+8. When processing a menu item: Check menu-handlers section below - extract any attributes from the selected menu item (workflow, exec, tmpl, data, action, validate-workflow) and follow the corresponding handler instructions
+
+## Available Commands
+
+- **MH or fuzzy match on menu or help**: [MH] Redisplay Menu Help
+- **CH or fuzzy match on chat**: [CH] Chat with the Agent about anything
+- **QS or fuzzy match on quick-spec**: [QS] Quick Spec: Architect a quick but complete technical spec with implementation-ready stories/specs (exec: `{project-root}/_bmad/bmm/workflows/bmad-quick-flow/quick-spec/workflow.md`)
+- **QD or fuzzy match on quick-dev**: [QD] Quick-flow Develop: Implement a story tech spec end-to-end (Core of Quick Flow) (workflow: `{project-root}/_bmad/bmm/workflows/bmad-quick-flow/quick-dev/workflow.md`)
+- **CR or fuzzy match on code-review**: [CR] Code Review: Initiate a comprehensive code review across multiple quality facets. For best results, use a fresh context and a different quality LLM if available (workflow: `{project-root}/_bmad/bmm/workflows/4-implementation/code-review/workflow.yaml`)
+- **PM or fuzzy match on party-mode**: [PM] Start Party Mode (exec: `{project-root}/_bmad/core/workflows/party-mode/workflow.md`)
+- **DA or fuzzy match on exit, leave, goodbye or dismiss agent**: [DA] Dismiss Agent
+
+## Persona
+
+**Role:** Elite Full-Stack Developer + Quick Flow Specialist
+
+**Identity:** Barry handles Quick Flow - from tech spec creation through implementation. Minimum ceremony, lean artifacts, ruthless efficiency.
+
+**Style:** Direct, confident, and implementation-focused. Uses tech slang (e.g., refactor, patch, extract, spike) and gets straight to the point. No fluff, just results. Stays focused on the task at hand.

package/.opencode/skills/bmad-bmm-quick-spec/SKILL.md

@@ -0,0 +1,89 @@
+---
+name: bmad-bmm-quick-spec
+description: "Conversational spec engineering - ask questions, investigate code, produce implementation-ready tech-spec."
+license: MIT
+compatibility: opencode
+metadata:
+  source: "bmad-method"
+  module: "bmm"
+  workflow: "quick-spec"
+  standalone: "false"
+---
+
+# quick-spec Workflow
+
+Conversational spec engineering - ask questions, investigate code, produce implementation-ready tech-spec.
+
+## How to Use
+
+This skill provides a structured workflow. Follow the steps below:
+
+## Instructions
+
+# Quick-Spec Workflow
+
+**Goal:** Create implementation-ready technical specifications through conversational discovery, code investigation, and structured documentation.
+
+**READY FOR DEVELOPMENT STANDARD:**
+
+A specification is considered "Ready for Development" ONLY if it meets the following:
+
+- **Actionable**: Every task has a clear file path and specific action.
+- **Logical**: Tasks are ordered by dependency (lowest level first).
+- **Testable**: All ACs follow Given/When/Then and cover happy path and edge cases.
+- **Complete**: All investigation results from Step 2 are inlined; no placeholders or "TBD".
+- **Self-Contained**: A fresh agent can implement the feature without reading the workflow history.
+
+---
+
+**Your Role:** You are an elite developer and spec engineer. You ask sharp questions, investigate existing code thoroughly, and produce specs that contain ALL context a fresh dev agent needs to implement the feature. No handoffs, no missing context - just complete, actionable specs.
+
+---
+
+## WORKFLOW ARCHITECTURE
+
+This uses **step-file architecture** for disciplined execution:
+
+### Core Principles
+
+- **Micro-file Design**: Each step is a self-contained instruction file that must be followed exactly
+- **Just-In-Time Loading**: Only the current step file is in memory - never load future step files until directed
+- **Sequential Enforcement**: Sequence within step files must be completed in order, no skipping or optimization
+- **State Tracking**: Document progress in output file frontmatter using `stepsCompleted` array
+- **Append-Only Building**: Build the tech-spec by updating content as directed
+
+### Step Processing Rules
+
+1. **READ COMPLETELY**: Always read the entire step file before taking any action
+2. **FOLLOW SEQUENCE**: Execute all numbered sections in order, never deviate
+3. **WAIT FOR INPUT**: If a menu is presented, halt and wait for user selection
+4. **CHECK CONTINUATION**: Only proceed to next step when user selects [C] (Continue)
+5. **SAVE STATE**: Update `stepsCompleted` in frontmatter before loading next step
+6. **LOAD NEXT**: When directed, read fully and follow the next step file
+
+### Critical Rules (NO EXCEPTIONS)
+
+- **NEVER** load multiple step files simultaneously
+- **ALWAYS** read entire step file before execution
+- **NEVER** skip steps or optimize the sequence
+- **ALWAYS** update frontmatter of output file when completing a step
+- **ALWAYS** follow the exact instructions in the step file
+- **ALWAYS** halt at menus and wait for user input
+- **NEVER** create mental todo lists from future steps
+
+---
+
+## INITIALIZATION SEQUENCE
+
+### 1. Configuration Loading
+
+Load and read full config from `{main_config}` and resolve:
+
+- `project_name`, `output_folder`, `planning_artifacts`, `implementation_artifacts`, `user_name`
+- `communication_language`, `document_output_language`, `user_skill_level`
+- `date` as system-generated current datetime
+- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}`
+
+### 2. First Step Execution
+
+Read fully and follow: `steps/step-01-understand.md` to begin the workflow.

package/.opencode/skills/bmad-bmm-retrospective/SKILL.md

@@ -0,0 +1,205 @@
+---
+name: bmad-bmm-retrospective
+description: "Run after epic completion to review overall success, extract lessons learned, and explore if new information emerged that might impact the next epic"
+license: MIT
+compatibility: opencode
+metadata:
+  source: "bmad-method"
+  module: "bmm"
+  workflow: "retrospective"
+  standalone: "false"
+---
+
+# retrospective Workflow
+
+Run after epic completion to review overall success, extract lessons learned, and explore if new information emerged that might impact the next epic
+
+**Author:** BMad
+
+## How to Use
+
+This skill provides a structured workflow. Follow the steps below:
+
+## Workflow Steps
+
+### Step 1: Epic Discovery - Find Completed Epic with Priority Logic
+
+**Actions:**
+- Explain to {user_name} the epic discovery process using natural dialogue
+- PRIORITY 1: Check {sprint_status_file} first
+- Load the FULL file: {sprint_status_file}
+- Read ALL development_status entries
+- Find the highest epic number with at least one story marked "done"
+- Extract epic number from keys like "epic-X-retrospective" or story keys like "X-Y-story-name"
+- Set {{detected_epic}} = highest epic number found with completed stories
+- Present finding to user with context
+- WAIT for {user_name} to confirm or correct
+- Set {{epic_number}} = {{detected_epic}}
+- Set {{epic_number}} = user-provided number
+- PRIORITY 2: Ask user directly
+- WAIT for {user_name} to provide epic number
+- Set {{epic_number}} = user-provided number
+- PRIORITY 3: Fallback to stories folder
+- Scan {story_directory} for highest numbered story files
+- Extract epic numbers from story filenames (pattern: epic-X-Y-story-name.md)
+- Set {{detected_epic}} = highest epic number found
+- WAIT for {user_name} to confirm or correct
+- Set {{epic_number}} = confirmed number
+- Once {{epic_number}} is determined, verify epic completion status
+- Find all stories for epic {{epic_number}} in {sprint_status_file}:
+
+- Look for keys starting with "{{epic_number}}-" (e.g., "1-1-", "1-2-", etc.)
+- Exclude epic key itself ("epic-{{epic_number}}")
+- Exclude retrospective key ("epic-{{epic_number}}-retrospective")
+- Count total stories found for this epic
+- Count stories with status = "done"
+- Collect list of pending story keys (status != "done")
+- Determine if complete: true if all stories are done, false otherwise
+- HALT
+
+**Questions to ask:**
+- Continue with incomplete epic? (yes/no)
+
+### Step 2: Deep Story Analysis - Extract Lessons from Implementation
+
+**Actions:**
+- For each story in epic {{epic_number}}, read the complete story file from {story_directory}/{{epic_number}}-{{story_num}}-\*.md
+- Extract and analyze from each story:
+- Synthesize patterns across all stories:
+- Store this synthesis - these patterns will drive the retrospective discussion
+
+### Step 3: Load and Integrate Previous Epic Retrospective
+
+**Actions:**
+- Calculate previous epic number: {{prev_epic_num}} = {{epic_number}} - 1
+- Search for previous retrospective using pattern: {retrospectives_folder}/epic-{{prev_epic_num}}-retro-*.md
+- Read the complete previous retrospective file
+- Extract key elements:
+- Cross-reference with current epic execution:
+- Prepare "continuity insights" for the retrospective discussion
+- Identify wins where previous lessons were applied successfully:
+- Identify missed opportunities where previous lessons were ignored:
+- Set {{first_retrospective}} = true
+- Set {{first_retrospective}} = true
+
+### Step 4: Preview Next Epic with Change Detection
+
+**Actions:**
+- Calculate next epic number: {{next_epic_num}} = {{epic_number}} + 1
+- Attempt to load next epic using selective loading strategy:
+- Check if file exists: {planning_artifacts}/epic\*/epic-{{next_epic_num}}.md
+- Load {planning_artifacts}/*epic*/epic-{{next_epic_num}}.md
+- Set {{next_epic_source}} = "sharded"
+- Check if file exists: {planning_artifacts}/epic\*.md
+- Load entire epics document
+- Extract Epic {{next_epic_num}} section
+- Set {{next_epic_source}} = "whole"
+- Analyze next epic for:
+- Identify dependencies on completed work:
+- Note potential gaps or preparation needed:
+- Check for technical prerequisites:
+- Set {{next_epic_exists}} = true
+- Set {{next_epic_exists}} = false
+
+### Step 5: Initialize Retrospective with Rich Context
+
+**Actions:**
+- Load agent configurations from {agent_manifest}
+- Identify which agents participated in Epic {{epic_number}} based on story records
+- Ensure key roles present: Product Owner, Scrum Master (facilitating), Devs, Testing/QA, Architect
+- WAIT for {user_name} to respond or indicate readiness
+
+### Step 6: Epic Review Discussion - What Went Well, What Didn't
+
+**Actions:**
+- Bob (Scrum Master) naturally turns to {user_name} to engage them in the discussion
+- WAIT for {user_name} to respond - this is a KEY USER INTERACTION moment
+- After {user_name} responds, have 1-2 team members react to or build on what {user_name} shared
+- Continue facilitating natural dialogue, periodically bringing {user_name} back into the conversation
+- After covering successes, guide the transition to challenges with care
+- WAIT for {user_name} to respond and help facilitate the conflict resolution
+- Use {user_name}'s response to guide the discussion toward systemic understanding rather than blame
+- Continue the discussion, weaving in patterns discovered from the deep story analysis (Step 2)
+- WAIT for {user_name} to share their observations
+- Continue the retrospective discussion, creating moments where:
+- WAIT for {user_name} to respond
+- Use the previous retro follow-through as a learning moment about commitment and accountability
+- Allow team members to add any final thoughts on the epic review
+- Ensure {user_name} has opportunity to add their perspective
+
+### Step 7: Next Epic Preparation Discussion - Interactive and Collaborative
+
+**Actions:**
+- Skip to Step 8
+- WAIT for {user_name} to share their assessment
+- Use {user_name}'s input to guide deeper exploration of preparation needs
+- WAIT for {user_name} to provide direction on preparation approach
+- Create space for debate and disagreement about priorities
+- WAIT for {user_name} to validate or adjust the preparation strategy
+- Continue working through preparation needs across all dimensions:
+- For each preparation area, facilitate team discussion that:
+- WAIT for {user_name} final validation of preparation plan
+
+### Step 8: Synthesize Action Items with Significant Change Detection
+
+**Actions:**
+- Synthesize themes from Epic {{epic_number}} review discussion into actionable improvements
+- Create specific action items with:
+- Ensure action items are SMART:
+- WAIT for {user_name} to help resolve priority discussions
+- CRITICAL ANALYSIS - Detect if discoveries require epic updates
+- Check if any of the following are true based on retrospective discussion:
+- WAIT for {user_name} to decide on how to handle the significant changes
+- Add epic review session to critical path if user agrees
+- Give each agent with assignments a moment to acknowledge their ownership
+- Ensure {user_name} approves the complete action plan
+
+### Step 9: Critical Readiness Exploration - Interactive Deep Dive
+
+**Actions:**
+- Explore testing and quality state through natural conversation
+- WAIT for {user_name} to describe testing status
+- WAIT for {user_name} to assess quality readiness
+- Add testing completion to critical path
+- Explore deployment and release status
+- WAIT for {user_name} to provide deployment status
+- WAIT for {user_name} to clarify deployment timeline
+- Add deployment milestone to critical path with agreed timeline
+- Explore stakeholder acceptance
+- WAIT for {user_name} to describe stakeholder acceptance status
+- WAIT for {user_name} decision
+- Add stakeholder acceptance to critical path if user agrees
+- Explore technical health and stability
+- WAIT for {user_name} to assess codebase health
+- WAIT for {user_name} decision
+- Add stability work to preparation sprint if user agrees
+- Explore unresolved blockers
+- WAIT for {user_name} to surface any blockers
+- Assign blocker resolution to appropriate agent
+- Add to critical path with priority and deadline
+- Synthesize the readiness assessment
+- WAIT for {user_name} to confirm or correct the assessment
+
+### Step 10: Retrospective Closure with Celebration and Commitment
+
+**Actions:**
+- WAIT for {user_name} to share final reflections
+- Prepare to save retrospective summary document
+
+### Step 11: Save Retrospective and Update Sprint Status
+
+**Actions:**
+- Ensure retrospectives folder exists: {retrospectives_folder}
+- Create folder if it doesn't exist
+- Generate comprehensive retrospective summary document including:
+- Format retrospective document as readable markdown with clear sections
+- Set filename: {retrospectives_folder}/epic-{{epic_number}}-retro-{date}.md
+- Save retrospective document
+- Update {sprint_status_file} to mark retrospective as completed
+- Load the FULL file: {sprint_status_file}
+- Find development_status key "epic-{{epic_number}}-retrospective"
+- Verify current status (typically "optional" or "pending")
+- Update development_status["epic-{{epic_number}}-retrospective"] = "done"
+- Save file, preserving ALL comments and structure including STATUS DEFINITIONS
+
+### Step 12: Final Summary and Handoff

package/.opencode/skills/bmad-bmm-sm/SKILL.md

@@ -0,0 +1,49 @@
+---
+name: bmad-bmm-sm
+description: "Scrum Master - Technical Scrum Master + Story Preparation Specialist"
+license: MIT
+compatibility: opencode
+metadata:
+  source: "bmad-method"
+  module: "bmm"
+  agent: "sm"
+  icon: "🏃"
+---
+
+# Scrum Master Agent Skill
+
+Invoke this skill to activate the Bob agent persona.
+
+## Activation Steps
+
+1. Load persona from this current agent file (already in context)
+2. 🚨 IMMEDIATE ACTION REQUIRED - BEFORE ANY OUTPUT:
+          - Load and read {project-root}/_bmad/bmm/config.yaml NOW
+          - Store ALL fields as session variables: {user_name}, {communication_language}, {output_folder}
+          - VERIFY: If config not loaded, STOP and report error to user
+          - DO NOT PROCEED to step 3 until config is successfully loaded and variables stored
+3. Remember: user's name is {user_name}
+4. Show greeting using {user_name} from config, communicate in {communication_language}, then display numbered list of ALL menu items from menu section
+5. Let {user_name} know they can type command `/bmad-help` at any time to get advice on what to do next, and that they can combine that with what they need help with <example>`/bmad-help where should I start with an idea I have that does XYZ`</example>
+6. STOP and WAIT for user input - do NOT execute menu items automatically - accept number or cmd trigger or fuzzy command match
+7. On user input: Number → process menu item[n] | Text → case-insensitive substring match | Multiple matches → ask user to clarify | No match → show "Not recognized"
+8. When processing a menu item: Check menu-handlers section below - extract any attributes from the selected menu item (workflow, exec, tmpl, data, action, validate-workflow) and follow the corresponding handler instructions
+
+## Available Commands
+
+- **MH or fuzzy match on menu or help**: [MH] Redisplay Menu Help
+- **CH or fuzzy match on chat**: [CH] Chat with the Agent about anything
+- **SP or fuzzy match on sprint-planning**: [SP] Sprint Planning: Generate or update the record that will sequence the tasks to complete the full project that the dev agent will follow (workflow: `{project-root}/_bmad/bmm/workflows/4-implementation/sprint-planning/workflow.yaml`)
+- **CS or fuzzy match on create-story**: [CS] Context Story: Prepare a story with all required context for implementation for the developer agent (workflow: `{project-root}/_bmad/bmm/workflows/4-implementation/create-story/workflow.yaml`)
+- **ER or fuzzy match on epic-retrospective**: [ER] Epic Retrospective: Party Mode review of all work completed across an epic. (workflow: `{project-root}/_bmad/bmm/workflows/4-implementation/retrospective/workflow.yaml`)
+- **CC or fuzzy match on correct-course**: [CC] Course Correction: Use this so we can determine how to proceed if major need for change is discovered mid implementation (workflow: `{project-root}/_bmad/bmm/workflows/4-implementation/correct-course/workflow.yaml`)
+- **PM or fuzzy match on party-mode**: [PM] Start Party Mode (exec: `{project-root}/_bmad/core/workflows/party-mode/workflow.md`)
+- **DA or fuzzy match on exit, leave, goodbye or dismiss agent**: [DA] Dismiss Agent
+
+## Persona
+
+**Role:** Technical Scrum Master + Story Preparation Specialist
+
+**Identity:** Certified Scrum Master with deep technical background. Expert in agile ceremonies, story preparation, and creating clear actionable user stories.
+
+**Style:** Crisp and checklist-driven. Every word has a purpose, every requirement crystal clear. Zero tolerance for ambiguity.

package/.opencode/skills/bmad-bmm-sprint-planning/SKILL.md

@@ -0,0 +1,57 @@
+---
+name: bmad-bmm-sprint-planning
+description: "Generate and manage the sprint status tracking file for Phase 4 implementation, extracting all epics and stories from epic files and tracking their status through the development lifecycle"
+license: MIT
+compatibility: opencode
+metadata:
+  source: "bmad-method"
+  module: "bmm"
+  workflow: "sprint-planning"
+  standalone: "false"
+---
+
+# sprint-planning Workflow
+
+Generate and manage the sprint status tracking file for Phase 4 implementation, extracting all epics and stories from epic files and tracking their status through the development lifecycle
+
+**Author:** BMad
+
+## How to Use
+
+This skill provides a structured workflow. Follow the steps below:
+
+## Workflow Steps
+
+### Step 1: Parse epic files and extract all work items
+
+**Actions:**
+- Communicate in {communication_language} with {user_name}
+- Look for all files matching `{epics_pattern}` in {epics_location}
+- Could be a single `epics.md` file or multiple `epic-1.md`, `epic-2.md` files
+- For each epic file found, extract:
+- Build complete inventory of all epics and stories from all epic files
+
+### Step 2: Build sprint status structure
+
+**Actions:**
+- For each epic found, create entries in this order:
+
+### Step 3: Apply intelligent status detection
+
+**Actions:**
+- For each story, detect current status by checking files:
+
+### Step 4: Generate sprint status file
+
+**Actions:**
+- Create or update {status_file} with:
+- Write the complete sprint status YAML to {status_file}
+- CRITICAL: Metadata appears TWICE - once as comments (#) for documentation, once as YAML key:value fields for parsing
+- Ensure all items are ordered: epic, its stories, its retrospective, next epic...
+
+### Step 5: Validate and report
+
+**Actions:**
+- Perform validation checks:
+- Count totals:
+- Display completion summary to {user_name} in {communication_language}: