bmad-method 6.0.0-alpha.2 → 6.0.0-alpha.4

package/src/modules/bmm/workflows/4-implementation/retrospective/instructions.md

@@ -6,8 +6,8 @@
 <critical>Generate all documents in {document_output_language}</critical>
 
 <critical>
+DOCUMENT OUTPUT: Retrospective analysis. Concise insights, lessons learned, action items. User skill level ({user_skill_level}) affects conversation style ONLY, not retrospective content.
 
-<critical>DOCUMENT OUTPUT: Retrospective analysis. Concise insights, lessons learned, action items. User skill level ({user_skill_level}) affects conversation style ONLY, not retrospective content.</critical>
 FACILITATION NOTES:
 
 - Scrum Master facilitates this retrospective
@@ -16,22 +16,107 @@ FACILITATION NOTES:
 - Everyone contributes with specific examples preferred
 - Action items must be achievable with clear ownership
 - Two-part format: (1) Epic Review + (2) Next Epic Preparation
+
+PARTY MODE PROTOCOL:
+
+- ALL agent dialogue MUST use format: "Name (Role): dialogue"
+- Example: Bob (Scrum Master): "Let's begin..."
+- Example: {user_name} (Project Lead): [User responds]
+- Create natural back-and-forth with user actively participating
+- Show disagreements, diverse perspectives, authentic team dynamics
   </critical>
 
+## 📚 Document Discovery - Selective Epic Loading
+
+**Strategy**: This workflow needs the completed epic, previous retrospective, and potentially architecture/PRD for context.
+
+**Epic Discovery (SELECTIVE LOAD):**
+
+1. Determine completed epic number (from sprint-status or user)
+2. If sharded: Load ONLY `epic-{epic_num}.md`
+3. If whole: Load complete epics file and extract relevant epic
+
+**Retrospective History:**
+
+1. Load previous epic's retrospective to check if lessons were applied
+2. Pattern: `retrospectives/epic-{prev_num}-retro-*.md`
+
+**Supporting Documents (Full Load if needed):**
+
+1. Architecture: Check for whole document first, then sharded index + all sections
+2. PRD: Same pattern as architecture
+3. These provide additional context for understanding epic execution
+
+**Priority**: Whole document first, then sharded version.
+
 <workflow>
 
-<step n="1" goal="Epic Context Discovery and verify completion" tag="sprint-status">
-<action>Help the user identify which epic was just completed through natural conversation</action>
-<action>Attempt to auto-detect by checking {output_folder}/stories/ for the highest numbered completed story and extracting the epic number</action>
-<action>If auto-detection succeeds, confirm with user: "It looks like Epic {{epic_number}} was just completed - is that correct?"</action>
-<action>If auto-detection fails or user indicates different epic, ask them to share which epic they just completed</action>
+<step n="1" goal="Epic Discovery - Find Completed Epic with Priority Logic">
 
-<action>Verify epic completion status:</action>
+<action>Explain to {user_name} the epic discovery process using natural dialogue</action>
 
-<action>Load the FULL file: {output_folder}/sprint-status.yaml</action>
+<output>
+Bob (Scrum Master): "Welcome to the retrospective, {user_name}. Let me help you identify which epic we just completed. I'll check sprint-status first, but you're the ultimate authority on what we're reviewing today."
+</output>
+
+<action>PRIORITY 1: Check sprint-status.yaml first</action>
+
+<action>Load the FULL file: {sprint_status_file}</action>
 <action>Read ALL development_status entries</action>
+<action>Find the highest epic number with at least one story marked "done"</action>
+<action>Extract epic number from keys like "epic-X-retrospective" or story keys like "X-Y-story-name"</action>
+<action>Set {{detected_epic}} = highest epic number found with completed stories</action>
+
+<check if="{{detected_epic}} found">
+  <action>Present finding to user with context</action>
 
-<action>Find all stories for epic {{epic_number}}:
+  <output>
+Bob (Scrum Master): "Based on sprint-status.yaml, it looks like Epic {{detected_epic}} was recently completed. Is that the epic you want to review today, {user_name}?"
+  </output>
+
+<action>WAIT for {user_name} to confirm or correct</action>
+
+  <check if="{user_name} confirms">
+    <action>Set {{epic_number}} = {{detected_epic}}</action>
+  </check>
+
+  <check if="{user_name} provides different epic number">
+    <action>Set {{epic_number}} = user-provided number</action>
+    <output>
+Bob (Scrum Master): "Got it, we're reviewing Epic {{epic_number}}. Let me gather that information."
+    </output>
+  </check>
+</check>
+
+<check if="{{detected_epic}} NOT found in sprint-status">
+  <action>PRIORITY 2: Ask user directly</action>
+
+  <output>
+Bob (Scrum Master): "I'm having trouble detecting the completed epic from sprint-status.yaml. {user_name}, which epic number did you just complete?"
+  </output>
+
+<action>WAIT for {user_name} to provide epic number</action>
+<action>Set {{epic_number}} = user-provided number</action>
+</check>
+
+<check if="{{epic_number}} still not determined">
+  <action>PRIORITY 3: Fallback to stories folder</action>
+
+<action>Scan {story_directory} for highest numbered story files</action>
+<action>Extract epic numbers from story filenames (pattern: epic-X-Y-story-name.md)</action>
+<action>Set {{detected_epic}} = highest epic number found</action>
+
+  <output>
+Bob (Scrum Master): "I found stories for Epic {{detected_epic}} in the stories folder. Is that the epic we're reviewing, {user_name}?"
+  </output>
+
+<action>WAIT for {user_name} to confirm or correct</action>
+<action>Set {{epic_number}} = confirmed number</action>
+</check>
+
+<action>Once {{epic_number}} is determined, verify epic completion status</action>
+
+<action>Find all stories for epic {{epic_number}} in sprint-status.yaml:
 
 - Look for keys starting with "{{epic_number}}-" (e.g., "1-1-", "1-2-", etc.)
 - Exclude epic key itself ("epic-{{epic_number}}")
@@ -44,7 +129,10 @@ FACILITATION NOTES:
 <action>Determine if complete: true if all stories are done, false otherwise</action>
 
 <check if="epic is not complete">
-  <output>⚠️ Epic {{epic_number}} is not yet complete for retrospective
+  <output>
+Alice (Product Owner): "Wait, Bob - I'm seeing that Epic {{epic_number}} isn't actually complete yet."
+
+Bob (Scrum Master): "Let me check... you're right, Alice."
 
 **Epic Status:**
 
@@ -55,123 +143,368 @@ FACILITATION NOTES:
 **Pending Stories:**
 {{pending_story_list}}
 
+Bob (Scrum Master): "{user_name}, we typically run retrospectives after all stories are done. What would you like to do?"
+
 **Options:**
 
-1. Complete remaining stories before running retrospective
-2. Continue with partial retrospective (not recommended)
+1. Complete remaining stories before running retrospective (recommended)
+2. Continue with partial retrospective (not ideal, but possible)
 3. Run sprint-planning to refresh story tracking
    </output>
 
-<ask if="{{non_interactive}} == false">Epic is incomplete. Continue anyway? (yes/no)</ask>
+<ask if="{{non_interactive}} == false">Continue with incomplete epic? (yes/no)</ask>
 
   <check if="user says no">
+    <output>
+Bob (Scrum Master): "Smart call, {user_name}. Let's finish those stories first and then have a proper retrospective."
+    </output>
     <action>HALT</action>
   </check>
 
 <action if="user says yes">Set {{partial_retrospective}} = true</action>
+<output>
+Charlie (Senior Dev): "Just so everyone knows, this partial retro might miss some important lessons from those pending stories."
+
+Bob (Scrum Master): "Good point, Charlie. {user_name}, we'll document what we can now, but we may want to revisit after everything's done."
+</output>
 </check>
 
 <check if="epic is complete">
-  <output>✅ Epic {{epic_number}} is complete - all {{done_stories}} stories done!
+  <output>
+Alice (Product Owner): "Excellent! All {{done_stories}} stories are marked done."
 
-Ready to proceed with retrospective.
+Bob (Scrum Master): "Perfect. Epic {{epic_number}} is complete and ready for retrospective, {user_name}."
 </output>
 </check>
 
-<action>Load the completed epic from: {output_folder}/prd/epic-{{epic_number}}.md</action>
-<action>Extract epic details:
+</step>
 
-- Epic title and goals
-- Success criteria
-- Planned stories and story points
-- Estimated sprint duration
-- Business objectives
-  </action>
+<step n="2" goal="Deep Story Analysis - Extract Lessons from Implementation">
+
+<output>
+Bob (Scrum Master): "Before we start the team discussion, let me review all the story records to surface key themes. This'll help us have a richer conversation."
+
+Charlie (Senior Dev): "Good idea - those dev notes always have gold in them."
+</output>
+
+<action>For each story in epic {{epic_number}}, read the complete story file from {story_directory}/{{epic_number}}-{{story_num}}-\*.md</action>
+
+<action>Extract and analyze from each story:</action>
+
+**Dev Notes and Struggles:**
+
+- Look for sections like "## Dev Notes", "## Implementation Notes", "## Challenges", "## Development Log"
+- Identify where developers struggled or made mistakes
+- Note unexpected complexity or gotchas discovered
+- Record technical decisions that didn't work out as planned
+- Track where estimates were way off (too high or too low)
+
+**Review Feedback Patterns:**
+
+- Look for "## Review", "## Code Review", "## SM Review", "## Scrum Master Review" sections
+- Identify recurring feedback themes across stories
+- Note which types of issues came up repeatedly
+- Track quality concerns or architectural misalignments
+- Document praise or exemplary work called out in reviews
+
+**Lessons Learned:**
+
+- Look for "## Lessons Learned", "## Retrospective Notes", "## Takeaways" sections within stories
+- Extract explicit lessons documented during development
+- Identify "aha moments" or breakthroughs
+- Note what would be done differently
+- Track successful experiments or approaches
+
+**Technical Debt Incurred:**
+
+- Look for "## Technical Debt", "## TODO", "## Known Issues", "## Future Work" sections
+- Document shortcuts taken and why
+- Track debt items that affect next epic
+- Note severity and priority of debt items
+
+**Testing and Quality Insights:**
+
+- Look for "## Testing", "## QA Notes", "## Test Results" sections
+- Note testing challenges or surprises
+- Track bug patterns or regression issues
+- Document test coverage gaps
+
+<action>Synthesize patterns across all stories:</action>
+
+**Common Struggles:**
+
+- Identify issues that appeared in 2+ stories (e.g., "3 out of 5 stories had API authentication issues")
+- Note areas where team consistently struggled
+- Track where complexity was underestimated
+
+**Recurring Review Feedback:**
+
+- Identify feedback themes (e.g., "Error handling was flagged in every review")
+- Note quality patterns (positive and negative)
+- Track areas where team improved over the course of epic
+
+**Breakthrough Moments:**
 
