diff --git a/src/modules/bmgd/workflows/4-production/code-review/backlog_template.md b/src/modules/bmgd/workflows/4-production/code-review/backlog_template.md
new file mode 100644
index 00000000..28cfe767
--- /dev/null
+++ b/src/modules/bmgd/workflows/4-production/code-review/backlog_template.md
@@ -0,0 +1,12 @@
+# Engineering Backlog
+
+This backlog collects cross-cutting or future action items that emerge from reviews and planning.
+
+Routing guidance:
+
+- Use this file for non-urgent optimizations, refactors, or follow-ups that span multiple stories/epics.
+- Must-fix items to ship a story belong in that story’s `Tasks / Subtasks`.
+- Same-epic improvements may also be captured under the epic Tech Spec `Post-Review Follow-ups` section.
+
+| Date | Story | Epic | Type | Severity | Owner | Status | Notes |
+| ---- | ----- | ---- | ---- | -------- | ----- | ------ | ----- |
diff --git a/src/modules/bmgd/workflows/4-production/code-review/checklist.md b/src/modules/bmgd/workflows/4-production/code-review/checklist.md
new file mode 100644
index 00000000..ce903701
--- /dev/null
+++ b/src/modules/bmgd/workflows/4-production/code-review/checklist.md
@@ -0,0 +1,22 @@
+# Senior Developer Review - Validation Checklist
+
+- [ ] Story file loaded from `{{story_path}}`
+- [ ] Story Status verified as one of: {{allow_status_values}}
+- [ ] Epic and Story IDs resolved ({{epic_num}}.{{story_num}})
+- [ ] Story Context located or warning recorded
+- [ ] Epic Tech Spec located or warning recorded
+- [ ] Architecture/standards docs loaded (as available)
+- [ ] Tech stack detected and documented
+- [ ] MCP doc search performed (or web fallback) and references captured
+- [ ] Acceptance Criteria cross-checked against implementation
+- [ ] File List reviewed and validated for completeness
+- [ ] Tests identified and mapped to ACs; gaps noted
+- [ ] Code quality review performed on changed files
+- [ ] Security review performed on changed files and dependencies
+- [ ] Outcome decided (Approve/Changes Requested/Blocked)
+- [ ] Review notes appended under "Senior Developer Review (AI)"
+- [ ] Change Log updated with review entry
+- [ ] Status updated according to settings (if enabled)
+- [ ] Story saved successfully
+
+_Reviewer: {{user_name}} on {{date}}_
diff --git a/src/modules/bmgd/workflows/4-production/code-review/instructions.md b/src/modules/bmgd/workflows/4-production/code-review/instructions.md
new file mode 100644
index 00000000..e277df46
--- /dev/null
+++ b/src/modules/bmgd/workflows/4-production/code-review/instructions.md
@@ -0,0 +1,420 @@
+# Senior Developer Review - Workflow Instructions
+
+````xml
+The workflow execution engine is governed by: {project-root}/bmad/core/tasks/workflow.xml
+You MUST have already loaded and processed: {installed_path}/workflow.yaml
+Communicate all responses in {communication_language} and language MUST be tailored to {user_skill_level}
+Generate all documents in {document_output_language}
+This workflow performs a SYSTEMATIC Senior Developer Review on a story with status "review", validates EVERY acceptance criterion and EVERY completed task, appends structured review notes with evidence, and updates the story status based on outcome.
+If story_path is provided, use it. Otherwise, find the first story in sprint-status.yaml with status "review". If none found, offer ad-hoc review option.
+Ad-hoc review mode: User can specify any files to review and what to review for (quality, security, requirements, etc.). Creates standalone review report.
+SYSTEMATIC VALIDATION REQUIREMENT: For EVERY acceptance criterion, verify implementation with evidence (file:line). For EVERY task marked complete, verify it was actually done. Tasks marked complete but not done = HIGH SEVERITY finding.
+⚠️ ZERO TOLERANCE FOR LAZY VALIDATION ⚠️
+If you FAIL to catch even ONE task marked complete that was NOT actually implemented, or ONE acceptance criterion marked done that is NOT in the code with evidence, you have FAILED YOUR ONLY PURPOSE. This is an IMMEDIATE DISQUALIFICATION. No shortcuts. No assumptions. No "looks good enough." You WILL read every file. You WILL verify every claim. You WILL provide evidence (file:line) for EVERY validation. Failure to catch false completions = you failed humanity and the project. Your job is to be the uncompromising gatekeeper. DO YOUR JOB COMPLETELY OR YOU WILL BE REPLACED.
+Only modify the story file in these areas: Status, Dev Agent Record (Completion Notes), File List (if corrections needed), Change Log, and the appended "Senior Developer Review (AI)" section.
+Execute ALL steps in exact order; do NOT skip steps
+
+DOCUMENT OUTPUT: Technical review reports. Structured findings with severity levels and action items. User skill level ({user_skill_level}) affects conversation style ONLY, not review content.
+
+## 📚 Document Discovery - Selective Epic Loading
+
+**Strategy**: This workflow needs only ONE specific epic and its stories for review context, not all epics. This provides huge efficiency gains when epics are sharded.
+
+**Epic Discovery Process (SELECTIVE OPTIMIZATION):**
+
+1. **Determine which epic** you need (epic_num from story being reviewed - e.g., story "3-2-feature-name" needs Epic 3)
+2. **Check for sharded version**: Look for `epics/index.md`
+3. **If sharded version found**:
+ - Read `index.md` to understand structure
+ - **Load ONLY `epic-{epic_num}.md`** (e.g., `epics/epic-3.md` for Epic 3)
+ - DO NOT load all epic files - only the one needed!
+ - This is the key efficiency optimization for large multi-epic projects
+4. **If whole document found**: Load the complete `epics.md` file and extract the relevant epic
+
+**Other Documents (architecture, ux-design) - Full Load:**
+
+1. **Search for whole document first** - Use fuzzy file matching
+2. **Check for sharded version** - If whole document not found, look for `{doc-name}/index.md`
+3. **If sharded version found**:
+ - Read `index.md` to understand structure
+ - Read ALL section files listed in the index
+ - Treat combined content as single document
+4. **Brownfield projects**: The `document-project` workflow creates `{output_folder}/docs/index.md`
+
+**Priority**: If both whole and sharded versions exist, use the whole document.
+
+**UX-Heavy Projects**: Always check for ux-design documentation as it provides critical context for reviewing UI-focused stories.
+
+
+
+
+
+ Use {{story_path}} directly
+ Read COMPLETE story file and parse sections
+ Extract story_key from filename or story metadata
+ Verify Status is "review" - if not, HALT with message: "Story status must be 'review' to proceed"
+
+
+
+ MUST read COMPLETE sprint-status.yaml file from start to end to preserve order
+ Load the FULL file: {{output_folder}}/sprint-status.yaml
+ Read ALL lines from beginning to end - do not skip any content
+ Parse the development_status section completely
+
+ Find FIRST story (reading in order from top to bottom) where:
+ - Key matches pattern: number-number-name (e.g., "1-2-user-auth")
+ - NOT an epic key (epic-X) or retrospective (epic-X-retrospective)
+ - Status value equals "review"
+
+
+
+
+ Select an option (1/2/3):
+
+
+ What code would you like me to review?
+
+Provide:
+- File path(s) or directory to review
+- What to review for:
+ • General quality and standards
+ • Requirements compliance
+ • Security concerns
+ • Performance issues
+ • Architecture alignment
+ • Something else (specify)
+
+Your input:
+
+ Parse user input to extract:
+ - {{review_files}}: file paths or directories to review
+ - {{review_focus}}: what aspects to focus on
+ - {{review_context}}: any additional context provided
+
+
+ Set ad_hoc_review_mode = true
+ Skip to step 4 with custom scope
+
+
+
+ HALT
+
+
+
+ Use the first story found with status "review"
+ Resolve story file path in {{story_dir}}
+ Read the COMPLETE story file
+
+
+ Extract {{epic_num}} and {{story_num}} from filename (e.g., story-2.3.*.md) and story metadata
+ Parse sections: Status, Story, Acceptance Criteria, Tasks/Subtasks (and completion states), Dev Notes, Dev Agent Record (Context Reference, Completion Notes, File List), Change Log
+ HALT with message: "Unable to read story file"
+
+
+
+ Locate story context file: Under Dev Agent Record → Context Reference, read referenced path(s). If missing, search {{output_folder}} for files matching pattern "story-{{epic_num}}.{{story_num}}*.context.xml" and use the most recent.
+ Continue but record a WARNING in review notes: "No story context file found"
+
+ Locate Epic Tech Spec: Search {{tech_spec_search_dir}} with glob {{tech_spec_glob_template}} (resolve {{epic_num}})
+ Continue but record a WARNING in review notes: "No Tech Spec found for epic {{epic_num}}"
+
+ Load architecture/standards docs: For each file name in {{arch_docs_file_names}} within {{arch_docs_search_dirs}}, read if exists. Collect testing, coding standards, security, and architectural patterns.
+
+
+
+ Detect primary ecosystem(s) by scanning for manifests (e.g., package.json, pyproject.toml, go.mod, Dockerfile). Record key frameworks (e.g., Node/Express, React/Vue, Python/FastAPI, etc.).
+ Synthesize a concise "Best-Practices and References" note capturing any updates or considerations that should influence the review (cite links and versions if available).
+
+
+
+
+ Use {{review_files}} as the file list to review
+ Focus review on {{review_focus}} aspects specified by user
+ Use {{review_context}} for additional guidance
+ Skip acceptance criteria checking (no story context)
+ If architecture docs exist, verify alignment with architectural constraints
+
+
+
+ SYSTEMATIC VALIDATION - Check EVERY AC and EVERY task marked complete
+
+ From the story, read Acceptance Criteria section completely - parse into numbered list
+ From the story, read Tasks/Subtasks section completely - parse ALL tasks and subtasks with their completion state ([x] = completed, [ ] = incomplete)
+ From Dev Agent Record → File List, compile list of changed/added files. If File List is missing or clearly incomplete, search repo for recent changes relevant to the story scope (heuristics: filenames matching components/services/routes/tests inferred from ACs/tasks).
+
+ Step 4A: SYSTEMATIC ACCEPTANCE CRITERIA VALIDATION
+ Create AC validation checklist with one entry per AC
+ For EACH acceptance criterion (AC1, AC2, AC3, etc.):
+ 1. Read the AC requirement completely
+ 2. Search changed files for evidence of implementation
+ 3. Determine: IMPLEMENTED, PARTIAL, or MISSING
+ 4. Record specific evidence (file:line references where AC is satisfied)
+ 5. Check for corresponding tests (unit/integration/E2E as applicable)
+ 6. If PARTIAL or MISSING: Flag as finding with severity based on AC criticality
+ 7. Document in AC validation checklist
+
+ Generate AC Coverage Summary: "X of Y acceptance criteria fully implemented"
+
+ Step 4B: SYSTEMATIC TASK COMPLETION VALIDATION
+ Create task validation checklist with one entry per task/subtask
+ For EACH task/subtask marked as COMPLETED ([x]):
+ 1. Read the task description completely
+ 2. Search changed files for evidence the task was actually done
+ 3. Determine: VERIFIED COMPLETE, QUESTIONABLE, or NOT DONE
+ 4. Record specific evidence (file:line references proving task completion)
+ 5. **CRITICAL**: If marked complete but NOT DONE → Flag as HIGH SEVERITY finding with message: "Task marked complete but implementation not found: [task description]"
+ 6. If QUESTIONABLE → Flag as MEDIUM SEVERITY finding: "Task completion unclear: [task description]"
+ 7. Document in task validation checklist
+
+ For EACH task/subtask marked as INCOMPLETE ([ ]):
+ 1. Note it was not claimed to be complete
+ 2. Check if it was actually done anyway (sometimes devs forget to check boxes)
+ 3. If done but not marked: Note in review (helpful correction, not a finding)
+
+ Generate Task Completion Summary: "X of Y completed tasks verified, Z questionable, W falsely marked complete"
+
+ Step 4C: CROSS-CHECK EPIC TECH-SPEC REQUIREMENTS
+ Cross-check epic tech-spec requirements and architecture constraints against the implementation intent in files.
+ flag as High Severity finding.
+
+ Step 4D: COMPILE VALIDATION FINDINGS
+ Compile all validation findings into structured list:
+ - Missing AC implementations (severity based on AC importance)
+ - Partial AC implementations (MEDIUM severity)
+ - Tasks falsely marked complete (HIGH severity - this is critical)
+ - Questionable task completions (MEDIUM severity)
+ - Missing tests for ACs (severity based on AC criticality)
+ - Architecture violations (HIGH severity)
+
+
+
+
+
+ For each changed file, skim for common issues appropriate to the stack: error handling, input validation, logging, dependency injection, thread-safety/async correctness, resource cleanup, performance anti-patterns.
+ Perform security review: injection risks, authZ/authN handling, secret management, unsafe defaults, un-validated redirects, CORS misconfigured, dependency vulnerabilities (based on manifests).
+ Check tests quality: assertions are meaningful, edge cases covered, deterministic behavior, proper fixtures, no flakiness patterns.
+ Capture concrete, actionable suggestions with severity (High/Med/Low) and rationale. When possible, suggest specific code-level changes (filenames + line ranges) without rewriting large sections.
+
+
+
+ Determine outcome based on validation results:
+ - BLOCKED: Any HIGH severity finding (AC missing, task falsely marked complete, critical architecture violation)
+ - CHANGES REQUESTED: Any MEDIUM severity findings or multiple LOW severity issues
+ - APPROVE: All ACs implemented, all completed tasks verified, no significant issues
+
+
+ Prepare a structured review report with sections:
+ 1. **Summary**: Brief overview of review outcome and key concerns
+ 2. **Outcome**: Approve | Changes Requested | Blocked (with justification)
+ 3. **Key Findings** (by severity):
+ - HIGH severity issues first (especially falsely marked complete tasks)
+ - MEDIUM severity issues
+ - LOW severity issues
+ 4. **Acceptance Criteria Coverage**:
+ - Include complete AC validation checklist from Step 4A
+ - Show: AC# | Description | Status (IMPLEMENTED/PARTIAL/MISSING) | Evidence (file:line)
+ - Summary: "X of Y acceptance criteria fully implemented"
+ - List any missing or partial ACs with severity
+ 5. **Task Completion Validation**:
+ - Include complete task validation checklist from Step 4B
+ - Show: Task | Marked As | Verified As | Evidence (file:line)
+ - **CRITICAL**: Highlight any tasks marked complete but not done in RED/bold
+ - Summary: "X of Y completed tasks verified, Z questionable, W falsely marked complete"
+ 6. **Test Coverage and Gaps**:
+ - Which ACs have tests, which don't
+ - Test quality issues found
+ 7. **Architectural Alignment**:
+ - Tech-spec compliance
+ - Architecture violations if any
+ 8. **Security Notes**: Security findings if any
+ 9. **Best-Practices and References**: With links
+ 10. **Action Items**:
+ - CRITICAL: ALL action items requiring code changes MUST have checkboxes for tracking
+ - Format for actionable items: `- [ ] [Severity] Description (AC #X) [file: path:line]`
+ - Format for informational notes: `- Note: Description (no action required)`
+ - Imperative phrasing for action items
+ - Map to related ACs or files with specific line references
+ - Include suggested owners if clear
+ - Example format:
+ ```
+ ### Action Items
+
+ **Code Changes Required:**
+ - [ ] [High] Add input validation on login endpoint (AC #1) [file: src/routes/auth.js:23-45]
+ - [ ] [Med] Add unit test for invalid email format [file: tests/unit/auth.test.js]
+
+ **Advisory Notes:**
+ - Note: Consider adding rate limiting for production deployment
+ - Note: Document the JWT expiration policy in README
+ ```
+
+
+ The AC validation checklist and task validation checklist MUST be included in the review - this is the evidence trail
+
+
+
+
+ Generate review report as a standalone document
+ Save to {{output_folder}}/code-review-{{date}}.md
+ Include sections:
+ - Review Type: Ad-Hoc Code Review
+ - Reviewer: {{user_name}}
+ - Date: {{date}}
+ - Files Reviewed: {{review_files}}
+ - Review Focus: {{review_focus}}
+ - Outcome: (Approve | Changes Requested | Blocked)
+ - Summary
+ - Key Findings
+ - Test Coverage and Gaps
+ - Architectural Alignment
+ - Security Notes
+ - Best-Practices and References (with links)
+ - Action Items
+
+
+
+
+
+ Open {{story_path}} and append a new section at the end titled exactly: "Senior Developer Review (AI)".
+ Insert subsections:
+ - Reviewer: {{user_name}}
+ - Date: {{date}}
+ - Outcome: (Approve | Changes Requested | Blocked) with justification
+ - Summary
+ - Key Findings (by severity - HIGH/MEDIUM/LOW)
+ - **Acceptance Criteria Coverage**:
+ * Include complete AC validation checklist with table format
+ * AC# | Description | Status | Evidence
+ * Summary: X of Y ACs implemented
+ - **Task Completion Validation**:
+ * Include complete task validation checklist with table format
+ * Task | Marked As | Verified As | Evidence
+ * **Highlight falsely marked complete tasks prominently**
+ * Summary: X of Y tasks verified, Z questionable, W false completions
+ - Test Coverage and Gaps
+ - Architectural Alignment
+ - Security Notes
+ - Best-Practices and References (with links)
+ - Action Items:
+ * CRITICAL: Format with checkboxes for tracking resolution
+ * Code changes required: `- [ ] [Severity] Description [file: path:line]`
+ * Advisory notes: `- Note: Description (no action required)`
+ * Group by type: "Code Changes Required" and "Advisory Notes"
+
+ Add a Change Log entry with date, version bump if applicable, and description: "Senior Developer Review notes appended".
+ If {{update_status_on_result}} is true: update Status to {{status_on_approve}} when approved; to {{status_on_changes_requested}} when changes requested; otherwise leave unchanged.
+ Save the story file.
+
+ MUST include the complete validation checklists - this is the evidence that systematic review was performed
+
+
+
+
+
+ Skip sprint status update (no story context)
+
+
+
+
+ Determine target status based on review outcome:
+ - If {{outcome}} == "Approve" → target_status = "done"
+ - If {{outcome}} == "Changes Requested" → target_status = "in-progress"
+ - If {{outcome}} == "Blocked" → target_status = "review" (stay in review)
+
+
+ Load the FULL file: {{output_folder}}/sprint-status.yaml
+ Read all development_status entries to find {{story_key}}
+ Verify current status is "review" (expected previous state)
+ Update development_status[{{story_key}}] = {{target_status}}
+ Save file, preserving ALL comments and structure including STATUS DEFINITIONS
+
+
+
+
+
+
+
+
+
+
+
+
+
+ All action items are included in the standalone review report
+ Would you like me to create tracking items for these action items? (backlog/tasks)
+
+ If {{backlog_file}} does not exist, copy {installed_path}/backlog_template.md to {{backlog_file}} location.
+ Append a row per action item with Date={{date}}, Story="Ad-Hoc Review", Epic="N/A", Type, Severity, Owner (or "TBD"), Status="Open", Notes with file refs and context.
+
+
+
+
+ Normalize Action Items into a structured list: description, severity (High/Med/Low), type (Bug/TechDebt/Enhancement), suggested owner (if known), related AC/file references.
+ Add {{action_item_count}} follow-up items to story Tasks/Subtasks?
+
+ Append under the story's "Tasks / Subtasks" a new subsection titled "Review Follow-ups (AI)", adding each item as an unchecked checkbox in imperative form, prefixed with "[AI-Review]" and severity. Example: "- [ ] [AI-Review][High] Add input validation on server route /api/x (AC #2)".
+
+
+ If {{backlog_file}} does not exist, copy {installed_path}/backlog_template.md to {{backlog_file}} location.
+ Append a row per action item with Date={{date}}, Story={{epic_num}}.{{story_num}}, Epic={{epic_num}}, Type, Severity, Owner (or "TBD"), Status="Open", Notes with short context and file refs.
+
+
+ If an epic Tech Spec was found: open it and create (if missing) a section titled "{{epic_followups_section_title}}". Append a bullet list of action items scoped to this epic with references back to Story {{epic_num}}.{{story_num}}.
+
+ Save modified files.
+ Optionally invoke tests or linters to verify quick fixes if any were applied as part of review (requires user approval for any dependency changes).
+
+
+
+
+ Run validation checklist at {installed_path}/checklist.md using {project-root}/bmad/core/tasks/validate-workflow.xml
+ Report workflow completion.
+
+
+
+
+
+
+
+
+
+
+
+````
diff --git a/src/modules/bmgd/workflows/4-production/code-review/workflow.yaml b/src/modules/bmgd/workflows/4-production/code-review/workflow.yaml
new file mode 100644
index 00000000..75644b44
--- /dev/null
+++ b/src/modules/bmgd/workflows/4-production/code-review/workflow.yaml
@@ -0,0 +1,76 @@
+# Review Story Workflow
+name: code-review
+description: "Perform a Senior Developer code review on a completed story flagged Ready for Review, leveraging story-context, epic tech-spec, repo docs, MCP servers for latest best-practices, and web search as fallback. Appends structured review notes to the story."
+author: "BMad"
+
+# Critical variables from config
+config_source: "{project-root}/bmad/bmgd/config.yaml"
+output_folder: "{config_source}:output_folder"
+user_name: "{config_source}:user_name"
+communication_language: "{config_source}:communication_language"
+user_skill_level: "{config_source}:user_skill_level"
+document_output_language: "{config_source}:document_output_language"
+date: system-generated
+
+# Workflow components
+installed_path: "{project-root}/bmad/bmm/workflows/4-implementation/code-review"
+instructions: "{installed_path}/instructions.md"
+validation: "{installed_path}/checklist.md"
+
+# This is an action workflow (no output template document)
+template: false
+
+# Variables (can be provided by caller)
+variables:
+ story_path: "" # Optional: Explicit path to story file. If not provided, finds first story with status "review"
+ story_dir: "{config_source}:dev_story_location" # Directory containing story files
+ tech_spec_search_dir: "{project-root}/docs"
+ tech_spec_glob_template: "tech-spec-epic-{{epic_num}}*.md"
+ arch_docs_search_dirs: |
+ - "{project-root}/docs"
+ - "{output_folder}"
+ arch_docs_file_names: |
+ - architecture.md
+ enable_mcp_doc_search: true # Prefer enabled MCP servers for doc/best-practice lookup
+ enable_web_fallback: true # Fallback to web search/read-url if MCP not available
+ # Persistence controls for review action items and notes
+ persist_action_items: true
+ # Valid targets: story_tasks, story_review_section, backlog_file, epic_followups
+ persist_targets: |
+ - story_review_section
+ - story_tasks
+ - backlog_file
+ - epic_followups
+ backlog_file: "{project-root}/docs/backlog.md"
+ update_epic_followups: true
+ epic_followups_section_title: "Post-Review Follow-ups"
+
+# Recommended inputs
+recommended_inputs:
+ - story: "Path to the story file (auto-discovered if omitted - finds first story with status 'review')"
+ - tech_spec: "Epic technical specification document (auto-discovered)"
+ - story_context_file: "Story context file (.context.xml) (auto-discovered)"
+
+# Smart input file references - handles both whole docs and sharded docs
+# Priority: Whole document first, then sharded version
+# Strategy: SELECTIVE LOAD - only load the specific epic needed for this story review
+input_file_patterns:
+ architecture:
+ whole: "{output_folder}/*architecture*.md"
+ sharded: "{output_folder}/*architecture*/index.md"
+
+ ux_design:
+ whole: "{output_folder}/*ux*.md"
+ sharded: "{output_folder}/*ux*/index.md"
+
+ epics:
+ whole: "{output_folder}/*epic*.md"
+ sharded_index: "{output_folder}/*epic*/index.md"
+ sharded_single: "{output_folder}/*epic*/epic-{{epic_num}}.md"
+
+ document_project:
+ sharded: "{output_folder}/docs/index.md"
+
+standalone: true
+
+web_bundle: false
diff --git a/src/modules/bmgd/workflows/4-production/correct-course/checklist.md b/src/modules/bmgd/workflows/4-production/correct-course/checklist.md
new file mode 100644
index 00000000..b42b2381
--- /dev/null
+++ b/src/modules/bmgd/workflows/4-production/correct-course/checklist.md
@@ -0,0 +1,279 @@
+# Change Navigation Checklist
+
+This checklist is executed as part of: {project-root}/bmad/bmm/workflows/4-implementation/correct-course/workflow.yaml
+Work through each section systematically with the user, recording findings and impacts
+
+
+
+
+
+
+Identify the triggering story that revealed this issue
+Document story ID and brief description
+[ ] Done / [ ] N/A / [ ] Action-needed
+
+
+
+Define the core problem precisely
+Categorize issue type:
+ - Technical limitation discovered during implementation
+ - New requirement emerged from stakeholders
+ - Misunderstanding of original requirements
+ - Strategic pivot or market change
+ - Failed approach requiring different solution
+Write clear problem statement
+[ ] Done / [ ] N/A / [ ] Action-needed
+
+
+
+Assess initial impact and gather supporting evidence
+Collect concrete examples, error messages, stakeholder feedback, or technical constraints
+Document evidence for later reference
+[ ] Done / [ ] N/A / [ ] Action-needed
+
+
+
+HALT: "Cannot proceed without understanding what caused the need for change"
+HALT: "Need concrete evidence or examples of the issue before analyzing impact"
+
+
+
+
+
+
+
+Evaluate current epic containing the trigger story
+Can this epic still be completed as originally planned?
+If no, what modifications are needed?
+[ ] Done / [ ] N/A / [ ] Action-needed
+
+
+
+Determine required epic-level changes
+Check each scenario:
+ - Modify existing epic scope or acceptance criteria
+ - Add new epic to address the issue
+ - Remove or defer epic that's no longer viable
+ - Completely redefine epic based on new understanding
+Document specific epic changes needed
+[ ] Done / [ ] N/A / [ ] Action-needed
+
+
+
+Review all remaining planned epics for required changes
+Check each future epic for impact
+Identify dependencies that may be affected
+[ ] Done / [ ] N/A / [ ] Action-needed
+
+
+
+Check if issue invalidates future epics or necessitates new ones
+Does this change make any planned epics obsolete?
+Are new epics needed to address gaps created by this change?
+[ ] Done / [ ] N/A / [ ] Action-needed
+
+
+
+Consider if epic order or priority should change
+Should epics be resequenced based on this issue?
+Do priorities need adjustment?
+[ ] Done / [ ] N/A / [ ] Action-needed
+
+
+
+
+
+
+
+Check PRD for conflicts
+Does issue conflict with core PRD goals or objectives?
+Do requirements need modification, addition, or removal?
+Is the defined MVP still achievable or does scope need adjustment?
+[ ] Done / [ ] N/A / [ ] Action-needed
+
+
+
+Review Architecture document for conflicts
+Check each area for impact:
+ - System components and their interactions
+ - Architectural patterns and design decisions
+ - Technology stack choices
+ - Data models and schemas
+ - API designs and contracts
+ - Integration points
+Document specific architecture sections requiring updates
+[ ] Done / [ ] N/A / [ ] Action-needed
+
+
+
+Examine UI/UX specifications for conflicts
+Check for impact on:
+ - User interface components
+ - User flows and journeys
+ - Wireframes or mockups
+ - Interaction patterns
+ - Accessibility considerations
+Note specific UI/UX sections needing revision
+[ ] Done / [ ] N/A / [ ] Action-needed
+
+
+
+Consider impact on other artifacts
+Review additional artifacts for impact:
+ - Deployment scripts
+ - Infrastructure as Code (IaC)
+ - Monitoring and observability setup
+ - Testing strategies
+ - Documentation
+ - CI/CD pipelines
+Document any secondary artifacts requiring updates
+[ ] Done / [ ] N/A / [ ] Action-needed
+
+
+
+
+
+
+
+Evaluate Option 1: Direct Adjustment
+Can the issue be addressed by modifying existing stories?
+Can new stories be added within the current epic structure?
+Would this approach maintain project timeline and scope?
+Effort estimate: [High/Medium/Low]
+Risk level: [High/Medium/Low]
+[ ] Viable / [ ] Not viable
+
+
+
+Evaluate Option 2: Potential Rollback
+Would reverting recently completed stories simplify addressing this issue?
+Which stories would need to be rolled back?
+Is the rollback effort justified by the simplification gained?
+Effort estimate: [High/Medium/Low]
+Risk level: [High/Medium/Low]
+[ ] Viable / [ ] Not viable
+
+
+
+Evaluate Option 3: PRD MVP Review
+Is the original PRD MVP still achievable with this issue?
+Does MVP scope need to be reduced or redefined?
+Do core goals need modification based on new constraints?
+What would be deferred to post-MVP if scope is reduced?
+Effort estimate: [High/Medium/Low]
+Risk level: [High/Medium/Low]
+[ ] Viable / [ ] Not viable
+
+
+
+Select recommended path forward
+Based on analysis of all options, choose the best path
+Provide clear rationale considering:
+ - Implementation effort and timeline impact
+ - Technical risk and complexity
+ - Impact on team morale and momentum
+ - Long-term sustainability and maintainability
+ - Stakeholder expectations and business value
+Selected approach: [Option 1 / Option 2 / Option 3 / Hybrid]
+Justification: [Document reasoning]
+[ ] Done / [ ] N/A / [ ] Action-needed
+
+
+
+
+
+
+
+Create identified issue summary
+Write clear, concise problem statement
+Include context about discovery and impact
+[ ] Done / [ ] N/A / [ ] Action-needed
+
+
+
+Document epic impact and artifact adjustment needs
+Summarize findings from Epic Impact Assessment (Section 2)
+Summarize findings from Artifact Conflict Analysis (Section 3)
+Be specific about what changes are needed and why
+[ ] Done / [ ] N/A / [ ] Action-needed
+
+
+
+Present recommended path forward with rationale
+Include selected approach from Section 4
+Provide complete justification for recommendation
+Address trade-offs and alternatives considered
+[ ] Done / [ ] N/A / [ ] Action-needed
+
+
+
+Define PRD MVP impact and high-level action plan
+State clearly if MVP is affected
+Outline major action items needed for implementation
+Identify dependencies and sequencing
+[ ] Done / [ ] N/A / [ ] Action-needed
+
+
+
+Establish agent handoff plan
+Identify which roles/agents will execute the changes:
+ - Development team (for implementation)
+ - Product Owner / Scrum Master (for backlog changes)
+ - Product Manager / Architect (for strategic changes)
+Define responsibilities for each role
+[ ] Done / [ ] N/A / [ ] Action-needed
+
+
+
+
+
+
+
+Review checklist completion
+Verify all applicable sections have been addressed
+Confirm all [Action-needed] items have been documented
+Ensure analysis is comprehensive and actionable
+[ ] Done / [ ] N/A / [ ] Action-needed
+
+
+
+Verify Sprint Change Proposal accuracy
+Review complete proposal for consistency and clarity
+Ensure all recommendations are well-supported by analysis
+Check that proposal is actionable and specific
+[ ] Done / [ ] N/A / [ ] Action-needed
+
+
+
+Obtain explicit user approval
+Present complete proposal to user
+Get clear yes/no approval for proceeding
+Document approval and any conditions
+[ ] Done / [ ] N/A / [ ] Action-needed
+
+
+
+Confirm next steps and handoff plan
+Review handoff responsibilities with user
+Ensure all stakeholders understand their roles
+Confirm timeline and success criteria
+[ ] Done / [ ] N/A / [ ] Action-needed
+
+
+
+HALT: "Cannot proceed to proposal without complete impact analysis"
+HALT: "Must have explicit approval before implementing changes"
+HALT: "Must clearly define who will execute the proposed changes"
+
+
+
+
+
+
+
+This checklist is for SIGNIFICANT changes affecting project direction
+Work interactively with user - they make final decisions
+Be factual, not blame-oriented when analyzing issues
+Handle changes professionally as opportunities to improve the project
+Maintain conversation context throughout - this is collaborative work
+
diff --git a/src/modules/bmgd/workflows/4-production/correct-course/instructions.md b/src/modules/bmgd/workflows/4-production/correct-course/instructions.md
new file mode 100644
index 00000000..8c5f964c
--- /dev/null
+++ b/src/modules/bmgd/workflows/4-production/correct-course/instructions.md
@@ -0,0 +1,201 @@
+# Correct Course - Sprint Change Management Instructions
+
+The workflow execution engine is governed by: {project-root}/bmad/core/tasks/workflow.xml
+You MUST have already loaded and processed: {project-root}/bmad/bmm/workflows/4-implementation/correct-course/workflow.yaml
+Communicate all responses in {communication_language} and language MUST be tailored to {user_skill_level}
+Generate all documents in {document_output_language}
+
+DOCUMENT OUTPUT: Updated epics, stories, or PRD sections. Clear, actionable changes. User skill level ({user_skill_level}) affects conversation style ONLY, not document updates.
+
+
+
+
+ Confirm change trigger and gather user description of the issue
+ Ask: "What specific issue or change has been identified that requires navigation?"
+ Verify access to required project documents:
+ - PRD (Product Requirements Document)
+ - Current Epics and Stories
+ - Architecture documentation
+ - UI/UX specifications
+ Ask user for mode preference:
+ - **Incremental** (recommended): Refine each edit collaboratively
+ - **Batch**: Present all changes at once for review
+ Store mode selection for use throughout workflow
+
+HALT: "Cannot navigate change without clear understanding of the triggering issue. Please provide specific details about what needs to change and why."
+
+HALT: "Need access to project documents (PRD, Epics, Architecture, UI/UX) to assess change impact. Please ensure these documents are accessible."
+
+
+
+ Load and execute the systematic analysis from: {checklist}
+ Work through each checklist section interactively with the user
+ Record status for each checklist item:
+ - [x] Done - Item completed successfully
+ - [N/A] Skip - Item not applicable to this change
+ - [!] Action-needed - Item requires attention or follow-up
+ Maintain running notes of findings and impacts discovered
+ Present checklist progress after each major section
+
+Identify blocking issues and work with user to resolve before continuing
+
+
+
+Based on checklist findings, create explicit edit proposals for each identified artifact
+
+For Story changes:
+
+- Show old → new text format
+- Include story ID and section being modified
+- Provide rationale for each change
+- Example format:
+
+ ```
+ Story: [STORY-123] User Authentication
+ Section: Acceptance Criteria
+
+ OLD:
+ - User can log in with email/password
+
+ NEW:
+ - User can log in with email/password
+ - User can enable 2FA via authenticator app
+
+ Rationale: Security requirement identified during implementation
+ ```
+
+For PRD modifications:
+
+- Specify exact sections to update
+- Show current content and proposed changes
+- Explain impact on MVP scope and requirements
+
+For Architecture changes:
+
+- Identify affected components, patterns, or technology choices
+- Describe diagram updates needed
+- Note any ripple effects on other components
+
+For UI/UX specification updates:
+
+- Reference specific screens or components
+- Show wireframe or flow changes needed
+- Connect changes to user experience impact
+
+
+ Present each edit proposal individually
+ Review and refine this change? Options: Approve [a], Edit [e], Skip [s]
+ Iterate on each proposal based on user feedback
+
+
+Collect all edit proposals and present together at end of step
+
+
+
+
+Compile comprehensive Sprint Change Proposal document with following sections:
+
+Section 1: Issue Summary
+
+- Clear problem statement describing what triggered the change
+- Context about when/how the issue was discovered
+- Evidence or examples demonstrating the issue
+
+Section 2: Impact Analysis
+
+- Epic Impact: Which epics are affected and how
+- Story Impact: Current and future stories requiring changes
+- Artifact Conflicts: PRD, Architecture, UI/UX documents needing updates
+- Technical Impact: Code, infrastructure, or deployment implications
+
+Section 3: Recommended Approach
+
+- Present chosen path forward from checklist evaluation:
+ - Direct Adjustment: Modify/add stories within existing plan
+ - Potential Rollback: Revert completed work to simplify resolution
+ - MVP Review: Reduce scope or modify goals
+- Provide clear rationale for recommendation
+- Include effort estimate, risk assessment, and timeline impact
+
+Section 4: Detailed Change Proposals
+
+- Include all refined edit proposals from Step 3
+- Group by artifact type (Stories, PRD, Architecture, UI/UX)
+- Ensure each change includes before/after and justification
+
+Section 5: Implementation Handoff
+
+- Categorize change scope:
+ - Minor: Direct implementation by dev team
+ - Moderate: Backlog reorganization needed (PO/SM)
+ - Major: Fundamental replan required (PM/Architect)
+- Specify handoff recipients and their responsibilities
+- Define success criteria for implementation
+
+Present complete Sprint Change Proposal to user
+Write Sprint Change Proposal document to {default_output_file}
+Review complete proposal. Continue [c] or Edit [e]?
+
+
+
+Get explicit user approval for complete proposal
+Do you approve this Sprint Change Proposal for implementation? (yes/no/revise)
+
+
+ Gather specific feedback on what needs adjustment
+ Return to appropriate step to address concerns
+ If changes needed to edit proposals
+ If changes needed to overall proposal structure
+
+
+
+
+ Finalize Sprint Change Proposal document
+ Determine change scope classification:
+
+- **Minor**: Can be implemented directly by development team
+- **Moderate**: Requires backlog reorganization and PO/SM coordination
+- **Major**: Needs fundamental replan with PM/Architect involvement
+
+Provide appropriate handoff based on scope:
+
+
+
+
+ Route to: Development team for direct implementation
+ Deliverables: Finalized edit proposals and implementation tasks
+
+
+
+ Route to: Product Owner / Scrum Master agents
+ Deliverables: Sprint Change Proposal + backlog reorganization plan
+
+
+
+ Route to: Product Manager / Solution Architect
+ Deliverables: Complete Sprint Change Proposal + escalation notice
+
+Confirm handoff completion and next steps with user
+Document handoff in workflow execution log
+
+
+
+
+
+Summarize workflow execution:
+ - Issue addressed: {{change_trigger}}
+ - Change scope: {{scope_classification}}
+ - Artifacts modified: {{list_of_artifacts}}
+ - Routed to: {{handoff_recipients}}
+
+Confirm all deliverables produced:
+
+- Sprint Change Proposal document
+- Specific edit proposals with before/after
+- Implementation handoff plan
+
+Report workflow completion to user with personalized message: "✅ Correct Course workflow complete, {user_name}!"
+Remind user of success criteria and next steps for implementation team
+
+
+
diff --git a/src/modules/bmgd/workflows/4-production/correct-course/workflow.yaml b/src/modules/bmgd/workflows/4-production/correct-course/workflow.yaml
new file mode 100644
index 00000000..69b4e541
--- /dev/null
+++ b/src/modules/bmgd/workflows/4-production/correct-course/workflow.yaml
@@ -0,0 +1,45 @@
+# Correct Course - Sprint Change Management Workflow
+name: "correct-course"
+description: "Navigate significant changes during sprint execution by analyzing impact, proposing solutions, and routing for implementation"
+author: "BMad Method"
+
+config_source: "{project-root}/bmad/bmgd/config.yaml"
+output_folder: "{config_source}:output_folder"
+user_name: "{config_source}:user_name"
+communication_language: "{config_source}:communication_language"
+user_skill_level: "{config_source}:user_skill_level"
+document_output_language: "{config_source}:document_output_language"
+date: system-generated
+
+installed_path: "{project-root}/bmad/bmm/workflows/4-implementation/correct-course"
+template: false
+instructions: "{installed_path}/instructions.md"
+validation: "{installed_path}/checklist.md"
+checklist: "{installed_path}/checklist.md"
+default_output_file: "{output_folder}/sprint-change-proposal-{date}.md"
+
+# Workflow execution mode (interactive: step-by-step with user, non-interactive: automated)
+mode: interactive
+
+required_inputs:
+ - change_trigger: "Description of the issue or change that triggered this workflow"
+ - project_documents: "Access to PRD, Epics/Stories, Architecture, UI/UX specs"
+
+output_artifacts:
+ - sprint_change_proposal: "Comprehensive proposal documenting issue, impact, and recommended changes"
+ - artifact_edits: "Specific before/after edits for affected documents"
+ - handoff_plan: "Clear routing for implementation based on change scope"
+
+halt_conditions:
+ - "Change trigger unclear or undefined"
+ - "Core project documents unavailable"
+ - "Impact analysis incomplete"
+ - "User approval not obtained"
+
+execution_modes:
+ - incremental: "Recommended - Refine each edit with user collaboration"
+ - batch: "Present all changes at once for review"
+
+standalone: true
+
+web_bundle: false
diff --git a/src/modules/bmgd/workflows/4-production/create-story/checklist.md b/src/modules/bmgd/workflows/4-production/create-story/checklist.md
new file mode 100644
index 00000000..6d9f1460
--- /dev/null
+++ b/src/modules/bmgd/workflows/4-production/create-story/checklist.md
@@ -0,0 +1,240 @@
+# Create Story Quality Validation Checklist
+
+```xml
+This validation runs in a FRESH CONTEXT by an independent validator agent
+The validator audits story quality and offers to improve if issues are found
+Load only the story file and necessary source documents - do NOT load workflow instructions
+
+
+
+
+**What create-story workflow should have accomplished:**
+
+1. **Previous Story Continuity:** If a previous story exists (status: done/review/in-progress), current story should have "Learnings from Previous Story" subsection in Dev Notes that references: new files created, completion notes, architectural decisions, unresolved review items
+2. **Source Document Coverage:** Story should cite tech spec (if exists), epics, PRD, and relevant architecture docs (architecture.md, testing-strategy.md, coding-standards.md, unified-project-structure.md)
+3. **Requirements Traceability:** ACs sourced from tech spec (preferred) or epics, not invented
+4. **Dev Notes Quality:** Specific guidance with citations, not generic advice
+5. **Task-AC Mapping:** Every AC has tasks, every task references AC, testing subtasks present
+6. **Structure:** Status="drafted", proper story statement, Dev Agent Record sections initialized
+
+
+## Validation Steps
+
+### 1. Load Story and Extract Metadata
+- [ ] Load story file: {{story_file_path}}
+- [ ] Parse sections: Status, Story, ACs, Tasks, Dev Notes, Dev Agent Record, Change Log
+- [ ] Extract: epic_num, story_num, story_key, story_title
+- [ ] Initialize issue tracker (Critical/Major/Minor)
+
+### 2. Previous Story Continuity Check
+
+**Find previous story:**
+- [ ] Load {output_folder}/sprint-status.yaml
+- [ ] Find current {{story_key}} in development_status
+- [ ] Identify story entry immediately above (previous story)
+- [ ] Check previous story status
+
+**If previous story status is done/review/in-progress:**
+- [ ] Load previous story file: {story_dir}/{{previous_story_key}}.md
+- [ ] Extract: Dev Agent Record (Completion Notes, File List with NEW/MODIFIED)
+- [ ] Extract: Senior Developer Review section if present
+- [ ] Count unchecked [ ] items in Review Action Items
+- [ ] Count unchecked [ ] items in Review Follow-ups (AI)
+
+**Validate current story captured continuity:**
+- [ ] Check: "Learnings from Previous Story" subsection exists in Dev Notes
+ - If MISSING and previous story has content → **CRITICAL ISSUE**
+- [ ] If subsection exists, verify it includes:
+ - [ ] References to NEW files from previous story → If missing → **MAJOR ISSUE**
+ - [ ] Mentions completion notes/warnings → If missing → **MAJOR ISSUE**
+ - [ ] Calls out unresolved review items (if any exist) → If missing → **CRITICAL ISSUE**
+ - [ ] Cites previous story: [Source: stories/{{previous_story_key}}.md]
+
+**If previous story status is backlog/drafted:**
+- [ ] No continuity expected (note this)
+
+**If no previous story exists:**
+- [ ] First story in epic, no continuity expected
+
+### 3. Source Document Coverage Check
+
+**Build available docs list:**
+- [ ] Check exists: tech-spec-epic-{{epic_num}}*.md in {tech_spec_search_dir}
+- [ ] Check exists: {output_folder}/epics.md
+- [ ] Check exists: {output_folder}/PRD.md
+- [ ] Check exists in {output_folder}/ or {project-root}/docs/:
+ - architecture.md, testing-strategy.md, coding-standards.md
+ - unified-project-structure.md, tech-stack.md
+ - backend-architecture.md, frontend-architecture.md, data-models.md
+
+**Validate story references available docs:**
+- [ ] Extract all [Source: ...] citations from story Dev Notes
+- [ ] Tech spec exists but not cited → **CRITICAL ISSUE**
+- [ ] Epics exists but not cited → **CRITICAL ISSUE**
+- [ ] Architecture.md exists → Read for relevance → If relevant but not cited → **MAJOR ISSUE**
+- [ ] Testing-strategy.md exists → Check Dev Notes mentions testing standards → If not → **MAJOR ISSUE**
+- [ ] Testing-strategy.md exists → Check Tasks have testing subtasks → If not → **MAJOR ISSUE**
+- [ ] Coding-standards.md exists → Check Dev Notes references standards → If not → **MAJOR ISSUE**
+- [ ] Unified-project-structure.md exists → Check Dev Notes has "Project Structure Notes" subsection → If not → **MAJOR ISSUE**
+
+**Validate citation quality:**
+- [ ] Verify cited file paths are correct and files exist → Bad citations → **MAJOR ISSUE**
+- [ ] Check citations include section names, not just file paths → Vague citations → **MINOR ISSUE**
+
+### 4. Acceptance Criteria Quality Check
+
+- [ ] Extract Acceptance Criteria from story
+- [ ] Count ACs: {{ac_count}} (if 0 → **CRITICAL ISSUE** and halt)
+- [ ] Check story indicates AC source (tech spec, epics, PRD)
+
+**If tech spec exists:**
+- [ ] Load tech spec
+- [ ] Search for this story number
+- [ ] Extract tech spec ACs for this story
+- [ ] Compare story ACs vs tech spec ACs → If mismatch → **MAJOR ISSUE**
+
+**If no tech spec but epics.md exists:**
+- [ ] Load epics.md
+- [ ] Search for Epic {{epic_num}}, Story {{story_num}}
+- [ ] Story not found in epics → **CRITICAL ISSUE** (should have halted)
+- [ ] Extract epics ACs
+- [ ] Compare story ACs vs epics ACs → If mismatch without justification → **MAJOR ISSUE**
+
+**Validate AC quality:**
+- [ ] Each AC is testable (measurable outcome)
+- [ ] Each AC is specific (not vague)
+- [ ] Each AC is atomic (single concern)
+- [ ] Vague ACs found → **MINOR ISSUE**
+
+### 5. Task-AC Mapping Check
+
+- [ ] Extract Tasks/Subtasks from story
+- [ ] For each AC: Search tasks for "(AC: #{{ac_num}})" reference
+ - [ ] AC has no tasks → **MAJOR ISSUE**
+- [ ] For each task: Check if references an AC number
+ - [ ] Tasks without AC refs (and not testing/setup) → **MINOR ISSUE**
+- [ ] Count tasks with testing subtasks
+ - [ ] Testing subtasks < ac_count → **MAJOR ISSUE**
+
+### 6. Dev Notes Quality Check
+
+**Check required subsections exist:**
+- [ ] Architecture patterns and constraints
+- [ ] References (with citations)
+- [ ] Project Structure Notes (if unified-project-structure.md exists)
+- [ ] Learnings from Previous Story (if previous story has content)
+- [ ] Missing required subsections → **MAJOR ISSUE**
+
+**Validate content quality:**
+- [ ] Architecture guidance is specific (not generic "follow architecture docs") → If generic → **MAJOR ISSUE**
+- [ ] Count citations in References subsection
+ - [ ] No citations → **MAJOR ISSUE**
+ - [ ] < 3 citations and multiple arch docs exist → **MINOR ISSUE**
+- [ ] Scan for suspicious specifics without citations:
+ - API endpoints, schema details, business rules, tech choices
+ - [ ] Likely invented details found → **MAJOR ISSUE**
+
+### 7. Story Structure Check
+
+- [ ] Status = "drafted" → If not → **MAJOR ISSUE**
+- [ ] Story section has "As a / I want / so that" format → If malformed → **MAJOR ISSUE**
+- [ ] Dev Agent Record has required sections:
+ - Context Reference, Agent Model Used, Debug Log References, Completion Notes List, File List
+ - [ ] Missing sections → **MAJOR ISSUE**
+- [ ] Change Log initialized → If missing → **MINOR ISSUE**
+- [ ] File in correct location: {story_dir}/{{story_key}}.md → If not → **MAJOR ISSUE**
+
+### 8. Unresolved Review Items Alert
+
+**CRITICAL CHECK for incomplete review items from previous story:**
+
+- [ ] If previous story has "Senior Developer Review (AI)" section:
+ - [ ] Count unchecked [ ] items in "Action Items"
+ - [ ] Count unchecked [ ] items in "Review Follow-ups (AI)"
+ - [ ] If unchecked items > 0:
+ - [ ] Check current story "Learnings from Previous Story" mentions these
+ - [ ] If NOT mentioned → **CRITICAL ISSUE** with details:
+ - List all unchecked items with severity
+ - Note: "These may represent epic-wide concerns"
+ - Required: Add to Learnings section with note about pending items
+
+## Validation Report Generation
+
+**Calculate severity counts:**
+- Critical: {{critical_count}}
+- Major: {{major_count}}
+- Minor: {{minor_count}}
+
+**Determine outcome:**
+- Critical > 0 OR Major > 3 → **FAIL**
+- Major ≤ 3 and Critical = 0 → **PASS with issues**
+- All = 0 → **PASS**
+
+**Generate report:**
+```
+
+# Story Quality Validation Report
+
+Story: {{story_key}} - {{story_title}}
+Outcome: {{outcome}} (Critical: {{critical_count}}, Major: {{major_count}}, Minor: {{minor_count}})
+
+## Critical Issues (Blockers)
+
+{{list_each_with_description_and_evidence}}
+
+## Major Issues (Should Fix)
+
+{{list_each_with_description_and_evidence}}
+
+## Minor Issues (Nice to Have)
+
+{{list_each_with_description}}
+
+## Successes
+
+{{list_what_was_done_well}}
+
+```
+
+## User Alert and Remediation
+
+**If FAIL:**
+- Show issues summary and top 3 issues
+- Offer options: (1) Auto-improve story, (2) Show detailed findings, (3) Fix manually, (4) Accept as-is
+- If option 1: Re-load source docs, regenerate affected sections, re-run validation
+
+**If PASS with issues:**
+- Show issues list
+- Ask: "Improve story? (y/n)"
+- If yes: Enhance story with missing items
+
+**If PASS:**
+- Confirm: All quality standards met
+- List successes
+- Ready for story-context generation
+
+
+```
+
+## Quick Reference
+
+**Validation runs in fresh context and checks:**
+
+1. ✅ Previous story continuity captured (files, notes, **unresolved review items**)
+2. ✅ All relevant source docs discovered and cited
+3. ✅ ACs match tech spec/epics exactly
+4. ✅ Tasks cover all ACs with testing
+5. ✅ Dev Notes have specific guidance with citations (not generic)
+6. ✅ Structure and metadata complete
+
+**Severity Levels:**
+
+- **CRITICAL** = Missing previous story reference, missing tech spec cite, unresolved review items not called out, story not in epics
+- **MAJOR** = Missing arch docs, missing files from previous story, vague Dev Notes, ACs don't match source, no testing subtasks
+- **MINOR** = Vague citations, orphan tasks, missing Change Log
+
+**Outcome Triggers:**
+
+- **FAIL** = Any critical OR >3 major issues
+- **PASS with issues** = ≤3 major issues, no critical
+- **PASS** = All checks passed
diff --git a/src/modules/bmgd/workflows/4-production/create-story/instructions.md b/src/modules/bmgd/workflows/4-production/create-story/instructions.md
new file mode 100644
index 00000000..e5b8182a
--- /dev/null
+++ b/src/modules/bmgd/workflows/4-production/create-story/instructions.md
@@ -0,0 +1,283 @@
+# Create Story - Workflow Instructions (Spec-compliant, non-interactive by default)
+
+````xml
+The workflow execution engine is governed by: {project_root}/bmad/core/tasks/workflow.xml
+You MUST have already loaded and processed: {installed_path}/workflow.yaml
+Generate all documents in {document_output_language}
+This workflow creates or updates the next user story from epics/PRD and architecture context, saving to the configured stories directory and optionally invoking Story Context.
+DOCUMENT OUTPUT: Concise, technical, actionable story specifications. Use tables/lists for acceptance criteria and tasks.
+
+## 📚 Document Discovery - Selective Epic Loading
+
+**Strategy**: This workflow needs only ONE specific epic and its stories, not all epics. This provides huge efficiency gains when epics are sharded.
+
+**Epic Discovery Process (SELECTIVE OPTIMIZATION):**
+
+1. **Determine which epic** you need (epic_num from story context - e.g., story "3-2-feature-name" needs Epic 3)
+2. **Check for sharded version**: Look for `epics/index.md`
+3. **If sharded version found**:
+ - Read `index.md` to understand structure
+ - **Load ONLY `epic-{epic_num}.md`** (e.g., `epics/epic-3.md` for Epic 3)
+ - DO NOT load all epic files - only the one needed!
+ - This is the key efficiency optimization for large multi-epic projects
+4. **If whole document found**: Load the complete `epics.md` file and extract the relevant epic
+
+**Other Documents (prd, architecture, ux-design) - Full Load:**
+
+1. **Search for whole document first** - Use fuzzy file matching
+2. **Check for sharded version** - If whole document not found, look for `{doc-name}/index.md`
+3. **If sharded version found**:
+ - Read `index.md` to understand structure
+ - Read ALL section files listed in the index
+ - Treat combined content as single document
+4. **Brownfield projects**: The `document-project` workflow creates `{output_folder}/docs/index.md`
+
+**Priority**: If both whole and sharded versions exist, use the whole document.
+
+**UX-Heavy Projects**: Always check for ux-design documentation as it provides critical context for UI-focused stories.
+
+
+
+
+ Resolve variables from config_source: story_dir (dev_story_location), output_folder, user_name, communication_language. If story_dir missing and {{non_interactive}} == false → ASK user to provide a stories directory and update variable. If {{non_interactive}} == true and missing, HALT with a clear message.
+ Create {{story_dir}} if it does not exist
+ Resolve installed component paths from workflow.yaml: template, instructions, validation
+ Resolve recommended inputs if present: epics_file, prd_file, architecture_file
+
+
+
+ PREVIOUS STORY CONTINUITY: Essential for maintaining context and learning from prior development
+
+ Find the previous completed story to extract dev agent learnings and review findings:
+ 1. Load {{output_folder}}/sprint-status.yaml COMPLETELY
+ 2. Find current {{story_key}} in development_status section
+ 3. Identify the story entry IMMEDIATELY ABOVE current story (previous row in file order)
+ 4. If previous story exists:
+ - Extract {{previous_story_key}}
+ - Check previous story status (done, in-progress, review, etc.)
+ - If status is "done", "review", or "in-progress" (has some completion):
+ * Construct path: {{story_dir}}/{{previous_story_key}}.md
+ * Load the COMPLETE previous story file
+ * Parse ALL sections comprehensively:
+
+ A) Dev Agent Record → Completion Notes List:
+ - New patterns/services created (to reuse, not recreate)
+ - Architectural deviations or decisions made
+ - Technical debt deferred to future stories
+ - Warnings or recommendations for next story
+ - Interfaces/methods created for reuse
+
+ B) Dev Agent Record → Debug Log References:
+ - Issues encountered and solutions
+ - Gotchas or unexpected challenges
+ - Workarounds applied
+
+ C) Dev Agent Record → File List:
+ - Files created (NEW) - understand new capabilities
+ - Files modified (MODIFIED) - track evolving components
+ - Files deleted (DELETED) - removed functionality
+
+ D) Dev Notes:
+ - Any "future story" notes or TODOs
+ - Patterns established
+ - Constraints discovered
+
+ E) Senior Developer Review (AI) section (if present):
+ - Review outcome (Approve/Changes Requested/Blocked)
+ - Unresolved action items (unchecked [ ] items)
+ - Key findings that might affect this story
+ - Architectural concerns raised
+
+ F) Senior Developer Review → Action Items (if present):
+ - Check for unchecked [ ] items still pending
+ - Note any systemic issues that apply to multiple stories
+
+ G) Review Follow-ups (AI) tasks (if present):
+ - Check for unchecked [ ] review tasks still pending
+ - Determine if they're epic-wide concerns
+
+ H) Story Status:
+ - If "review" or "in-progress" - incomplete, note what's pending
+ - If "done" - confirmed complete
+ * Store ALL findings as {{previous_story_learnings}} with structure:
+ - new_files: [list]
+ - modified_files: [list]
+ - new_services: [list with descriptions]
+ - architectural_decisions: [list]
+ - technical_debt: [list]
+ - warnings_for_next: [list]
+ - review_findings: [list if review exists]
+ - pending_items: [list of unchecked action items]
+ - If status is "backlog" or "drafted":
+ * Set {{previous_story_learnings}} = "Previous story not yet implemented"
+ 5. If no previous story exists (first story in epic):
+ - Set {{previous_story_learnings}} = "First story in epic - no predecessor context"
+
+
+ If {{tech_spec_file}} empty: derive from {{tech_spec_glob_template}} with {{epic_num}} and search {{tech_spec_search_dir}} recursively. If multiple, pick most recent by modified time.
+ Build a prioritized document set for this epic:
+ 1) tech_spec_file (epic-scoped)
+ 2) epics_file (acceptance criteria and breakdown)
+ 3) prd_file (business requirements and constraints)
+ 4) architecture_file (architecture constraints)
+ 5) Architecture docs under docs/ and output_folder/: tech-stack.md, unified-project-structure.md, coding-standards.md, testing-strategy.md, backend-architecture.md, frontend-architecture.md, data-models.md, database-schema.md, rest-api-spec.md, external-apis.md (include if present)
+
+ READ COMPLETE FILES for all items found in the prioritized set. Store content and paths for citation.
+
+
+
+ MUST read COMPLETE sprint-status.yaml file from start to end to preserve order
+ Load the FULL file: {{output_folder}}/sprint-status.yaml
+ Read ALL lines from beginning to end - do not skip any content
+ Parse the development_status section completely to understand story order
+
+ Find the FIRST story (by reading in order from top to bottom) where:
+ - Key matches pattern: number-number-name (e.g., "1-2-user-auth")
+ - NOT an epic key (epic-X) or retrospective (epic-X-retrospective)
+ - Status value equals "backlog"
+
+
+
+
+ HALT
+
+
+ Extract from found story key (e.g., "1-2-user-authentication"):
+ - epic_num: first number before dash (e.g., "1")
+ - story_num: second number after first dash (e.g., "2")
+ - story_title: remainder after second dash (e.g., "user-authentication")
+
+ Set {{story_id}} = "{{epic_num}}.{{story_num}}"
+ Store story_key for later use (e.g., "1-2-user-authentication")
+
+ Verify story is enumerated in {{epics_file}}. If not found, HALT with message:
+ "Story {{story_key}} not found in epics.md. Please load PM agent and run correct-course to sync epics, then rerun create-story."
+
+ Check if story file already exists at expected path in {{story_dir}}
+
+
+ Set update_mode = true
+
+
+
+
+ From tech_spec_file (preferred) or epics_file: extract epic {{epic_num}} title/summary, acceptance criteria for the next story, and any component references. If not present, fall back to PRD sections mapping to this epic/story.
+ From architecture and architecture docs: extract constraints, patterns, component boundaries, and testing guidance relevant to the extracted ACs. ONLY capture information that directly informs implementation of this story.
+ Derive a clear user story statement (role, action, benefit) grounded strictly in the above sources. If ambiguous and {{non_interactive}} == false → ASK user to clarify. If {{non_interactive}} == true → generate the best grounded statement WITHOUT inventing domain facts.
+ requirements_context_summary
+
+
+
+ Review {{previous_story_learnings}} and extract actionable intelligence:
+ - New patterns/services created → Note for reuse (DO NOT recreate)
+ - Architectural deviations → Understand and maintain consistency
+ - Technical debt items → Assess if this story should address them
+ - Files modified → Understand current state of evolving components
+ - Warnings/recommendations → Apply to this story's approach
+ - Review findings → Learn from issues found in previous story
+ - Pending action items → Determine if epic-wide concerns affect this story
+
+
+ If unified-project-structure.md present: align expected file paths, module names, and component locations; note any potential conflicts.
+
+ Cross-reference {{previous_story_learnings}}.new_files with project structure to understand where new capabilities are located.
+
+ structure_alignment_summary
+
+
+
+ Assemble acceptance criteria list from tech_spec or epics. If gaps exist, derive minimal, testable criteria from PRD verbatim phrasing (NO invention).
+ Create tasks/subtasks directly mapped to ACs. Include explicit testing subtasks per testing-strategy and existing tests framework. Cite architecture/source documents for any technical mandates.
+ acceptance_criteria
+ tasks_subtasks
+
+
+
+ Resolve output path: {default_output_file} using current {{epic_num}} and {{story_num}}. If targeting an existing story for update, use its path.
+ Initialize from template.md if creating a new file; otherwise load existing file for edit.
+ Compute a concise story_title from epic/story context; if missing, synthesize from PRD feature name and epic number.
+ story_header
+ story_body
+ dev_notes_with_citations
+
+ If {{previous_story_learnings}} contains actionable items (not "First story" or "not yet implemented"):
+ - Add "Learnings from Previous Story" subsection to Dev Notes
+ - Include relevant completion notes, new files/patterns, deviations
+ - Cite previous story file as reference [Source: stories/{{previous_story_key}}.md]
+ - Highlight interfaces/services to REUSE (not recreate)
+ - Note any technical debt to address in this story
+ - List pending review items that affect this story (if any)
+ - Reference specific files created: "Use {{file_path}} for {{purpose}}"
+ - Format example:
+ ```
+ ### Learnings from Previous Story
+
+ **From Story {{previous_story_key}} (Status: {{previous_status}})**
+
+ - **New Service Created**: `AuthService` base class available at `src/services/AuthService.js` - use `AuthService.register()` method
+ - **Architectural Change**: Switched from session-based to JWT authentication
+ - **Schema Changes**: User model now includes `passwordHash` field, migration applied
+ - **Technical Debt**: Email verification skipped, should be included in this or subsequent story
+ - **Testing Setup**: Auth test suite initialized at `tests/integration/auth.test.js` - follow patterns established there
+ - **Pending Review Items**: Rate limiting mentioned in review - consider for this story
+
+ [Source: stories/{{previous_story_key}}.md#Dev-Agent-Record]
+ ```
+
+
+ change_log
+
+
+
+ Validate against checklist at {installed_path}/checklist.md using bmad/core/tasks/validate-workflow.xml
+ Save document unconditionally (non-interactive default). In interactive mode, allow user confirmation.
+
+
+ Update {{output_folder}}/sprint-status.yaml
+ Load the FULL file and read all development_status entries
+ Find development_status key matching {{story_key}}
+ Verify current status is "backlog" (expected previous state)
+ Update development_status[{{story_key}}] = "drafted"
+ Save file, preserving ALL comments and structure including STATUS DEFINITIONS
+
+
+
+
+
+ Report created/updated story path
+
+
+
+
+````
diff --git a/src/modules/bmgd/workflows/4-production/create-story/template.md b/src/modules/bmgd/workflows/4-production/create-story/template.md
new file mode 100644
index 00000000..6aa80bad
--- /dev/null
+++ b/src/modules/bmgd/workflows/4-production/create-story/template.md
@@ -0,0 +1,51 @@
+# Story {{epic_num}}.{{story_num}}: {{story_title}}
+
+Status: drafted
+
+## Story
+
+As a {{role}},
+I want {{action}},
+so that {{benefit}}.
+
+## Acceptance Criteria
+
+1. [Add acceptance criteria from epics/PRD]
+
+## Tasks / Subtasks
+
+- [ ] Task 1 (AC: #)
+ - [ ] Subtask 1.1
+- [ ] Task 2 (AC: #)
+ - [ ] Subtask 2.1
+
+## Dev Notes
+
+- Relevant architecture patterns and constraints
+- Source tree components to touch
+- Testing standards summary
+
+### Project Structure Notes
+
+- Alignment with unified project structure (paths, modules, naming)
+- Detected conflicts or variances (with rationale)
+
+### References
+
+- Cite all technical details with source paths and sections, e.g. [Source: docs/.md#Section]
+
+## Dev Agent Record
+
+### Context Reference
+
+
+
+### Agent Model Used
+
+{{agent_model_name_version}}
+
+### Debug Log References
+
+### Completion Notes List
+
+### File List
diff --git a/src/modules/bmgd/workflows/4-production/create-story/workflow.yaml b/src/modules/bmgd/workflows/4-production/create-story/workflow.yaml
new file mode 100644
index 00000000..179a5173
--- /dev/null
+++ b/src/modules/bmgd/workflows/4-production/create-story/workflow.yaml
@@ -0,0 +1,76 @@
+name: create-story
+description: "Create the next user story markdown from epics/PRD and architecture, using a standard template and saving to the stories folder"
+author: "BMad"
+
+# Critical variables from config
+config_source: "{project-root}/bmad/bmgd/config.yaml"
+output_folder: "{config_source}:output_folder"
+user_name: "{config_source}:user_name"
+communication_language: "{config_source}:communication_language"
+date: system-generated
+
+# Workflow components
+installed_path: "{project-root}/bmad/bmm/workflows/4-implementation/create-story"
+template: "{installed_path}/template.md"
+instructions: "{installed_path}/instructions.md"
+validation: "{installed_path}/checklist.md"
+
+# Variables and inputs
+variables:
+ story_dir: "{config_source}:dev_story_location" # Directory where stories are stored
+ epics_file: "{output_folder}/epics.md" # Preferred source for epic/story breakdown
+ prd_file: "{output_folder}/PRD.md" # Fallback for requirements
+ architecture_file: "{output_folder}/architecture.md" # Optional architecture context
+ tech_spec_file: "" # Will be auto-discovered from docs as tech-spec-epic-{{epic_num}}-*.md
+ tech_spec_search_dir: "{project-root}/docs"
+ tech_spec_glob_template: "tech-spec-epic-{{epic_num}}*.md"
+ arch_docs_search_dirs: |
+ - "{project-root}/docs"
+ - "{output_folder}"
+ arch_docs_file_names: |
+ - architecture.md
+ - infrastructure-architecture.md
+ story_title: "" # Will be elicited if not derivable
+ epic_num: 1
+ story_num: 1
+ non_interactive: true # Generate without elicitation; avoid interactive prompts
+
+# Output configuration
+# Uses story_key from sprint-status.yaml (e.g., "1-2-user-authentication")
+default_output_file: "{story_dir}/{{story_key}}.md"
+
+recommended_inputs:
+ - epics: "Epic breakdown (epics.md)"
+ - prd: "PRD document"
+ - architecture: "Architecture (optional)"
+
+# Smart input file references - handles both whole docs and sharded docs
+# Priority: Whole document first, then sharded version
+# Strategy: SELECTIVE LOAD - only load the specific epic needed for this story
+input_file_patterns:
+ prd:
+ whole: "{output_folder}/*prd*.md"
+ sharded: "{output_folder}/*prd*/index.md"
+
+ tech_spec:
+ whole: "{output_folder}/tech-spec.md"
+
+ architecture:
+ whole: "{output_folder}/*architecture*.md"
+ sharded: "{output_folder}/*architecture*/index.md"
+
+ ux_design:
+ whole: "{output_folder}/*ux*.md"
+ sharded: "{output_folder}/*ux*/index.md"
+
+ epics:
+ whole: "{output_folder}/*epic*.md"
+ sharded_index: "{output_folder}/*epic*/index.md"
+ sharded_single: "{output_folder}/*epic*/epic-{{epic_num}}.md"
+
+ document_project:
+ sharded: "{output_folder}/docs/index.md"
+
+standalone: true
+
+web_bundle: false
diff --git a/src/modules/bmgd/workflows/4-production/dev-story/AUDIT-REPORT.md b/src/modules/bmgd/workflows/4-production/dev-story/AUDIT-REPORT.md
new file mode 100644
index 00000000..528e03eb
--- /dev/null
+++ b/src/modules/bmgd/workflows/4-production/dev-story/AUDIT-REPORT.md
@@ -0,0 +1,367 @@
+# Workflow Audit Report
+
+**Workflow:** dev-story
+**Audit Date:** 2025-10-25
+**Auditor:** Audit Workflow (BMAD v6)
+**Workflow Type:** Action Workflow
+**Module:** BMM (BMad Method)
+
+---
+
+## Executive Summary
+
+**Overall Status:** GOOD - Minor issues to address
+
+- Critical Issues: 0
+- Important Issues: 3
+- Cleanup Recommendations: 2
+
+The dev-story workflow is well-structured and follows most BMAD v6 standards. The workflow correctly sets `web_bundle: false` as expected for implementation workflows. However, there are several config variable usage issues and some variables referenced in instructions that are not defined in the YAML.
+
+---
+
+## 1. Standard Config Block Validation
+
+**Status:** PASS ✓
+
+The workflow.yaml contains all required standard config variables:
+
+- ✓ `config_source: "{project-root}/bmad/bmm/config.yaml"` - Correctly defined
+- ✓ `output_folder: "{config_source}:output_folder"` - Pulls from config_source
+- ✓ `user_name: "{config_source}:user_name"` - Pulls from config_source
+- ✓ `communication_language: "{config_source}:communication_language"` - Pulls from config_source
+- ✓ `date: system-generated` - Correctly set
+
+All standard config variables are present and properly formatted using {project-root} variable syntax.
+
+---
+
+## 2. YAML/Instruction/Template Alignment
+
+**Variables Analyzed:** 9 (excluding standard config)
+**Used in Instructions:** 6
+**Unused (Bloat):** 3
+
+### YAML Variables Defined
+
+1. `story_dir` - USED in instructions (file paths)
+2. `context_path` - UNUSED (appears to duplicate story_dir)
+3. `story_file` - USED in instructions
+4. `context_file` - USED in instructions
+5. `installed_path` - USED in instructions (workflow.xml reference)
+6. `instructions` - USED in instructions (self-reference in critical tag)
+7. `validation` - USED in instructions (checklist reference)
+8. `web_bundle` - CONFIGURATION (correctly set to false)
+9. `date` - USED in instructions (config variable)
+
+### Variables Used in Instructions But NOT Defined in YAML
+
+**IMPORTANT ISSUE:** The following variables are referenced in instructions.md but are NOT defined in workflow.yaml:
+
+1. `{user_skill_level}` - Used 4 times (lines 6, 13, 173, 182)
+2. `{document_output_language}` - Used 1 time (line 7)
+3. `{run_until_complete}` - Used 1 time (line 108)
+4. `{run_tests_command}` - Used 1 time (line 120)
+
+These variables appear to be pulling from config.yaml but are not explicitly defined in the workflow.yaml file. While the config_source mechanism may provide these, workflow.yaml should document all variables used in the workflow for clarity.
+
+### Unused Variables (Bloat)
+
+1. **context_path** - Defined as `"{config_source}:dev_story_location"` but never used. This duplicates `story_dir` functionality.
+
+---
+
+## 3. Config Variable Usage
+
+**Communication Language:** PASS ✓
+**User Name:** PASS ✓
+**Output Folder:** PASS ✓
+**Date:** PASS ✓
+
+### Detailed Analysis
+
+**Communication Language:**
+
+- ✓ Used in line 6: "Communicate all responses in {communication_language}"
+- ✓ Properly used as agent instruction variable (not in template)
+
+**User Name:**
+
+- ✓ Used in line 169: "Communicate to {user_name} that story implementation is complete"
+- ✓ Appropriately used for personalization
+
+**Output Folder:**
+
+- ✓ Used multiple times for sprint-status.yaml file paths
+- ✓ All file operations target {output_folder} correctly
+- ✓ No hardcoded paths detected
+
+**Date:**
+
+- ✓ Available for agent use (system-generated)
+- ✓ Used appropriately in context of workflow execution
+
+### Additional Config Variables
+
+**IMPORTANT ISSUE:** The workflow uses additional variables that appear to come from config but are not explicitly documented:
+
+1. `{user_skill_level}` - Used to tailor communication style
+2. `{document_output_language}` - Used for document generation
+3. `{run_until_complete}` - Used for execution control
+4. `{run_tests_command}` - Used for test execution
+
+These should either be:
+
+- Added to workflow.yaml with proper config_source references, OR
+- Documented as optional config variables with defaults
+
+---
+
+## 4. Web Bundle Validation
+
+**Web Bundle Present:** No (Intentional)
+**Status:** EXPECTED ✓
+
+The workflow correctly sets `web_bundle: false`. This is the expected configuration for implementation workflows that:
+
+- Run locally in the development environment
+- Don't need to be bundled for web deployment
+- Are IDE-integrated workflows
+
+**No issues found** - This is the correct configuration for dev-story.
+
+---
+
+## 5. Bloat Detection
+
+**Bloat Percentage:** 11% (1 unused field / 9 total fields)
+**Cleanup Potential:** Low
+
+### Unused YAML Fields
+
+1. **context_path** (line 11 in workflow.yaml)
+ - Defined as: `"{config_source}:dev_story_location"`
+ - Never referenced in instructions.md
+ - Duplicates functionality of `story_dir` variable
+ - **Recommendation:** Remove this variable as `story_dir` serves the same purpose
+
+### Hardcoded Values
+
+No significant hardcoded values that should be variables were detected. The workflow properly uses variables for:
+
+- File paths ({output_folder}, {story_dir})
+- User personalization ({user_name})
+- Communication style ({communication_language}, {user_skill_level})
+
+### Calculation
+
+- Total yaml fields: 9 (excluding standard config and metadata)
+- Used fields: 8
+- Unused fields: 1 (context_path)
+- Bloat percentage: 11%
+
+**Status:** Acceptable (under 15% threshold)
+
+---
+
+## 6. Template Variable Mapping
+
+**Not Applicable** - This is an action workflow, not a document workflow.
+
+No template.md file exists, which is correct for action-type workflows.
+
+---
+
+## 7. Instructions Quality Analysis
+
+### Structure
+
+- ✓ Steps numbered sequentially (1, 1.5, 2-7)
+- ✓ Each step has clear goal attributes
+- ✓ Proper use of XML tags (, , , ,