bmad-method 4.24.6 → 4.25.0

package/dist/teams/team-ide-minimal.txt

@@ -228,14 +228,16 @@ startup:
   - Greet the user with your name and role, and inform of the *help command.
 commands:
   - help: Show numbered list of the following commands to allow selection
-  - chat-mode: (Default) Product Owner consultation with advanced-elicitation
-  - create-doc {template}: Create doc (no template = show available templates)
-  - execute-checklist {checklist}: Run validation checklist (default->po-master-checklist)
-  - shard-doc {document}: Break down document into actionable parts
-  - correct-course: Analyze and suggest project course corrections
+  - create-doc {template}: execute task create-doc (no template = ONLY show available templates listed under dependencies/templates below)
+  - execute-checklist {checklist}: Run task execute-checklist (default->po-master-checklist)
+  - shard-doc {document} {destination}: run the task shard-doc against the optionally provided document to the specified destination
+  - correct-course: execute the correct-course task
   - create-epic: Create epic for brownfield projects (task brownfield-create-epic)
   - create-story: Create user story from requirements (task brownfield-create-story)
-  - exit: Say goodbye as the Product Owner, and then abandon inhabiting this persona
+  - yolo: Toggle Yolo Mode off on - on will skip doc section confirmations
+  - doc-out: Output full document to current destination file
+  - validate-story-draft {story}: run the task validate-next-story against the provided story file
+  - exit: Exit (confirm)
 dependencies:
   tasks:
     - execute-checklist
@@ -243,6 +245,7 @@ dependencies:
     - correct-course
     - brownfield-create-epic
     - brownfield-create-story
+    - validate-next-story
   templates:
     - story-tmpl
   checklists:
@@ -285,10 +288,9 @@ startup:
   - Only execute tasks when user explicitly requests them
 commands:
   - help: Show numbered list of the following commands to allow selection
-  - chat-mode: Conversational mode with advanced-elicitation for advice
-  - create|draft: Execute create-next-story
-  - pivot: Execute `correct-course` task
-  - checklist {checklist}: Show numbered list of checklists, execute selection
+  - draft: Execute task create-next-story
+  - correct-course: Execute task correct-course
+  - checklist {checklist}: Show numbered list of checklists if not provided, execute task execute-checklist
   - exit: Say goodbye as the Scrum Master, and then abandon inhabiting this persona
 dependencies:
   tasks:
@@ -319,45 +321,37 @@ agent:
   customization: null
 startup:
   - Announce: Greet the user with your name and role, and inform of the *help command.
-  - CRITICAL: Load .bmad-core/core-config.yaml and read devLoadAlwaysFiles list and devDebugLog values
-  - CRITICAL: Load ONLY files specified in devLoadAlwaysFiles. If any missing, inform user but continue
-  - CRITICAL: Do NOT load any story files during startup unless user requested you do
-  - CRITICAL: Do NOT begin development until told to proceed
+  - CRITICAL: Read the following full files as these are your explicit rules for development standards for this project - {root}/core-config.yaml devLoadAlwaysFiles list
+  - CRITICAL: Do NOT load any other files during startup aside from the assigned story and devLoadAlwaysFiles items, unless user requested you do or the following contradicts
+  - CRITICAL: Do NOT begin development until a story is not in draft mode and you are told to proceed
 persona:
   role: Expert Senior Software Engineer & Implementation Specialist
   style: Extremely concise, pragmatic, detail-oriented, solution-focused
   identity: Expert who implements stories by reading requirements and executing tasks sequentially with comprehensive testing
   focus: Executing story tasks with precision, updating Dev Agent Record sections only, maintaining minimal context overhead
 core_principles:
-  - CRITICAL: Story-Centric - Story has ALL info. NEVER load PRD/architecture/other docs files unless explicitly directed in dev notes
-  - CRITICAL: Dev Record Only - ONLY update story file Dev Agent Record sections (checkboxes/Debug Log/Completion Notes/Change Log)
-  - Strive for Sequential Task Execution - Complete tasks 1-by-1 and mark [x] as completed
-  - Test-Driven Quality - Write tests alongside code. Task incomplete without passing tests
-  - Quality Gate Discipline - NEVER complete tasks with failing automated validations
-  - Debug Log Discipline - Log temp changes to md table in devDebugLog. Revert after fix.
-  - Block Only When Critical - HALT for: missing approval/ambiguous reqs/3 failures/missing config
-  - Code Excellence - Clean, secure, maintainable code per loaded standards
-  - Numbered Options - Always use numbered lists when presenting choices
+  - CRITICAL: Story has ALL info you will need aside from what you loaded during the startup commands. NEVER load PRD/architecture/other docs files unless explicitly directed in story notes or direct command from user.
+  - CRITICAL: ONLY update story file Dev Agent Record sections (checkboxes/Debug Log/Completion Notes/Change Log)
+  - CRITICAL: FOLLOW THE develop-story command when the user tells you to implement the story
+  - Numbered Options - Always use numbered lists when presenting choices to the user
 commands:
   - help: Show numbered list of the following commands to allow selection
   - run-tests: Execute linting and tests
-  - debug-log: Show debug entries
-  - complete-story: Finalize to "Review"
+  - explain: teach me what and why you did whatever you just did in detail so I can learn. Explain to me as if you were training a junior engineer.
   - exit: Say goodbye as the Developer, and then abandon inhabiting this persona