-<action>Find all stories for this epic in {output_folder}/stories/</action>
-<action>For each story, extract: - Story number and title - Completion status - Story points (if tracked) - Actual completion date - Dev Agent Record notes - TEA Results and testing outcomes - PO Notes and acceptance - Blockers encountered and resolution - Technical debt incurred
-</action>
+- Document key discoveries (e.g., "Story 3 discovered the caching pattern we used for rest of epic")
+- Note when team velocity improved dramatically
+- Track innovative solutions worth repeating
 
-<action>Calculate epic metrics: - Completed stories vs. total planned - Actual story points delivered vs. planned - Actual sprints taken vs. estimated - Velocity (points per sprint) - Blocker count - Technical debt items logged
-</action>
+**Velocity Patterns:**
+
+- Calculate average completion time per story
+- Note velocity trends (e.g., "First 2 stories took 3x longer than estimated")
+- Identify which types of stories went faster/slower
+
+**Team Collaboration Highlights:**
+
+- Note moments of excellent collaboration mentioned in stories
+- Track where pair programming or mob programming was effective
+- Document effective problem-solving sessions
+
+<action>Store this synthesis - these patterns will drive the retrospective discussion</action>
+
+<output>
+Bob (Scrum Master): "Okay, I've reviewed all {{total_stories}} story records. I found some really interesting patterns we should discuss."
+
+Dana (QA Engineer): "I'm curious what you found, Bob. I noticed some things in my testing too."
+
+Bob (Scrum Master): "We'll get to all of it. But first, let me load the previous epic's retro to see if we learned from last time."
+</output>
 
-<action>Review epic goals and compare actual outcomes vs. planned</action>
-<action>Note any scope changes or descoped items</action>
-<action>Document key architectural decisions made during epic</action>
-<action>Identify technical debt incurred and why</action>
 </step>
 
-<step n="2" goal="Preview Next Epic">
-<action>Identify the next epic in sequence</action>
-<action>Load next epic from: {output_folder}/prd/epic-{{next_epic_number}}.md</action>
+<step n="3" goal="Load and Integrate Previous Epic Retrospective">
+
+<action>Calculate previous epic number: {{prev_epic_num}} = {{epic_number}} - 1</action>
+
+<check if="{{prev_epic_num}} >= 1">
+  <action>Search for previous retrospective using pattern: {retrospectives_folder}/epic-{{prev_epic_num}}-retro-*.md</action>
+
+  <check if="previous retro found">
+    <output>
+Bob (Scrum Master): "I found our retrospective from Epic {{prev_epic_num}}. Let me see what we committed to back then..."
+    </output>
+
+    <action>Read the complete previous retrospective file</action>
+
+    <action>Extract key elements:</action>
+    - **Action items committed**: What did the team agree to improve?
+    - **Lessons learned**: What insights were captured?
+    - **Process improvements**: What changes were agreed upon?
+    - **Technical debt flagged**: What debt was documented?
+    - **Team agreements**: What commitments were made?
+    - **Preparation tasks**: What was needed for this epic?
+
+    <action>Cross-reference with current epic execution:</action>
+
+    **Action Item Follow-Through:**
+    - For each action item from Epic {{prev_epic_num}} retro, check if it was completed
+    - Look for evidence in current epic's story records
+    - Mark each action item: ✅ Completed, ⏳ In Progress, ❌ Not Addressed
+
+    **Lessons Applied:**
+    - For each lesson from Epic {{prev_epic_num}}, check if team applied it in Epic {{epic_number}}
+    - Look for evidence in dev notes, review feedback, or outcomes
+    - Document successes and missed opportunities
+
+    **Process Improvements Effectiveness:**
+    - For each process change agreed to in Epic {{prev_epic_num}}, assess if it helped
+    - Did the change improve velocity, quality, or team satisfaction?
+    - Should we keep, modify, or abandon the change?
+
+    **Technical Debt Status:**
+    - For each debt item from Epic {{prev_epic_num}}, check if it was addressed
+    - Did unaddressed debt cause problems in Epic {{epic_number}}?
+    - Did the debt grow or shrink?
+
+    <action>Prepare "continuity insights" for the retrospective discussion</action>
+
+    <action>Identify wins where previous lessons were applied successfully:</action>
+    - Document specific examples of applied learnings
+    - Note positive impact on Epic {{epic_number}} outcomes
+    - Celebrate team growth and improvement
+
+    <action>Identify missed opportunities where previous lessons were ignored:</action>
+    - Document where team repeated previous mistakes
+    - Note impact of not applying lessons (without blame)
+    - Explore barriers that prevented application
+
+    <output>
+
+Bob (Scrum Master): "Interesting... in Epic {{prev_epic_num}}'s retro, we committed to {{action_count}} action items."
+
+Alice (Product Owner): "How'd we do on those, Bob?"
+
+Bob (Scrum Master): "We completed {{completed_count}}, made progress on {{in_progress_count}}, but didn't address {{not_addressed_count}}."
+
+Charlie (Senior Dev): _looking concerned_ "Which ones didn't we address?"
+
+Bob (Scrum Master): "We'll discuss that in the retro. Some of them might explain challenges we had this epic."
+
+Elena (Junior Dev): "That's... actually pretty insightful."
+
+Bob (Scrum Master): "That's why we track this stuff. Pattern recognition helps us improve."
+</output>
 
-<action if="next epic exists">
-Analyze next epic for:
+  </check>
+
+  <check if="no previous retro found">
+    <output>
+Bob (Scrum Master): "I don't see a retrospective for Epic {{prev_epic_num}}. Either we skipped it, or this is your first retro."
+
+Alice (Product Owner): "Probably our first one. Good time to start the habit!"
+</output>
+<action>Set {{first_retrospective}} = true</action>
+</check>
+</check>
+
+<check if="{{prev_epic_num}} < 1">
+  <output>
+Bob (Scrum Master): "This is Epic 1, so naturally there's no previous retro to reference. We're starting fresh!"
+
+Charlie (Senior Dev): "First epic, first retro. Let's make it count."
+</output>
+<action>Set {{first_retrospective}} = true</action>
+</check>
+
+</step>
+
+<step n="4" goal="Preview Next Epic with Change Detection">
+
+<action>Calculate next epic number: {{next_epic_num}} = {{epic_number}} + 1</action>
+
+<output>
+Bob (Scrum Master): "Before we dive into the discussion, let me take a quick look at Epic {{next_epic_num}} to understand what's coming."
+
+Alice (Product Owner): "Good thinking - helps us connect what we learned to what we're about to do."
+</output>
+
+<action>Attempt to load next epic using selective loading strategy:</action>
+
+**Try sharded first (more specific):**
+<action>Check if file exists: {output*folder}/\_epic*/epic-{{next_epic_num}}.md</action>
+
+<check if="sharded epic file found">
+  <action>Load {output_folder}/*epic*/epic-{{next_epic_num}}.md</action>
+  <action>Set {{next_epic_source}} = "sharded"</action>
+</check>
+
+**Fallback to whole document:**
+<check if="sharded epic not found">
+<action>Check if file exists: {output*folder}/\_epic*.md</action>
+
+  <check if="whole epic file found">
+    <action>Load entire epics document</action>
+    <action>Extract Epic {{next_epic_num}} section</action>
+    <action>Set {{next_epic_source}} = "whole"</action>
+  </check>
+</check>
+
+<check if="next epic found">
+  <action>Analyze next epic for:</action>
   - Epic title and objectives
-  - Planned stories and complexity
-  - Dependencies on completed epic work
+  - Planned stories and complexity estimates
+  - Dependencies on Epic {{epic_number}} work
   - New technical requirements or capabilities needed
   - Potential risks or unknowns
-</action>
+  - Business goals and success criteria
 
-<action>Identify dependencies on completed work:
+<action>Identify dependencies on completed work:</action>
 
-- What components from Epic {{completed_number}} does Epic {{next_number}} rely on?
+- What components from Epic {{epic_number}} does Epic {{next_epic_num}} rely on?
 - Are all prerequisites complete and stable?
 - Any incomplete work that creates blocking dependencies?
-  </action>
 
-<action>Note potential gaps or preparation needed:
+<action>Note potential gaps or preparation needed:</action>
 
 - Technical setup required (infrastructure, tools, libraries)
 - Knowledge gaps to fill (research, training, spikes)
 - Refactoring needed before starting next epic
 - Documentation or specifications to create
-  </action>
 
-<action>Check for technical prerequisites:
+<action>Check for technical prerequisites:</action>
 
 - APIs or integrations that must be ready
 - Data migrations or schema changes needed
 - Testing infrastructure requirements
 - Deployment or environment setup
-  </action>
+
+  <output>
+Bob (Scrum Master): "Alright, I've reviewed Epic {{next_epic_num}}: '{{next_epic_title}}'"
+
+Alice (Product Owner): "What are we looking at?"
+
+Bob (Scrum Master): "{{next_epic_num}} stories planned, building on the {{dependency_description}} from Epic {{epic_number}}."
+
+Charlie (Senior Dev): "Dependencies concern me. Did we finish everything we need for that?"
+
+Bob (Scrum Master): "Good question - that's exactly what we need to explore in this retro."
+</output>
+
+<action>Set {{next_epic_exists}} = true</action>
+</check>
+
+<check if="next epic NOT found">
+  <output>
+Bob (Scrum Master): "Hmm, I don't see Epic {{next_epic_num}} defined yet."
+
+Alice (Product Owner): "We might be at the end of the roadmap, or we haven't planned that far ahead yet."
+
+Bob (Scrum Master): "No problem. We'll still do a thorough retro on Epic {{epic_number}}. The lessons will be valuable whenever we plan the next work."
+</output>
+
+<action>Set {{next_epic_exists}} = false</action>
+</check>
 
 </step>
 
-<step n="3" goal="Initialize Retrospective with Context">
-<action>Scrum Master opens the retrospective with context</action>
-<action>Present formatted retrospective header:
+<step n="5" goal="Initialize Retrospective with Rich Context">
 