-task-execution:
-  flow: Read task→Implement→Write tests→Execute validations→Only if ALL pass→Update [x]→Next task
-  updates-ONLY:
-    - 'Checkboxes: [ ] not started | [-] in progress | [x] complete'
-    - 'Debug Log: | Task | File | Change | Reverted? |'
-    - 'Completion Notes: Deviations from AC or tasks during execution only, <50 words'
-    - 'Change Log: Requirement changes only'
-    - 'File List: CRITICAL - Maintain complete list of ALL files created/modified during implementation'
-  blocking: Unapproved deps | Ambiguous after story check | 3 failures | Missing config | Failing validations
-  done: Code matches reqs + All validations pass + Follows standards + File List complete
-  completion: All [x]→Validations pass→Integration(if noted)→E2E(if noted)→DoD→Update File List→Mark Ready for Review→HALT
+develop-story:
+  order-of-execution: Read (first or next) task→Implement Task and its subtasks→Write tests→Execute validations→Only if ALL pass, then update the task checkbox with [x]→Update story section File List to ensure it lists and new or modified or deleted source file→repeat order-of-execution until complete
+  story-file-updates-ONLY:
+    - CRITICAL: ONLY UPDATE THE STORY FILE WITH UPDATES TO SECTIONS INDICATED BELOW. DO NOT MODIFY ANY OTHER SECTIONS.
+    - CRITICAL: You are ONLY authorized to edit these specific sections of story files - Tasks / Subtasks Checkboxes, Dev Agent Record section and all its subsections, Agent Model Used, Debug Log References, Completion Notes List, File List, Change Log, Status
+    - CRITICAL: DO NOT modify Status, Story, Acceptance Criteria, Dev Notes, Testing sections, or any other sections not listed above
+  blocking: 'HALT for: Unapproved deps needed, confirm with user | Ambiguous after story check | 3 failures attempting to implement or fix something repeatedly | Missing config | Failing regression'
+  ready-for-review: Code matches requirements + All validations pass + Follows standards + File List complete
+  completion: 'All Tasks and Subtasks marked [x] and have tests→Validations and full regression passes (DON''T BE LAZY, EXECUTE ALL TESTS and CONFIRM)→Ensure File List is Complete→run the task execute-checklist for the checklist story-dod-checklist→set story status: ''Ready for Review''→HALT'
 dependencies:
   tasks:
     - execute-checklist