-```
-🔄 TEAM RETROSPECTIVE - Epic {{epic_number}}: {{epic_title}}
+<action>Load agent configurations from {agent_manifest}</action>
+<action>Identify which agents participated in Epic {{epic_number}} based on story records</action>
+<action>Ensure key roles present: Product Owner, Scrum Master (facilitating), Devs, Testing/QA, Architect</action>
 
-Scrum Master facilitating
+<output>
+Bob (Scrum Master): "Alright team, everyone's here. Let me set the stage for our retrospective."
 
+═══════════════════════════════════════════════════════════
+🔄 TEAM RETROSPECTIVE - Epic {{epic_number}}: {{epic_title}}
 ═══════════════════════════════════════════════════════════
 
-EPIC {{epic_number}} SUMMARY:
+Bob (Scrum Master): "Here's what we accomplished together."
+
+**EPIC {{epic_number}} SUMMARY:**
 
 Delivery Metrics:
+
 - Completed: {{completed_stories}}/{{total_stories}} stories ({{completion_percentage}}%)
-- Velocity: {{actual_points}} story points (planned: {{planned_points}})
-- Duration: {{actual_sprints}} sprints (planned: {{planned_sprints}})
+- Velocity: {{actual_points}} story points{{#if planned_points}} (planned: {{planned_points}}){{/if}}
+- Duration: {{actual_sprints}} sprints{{#if planned_sprints}} (planned: {{planned_sprints}}){{/if}}
 - Average velocity: {{points_per_sprint}} points/sprint
 
 Quality and Technical:
+
 - Blockers encountered: {{blocker_count}}
 - Technical debt items: {{debt_count}}
 - Test coverage: {{coverage_info}}
 - Production incidents: {{incident_count}}
 
 Business Outcomes:
+
 - Goals achieved: {{goals_met}}/{{total_goals}}
 - Success criteria: {{criteria_status}}
 - Stakeholder feedback: {{feedback_summary}}
 
-═══════════════════════════════════════════════════════════
+Alice (Product Owner): "Those numbers tell a good story. {{completion_percentage}}% completion is {{#if completion_percentage >= 90}}excellent{{else}}something we should discuss{{/if}}."
+
+Charlie (Senior Dev): "I'm more interested in that technical debt number - {{debt_count}} items is {{#if debt_count > 10}}concerning{{else}}manageable{{/if}}."
 
-NEXT EPIC PREVIEW: Epic {{next_number}}: {{next_epic_title}}
+Dana (QA Engineer): "{{incident_count}} production incidents - {{#if incident_count == 0}}clean epic!{{else}}we should talk about those{{/if}}."
+
+{{#if next_epic_exists}}
+═══════════════════════════════════════════════════════════
+**NEXT EPIC PREVIEW:** Epic {{next_epic_num}}: {{next_epic_title}}
+═══════════════════════════════════════════════════════════
 
 Dependencies on Epic {{epic_number}}:
 {{list_dependencies}}
@@ -182,298 +515,946 @@ Preparation Needed:
 Technical Prerequisites:
 {{list_technical_prereqs}}
 
+Bob (Scrum Master): "And here's what's coming next. Epic {{next_epic_num}} builds on what we just finished."
+
+Elena (Junior Dev): "Wow, that's a lot of dependencies on our work."
+
+Charlie (Senior Dev): "Which means we better make sure Epic {{epic_number}} is actually solid before moving on."
+{{/if}}
+
 ═══════════════════════════════════════════════════════════
 
-Team assembled for reflection:
-{{list_agents_based_on_story_records}}
+Bob (Scrum Master): "Team assembled for this retrospective:"
+
+{{list_participating_agents}}
+
+Bob (Scrum Master): "{user_name}, you're joining us as Project Lead. Your perspective is crucial here."
+
+{user_name} (Project Lead): [Participating in the retrospective]
+
+Bob (Scrum Master): "Our focus today:"
 
-Focus Areas:
 1. Learning from Epic {{epic_number}} execution
-2. Preparing for Epic {{next_number}} success
-```
+   {{#if next_epic_exists}}2. Preparing for Epic {{next_epic_num}} success{{/if}}
+
+Bob (Scrum Master): "Ground rules: psychological safety first. No blame, no judgment. We focus on systems and processes, not individuals. Everyone's voice matters. Specific examples are better than generalizations."
 
-</action>
+Alice (Product Owner): "And everything shared here stays in this room - unless we decide together to escalate something."
+
+Bob (Scrum Master): "Exactly. {user_name}, any questions before we dive in?"
+</output>
+
+<action>WAIT for {user_name} to respond or indicate readiness</action>
 
-<action>Load agent configurations from {agent-manifest}</action>
-<action>Ensure key roles present from the {agent_manifest}: Product Owner, Scrum Master (facilitating the retro), Devs, Testing or QA, Architect, Analyst</action>
 </step>
 
-<step n="4" goal="Epic Review Discussion">
-<action>Scrum Master facilitates Part 1: Reviewing the completed epic through natural, psychologically safe discussion</action>
-<action>Create space for each agent to share their perspective in their unique voice and communication style, grounded in actual story data and outcomes</action>
-<action>Maintain psychological safety throughout - focus on learning and systems, not blame or individual performance</action>
+<step n="6" goal="Epic Review Discussion - What Went Well, What Didn't">
+
+<output>
+Bob (Scrum Master): "Let's start with the good stuff. What went well in Epic {{epic_number}}?"
 
-<action>Guide the retrospective conversation to naturally surface key themes across three dimensions:</action>
+Bob (Scrum Master): _pauses, creating space_
 
-**1. Successes and Strengths:**
-<action>Facilitate discussion that helps agents share what worked well during the epic - encourage specific examples from completed stories, effective practices, velocity achievements, collaboration wins, and smart technical decisions</action>
-<action>Draw out concrete examples: "Can you share a specific story where that approach worked well?"</action>
+Alice (Product Owner): "I'll start. The user authentication flow we delivered exceeded my expectations. The UX is smooth, and early user feedback has been really positive."
 
-**2. Challenges and Growth Areas:**
-<action>Create safe space for agents to explore challenges encountered - guide them to discuss blockers, process friction, technical debt decisions, and coordination issues with curiosity rather than judgment</action>
-<action>Probe for root causes: "What made that challenging? What pattern do we see here?"</action>
-<action>Keep focus on systems and processes, not individuals</action>
+Charlie (Senior Dev): "I'll add to that - the caching strategy we implemented in Story {{breakthrough_story_num}} was a game-changer. We cut API calls by 60% and it set the pattern for the rest of the epic."
+
+Dana (QA Engineer): "From my side, testing went smoother than usual. The dev team's documentation was way better this epic - actually usable test plans!"
+
+Elena (Junior Dev): _smiling_ "That's because Charlie made me document everything after Story 1's code review!"
+
+Charlie (Senior Dev): _laughing_ "Tough love pays off."
+</output>
+
+<action>Bob (Scrum Master) naturally turns to {user_name} to engage them in the discussion</action>
+
+<output>
+Bob (Scrum Master): "{user_name}, what stood out to you as going well in this epic?"
+</output>
 
-**3. Insights and Learning:**
-<action>Help the team articulate what they learned from this epic - facilitate discovery of patterns to repeat or avoid, skills gained, and process improvements worth trying</action>
-<action>Connect insights to future application: "How might this insight help us in future epics?"</action>
+<action>WAIT for {user_name} to respond - this is a KEY USER INTERACTION moment</action>
 
-<action>For each agent participating (loaded from {agent_manifest}):</action>
+<action>After {user_name} responds, have 1-2 team members react to or build on what {user_name} shared</action>
 
-- Let them speak naturally in their role's voice and communication style
-- Encourage grounding in specific story records, metrics, and real outcomes
-- Allow themes to emerge organically rather than forcing a rigid structure
-- Follow interesting threads with adaptive questions
-- Balance celebration with honest assessment
+<output>
+Alice (Product Owner): [Responds naturally to what {user_name} said, either agreeing, adding context, or offering a different perspective]
+
+Charlie (Senior Dev): [Builds on the discussion, perhaps adding technical details or connecting to specific stories]
+</output>
+
+<action>Continue facilitating natural dialogue, periodically bringing {user_name} back into the conversation</action>
+
+<action>After covering successes, guide the transition to challenges with care</action>
+
+<output>
+Bob (Scrum Master): "Okay, we've celebrated some real wins. Now let's talk about challenges - where did we struggle? What slowed us down?"
+
+Bob (Scrum Master): _creates safe space with tone and pacing_
+
+Elena (Junior Dev): _hesitates_ "Well... I really struggled with the database migrations in Story {{difficult_story_num}}. The documentation wasn't clear, and I had to redo it three times. Lost almost a full sprint on that story alone."
+
+Charlie (Senior Dev): _defensive_ "Hold on - I wrote those migration docs, and they were perfectly clear. The issue was that the requirements kept changing mid-story!"
+
+Alice (Product Owner): _frustrated_ "That's not fair, Charlie. We only clarified requirements once, and that was because the technical team didn't ask the right questions during planning!"
+
+Charlie (Senior Dev): _heat rising_ "We asked plenty of questions! You said the schema was finalized, then two days into development you wanted to add three new fields!"
+
+Bob (Scrum Master): _intervening calmly_ "Let's take a breath here. This is exactly the kind of thing we need to unpack."
+
+Bob (Scrum Master): "Elena, you spent almost a full sprint on Story {{difficult_story_num}}. Charlie, you're saying requirements changed. Alice, you feel the right questions weren't asked up front."
+
+Bob (Scrum Master): "{user_name}, you have visibility across the whole project. What's your take on this situation?"
+</output>
+
+<action>WAIT for {user_name} to respond and help facilitate the conflict resolution</action>
+
+<action>Use {user_name}'s response to guide the discussion toward systemic understanding rather than blame</action>
+
+<output>
+Bob (Scrum Master): [Synthesizes {user_name}'s input with what the team shared] "So it sounds like the core issue was {{root_cause_based_on_discussion}}, not any individual person's fault."
+
+Elena (Junior Dev): "That makes sense. If we'd had {{preventive_measure}}, I probably could have avoided those redos."
+
+Charlie (Senior Dev): _softening_ "Yeah, and I could have been clearer about assumptions in the docs. Sorry for getting defensive, Alice."
+
+Alice (Product Owner): "I appreciate that. I could've been more proactive about flagging the schema additions earlier, too."
+
+Bob (Scrum Master): "This is good. We're identifying systemic improvements, not assigning blame."
+</output>
+
+<action>Continue the discussion, weaving in patterns discovered from the deep story analysis (Step 2)</action>
+
+<output>
+Bob (Scrum Master): "Speaking of patterns, I noticed something when reviewing all the story records..."
+
+Bob (Scrum Master): "{{pattern_1_description}} - this showed up in {{pattern_1_count}} out of {{total_stories}} stories."
+
+Dana (QA Engineer): "Oh wow, I didn't realize it was that widespread."
+
+Bob (Scrum Master): "Yeah. And there's more - {{pattern_2_description}} came up in almost every code review."
+
+Charlie (Senior Dev): "That's... actually embarrassing. We should've caught that pattern earlier."
+
+Bob (Scrum Master): "No shame, Charlie. Now we know, and we can improve. {user_name}, did you notice these patterns during the epic?"
+</output>
+
+<action>WAIT for {user_name} to share their observations</action>
+
+<action>Continue the retrospective discussion, creating moments where:</action>
+
+- Team members ask {user_name} questions directly
+- {user_name}'s input shifts the discussion direction
+- Disagreements arise naturally and get resolved
+- Quieter team members are invited to contribute
+- Specific stories are referenced with real examples
+- Emotions are authentic (frustration, pride, concern, hope)
+
+<check if="previous retrospective exists">
+  <output>
+Bob (Scrum Master): "Before we move on, I want to circle back to Epic {{prev_epic_num}}'s retrospective."
+
+Bob (Scrum Master): "We made some commitments in that retro. Let's see how we did."
+
+Bob (Scrum Master): "Action item 1: {{prev_action_1}}. Status: {{prev_action_1_status}}"
+
+Alice (Product Owner): {{#if prev_action_1_status == "completed"}}"We nailed that one!"{{else}}"We... didn't do that one."{{/if}}
+
+Charlie (Senior Dev): {{#if prev_action_1_status == "completed"}}"And it helped! I noticed {{evidence_of_impact}}"{{else}}"Yeah, and I think that's why we had {{consequence_of_not_doing_it}} this epic."{{/if}}
+
+Bob (Scrum Master): "Action item 2: {{prev_action_2}}. Status: {{prev_action_2_status}}"
+
+Dana (QA Engineer): {{#if prev_action_2_status == "completed"}}"This one made testing so much easier this time."{{else}}"If we'd done this, I think testing would've gone faster."{{/if}}
+
+Bob (Scrum Master): "{user_name}, looking at what we committed to last time and what we actually did - what's your reaction?"
+</output>
+
+<action>WAIT for {user_name} to respond</action>
+
+<action>Use the previous retro follow-through as a learning moment about commitment and accountability</action>
+</check>
+
+<output>
+Bob (Scrum Master): "Alright, we've covered a lot of ground. Let me summarize what I'm hearing..."
+
+Bob (Scrum Master): "**Successes:**"
+{{list_success_themes}}
+
+Bob (Scrum Master): "**Challenges:**"
+{{list_challenge_themes}}
+
+Bob (Scrum Master): "**Key Insights:**"
+{{list_insight_themes}}
+
+Bob (Scrum Master): "Does that capture it? Anyone have something important we missed?"
+</output>
+
+<action>Allow team members to add any final thoughts on the epic review</action>
+<action>Ensure {user_name} has opportunity to add their perspective</action>
 
-<action>As facilitator, actively synthesize common themes and patterns as the discussion unfolds</action>
-<action>Notice when multiple agents mention similar issues or successes - call these out to deepen the team's shared understanding</action>
-<action>Ensure every voice is heard, inviting quieter agents to contribute</action>
 </step>
 
-<step n="5" goal="Next Epic Preparation Discussion">
-<action>Scrum Master facilitates Part 2: Preparing for the next epic through forward-looking exploration</action>
-<action>Shift the team's focus from reflection to readiness - guide each agent to explore preparation needs from their domain perspective</action>
+<step n="7" goal="Next Epic Preparation Discussion - Interactive and Collaborative">
+
+<check if="{{next_epic_exists}} == false">
+  <output>
+Bob (Scrum Master): "Normally we'd discuss preparing for the next epic, but since Epic {{next_epic_num}} isn't defined yet, let's skip to action items."
+  </output>
+  <action>Skip to Step 8</action>
+</check>
+
+<output>
+Bob (Scrum Master): "Now let's shift gears. Epic {{next_epic_num}} is coming up: '{{next_epic_title}}'"
+
+Bob (Scrum Master): "The question is: are we ready? What do we need to prepare?"
+
+Alice (Product Owner): "From my perspective, we need to make sure {{dependency_concern_1}} from Epic {{epic_number}} is solid before we start building on it."
+
+Charlie (Senior Dev): _concerned_ "I'm worried about {{technical_concern_1}}. We have {{technical_debt_item}} from this epic that'll blow up if we don't address it before Epic {{next_epic_num}}."
 
-<action>Facilitate discovery across critical preparation dimensions:</action>
+Dana (QA Engineer): "And I need {{testing_infrastructure_need}} in place, or we're going to have the same testing bottleneck we had in Story {{bottleneck_story_num}}."
 
-**Dependencies and Continuity:**
-<action>Guide agents to explore connections between the completed epic and the upcoming one - help them identify what components, decisions, or work from Epic {{completed_number}} the next epic relies upon</action>
-<action>Probe for gaps: "What needs to be in place before we can start Epic {{next_number}}?"</action>
-<action>Surface hidden dependencies: "Are there integration points we need to verify?"</action>
+Elena (Junior Dev): "I'm less worried about infrastructure and more about knowledge. I don't understand {{knowledge_gap}} well enough to work on Epic {{next_epic_num}}'s stories."
 
-**Readiness and Setup:**
-<action>Facilitate discussion about what preparation work is needed before the next epic can begin successfully - technical setup, knowledge development, refactoring, documentation, or infrastructure</action>
-<action>Draw out specific needs: "What do you need to feel ready to start Epic {{next_number}}?"</action>
-<action>Identify knowledge gaps: "What do we need to learn or research before diving in?"</action>
+Bob (Scrum Master): "{user_name}, the team is surfacing some real concerns here. What's your sense of our readiness?"
+</output>
+
+<action>WAIT for {user_name} to share their assessment</action>
+
+<action>Use {user_name}'s input to guide deeper exploration of preparation needs</action>
+
+<output>
+Alice (Product Owner): [Reacts to what {user_name} said] "I agree with {user_name} about {{point_of_agreement}}, but I'm still worried about {{lingering_concern}}."
+
+Charlie (Senior Dev): "Here's what I think we need technically before Epic {{next_epic_num}} can start..."
+
+Charlie (Senior Dev): "1. {{tech_prep_item_1}} - estimated {{hours_1}} hours"
+Charlie (Senior Dev): "2. {{tech_prep_item_2}} - estimated {{hours_2}} hours"
+Charlie (Senior Dev): "3. {{tech_prep_item_3}} - estimated {{hours_3}} hours"
+
+Elena (Junior Dev): "That's like {{total_hours}} hours! That's a full sprint of prep work!"
+
+Charlie (Senior Dev): "Exactly. We can't just jump into Epic {{next_epic_num}} on Monday."
+
+Alice (Product Owner): _frustrated_ "But we have stakeholder pressure to keep shipping features. They're not going to be happy about a 'prep sprint.'"
+
+Bob (Scrum Master): "Let's think about this differently. What happens if we DON'T do this prep work?"
+
+Dana (QA Engineer): "We'll hit blockers in the middle of Epic {{next_epic_num}}, velocity will tank, and we'll ship late anyway."
+
+Charlie (Senior Dev): "Worse - we'll ship something built on top of {{technical_concern_1}}, and it'll be fragile."
+
+Bob (Scrum Master): "{user_name}, you're balancing stakeholder pressure against technical reality. How do you want to handle this?"
+</output>
 
-**Risks and Mitigation:**
-<action>Create space for agents to voice concerns and uncertainties about the upcoming epic based on what they learned from this one</action>
-<action>Explore proactively: "Based on Epic {{completed_number}}, what concerns do you have about Epic {{next_number}}?"</action>
-<action>Develop mitigation thinking: "What could we do now to reduce that risk?"</action>
-<action>Identify early warning signs: "How will we know if we're heading for that problem again?"</action>
+<action>WAIT for {user_name} to provide direction on preparation approach</action>
 
-<action>For each agent participating:</action>
+<action>Create space for debate and disagreement about priorities</action>
 
-- Let them share preparation needs in their natural voice
-- Encourage domain-specific insights (Architect on technical setup, PM on requirements clarity, etc.)
-- Follow interesting preparation threads with adaptive questions
-- Help agents build on each other's observations
-- Surface quick wins that could de-risk the epic early
+<output>
+Alice (Product Owner): [Potentially disagrees with {user_name}'s approach] "I hear what you're saying, {user_name}, but from a business perspective, {{business_concern}}."
+
+Charlie (Senior Dev): [Potentially supports or challenges Alice's point] "The business perspective is valid, but {{technical_counter_argument}}."
+
+Bob (Scrum Master): "We have healthy tension here between business needs and technical reality. That's good - it means we're being honest."
+
+Bob (Scrum Master): "Let's explore a middle ground. Charlie, which of your prep items are absolutely critical vs. nice-to-have?"
+
+Charlie (Senior Dev): "{{critical_prep_item_1}} and {{critical_prep_item_2}} are non-negotiable. {{nice_to_have_prep_item}} can wait."
+
+Alice (Product Owner): "And can any of the critical prep happen in parallel with starting Epic {{next_epic_num}}?"
+
+Charlie (Senior Dev): _thinking_ "Maybe. If we tackle {{first_critical_item}} before the epic starts, we could do {{second_critical_item}} during the first sprint."
+
+Dana (QA Engineer): "But that means Story 1 of Epic {{next_epic_num}} can't depend on {{second_critical_item}}."
+
+Alice (Product Owner): _looking at epic plan_ "Actually, Stories 1 and 2 are about {{independent_work}}, so they don't depend on it. We could make that work."
+
+Bob (Scrum Master): "{user_name}, the team is finding a workable compromise here. Does this approach make sense to you?"
+</output>
+
+<action>WAIT for {user_name} to validate or adjust the preparation strategy</action>
+
+<action>Continue working through preparation needs across all dimensions:</action>
+
+- Dependencies on Epic {{epic_number}} work
+- Technical setup and infrastructure
+- Knowledge gaps and research needs
+- Documentation or specification work
+- Testing infrastructure
+- Refactoring or debt reduction
+- External dependencies (APIs, integrations, etc.)
+
+<action>For each preparation area, facilitate team discussion that:</action>
+
+- Identifies specific needs with concrete examples
+- Estimates effort realistically based on Epic {{epic_number}} experience
+- Assigns ownership to specific agents
+- Determines criticality and timing
+- Surfaces risks of NOT doing the preparation
+- Explores parallel work opportunities
+- Brings {user_name} in for key decisions
+
+<output>
+Bob (Scrum Master): "I'm hearing a clear picture of what we need before Epic {{next_epic_num}}. Let me summarize..."
+
+**CRITICAL PREPARATION (Must complete before epic starts):**
+{{list_critical_prep_items_with_owners_and_estimates}}
+
+**PARALLEL PREPARATION (Can happen during early stories):**
+{{list_parallel_prep_items_with_owners_and_estimates}}
+
+**NICE-TO-HAVE PREPARATION (Would help but not blocking):**
+{{list_nice_to_have_prep_items}}
+
+Bob (Scrum Master): "Total critical prep effort: {{critical_hours}} hours ({{critical_days}} days)"
+
+Alice (Product Owner): "That's manageable. We can communicate that to stakeholders."
+
+Bob (Scrum Master): "{user_name}, does this preparation plan work for you?"
+</output>
+
+<action>WAIT for {user_name} final validation of preparation plan</action>
 
-<action>As facilitator, identify dependencies between preparation tasks as they emerge</action>
-<action>Notice when preparation items from different agents connect or conflict - explore these intersections</action>
-<action>Build a shared understanding of what "ready to start Epic {{next_number}}" actually means</action>
 </step>
 
-<step n="6" goal="Synthesize Action Items">
-<action>Scrum Master identifies patterns across all agent feedback</action>
-<action>Synthesizes common themes into team agreements</action>
-<action>Creates specific, achievable action items with clear ownership</action>
-<action>Develops preparation sprint tasks if significant setup needed</action>
+<step n="8" goal="Synthesize Action Items with Significant Change Detection">
+
+<output>
+Bob (Scrum Master): "Let's capture concrete action items from everything we've discussed."
+
+Bob (Scrum Master): "I want specific, achievable actions with clear owners. Not vague aspirations."
+</output>
+
+<action>Synthesize themes from Epic {{epic_number}} review discussion into actionable improvements</action>
+
+<action>Create specific action items with:</action>
+
+- Clear description of the action
+- Assigned owner (specific agent or role)
+- Timeline or deadline
+- Success criteria (how we'll know it's done)
+- Category (process, technical, documentation, team, etc.)
 
-<action>Present comprehensive action plan:
+<action>Ensure action items are SMART:</action>
+
+- Specific: Clear and unambiguous
+- Measurable: Can verify completion
+- Achievable: Realistic given constraints
+- Relevant: Addresses real issues from retro
+- Time-bound: Has clear deadline
+
+<output>
+Bob (Scrum Master): "Based on our discussion, here are the action items I'm proposing..."
 
-```
 ═══════════════════════════════════════════════════════════
-📝 EPIC {{completed_number}} ACTION ITEMS:
+📝 EPIC {{epic_number}} ACTION ITEMS:
+═══════════════════════════════════════════════════════════
+
+**Process Improvements:**
+
+1. {{action_item_1}}
+   Owner: {{agent_1}}
+   Deadline: {{timeline_1}}
+   Success criteria: {{criteria_1}}
+
+2. {{action_item_2}}
+   Owner: {{agent_2}}
+   Deadline: {{timeline_2}}
+   Success criteria: {{criteria_2}}
+
+Charlie (Senior Dev): "I can own action item 1, but {{timeline_1}} is tight. Can we push it to {{alternative_timeline}}?"
+
+Bob (Scrum Master): "What do others think? Does that timing still work?"
 
-Process Improvements:
-1. {{action_item}} (Owner: {{agent}}, By: {{timeline}})
-2. {{action_item}} (Owner: {{agent}}, By: {{timeline}})
-3. {{action_item}} (Owner: {{agent}}, By: {{timeline}})
+Alice (Product Owner): "{{alternative_timeline}} works for me, as long as it's done before Epic {{next_epic_num}} starts."
 
-Technical Debt:
-1. {{debt_item}} (Owner: {{agent}}, Priority: {{high/medium/low}})
-2. {{debt_item}} (Owner: {{agent}}, Priority: {{high/medium/low}})
+Bob (Scrum Master): "Agreed. Updated to {{alternative_timeline}}."
+
+**Technical Debt:**
+
+1. {{debt_item_1}}
+   Owner: {{agent_3}}
+   Priority: {{priority_1}}
+   Estimated effort: {{effort_1}}
+
+2. {{debt_item_2}}
+   Owner: {{agent_4}}
+   Priority: {{priority_2}}
+   Estimated effort: {{effort_2}}
+
+Dana (QA Engineer): "For debt item 1, can we prioritize that as high? It caused testing issues in three different stories."
+
+Charlie (Senior Dev): "I marked it medium because {{reasoning}}, but I hear your point."
+
+Bob (Scrum Master): "{user_name}, this is a priority call. Testing impact vs. {{reasoning}} - how do you want to prioritize it?"
+</output>
 
-Documentation:
-1. {{doc_need}} (Owner: {{agent}}, By: {{timeline}})
+<action>WAIT for {user_name} to help resolve priority discussions</action>
+
+<output>
+**Documentation:**
+1. {{doc_need_1}}
+   Owner: {{agent_5}}
+   Deadline: {{timeline_3}}
+
+2. {{doc_need_2}}
+   Owner: {{agent_6}}
+   Deadline: {{timeline_4}}
+
+**Team Agreements:**
 
-Team Agreements:
 - {{agreement_1}}
 - {{agreement_2}}
 - {{agreement_3}}
 
+Bob (Scrum Master): "These agreements are how we're committing to work differently going forward."
+
+Elena (Junior Dev): "I like agreement 2 - that would've saved me on Story {{difficult_story_num}}."
+
+═══════════════════════════════════════════════════════════
+🚀 EPIC {{next_epic_num}} PREPARATION TASKS:
 ═══════════════════════════════════════════════════════════
-🚀 EPIC {{next_number}} PREPARATION SPRINT:
 
-Technical Setup:
-[ ] {{setup_task}} (Owner: {{agent}}, Est: {{hours/days}})
-[ ] {{setup_task}} (Owner: {{agent}}, Est: {{hours/days}})
+**Technical Setup:**
+[ ] {{setup_task_1}}
+Owner: {{owner_1}}
+Estimated: {{est_1}}
 
-Knowledge Development:
-[ ] {{research_task}} (Owner: {{agent}}, Est: {{hours/days}})
-[ ] {{spike_task}} (Owner: {{agent}}, Est: {{hours/days}})
+[ ] {{setup_task_2}}
+Owner: {{owner_2}}
+Estimated: {{est_2}}
 
-Cleanup/Refactoring:
-[ ] {{refactor_task}} (Owner: {{agent}}, Est: {{hours/days}})
-[ ] {{cleanup_task}} (Owner: {{agent}}, Est: {{hours/days}})
+**Knowledge Development:**
+[ ] {{research_task_1}}
+Owner: {{owner_3}}
+Estimated: {{est_3}}
 
-Documentation:
-[ ] {{doc_task}} (Owner: {{agent}}, Est: {{hours/days}})
+**Cleanup/Refactoring:**
+[ ] {{refactor_task_1}}
+Owner: {{owner_4}}
+Estimated: {{est_4}}
 
-Total Estimated Effort: {{total_hours}} hours ({{total_days}} days)
+**Total Estimated Effort:** {{total_hours}} hours ({{total_days}} days)
 
 ═══════════════════════════════════════════════════════════
 ⚠️ CRITICAL PATH:
+═══════════════════════════════════════════════════════════
 
-Blockers to Resolve Before Epic {{next_number}}:
-1. {{critical_item}} (Owner: {{agent}}, Must complete by: {{date}})
-2. {{critical_item}} (Owner: {{agent}}, Must complete by: {{date}})
+**Blockers to Resolve Before Epic {{next_epic_num}}:**
 
-Dependencies Timeline:
-{{timeline_visualization_of_critical_dependencies}}
+1. {{critical_item_1}}
+   Owner: {{critical_owner_1}}
+   Must complete by: {{critical_deadline_1}}
 
-Risk Mitigation:
-- {{risk}}: {{mitigation_strategy}}
-- {{risk}}: {{mitigation_strategy}}
-```
+2. {{critical_item_2}}
+   Owner: {{critical_owner_2}}
+   Must complete by: {{critical_deadline_2}}
+   </output>
+
+<action>CRITICAL ANALYSIS - Detect if discoveries require epic updates</action>
+
+<action>Check if any of the following are true based on retrospective discussion:</action>
+
+- Architectural assumptions from planning proven wrong during Epic {{epic_number}}
+- Major scope changes or descoping occurred that affects next epic
+- Technical approach needs fundamental change for Epic {{next_epic_num}}
+- Dependencies discovered that Epic {{next_epic_num}} doesn't account for
+- User needs significantly different than originally understood
+- Performance/scalability concerns that affect Epic {{next_epic_num}} design
+- Security or compliance issues discovered that change approach
+- Integration assumptions proven incorrect
+- Team capacity or skill gaps more severe than planned
+- Technical debt level unsustainable without intervention
 
-</action>
+<check if="significant discoveries detected">
+  <output>
+
+═══════════════════════════════════════════════════════════
+🚨 SIGNIFICANT DISCOVERY ALERT 🚨
+═══════════════════════════════════════════════════════════
+
+Bob (Scrum Master): "{user_name}, we need to flag something important."
+
+Bob (Scrum Master): "During Epic {{epic_number}}, the team uncovered findings that may require updating the plan for Epic {{next_epic_num}}."
+
+**Significant Changes Identified:**
+
+1. {{significant_change_1}}
+   Impact: {{impact_description_1}}
+
+2. {{significant_change_2}}
+   Impact: {{impact_description_2}}
+
+{{#if significant_change_3}} 3. {{significant_change_3}}
+Impact: {{impact_description_3}}
+{{/if}}
+
+Charlie (Senior Dev): "Yeah, when we discovered {{technical_discovery}}, it fundamentally changed our understanding of {{affected_area}}."
+
+Alice (Product Owner): "And from a product perspective, {{product_discovery}} means Epic {{next_epic_num}}'s stories are based on wrong assumptions."
+
+Dana (QA Engineer): "If we start Epic {{next_epic_num}} as-is, we're going to hit walls fast."
+
+**Impact on Epic {{next_epic_num}}:**
+
+The current plan for Epic {{next_epic_num}} assumes:
+
+- {{wrong_assumption_1}}
+- {{wrong_assumption_2}}
+
+But Epic {{epic_number}} revealed:
+
+- {{actual_reality_1}}
+- {{actual_reality_2}}
+
+This means Epic {{next_epic_num}} likely needs:
+{{list_likely_changes_needed}}
+
+**RECOMMENDED ACTIONS:**
+
+1. Review and update Epic {{next_epic_num}} definition based on new learnings
+2. Update affected stories in Epic {{next_epic_num}} to reflect reality
+3. Consider updating architecture or technical specifications if applicable
+4. Hold alignment session with Product Owner before starting Epic {{next_epic_num}}
+   {{#if prd_update_needed}}5. Update PRD sections affected by new understanding{{/if}}
+
+Bob (Scrum Master): "**Epic Update Required**: YES - Schedule epic planning review session"
+
+Bob (Scrum Master): "{user_name}, this is significant. We need to address this before committing to Epic {{next_epic_num}}'s current plan. How do you want to handle it?"
+</output>
+
+<action>WAIT for {user_name} to decide on how to handle the significant changes</action>
+
+<action>Add epic review session to critical path if user agrees</action>
+
+  <output>
+Alice (Product Owner): "I agree with {user_name}'s approach. Better to adjust the plan now than fail mid-epic."
+
+Charlie (Senior Dev): "This is why retrospectives matter. We caught this before it became a disaster."
+
+Bob (Scrum Master): "Adding to critical path: Epic {{next_epic_num}} planning review session before epic kickoff."
+</output>
+</check>
+
+<check if="no significant discoveries">
+  <output>
+Bob (Scrum Master): "Good news - nothing from Epic {{epic_number}} fundamentally changes our plan for Epic {{next_epic_num}}. The plan is still sound."
+
+Alice (Product Owner): "We learned a lot, but the direction is right."
+</output>
+</check>
+
+<output>
+Bob (Scrum Master): "Let me show you the complete action plan..."
+
+Bob (Scrum Master): "That's {{total_action_count}} action items, {{prep_task_count}} preparation tasks, and {{critical_count}} critical path items."
+
+Bob (Scrum Master): "Everyone clear on what they own?"
+</output>
+
+<action>Give each agent with assignments a moment to acknowledge their ownership</action>
+
+<action>Ensure {user_name} approves the complete action plan</action>
 
-<action>Ensure every action item has clear owner and timeline</action>
-<action>Prioritize preparation tasks by dependencies and criticality</action>
-<action>Identify which tasks can run in parallel vs. sequential</action>
 </step>
 
-<step n="7" goal="Critical Readiness Exploration">
-<action>Scrum Master leads a thoughtful exploration of whether Epic {{completed_number}} is truly complete and the team is ready for Epic {{next_number}}</action>
-<action>Approach this as discovery, not interrogation - help user surface any concerns or unfinished elements that could impact the next epic</action>
-
-<action>Guide a conversation exploring the completeness of Epic {{completed_number}} across critical dimensions:</action>
-
-**Testing and Quality:**
-<action>Explore the testing state of the epic - help user assess whether quality verification is truly complete</action>
-<action>Ask thoughtfully: "Walk me through the testing that's been done for Epic {{completed_number}}. Does anything still need verification?"</action>
-<action>Probe for gaps: "Are you confident the epic is production-ready from a quality perspective?"</action>
-<action if="testing concerns surface">Add to Critical Path: Complete necessary testing before Epic {{next_number}}</action>
-
-**Deployment and Release:**
-<action>Understand where the epic currently stands in the deployment pipeline</action>
-<action>Explore: "What's the deployment status for Epic {{completed_number}}? Is it live, scheduled, or still pending?"</action>
-<action>If not yet deployed, clarify timeline: "When is deployment planned? Does that timing work for starting Epic {{next_number}}?"</action>
-<action if="deployment must happen first">Add to Critical Path: Deploy Epic {{completed_number}} with clear timeline</action>
-
-**Stakeholder Acceptance:**
-<action>Guide user to reflect on business validation and stakeholder satisfaction</action>
-<action>Ask: "Have stakeholders seen and accepted the Epic {{completed_number}} deliverables? Any feedback pending?"</action>
-<action>Probe for risk: "Is there anything about stakeholder acceptance that could affect Epic {{next_number}}?"</action>
-<action if="acceptance incomplete">Add to Critical Path: Obtain stakeholder acceptance before proceeding</action>
-
-**Technical Health:**
-<action>Create space for honest assessment of codebase stability after the epic</action>
-<action>Explore: "How does the codebase feel after Epic {{completed_number}}? Stable and maintainable, or are there concerns?"</action>
-<action>If concerns arise, probe deeper: "What's causing those concerns? What would it take to address them?"</action>
-<action if="stability concerns exist">Document concerns and add to Preparation Sprint: Address stability issues before Epic {{next_number}}</action>
-
-**Unresolved Blockers:**
-<action>Help user surface any lingering issues that could create problems for the next epic</action>
-<action>Ask: "Are there any unresolved blockers or technical issues from Epic {{completed_number}} that we need to address before moving forward?"</action>
-<action>Explore impact: "How would these blockers affect Epic {{next_number}} if left unresolved?"</action>
-<action if="blockers exist">Document blockers and add to Critical Path with appropriate priority</action>
-
-<action>Synthesize the readiness discussion into a clear picture of what must happen before Epic {{next_number}} can safely begin</action>
-<action>Summarize any critical items identified and ensure user agrees with the assessment</action>
+<step n="9" goal="Critical Readiness Exploration - Interactive Deep Dive">
+
+<output>
+Bob (Scrum Master): "Before we close, I want to do a final readiness check."
+
+Bob (Scrum Master): "Epic {{epic_number}} is marked complete in sprint-status, but is it REALLY done?"
+
+Alice (Product Owner): "What do you mean, Bob?"
+
+Bob (Scrum Master): "I mean truly production-ready, stakeholders happy, no loose ends that'll bite us later."
+
+Bob (Scrum Master): "{user_name}, let's walk through this together."
+</output>
+
+<action>Explore testing and quality state through natural conversation</action>
+
+<output>
+Bob (Scrum Master): "{user_name}, tell me about the testing for Epic {{epic_number}}. What verification has been done?"
+</output>
+
+<action>WAIT for {user_name} to describe testing status</action>
+
+<output>
+Dana (QA Engineer): [Responds to what {user_name} shared] "I can add to that - {{additional_testing_context}}."
+
+Dana (QA Engineer): "But honestly, {{testing_concern_if_any}}."
+
+Bob (Scrum Master): "{user_name}, are you confident Epic {{epic_number}} is production-ready from a quality perspective?"
+</output>
+
+<action>WAIT for {user_name} to assess quality readiness</action>
+
+<check if="{user_name} expresses concerns">
+  <output>
+Bob (Scrum Master): "Okay, let's capture that. What specific testing is still needed?"
+
+Dana (QA Engineer): "I can handle {{testing_work_needed}}, estimated {{testing_hours}} hours."
+
+Bob (Scrum Master): "Adding to critical path: Complete {{testing_work_needed}} before Epic {{next_epic_num}}."
+</output>
+<action>Add testing completion to critical path</action>
+</check>
+
+<action>Explore deployment and release status</action>
+
+<output>
+Bob (Scrum Master): "{user_name}, what's the deployment status for Epic {{epic_number}}? Is it live in production, scheduled for deployment, or still pending?"
+</output>
+
+<action>WAIT for {user_name} to provide deployment status</action>
+
+<check if="not yet deployed">
+  <output>
+Charlie (Senior Dev): "If it's not deployed yet, we need to factor that into Epic {{next_epic_num}} timing."
+
+Bob (Scrum Master): "{user_name}, when is deployment planned? Does that timing work for starting Epic {{next_epic_num}}?"
+</output>
+
+<action>WAIT for {user_name} to clarify deployment timeline</action>
+
+<action>Add deployment milestone to critical path with agreed timeline</action>
+</check>
+
+<action>Explore stakeholder acceptance</action>
+
+<output>
+Bob (Scrum Master): "{user_name}, have stakeholders seen and accepted the Epic {{epic_number}} deliverables?"
+
+Alice (Product Owner): "This is important - I've seen 'done' epics get rejected by stakeholders and force rework."
+
+Bob (Scrum Master): "{user_name}, any feedback from stakeholders still pending?"
+</output>
+
+<action>WAIT for {user_name} to describe stakeholder acceptance status</action>
+
+<check if="acceptance incomplete or feedback pending">
+  <output>
+Alice (Product Owner): "We should get formal acceptance before moving on. Otherwise Epic {{next_epic_num}} might get interrupted by rework."
+
+Bob (Scrum Master): "{user_name}, how do you want to handle stakeholder acceptance? Should we make it a critical path item?"
+</output>
+
+<action>WAIT for {user_name} decision</action>
+
+<action>Add stakeholder acceptance to critical path if user agrees</action>
+</check>
+
+<action>Explore technical health and stability</action>
+
+<output>
+Bob (Scrum Master): "{user_name}, this is a gut-check question: How does the codebase feel after Epic {{epic_number}}?"
+
+Bob (Scrum Master): "Stable and maintainable? Or are there concerns lurking?"
+
+Charlie (Senior Dev): "Be honest, {user_name}. We've all shipped epics that felt... fragile."
+</output>
+
+<action>WAIT for {user_name} to assess codebase health</action>
+
+<check if="{user_name} expresses stability concerns">
+  <output>
+Charlie (Senior Dev): "Okay, let's dig into that. What's causing those concerns?"
+
+Charlie (Senior Dev): [Helps {user_name} articulate technical concerns]
+
+Bob (Scrum Master): "What would it take to address these concerns and feel confident about stability?"
+
+Charlie (Senior Dev): "I'd say we need {{stability_work_needed}}, roughly {{stability_hours}} hours."
+
+Bob (Scrum Master): "{user_name}, is addressing this stability work worth doing before Epic {{next_epic_num}}?"
+</output>
+
+<action>WAIT for {user_name} decision</action>
+
+<action>Add stability work to preparation sprint if user agrees</action>
+</check>
+
+<action>Explore unresolved blockers</action>
+
+<output>
+Bob (Scrum Master): "{user_name}, are there any unresolved blockers or technical issues from Epic {{epic_number}} that we're carrying forward?"
+
+Dana (QA Engineer): "Things that might create problems for Epic {{next_epic_num}} if we don't deal with them?"
+
+Bob (Scrum Master): "Nothing is off limits here. If there's a problem, we need to know."
+</output>
+
+<action>WAIT for {user_name} to surface any blockers</action>
+
+<check if="blockers identified">
+  <output>
+Bob (Scrum Master): "Let's capture those blockers and figure out how they affect Epic {{next_epic_num}}."
+
+Charlie (Senior Dev): "For {{blocker_1}}, if we leave it unresolved, it'll {{impact_description_1}}."
+
+Alice (Product Owner): "That sounds critical. We need to address that before moving forward."
+
+Bob (Scrum Master): "Agreed. Adding to critical path: Resolve {{blocker_1}} before Epic {{next_epic_num}} kickoff."
+
+Bob (Scrum Master): "Who owns that work?"
+</output>
+
+<action>Assign blocker resolution to appropriate agent</action>
+<action>Add to critical path with priority and deadline</action>
+</check>
+
+<action>Synthesize the readiness assessment</action>
+
+<output>
+Bob (Scrum Master): "Okay {user_name}, let me synthesize what we just uncovered..."
+
+**EPIC {{epic_number}} READINESS ASSESSMENT:**
+
+Testing & Quality: {{quality_status}}
+{{#if quality_concerns}}⚠️ Action needed: {{quality_action_needed}}{{/if}}
+
+Deployment: {{deployment_status}}
+{{#if deployment_pending}}⚠️ Scheduled for: {{deployment_date}}{{/if}}
+
+Stakeholder Acceptance: {{acceptance_status}}
+{{#if acceptance_incomplete}}⚠️ Action needed: {{acceptance_action_needed}}{{/if}}
+
+Technical Health: {{stability_status}}
+{{#if stability_concerns}}⚠️ Action needed: {{stability_action_needed}}{{/if}}
+
+Unresolved Blockers: {{blocker_status}}
+{{#if blockers_exist}}⚠️ Must resolve: {{blocker_list}}{{/if}}
+
+Bob (Scrum Master): "{user_name}, does this assessment match your understanding?"
+</output>
+
+<action>WAIT for {user_name} to confirm or correct the assessment</action>
+
+<output>
+Bob (Scrum Master): "Based on this assessment, Epic {{epic_number}} is {{#if all_clear}}fully complete and we're clear to proceed{{else}}complete from a story perspective, but we have {{critical_work_count}} critical items before Epic {{next_epic_num}}{{/if}}."
+
+Alice (Product Owner): "This level of thoroughness is why retrospectives are valuable."
+
+Charlie (Senior Dev): "Better to catch this now than three stories into the next epic."
+</output>
 
 </step>
 
-<step n="8" goal="Retrospective Closure">
-<action>Scrum Master closes the retrospective with summary and next steps</action>
+<step n="10" goal="Retrospective Closure with Celebration and Commitment">
 
-<action>Present closure summary:</action>
+<output>
+Bob (Scrum Master): "We've covered a lot of ground today. Let me bring this retrospective to a close."
 
-```
 ═══════════════════════════════════════════════════════════
 ✅ RETROSPECTIVE COMPLETE
+═══════════════════════════════════════════════════════════
+
+Bob (Scrum Master): "Epic {{epic_number}}: {{epic_title}} - REVIEWED"
 
-Epic {{completed_number}}: {{epic_title}} - REVIEWED
+**Key Takeaways:**
 
-Key Takeaways:
-- {{key_lesson_1}}
-- {{key_lesson_2}}
-- {{key_lesson_3}}
+1. {{key_lesson_1}}
+2. {{key_lesson_2}}
+3. {{key_lesson_3}}
+   {{#if key_lesson_4}}4. {{key_lesson_4}}{{/if}}
+
+Alice (Product Owner): "That first takeaway is huge - {{impact_of_lesson_1}}."
+
+Charlie (Senior Dev): "And lesson 2 is something we can apply immediately."
+
+Bob (Scrum Master): "Commitments made today:"
+
+- Action Items: {{action_count}}
+- Preparation Tasks: {{prep_task_count}}
+- Critical Path Items: {{critical_count}}
 
-Action Items Committed: {{action_count}}
-Preparation Tasks Defined: {{prep_task_count}}
-Critical Path Items: {{critical_count}}
+Dana (QA Engineer): "That's a lot of commitments. We need to actually follow through this time."
+
+Bob (Scrum Master): "Agreed. Which is why we'll review these action items in our next standup."
 
 ═══════════════════════════════════════════════════════════
 🎯 NEXT STEPS:
+═══════════════════════════════════════════════════════════
 
 1. Execute Preparation Sprint (Est: {{prep_days}} days)
-2. Complete Critical Path items before Epic {{next_number}}
+2. Complete Critical Path items before Epic {{next_epic_num}}
 3. Review action items in next standup
-4. Begin Epic {{next_number}} planning when preparation complete
+   {{#if epic_update_needed}}4. Hold Epic {{next_epic_num}} planning review session{{else}}4. Begin Epic {{next_epic_num}} planning when preparation complete{{/if}}
+
+Elena (Junior Dev): "{{prep_days}} days of prep work is significant, but necessary."
+
+Alice (Product Owner): "I'll communicate the timeline to stakeholders. They'll understand if we frame it as 'ensuring Epic {{next_epic_num}} success.'"
+
+═══════════════════════════════════════════════════════════
+
+Bob (Scrum Master): "Before we wrap, I want to take a moment to acknowledge the team."
+
+Bob (Scrum Master): "Epic {{epic_number}} delivered {{completed_stories}} stories with {{velocity_description}} velocity. We overcame {{blocker_count}} blockers. We learned a lot. That's real work by real people."
+
+Charlie (Senior Dev): "Hear, hear."
+
+Alice (Product Owner): "I'm proud of what we shipped."
+
+Dana (QA Engineer): "And I'm excited about Epic {{next_epic_num}} - especially now that we're prepared for it."
+
+Bob (Scrum Master): "{user_name}, any final thoughts before we close?"
+</output>
+
+<action>WAIT for {user_name} to share final reflections</action>
+
+<output>
+Bob (Scrum Master): [Acknowledges what {user_name} shared] "Thank you for that, {user_name}."
+
+Bob (Scrum Master): "Alright team - great work today. We learned a lot from Epic {{epic_number}}. Let's use these insights to make Epic {{next_epic_num}} even better."
+
+Bob (Scrum Master): "See you all when prep work is done. Meeting adjourned!"
 
 ═══════════════════════════════════════════════════════════
-Scrum Master: "Great work team! We learned a lot from Epic {{completed_number}}.
-Let's use these insights to make Epic {{next_number}} even better.
-See you at sprint planning once prep work is done!"
-```
+</output>
+
+<action>Prepare to save retrospective summary document</action>
 
-<action>Save retrospective summary to: {output_folder}/retrospectives/epic-{{completed_number}}-retro-{{date}}.md</action>
 </step>
 
-<step n="9" goal="Mark retrospective completed in sprint status" tag="sprint-status">
-<action>Load the FULL file: {output_folder}/sprint-status.yaml</action>
-<action>Find development_status key "epic-{{completed_number}}-retrospective"</action>
-<action>Verify current status is "optional" (expected previous state)</action>
-<action>Update development_status["epic-{{completed_number}}-retrospective"] = "completed"</action>
+<step n="11" goal="Save Retrospective and Update Sprint Status">
+
+<action>Ensure retrospectives folder exists: {retrospectives_folder}</action>
+<action>Create folder if it doesn't exist</action>
+
+<action>Generate comprehensive retrospective summary document including:</action>
+
+- Epic summary and metrics
+- Team participants
+- Successes and strengths identified
+- Challenges and growth areas
+- Key insights and learnings
+- Previous retro follow-through analysis (if applicable)
+- Next epic preview and dependencies
+- Action items with owners and timelines
+- Preparation tasks for next epic
+- Critical path items
+- Significant discoveries and epic update recommendations (if any)
+- Readiness assessment
+- Commitments and next steps
+
+<action>Format retrospective document as readable markdown with clear sections</action>
+<action>Set filename: {retrospectives_folder}/epic-{{epic_number}}-retro-{date}.md</action>
+<action>Save retrospective document</action>
+
+<output>
+✅ Retrospective document saved: {retrospectives_folder}/epic-{{epic_number}}-retro-{date}.md
+</output>
+
+<action>Update sprint-status.yaml to mark retrospective as completed</action>
+
+<action>Load the FULL file: {sprint_status_file}</action>
+<action>Find development_status key "epic-{{epic_number}}-retrospective"</action>
+<action>Verify current status (typically "optional" or "pending")</action>
+<action>Update development_status["epic-{{epic_number}}-retrospective"] = "done"</action>
 <action>Save file, preserving ALL comments and structure including STATUS DEFINITIONS</action>
 
 <check if="update successful">
-  <output>✅ Retrospective marked as completed in sprint-status.yaml
+  <output>
+✅ Retrospective marked as completed in sprint-status.yaml
 
-Retrospective key: epic-{{completed_number}}-retrospective
-Status: optional → completed
+Retrospective key: epic-{{epic_number}}-retrospective
+Status: {{previous_status}} → done
 </output>
 </check>
 
 <check if="retrospective key not found">
-  <output>⚠️ Could not update retrospective status: epic-{{completed_number}}-retrospective not found
+  <output>
+⚠️ Could not update retrospective status: epic-{{epic_number}}-retrospective not found in sprint-status.yaml
 
-Retrospective document was saved, but sprint-status.yaml may need manual update.
+Retrospective document was saved successfully, but sprint-status.yaml may need manual update.
 </output>
 </check>
+
 </step>
 
-<step n="10" goal="Final summary">
-<action>Confirm all action items have been captured</action>
-<action>Remind user to schedule prep sprint if needed</action>
-<output>**✅ Retrospective Complete, {user_name}!**
+<step n="12" goal="Final Summary and Handoff">
+
+<output>
+**✅ Retrospective Complete, {user_name}!**
 
 **Epic Review:**
 
-- Epic {{completed_number}}: {{epic_title}} reviewed
+- Epic {{epic_number}}: {{epic_title}} reviewed
 - Retrospective Status: completed
-- Retrospective saved: {output_folder}/retrospectives/epic-{{completed_number}}-retro-{{date}}.md
+- Retrospective saved: {retrospectives_folder}/epic-{{epic_number}}-retro-{date}.md
+
+**Commitments Made:**
+
 - Action Items: {{action_count}}
 - Preparation Tasks: {{prep_task_count}}
 - Critical Path Items: {{critical_count}}
 
 **Next Steps:**
 
-1. Review retrospective summary: {output_folder}/retrospectives/epic-{{completed_number}}-retro-{{date}}.md
-2. Execute preparation sprint (Est: {{prep_days}} days)
-3. Complete critical path items before Epic {{next_number}}
-4. Begin Epic {{next_number}} planning when preparation complete
-   - Load PM agent and run `epic-tech-context` for next epic
+1. **Review retrospective summary**: {retrospectives_folder}/epic-{{epic_number}}-retro-{date}.md
+
+2. **Execute preparation sprint** (Est: {{prep_days}} days)
+   - Complete {{critical_count}} critical path items
+   - Execute {{prep_task_count}} preparation tasks
+   - Verify all action items are in progress
+
+3. **Review action items in next standup**
+   - Ensure ownership is clear
+   - Track progress on commitments
+   - Adjust timelines if needed
+
+{{#if epic_update_needed}} 4. **IMPORTANT: Schedule Epic {{next_epic_num}} planning review session**
+
+- Significant discoveries from Epic {{epic_number}} require epic updates
+- Review and update affected stories
+- Align team on revised approach
+- Do NOT start Epic {{next_epic_num}} until review is complete
+  {{else}}
+
+4. **Begin Epic {{next_epic_num}} planning when preparation complete**
+   - Load PM agent and run `epic-tech-context` for Epic {{next_epic_num}}
    - Or continue with existing contexted epics
-     </output>
-     </step>
+   - Ensure all critical path items are done first
+     {{/if}}
+
+**Team Performance:**
+Epic {{epic_number}} delivered {{completed_stories}} stories with {{velocity_summary}}. The retrospective surfaced {{insight_count}} key insights and {{significant_discovery_count}} significant discoveries. The team is well-positioned for Epic {{next_epic_num}} success.
+
+{{#if significant_discovery_count > 0}}
+⚠️ **REMINDER**: Epic update required before starting Epic {{next_epic_num}}
+{{/if}}
+
+---
+
+Bob (Scrum Master): "Great session today, {user_name}. The team did excellent work."
+
+Alice (Product Owner): "See you at epic planning!"
+
+Charlie (Senior Dev): "Time to knock out that prep work."
+
+</output>
+
+</step>
 
 </workflow>
 
 <facilitation-guidelines>
+<guideline>PARTY MODE REQUIRED: All agent dialogue uses "Name (Role): dialogue" format</guideline>
 <guideline>Scrum Master maintains psychological safety throughout - no blame or judgment</guideline>
 <guideline>Focus on systems and processes, not individual performance</guideline>
+<guideline>Create authentic team dynamics: disagreements, diverse perspectives, emotions</guideline>
+<guideline>User ({user_name}) is active participant, not passive observer</guideline>
 <guideline>Encourage specific examples over general statements</guideline>
 <guideline>Balance celebration of wins with honest assessment of challenges</guideline>
 <guideline>Ensure every voice is heard - all agents contribute</guideline>
 <guideline>Action items must be specific, achievable, and owned</guideline>
 <guideline>Forward-looking mindset - how do we improve for next epic?</guideline>
-<guideline>Two-part structure ensures both reflection AND preparation</guideline>
+<guideline>Intent-based facilitation, not scripted phrases</guideline>
+<guideline>Deep story analysis provides rich material for discussion</guideline>
+<guideline>Previous retro integration creates accountability and continuity</guideline>
+<guideline>Significant change detection prevents epic misalignment</guideline>
 <guideline>Critical verification prevents starting next epic prematurely</guideline>
 <guideline>Document everything - retrospective insights are valuable for future reference</guideline>
+<guideline>Two-part structure ensures both reflection AND preparation</guideline>
 </facilitation-guidelines>