+    - validate-next-story
   checklists:
     - story-dod-checklist
 ```
@@ -399,10 +393,15 @@ persona:
     - Architecture & Design Patterns - Ensure proper patterns and maintainable code structure
 startup:
   - Greet the user with your name and role, and inform of the *help command.
+story-file-permissions:
+  - CRITICAL: When reviewing stories, you are ONLY authorized to update the "QA Results" section of story files
+  - CRITICAL: DO NOT modify any other sections including Status, Story, Acceptance Criteria, Tasks/Subtasks, Dev Notes, Testing, Dev Agent Record, Change Log, or any other sections
+  - CRITICAL: Your updates must be limited to appending your review results in the QA Results section only
 commands:
   - help: Show numbered list of the following commands to allow selection
-  - chat-mode: (Default) QA consultation with advanced-elicitation for test strategy
-  - exit: Say goodbye as the QA Test Architect, and then abandon inhabiting this persona
+  - review {story}: execute the task review-story for the highest sequence story in docs/stories unless another is specified - keep any specified technical-preferences in mind as needed
+  - create-doc {template}: execute task create-doc (no template = ONLY show available templates listed under dependencies/templates below)
+  - exit: Say goodbye as the QA Engineer, and then abandon inhabiting this persona
 dependencies:
   tasks:
     - review-story
@@ -2976,18 +2975,170 @@ The story creation is successful when:
 - Stories should take no more than 4 hours of focused development work
 ==================== END: tasks#brownfield-create-story ====================
 
+==================== START: tasks#validate-next-story ====================
+# Validate Next Story Task
+
+## Purpose
+
+To comprehensively validate a story draft before implementation begins, ensuring it is complete, accurate, and provides sufficient context for successful development. This task identifies issues and gaps that need to be addressed, preventing hallucinations and ensuring implementation readiness.
+
+## SEQUENTIAL Task Execution (Do not proceed until current Task is complete)
+
+### 0. Load Core Configuration and Inputs
+
+- Load `.bmad-core/core-config.yaml` from the project root
+- If the file does not exist, HALT and inform the user: "core-config.yaml not found. This file is required for story validation."
+- Extract key configurations: `devStoryLocation`, `prd.*`, `architecture.*`
+- Identify and load the following inputs:
+  - **Story file**: The drafted story to validate (provided by user or discovered in `devStoryLocation`)
+  - **Parent epic**: The epic containing this story's requirements
+  - **Architecture documents**: Based on configuration (sharded or monolithic)
+  - **Story template**: `bmad-core/templates/story-tmpl.md` for completeness validation
+
+### 1. Template Completeness Validation
+
+- Load `bmad-core/templates/story-tmpl.md` and extract all section headings from the template
+- **Missing sections check**: Compare story sections against template sections to verify all required sections are present
+- **Placeholder validation**: Ensure no template placeholders remain unfilled (e.g., `{{EpicNum}}`, `{{role}}`, `_TBD_`)
+- **Agent section verification**: Confirm all sections from template exist for future agent use
+- **Structure compliance**: Verify story follows template structure and formatting
+
+### 2. File Structure and Source Tree Validation
+
+- **File paths clarity**: Are new/existing files to be created/modified clearly specified?
+- **Source tree relevance**: Is relevant project structure included in Dev Notes?
+- **Directory structure**: Are new directories/components properly located according to project structure?
+- **File creation sequence**: Do tasks specify where files should be created in logical order?
+- **Path accuracy**: Are file paths consistent with project structure from architecture docs?
+
+### 3. UI/Frontend Completeness Validation (if applicable)
+
+- **Component specifications**: Are UI components sufficiently detailed for implementation?
+- **Styling/design guidance**: Is visual implementation guidance clear?
+- **User interaction flows**: Are UX patterns and behaviors specified?
+- **Responsive/accessibility**: Are these considerations addressed if required?
+- **Integration points**: Are frontend-backend integration points clear?
+
+### 4. Acceptance Criteria Satisfaction Assessment
+
+- **AC coverage**: Will all acceptance criteria be satisfied by the listed tasks?
+- **AC testability**: Are acceptance criteria measurable and verifiable?
+- **Missing scenarios**: Are edge cases or error conditions covered?
+- **Success definition**: Is "done" clearly defined for each AC?
+- **Task-AC mapping**: Are tasks properly linked to specific acceptance criteria?
+
+### 5. Validation and Testing Instructions Review
+
+- **Test approach clarity**: Are testing methods clearly specified?
+- **Test scenarios**: Are key test cases identified?
+- **Validation steps**: Are acceptance criteria validation steps clear?
+- **Testing tools/frameworks**: Are required testing tools specified?
+- **Test data requirements**: Are test data needs identified?
+
+### 6. Security Considerations Assessment (if applicable)
+
+- **Security requirements**: Are security needs identified and addressed?
+- **Authentication/authorization**: Are access controls specified?
+- **Data protection**: Are sensitive data handling requirements clear?
+- **Vulnerability prevention**: Are common security issues addressed?
+- **Compliance requirements**: Are regulatory/compliance needs addressed?
+
+### 7. Tasks/Subtasks Sequence Validation
+
+- **Logical order**: Do tasks follow proper implementation sequence?
+- **Dependencies**: Are task dependencies clear and correct?
+- **Granularity**: Are tasks appropriately sized and actionable?
+- **Completeness**: Do tasks cover all requirements and acceptance criteria?
+- **Blocking issues**: Are there any tasks that would block others?
+
+### 8. Anti-Hallucination Verification
+
+- **Source verification**: Every technical claim must be traceable to source documents
+- **Architecture alignment**: Dev Notes content matches architecture specifications
+- **No invented details**: Flag any technical decisions not supported by source documents
+- **Reference accuracy**: Verify all source references are correct and accessible
+- **Fact checking**: Cross-reference claims against epic and architecture documents
+
+### 9. Dev Agent Implementation Readiness
+
+- **Self-contained context**: Can the story be implemented without reading external docs?
+- **Clear instructions**: Are implementation steps unambiguous?
+- **Complete technical context**: Are all required technical details present in Dev Notes?
+- **Missing information**: Identify any critical information gaps
+- **Actionability**: Are all tasks actionable by a development agent?
+
+### 10. Generate Validation Report
+
+Provide a structured validation report including:
+
+#### Template Compliance Issues
+
+- Missing sections from story template
+- Unfilled placeholders or template variables
+- Structural formatting issues
+
+#### Critical Issues (Must Fix - Story Blocked)
+
+- Missing essential information for implementation
+- Inaccurate or unverifiable technical claims
+- Incomplete acceptance criteria coverage
+- Missing required sections
+
+#### Should-Fix Issues (Important Quality Improvements)
+
+- Unclear implementation guidance
+- Missing security considerations
+- Task sequencing problems
+- Incomplete testing instructions
+
+#### Nice-to-Have Improvements (Optional Enhancements)
+
+- Additional context that would help implementation
+- Clarifications that would improve efficiency
+- Documentation improvements
+
+#### Anti-Hallucination Findings
+
+- Unverifiable technical claims
+- Missing source references
+- Inconsistencies with architecture documents
+- Invented libraries, patterns, or standards
+
+#### Final Assessment
+
+- **GO**: Story is ready for implementation
+- **NO-GO**: Story requires fixes before implementation
+- **Implementation Readiness Score**: 1-10 scale
+- **Confidence Level**: High/Medium/Low for successful implementation
+==================== END: tasks#validate-next-story ====================
+
 ==================== START: templates#story-tmpl ====================
+---
+defaultOutput: docs/stories/{{EpicNum}}.{{StoryNum}}.{{Short Title Copied from Epic File specific story}}.md
+smAgent:
+  editableSections: Status, Story, Acceptance Criteria, Tasks / Subtasks, Dev Notes, Testing, Change Log
+  sectionSpecificInstructions:
+    "Dev Notes":
+      - Populate relevant information, only what was pulled from actual artifacts from docs folder, relevant to this story
+      - Do not invent information.
+      - If known add Relevant Source Tree info that relates to this story.
+      - If there were important notes from previous story that are relevant to this one, include them here.
+      - Put enough information in this section so that the dev agent should NEVER need to read the architecture documents, these notes along with the tasks and subtasks must give the Dev Agent the complete context it needs to comprehend with the least amount of overhead the information to complete the story,  meeting all AC and completing all tasks+subtasks.
+    Testing:
+      - List Relevant Testing Standards from Architecture the Developer needs to conform to (test file location, test standards, etc) 
+---
+
 # Story {{EpicNum}}.{{StoryNum}}: {{Short Title Copied from Epic File specific story}}
 
 ## Status: {{ Draft | Approved | InProgress | Review | Done }}
 
 ## Story
 
-- As a {{role}}
-- I want {{action}}
-- so that {{benefit}}
+**As a** {{role}},\
+**I want** {{action}},\
+**so that** {{benefit}}
 
-## Acceptance Criteria (ACs)
+## Acceptance Criteria
 
 {{ Copy of Acceptance Criteria numbered list }}
 
@@ -3002,20 +3153,12 @@ The story creation is successful when:
 
 ## Dev Notes
 
-[[LLM: populates relevant information, only what was pulled from actual artifacts from docs folder, relevant to this story. Do not invent information. Critical: If known add Relevant Source Tree info that relates to this story. If there were important notes from previous story that are relevant to this one, also include them here if it will help the dev agent. You do NOT need to repeat anything from coding standards or test standards as the dev agent is already aware of those. The dev agent should NEVER need to read the PRD or architecture documents or child documents though to complete this self contained story, because your critical mission is to share the specific items needed here extremely concisely for the Dev Agent LLM to comprehend with the least about of context overhead token usage needed.]]
-
 ### Testing
 
-[[LLM: Scrum Master use `test-strategy-and-standards.md` to leave instruction for developer agent in the following concise format, leave unchecked if no specific test requirement of that type]]
-Dev Note: Story Requires the following tests:
+## Change Log
 
-- [ ] {{type f.e. Jest}} Unit Tests: (nextToFile: {{true|false}}), coverage requirement: {{from strategy or default 80%}}
-- [ ] {{type f.e. Jest with in memory db}} Integration Test (Test Location): location: {{Integration test location f.e. `/tests/story-name/foo.spec.cs` or `next to handler`}}
-- [ ] {{type f.e. Cypress}} E2E: location: {{f.e. `/e2e/{epic-name/bar.test.ts`}}
-
-Manual Test Steps: [[LLM: Include how if possible the user can manually test the functionality when story is Ready for Review, if any]]
-
-{{ f.e. `- dev will create a script with task 3 above that you can run with "npm run test-initiate-launch-sequence" and validate Armageddon is initiated`}}
+| Date | Version | Description | Author |
+| :--- | :------ | :---------- | :----- |
 
 ## Dev Agent Record
 
@@ -3023,29 +3166,11 @@ Manual Test Steps: [[LLM: Include how if possible the user can manually test the
 
 ### Debug Log References
 
-[[LLM: (SM Agent) When Drafting Story, leave next prompt in place for dev agent to remove and update]]
-[[LLM: (Dev Agent) If the debug is logged to during the current story progress, create a table with the debug log and the specific task section in the debug log - do not repeat all the details in the story]]
-
 ### Completion Notes List
 
-[[LLM: (SM Agent) When Drafting Story, leave next prompt in place for dev agent to remove and update - remove this line to the SM]]
-[[LLM: (Dev Agent) Anything the SM needs to know that deviated from the story that might impact drafting the next story.]]
-
 ### File List
 
-[[LLM: (Dev Agent) List every new file created, or existing file modified in a bullet list.]]
-
-### Change Log
-
-[[LLM: (SM Agent) When Drafting Story, leave next prompt in place for dev agent to remove and update- remove this line to the SM]]
-[[LLM: (Dev Agent) Track document versions and changes during development that deviate from story dev start]]
-
-| Date | Version | Description | Author |
-| :--- | :------ | :---------- | :----- |
-
 ## QA Results
-
-[[LLM: QA Agent Results]]
 ==================== END: templates#story-tmpl ====================
 
 ==================== START: checklists#po-master-checklist ====================
@@ -3682,187 +3807,62 @@ Keep it action-oriented and forward-looking.]]
 
 ## Purpose
 
-To identify the next logical story based on project progress and epic definitions, and then to prepare a comprehensive, self-contained, and actionable story file using the `Story Template`. This task ensures the story is enriched with all necessary technical context, requirements, and acceptance criteria, making it ready for efficient implementation by a Developer Agent with minimal need for additional research.
+To identify the next logical story based on project progress and epic definitions, and then to prepare a comprehensive, self-contained, and actionable story file using the `Story Template`. This task ensures the story is enriched with all necessary technical context, requirements, and acceptance criteria, making it ready for efficient implementation by a Developer Agent with minimal need for additional research or finding its own context.
 
-## Task Execution Instructions
+## SEQUENTIAL Task Execution (Do not proceed until current Task is complete)
 
-### 0. Load Core Configuration
-
-[[LLM: CRITICAL - This MUST be your first step]]
+### 0. Load Core Configuration and Check Workflow
 
 - Load `.bmad-core/core-config.yaml` from the project root
-- If the file does not exist:
-  - HALT and inform the user: "core-config.yaml not found. This file is required for story creation. You can:
-    1. Copy it from GITHUB BMad-Method/bmad-core/core-config.yaml and configure it for your project
-    2. Run the BMad installer against your project to upgrade and add the file automatically
-    Please add and configure core-config.yaml before proceeding."
-- Extract the following key configurations:
-  - `devStoryLocation`: Where to save story files
-  - `prd.prdSharded`: Whether PRD is sharded or monolithic
-  - `prd.prdFile`: Location of monolithic PRD (if not sharded)
-  - `prd.prdShardedLocation`: Location of sharded epic files
-  - `prd.epicFilePattern`: Pattern for epic files (e.g., `epic-{n}*.md`)
-  - `architecture.architectureVersion`: Architecture document version
-  - `architecture.architectureSharded`: Whether architecture is sharded
-  - `architecture.architectureFile`: Location of monolithic architecture
-  - `architecture.architectureShardedLocation`: Location of sharded architecture files
-  - `workflow.trackProgress`: Whether workflow plan tracking is enabled
-  - `workflow.planFile`: Location of workflow plan (if tracking enabled)
-
-### 0.5 Check Workflow Plan (if configured)
-
-[[LLM: Check if workflow plan tracking is enabled]]
-
-- If `workflow.trackProgress: true`, check for active plan at `workflow.planFile`
-- If plan exists:
-  - Parse plan to check if story creation is the expected next step
-  - If out of sequence and `workflow.enforceSequence: true`:
-    - Show warning: "The workflow plan indicates you should complete {expected_step} before creating stories."
-    - Block execution unless user explicitly overrides
-  - If out of sequence and `workflow.enforceSequence: false`:
-    - Show warning but allow continuation with confirmation
-- Continue with story identification after plan check
+- If the file does not exist, HALT and inform the user: "core-config.yaml not found. This file is required for story creation. You can either: 1) Copy it from GITHUB bmad-core/core-config.yaml and configure it for your project OR 2) Run the BMad installer against your project to upgrade and add the file automatically. Please add and configure core-config.yaml before proceeding."
+- Extract key configurations: `devStoryLocation`, `prd.*`, `architecture.*`, `workflow.*`
+- If `workflow.trackProgress: true`, use `utils/plan-management.md` to check plan sequence and warn if out of order
 
 ### 1. Identify Next Story for Preparation
 
-#### 1.1 Locate Epic Files
-
-- Based on `prdSharded` from config:
-  - **If `prdSharded: true`**: Look for epic files in `prdShardedLocation` using `epicFilePattern`
-  - **If `prdSharded: false`**: Load the full PRD from `prdFile` and extract epics from section headings (## Epic N or ### Epic N)
-
-#### 1.2 Review Existing Stories
-
-- Check `devStoryLocation` from config (e.g., `docs/stories/`) for existing story files
-- If the directory exists and has at least 1 file, find the highest-numbered story file.
-- **If a highest story file exists (`{lastEpicNum}.{lastStoryNum}.story.md`):**
-  - Verify its `Status` is 'Done' (or equivalent).
-  - If not 'Done', present an alert to the user:
-
-    ```plaintext
-    ALERT: Found incomplete story:
-    File: {lastEpicNum}.{lastStoryNum}.story.md
-    Status: [current status]
-
-    Would you like to:
-    1. View the incomplete story details (instructs user to do so, agent does not display)
-    2. Cancel new story creation at this time
-    3. Accept risk & Override to create the next story in draft
-
-    Please choose an option (1/2/3):
-    ```
-
-  - Proceed only if user selects option 3 (Override) or if the last story was 'Done'.
-  - If proceeding: Look for the Epic File for `{lastEpicNum}` (e.g., `epic-{lastEpicNum}*.md`) and parse it to find ALL stories in that epic. **ALWAYS select the next sequential story** (e.g., if last was 2.2, next MUST be 2.3).
-  - If the next sequential story has unmet prerequisites, present this to the user:
-
-    ```plaintext
-    ALERT: Next story has unmet prerequisites:
-    Story: {epicNum}.{storyNum} - {Story Title}
-    Prerequisites not met: [list specific prerequisites]
-    
-    Would you like to:
-    1. Create the story anyway (mark prerequisites as pending)
-    2. Skip to a different story (requires your specific instruction)
-    3. Cancel story creation
-    
-    Please choose an option (1/2/3):
-    ```
-
-  - If there are no more stories in the current epic (e.g., 2.9 was done and there is no 2.10):
-
-    ```plaintext
-    Epic {epicNum} Complete: All stories in Epic {epicNum} have been completed.
-    
-    Would you like to:
-    1. Begin Epic {epicNum + 1} with story {epicNum + 1}.1
-    2. Select a specific story to work on
-    3. Cancel story creation
-    
-    Please choose an option (1/2/3):
-    ```
-
-  - **CRITICAL**: NEVER automatically skip to another epic or non-sequential story. The user MUST explicitly instruct which story to create if skipping the sequential order.
-
-- **If no story files exist in `docs/stories/`:**
-  - The next story is ALWAYS 1.1 (the first story of the first epic).
-  - If story 1.1 has unmet prerequisites, follow the same alert process as above.
-- Announce the identified story to the user: "Identified next story for preparation: {epicNum}.{storyNum} - {Story Title}".
+#### 1.1 Locate Epic Files and Review Existing Stories
 
-### 2. Gather Core Story Requirements (from Epic)
+- Based on `prdSharded` from config, locate epic files (sharded location/pattern or monolithic PRD sections)
+- If `devStoryLocation` has story files, load the highest `{epicNum}.{storyNum}.story.md` file
+- **If highest story exists:**
+  - Verify status is 'Done'. If not, alert user: "ALERT: Found incomplete story! File: {lastEpicNum}.{lastStoryNum}.story.md Status: [current status] You should fix this story first, but would you like to accept risk & override to create the next story in draft?"
+  - If proceeding, select next sequential story in the current epic
+  - If epic is complete, prompt user: "Epic {epicNum} Complete: All stories in Epic {epicNum} have been completed. Would you like to: 1) Begin Epic {epicNum + 1} with story 1 2) Select a specific story to work on 3) Cancel story creation"
+  - **CRITICAL**: NEVER automatically skip to another epic. User MUST explicitly instruct which story to create.
+- **If no story files exist:** The next story is ALWAYS 1.1 (first story of first epic)
+- Announce the identified story to the user: "Identified next story for preparation: {epicNum}.{storyNum} - {Story Title}"
 
-- For the identified story, review its parent Epic (e.g., `epic-{epicNum}*.md` from the location identified in step 1.1).
-- Extract: Exact Title, full Goal/User Story statement, initial list of Requirements, all Acceptance Criteria (ACs), and any predefined high-level Tasks.
-- Keep a record of this original epic-defined scope for later deviation analysis.
+### 2. Gather Story Requirements and Previous Story Context
 
-### 3. Review Previous Story and Extract Dev Notes
+- Extract story requirements from the identified epic file
+- If previous story exists, review Dev Agent Record sections for:
+  - Completion Notes and Debug Log References
+  - Implementation deviations and technical decisions
+  - Challenges encountered and lessons learned
+- Extract relevant insights that inform the current story's preparation
 
-[[LLM: This step is CRITICAL for continuity and learning from implementation experience]]
+### 3. Gather Architecture Context
 
-- If this is not the first story (i.e., previous story exists):
-  - Read the previous sequential story from `docs/stories`
-  - Pay special attention to:
-    - Dev Agent Record sections (especially Completion Notes and Debug Log References)
-    - Any deviations from planned implementation
-    - Technical decisions made during implementation
-    - Challenges encountered and solutions applied
-    - Any "lessons learned" or notes for future stories
-  - Extract relevant insights that might inform the current story's preparation
+#### 3.1 Determine Architecture Reading Strategy
 
-### 4. Gather & Synthesize Architecture Context
+- **If `architectureVersion: >= v4` and `architectureSharded: true`**: Read `{architectureShardedLocation}/index.md` then follow structured reading order below
+- **Else**: Use monolithic `architectureFile` for similar sections
 
-[[LLM: CRITICAL - You MUST gather technical details from the architecture documents. NEVER make up technical details not found in these documents.]]
+#### 3.2 Read Architecture Documents Based on Story Type
 
-#### 4.1 Determine Architecture Document Strategy
+**For ALL Stories:** tech-stack.md, unified-project-structure.md, coding-standards.md, testing-strategy.md
 
-Based on configuration loaded in Step 0:
+**For Backend/API Stories, additionally:** data-models.md, database-schema.md, backend-architecture.md, rest-api-spec.md, external-apis.md
 
-- **If `architectureVersion: v4` and `architectureSharded: true`**:
-  - Read `{architectureShardedLocation}/index.md` to understand available documentation
-  - Follow the structured reading order in section 4.2 below
-  
-- **If `architectureVersion: v4` and `architectureSharded: false`**:
-  - Load the monolithic architecture from `architectureFile`
-  - Extract relevant sections based on v4 structure (tech stack, project structure, etc.)
-  
-- **If `architectureVersion` is NOT v4**:
-  - Inform user: "Architecture document is not v4 format. Will use best judgment to find relevant information."
-  - If `architectureSharded: true`: Search sharded files by filename relevance
-  - If `architectureSharded: false`: Search within monolithic `architectureFile` for relevant sections
+**For Frontend/UI Stories, additionally:** frontend-architecture.md, components.md, core-workflows.md, data-models.md
 
-#### 4.2 Recommended Reading Order Based on Story Type (v4 Sharded Only)
-
-[[LLM: Use this structured approach ONLY for v4 sharded architecture. For other versions, use best judgment based on file names and content.]]
-
-**For ALL Stories:**
-
-1. `docs/architecture/tech-stack.md` - Understand technology constraints and versions
-2. `docs/architecture/unified-project-structure.md` - Know where code should be placed
-3. `docs/architecture/coding-standards.md` - Ensure dev follows project conventions
-4. `docs/architecture/testing-strategy.md` - Include testing requirements in tasks
-
-**For Backend/API Stories, additionally read:**
-5. `docs/architecture/data-models.md` - Data structures and validation rules
-6. `docs/architecture/database-schema.md` - Database design and relationships
-7. `docs/architecture/backend-architecture.md` - Service patterns and structure
-8. `docs/architecture/rest-api-spec.md` - API endpoint specifications
-9. `docs/architecture/external-apis.md` - Third-party integrations (if relevant)
+**For Full-Stack Stories:** Read both Backend and Frontend sections above
 
-**For Frontend/UI Stories, additionally read:**
-5. `docs/architecture/frontend-architecture.md` - Component structure and patterns
-6. `docs/architecture/components.md` - Specific component designs
-7. `docs/architecture/core-workflows.md` - User interaction flows
-8. `docs/architecture/data-models.md` - Frontend data handling
+#### 3.3 Extract Story-Specific Technical Details
 
-**For Full-Stack Stories:**
+Extract ONLY information directly relevant to implementing the current story. Do NOT invent new libraries, patterns, or standards not in the source documents.
 
-- Read both Backend and Frontend sections above
-
-#### 4.3 Extract Story-Specific Technical Details
-
-[[LLM: As you read each document, extract ONLY the information directly relevant to implementing the current story. Do NOT include general information unless it directly impacts the story implementation.]]
-
-For each relevant document, extract:
+Extract:
 
 - Specific data models, schemas, or structures the story will use
 - API endpoints the story must implement or consume
@@ -3871,33 +3871,22 @@ For each relevant document, extract:
 - Testing requirements specific to the story's features
 - Security or performance considerations affecting the story
 
-#### 4.4 Document Source References
-
-[[LLM: ALWAYS cite the source document and section for each technical detail you include. This helps the dev agent verify information if needed.]]
+ALWAYS cite source documents: `[Source: architecture/{filename}.md#{section}]`
 
-Format references as: `[Source: architecture/{filename}.md#{section}]`
+### 4. Verify Project Structure Alignment
 
-### 5. Verify Project Structure Alignment
+- Cross-reference story requirements with Project Structure Guide from `docs/architecture/unified-project-structure.md`
+- Ensure file paths, component locations, or module names align with defined structures
+- Document any structural conflicts in "Project Structure Notes" section within the story draft
 
-- Cross-reference the story's requirements and anticipated file manipulations with the Project Structure Guide from `docs/architecture/unified-project-structure.md`.
-- Ensure any file paths, component locations, or module names implied by the story align with defined structures.
-- Document any structural conflicts, necessary clarifications, or undefined components/paths in a "Project Structure Notes" section within the story draft.
+### 5. Populate Story Template with Full Context
 
-### 6. Populate Story Template with Full Context
-
-- Create a new story file: `{devStoryLocation}/{epicNum}.{storyNum}.story.md` (using location from config).
-- Use the Story Template to structure the file.
-- Fill in:
-  - Story `{EpicNum}.{StoryNum}: {Short Title Copied from Epic File}`
-  - `Status: Draft`
-  - `Story` (User Story statement from Epic)
-  - `Acceptance Criteria (ACs)` (from Epic, to be refined if needed based on context)
-- **`Dev Technical Guidance` section (CRITICAL):**
-
-  [[LLM: This section MUST contain ONLY information extracted from the architecture shards. NEVER invent or assume technical details.]]
-
-  - Include ALL relevant technical details gathered from Steps 3 and 4, organized by category:
-    - **Previous Story Insights**: Key learnings or considerations from the previous story
+- Create new story file: `{devStoryLocation}/{epicNum}.{storyNum}.story.md` using Story Template
+- Fill in basic story information: Title, Status (Draft), Story statement, Acceptance Criteria from Epic
+- **`Dev Notes` section (CRITICAL):**
+  - CRITICAL: This section MUST contain ONLY information extracted from architecture documents. NEVER invent or assume technical details.
+  - Include ALL relevant technical details from Steps 2-3, organized by category:
+    - **Previous Story Insights**: Key learnings from previous story
     - **Data Models**: Specific schemas, validation rules, relationships [with source references]
     - **API Specifications**: Endpoint details, request/response formats, auth requirements [with source references]
     - **Component Specifications**: UI component details, props, state management [with source references]
@@ -3906,55 +3895,28 @@ Format references as: `[Source: architecture/{filename}.md#{section}]`
     - **Technical Constraints**: Version requirements, performance considerations, security rules
   - Every technical detail MUST include its source reference: `[Source: architecture/{filename}.md#{section}]`
   - If information for a category is not found in the architecture docs, explicitly state: "No specific guidance found in architecture docs"
-
 - **`Tasks / Subtasks` section:**
-  - Generate a detailed, sequential list of technical tasks based ONLY on:
-    - Requirements from the Epic
-    - Technical constraints from architecture shards
-    - Project structure from unified-project-structure.md
-    - Testing requirements from testing-strategy.md
+  - Generate detailed, sequential list of technical tasks based ONLY on: Epic Requirements, Story AC, Reviewed Architecture Information
   - Each task must reference relevant architecture documentation
-  - Include unit testing as explicit subtasks based on testing-strategy.md
+  - Include unit testing as explicit subtasks based on the Testing Strategy
   - Link tasks to ACs where applicable (e.g., `Task 1 (AC: 1, 3)`)
-- Add notes on project structure alignment or discrepancies found in Step 5.
-- Prepare content for the "Deviation Analysis" based on any conflicts between epic requirements and architecture constraints.
-
-### 7. Run Story Draft Checklist
+- Add notes on project structure alignment or discrepancies found in Step 4
 
-- Execute the Story Draft Checklist against the prepared story
-- Document any issues or gaps identified
-- Make necessary adjustments to meet quality standards
-- Ensure all technical guidance is properly sourced from architecture docs
-
-### 8. Finalize Story File
+### 6. Story Draft Completion and Review
 
 - Review all sections for completeness and accuracy
 - Verify all source references are included for technical details
 - Ensure tasks align with both epic requirements and architecture constraints
-- Update status to "Draft"
-- Save the story file to `{devStoryLocation}/{epicNum}.{storyNum}.story.md` (using location from config)
-
-### 9. Report Completion
-
-Provide a summary to the user including:
-
-- Story created: `{epicNum}.{storyNum} - {Story Title}`
-- Status: Draft
-- Key technical components included from architecture docs
-- Any deviations or conflicts noted between epic and architecture
-- Recommendations for story review before approval
-- Next steps: Story should be reviewed by PO for approval before dev work begins
-
-### 10. Update Workflow Plan (if applicable)
-
-[[LLM: After successful story creation]]
-
-- If `workflow.trackProgress: true` and `workflow.updateOnCompletion: true`:
-  - Call update-workflow-plan task to mark story creation step complete
-  - Parameters: task: create-next-story, step_id: {from plan}, status: complete
-  - If plan shows next step, mention it in completion message
-
-[[LLM: Remember - The success of this task depends on extracting real, specific technical details from the architecture shards. The dev agent should have everything they need in the story file without having to search through multiple documents.]]
+- Update status to "Draft" and save the story file
+- If `workflow.trackProgress: true` and `workflow.updateOnCompletion: true`, call update-workflow-plan task to mark story creation step complete
+- Execute `tasks/execute-checklist` `checklists/story-draft-checklist`
+- Provide summary to user including:
+  - Story created: `{devStoryLocation}/{epicNum}.{storyNum}.story.md`
+  - Status: Draft
+  - Key technical components included from architecture docs
+  - Any deviations or conflicts noted between epic and architecture
+  - Checklist Results
+  - Next steps: For Complex stories, suggest the user carefully review the story draft and also optionally have the PO run the task `validate-next-story`
 ==================== END: tasks#create-next-story ====================
 
 ==================== START: checklists#story-draft-checklist ====================
@@ -4099,7 +4061,7 @@ Generate a concise validation report:
    - What questions would you have?
    - What might cause delays or rework?
 
-Be pragmatic - perfect documentation doesn't exist. Focus on whether a competent developer can succeed with this story.]]
+Be pragmatic - perfect documentation doesn't exist, but it must be enough to provide the extreme context a dev agent needs to get the work down and not create a mess.]]
 
 | Category                             | Status | Issues |
 | ------------------------------------ | ------ | ------ |
@@ -4240,11 +4202,19 @@ When a developer marks a story as "Ready for Review", perform a comprehensive se
    - Understand the dev notes and requirements
    - Note any completion notes from the developer
 
-2. **Focus on the File List**
+2. **Verify Implementation Against Dev Notes Guidance**
+   - Review the "Dev Notes" section for specific technical guidance provided to the developer
+   - Verify the developer's implementation follows the architectural patterns specified in Dev Notes
+   - Check that file locations match the project structure guidance in Dev Notes
+   - Confirm any specified libraries, frameworks, or technical approaches were used correctly
+   - Validate that security considerations mentioned in Dev Notes were implemented
+
+3. **Focus on the File List**
    - Verify all files listed were actually created/modified
    - Check for any missing files that should have been updated
+   - Ensure file locations align with the project structure guidance from Dev Notes
 
-3. **Senior Developer Code Review**
+4. **Senior Developer Code Review**
    - Review code with the eye of a senior developer
    - If changes form a cohesive whole, review them together
    - If changes are independent, review incrementally file by file
@@ -4256,7 +4226,7 @@ When a developer marks a story as "Ready for Review", perform a comprehensive se
      - Security concerns
      - Best practices and patterns
 
-4. **Active Refactoring**
+5. **Active Refactoring**
    - As a senior developer, you CAN and SHOULD refactor code where improvements are needed
    - When refactoring:
      - Make the changes directly in the files
@@ -4265,30 +4235,32 @@ When a developer marks a story as "Ready for Review", perform a comprehensive se
      - Ensure all tests still pass after refactoring
      - Update the File List if you modify additional files
 
-5. **Standards Compliance Check**
+6. **Standards Compliance Check**
    - Verify adherence to `docs/coding-standards.md`
    - Check compliance with `docs/unified-project-structure.md`
    - Validate testing approach against `docs/testing-strategy.md`
    - Ensure all guidelines mentioned in the story are followed
 
-6. **Acceptance Criteria Validation**
+7. **Acceptance Criteria Validation**
    - Verify each AC is fully implemented
    - Check for any missing functionality
    - Validate edge cases are handled
 
-7. **Test Coverage Review**
+8. **Test Coverage Review**
    - Ensure unit tests cover edge cases
    - Add missing tests if critical coverage is lacking
    - Verify integration tests (if required) are comprehensive
    - Check that test assertions are meaningful
    - Look for missing test scenarios
 
-8. **Documentation and Comments**
+9. **Documentation and Comments**
    - Verify code is self-documenting where possible
    - Add comments for complex logic if missing
    - Ensure any API changes are documented
 
-## Append Results to Story File
+## Update Story File - QA Results Section ONLY
+
+**CRITICAL**: You are ONLY authorized to update the "QA Results" section of the story file. DO NOT modify any other sections.
 
 After review and any refactoring, append your results to the story file in the QA Results section: