From 1031b1cd2107b2285562af88850e78865d3d53fd Mon Sep 17 00:00:00 2001 From: Jonah Schulte Date: Wed, 7 Jan 2026 20:33:18 -0500 Subject: [PATCH] feat: add story/epic revalidation with gap filling MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Implements user-requested revalidation capability to verify checkbox accuracy. Use Case: "I am uncertain about the real status of some stories and epics that I've worked on and would love a re-check" - User FEATURE: /revalidate-story ------------------------- Clears all checkboxes and re-verifies each item against codebase: 1. Clear Phase: - Uncheck all boxes in ACs, Tasks, DoD - Start from clean slate 2. Verification Phase: - For each item: search codebase with Glob/Grep - Read files to verify actual implementation (not stubs) - Check for tests and verify they pass - Re-check verified items: [x] verified, [~] partial, [ ] missing 3. Gap Reporting: - Report what exists vs what's documented - Calculate accuracy (before % vs after %) - Identify over-reported (checked but missing) and under-reported (exists but unchecked) 4. Gap Filling Mode (optional): - Implement missing items - Run tests to verify - Commit per gap or all at once - Re-verify after filling Token Cost Analysis: - Verify-only: ~30-45K tokens (just scan and report) - Verify-and-fill (10% gaps): ~35-55K tokens - Verify-and-fill (50% gaps): ~60-90K tokens - Compare to full re-implementation: ~80-120K tokens - Savings: 40-60% when gaps <30% FEATURE: /revalidate-epic ------------------------ Batch revalidation of all stories in an epic using semaphore pattern: - Maintain pool of N concurrent workers - As worker finishes → immediately start next story - Constant concurrency until all stories revalidated - Epic-wide summary with health score - Stories grouped by completion % Usage: ```bash # Verify only /revalidate-story story_file=path/to/story.md # Verify and fill gaps /revalidate-story story_file=path/to/story.md fill_gaps=true # Revalidate entire epic /revalidate-epic epic_number=2 # Revalidate epic and fill all gaps /revalidate-epic epic_number=2 fill_gaps=true max_concurrent=5 ``` Files Created: - revalidate-story/workflow.yaml: Story revalidation config - revalidate-story/instructions.md: 10-step revalidation process - revalidate-epic/workflow.yaml: Epic batch revalidation config - revalidate-epic/instructions.md: Semaphore pattern for parallel revalidation Files Modified: - dev.agent.yaml: Added RVS and RVE menu items - sm.agent.yaml: Added RVS and RVE menu items Next: Reverse gap analysis (detect orphaned code with no stories) --- src/modules/bmm/agents/dev.agent.yaml | 8 + src/modules/bmm/agents/sm.agent.yaml | 8 + .../revalidate-epic/instructions.md | 273 ++++++++++ .../revalidate-epic/workflow.yaml | 44 ++ .../revalidate-story/instructions.md | 510 ++++++++++++++++++ .../revalidate-story/workflow.yaml | 37 ++ 6 files changed, 880 insertions(+) create mode 100644 src/modules/bmm/workflows/4-implementation/revalidate-epic/instructions.md create mode 100644 src/modules/bmm/workflows/4-implementation/revalidate-epic/workflow.yaml create mode 100644 src/modules/bmm/workflows/4-implementation/revalidate-story/instructions.md create mode 100644 src/modules/bmm/workflows/4-implementation/revalidate-story/workflow.yaml diff --git a/src/modules/bmm/agents/dev.agent.yaml b/src/modules/bmm/agents/dev.agent.yaml index 50201eea..0033feda 100644 --- a/src/modules/bmm/agents/dev.agent.yaml +++ b/src/modules/bmm/agents/dev.agent.yaml @@ -55,3 +55,11 @@ agent: - trigger: CR or fuzzy match on code-review workflow: "{project-root}/_bmad/bmm/workflows/4-implementation/code-review/workflow.yaml" description: "[CR] Perform a thorough clean context code review (Highly Recommended, use fresh context and different LLM)" + + - trigger: RVS or fuzzy match on revalidate-story + workflow: "{project-root}/_bmad/bmm/workflows/4-implementation/revalidate-story/workflow.yaml" + description: "[RVS] Revalidate Story - clear checkboxes and re-verify against codebase (detect ghost features and gaps)" + + - trigger: RVE or fuzzy match on revalidate-epic + workflow: "{project-root}/_bmad/bmm/workflows/4-implementation/revalidate-epic/workflow.yaml" + description: "[RVE] Revalidate Epic - batch revalidation of all stories in an epic with semaphore pattern" diff --git a/src/modules/bmm/agents/sm.agent.yaml b/src/modules/bmm/agents/sm.agent.yaml index 0bffebf4..2fb883e5 100644 --- a/src/modules/bmm/agents/sm.agent.yaml +++ b/src/modules/bmm/agents/sm.agent.yaml @@ -49,3 +49,11 @@ agent: - trigger: CC or fuzzy match on correct-course workflow: "{project-root}/_bmad/bmm/workflows/4-implementation/correct-course/workflow.yaml" description: "[CC] Execute correct-course task (When implementation is off-track)" + + - trigger: RVS or fuzzy match on revalidate-story + workflow: "{project-root}/_bmad/bmm/workflows/4-implementation/revalidate-story/workflow.yaml" + description: "[RVS] Revalidate Story - clear checkboxes and verify against codebase reality (find gaps and ghost features)" + + - trigger: RVE or fuzzy match on revalidate-epic + workflow: "{project-root}/_bmad/bmm/workflows/4-implementation/revalidate-epic/workflow.yaml" + description: "[RVE] Revalidate Epic - batch revalidation of all stories with semaphore pattern" diff --git a/src/modules/bmm/workflows/4-implementation/revalidate-epic/instructions.md b/src/modules/bmm/workflows/4-implementation/revalidate-epic/instructions.md new file mode 100644 index 00000000..e229e944 --- /dev/null +++ b/src/modules/bmm/workflows/4-implementation/revalidate-epic/instructions.md @@ -0,0 +1,273 @@ +# Revalidate Epic - Batch Story Revalidation with Semaphore Pattern + +The workflow execution engine is governed by: {project-root}/_bmad/core/tasks/workflow.xml +You MUST have already loaded and processed: {installed_path}/workflow.yaml + + + + + Verify epic_number parameter provided + + + ❌ ERROR: epic_number parameter required + +Usage: + /revalidate-epic epic_number=2 + /revalidate-epic epic_number=2 fill_gaps=true + /revalidate-epic epic_number=2 fill_gaps=true max_concurrent=5 + + HALT + + + Read {sprint_status} file + Parse development_status map + + Filter stories starting with "{{epic_number}}-" (e.g., "2-1-", "2-2-", etc.) + Exclude epics (keys starting with "epic-") and retrospectives + + Store as: epic_stories (list of story keys) + + + ❌ No stories found for Epic {{epic_number}} + +Check sprint-status.yaml to verify epic number is correct. + + HALT + + + +━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ +🔍 EPIC {{epic_number}} REVALIDATION +━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ +**Stories Found:** {{epic_stories.length}} +**Mode:** {{#if fill_gaps}}Verify & Fill Gaps{{else}}Verify Only{{/if}} +**Max Concurrent:** {{max_concurrent}} agents +**Pattern:** Semaphore (continuous worker pool) + +**Stories to Revalidate:** +{{#each epic_stories}} +{{@index + 1}}. {{this}} +{{/each}} +━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ + + + Proceed with revalidation? (yes/no): + + + ❌ Revalidation cancelled + Exit workflow + + + + + +━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ +🚀 Starting Parallel Revalidation (Semaphore Pattern) +━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ + + + Initialize worker pool state: + + - story_queue = epic_stories + - active_workers = {} + - completed_stories = [] + - failed_stories = [] + - verification_results = {} + - next_story_index = 0 + - max_workers = {{max_concurrent}} + + + Fill initial worker slots: + + While next_story_index < min(max_workers, story_queue.length): + + + story_key = story_queue[next_story_index] + story_file = {sprint_artifacts}/{{story_key}}.md # Try multiple naming patterns if needed + worker_id = next_story_index + 1 + + Spawn Task agent: + - subagent_type: "general-purpose" + - description: "Revalidate story {{story_key}}" + - prompt: "Execute revalidate-story workflow for {{story_key}}. + + CRITICAL INSTRUCTIONS: + 1. Load workflow: _bmad/bmm/workflows/4-implementation/revalidate-story/workflow.yaml + 2. Parameters: story_file={{story_file}}, fill_gaps={{fill_gaps}} + 3. Clear all checkboxes + 4. Verify each AC/Task/DoD against codebase + 5. Re-check verified items + 6. Report gaps + {{#if fill_gaps}}7. Fill gaps and commit{{/if}} + 8. Return verification summary" + - run_in_background: true + + Store in active_workers[worker_id]: + story_key: {{story_key}} + task_id: {{returned_task_id}} + started_at: {{timestamp}} + + + Increment next_story_index + + +━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ +✅ {{active_workers.size}} workers active +📋 {{story_queue.length - next_story_index}} stories queued +━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ + + + + + SEMAPHORE PATTERN: Keep {{max_workers}} agents running continuously + + While active_workers.size > 0 OR next_story_index < story_queue.length: + + Poll for completed workers (non-blocking): + + For each worker_id in active_workers: + + Check worker status using TaskOutput(task_id, block=false) + + + Get verification results from worker output + Parse: verified_pct, gaps_found, gaps_filled + + Store in verification_results[story_key] + Add to completed_stories + Remove from active_workers + + ✅ Worker {{worker_id}}: {{story_key}} → {{verified_pct}}% verified{{#if gaps_filled > 0}}, {{gaps_filled}} gaps filled{{/if}} + + + Refill slot with next story (same pattern as batch-super-dev) + 🔄 Worker {{worker_id}} refilled: {{next_story_key}} + + + + + Add to failed_stories with error + Remove from active_workers + ❌ Worker {{worker_id}}: {{story_key}} failed + + + Refill slot despite failure + + + + Display live progress every 30 seconds: + +📊 Live Progress: {{completed_stories.length}} completed, {{active_workers.size}} active, {{story_queue.length - next_story_index}} queued + + + Sleep 5 seconds before next poll + + + + Aggregate verification results across all stories: + + epic_total_items = sum of all items across stories + epic_verified = sum of verified items + epic_partial = sum of partial items + epic_missing = sum of missing items + epic_gaps_filled = sum of gaps filled + + epic_verified_pct = (epic_verified / epic_total_items) × 100 + + + Group stories by verification percentage: + + - complete_stories (≥95% verified) + - mostly_complete_stories (80-94% verified) + - partial_stories (50-79% verified) + - incomplete_stories (<50% verified) + + + +━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ +📊 EPIC {{epic_number}} REVALIDATION SUMMARY +━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ +**Total Stories:** {{epic_stories.length}} +**Completed:** {{completed_stories.length}} +**Failed:** {{failed_stories.length}} + +**Epic-Wide Verification:** +- ✅ Verified: {{epic_verified}}/{{epic_total_items}} ({{epic_verified_pct}}%) +- 🔶 Partial: {{epic_partial}}/{{epic_total_items}} +- ❌ Missing: {{epic_missing}}/{{epic_total_items}} +{{#if fill_gaps}}- 🔧 Gaps Filled: {{epic_gaps_filled}}{{/if}} + +**Story Health:** +- ✅ Complete (≥95%): {{complete_stories.length}} stories +- 🔶 Mostly Complete (80-94%): {{mostly_complete_stories.length}} stories +- ⚠️ Partial (50-79%): {{partial_stories.length}} stories +- ❌ Incomplete (<50%): {{incomplete_stories.length}} stories + +--- + +**Complete Stories (≥95% verified):** +{{#each complete_stories}} +- {{story_key}}: {{verified_pct}}% verified +{{/each}} + +{{#if mostly_complete_stories.length > 0}} +**Mostly Complete Stories (80-94%):** +{{#each mostly_complete_stories}} +- {{story_key}}: {{verified_pct}}% verified ({{gaps_count}} gaps{{#if gaps_filled > 0}}, {{gaps_filled}} filled{{/if}}) +{{/each}} +{{/if}} + +{{#if partial_stories.length > 0}} +**⚠️ Partial Stories (50-79%):** +{{#each partial_stories}} +- {{story_key}}: {{verified_pct}}% verified ({{gaps_count}} gaps{{#if gaps_filled > 0}}, {{gaps_filled}} filled{{/if}}) +{{/each}} + +Recommendation: Continue development on these stories +{{/if}} + +{{#if incomplete_stories.length > 0}} +**❌ Incomplete Stories (<50%):** +{{#each incomplete_stories}} +- {{story_key}}: {{verified_pct}}% verified ({{gaps_count}} gaps{{#if gaps_filled > 0}}, {{gaps_filled}} filled{{/if}}) +{{/each}} + +Recommendation: Re-implement these stories from scratch +{{/if}} + +{{#if failed_stories.length > 0}} +**❌ Failed Revalidations:** +{{#each failed_stories}} +- {{story_key}}: {{error}} +{{/each}} +{{/if}} + +--- + +**Epic Health Score:** {{epic_verified_pct}}/100 + +{{#if epic_verified_pct >= 95}} +✅ Epic is COMPLETE and verified +{{else if epic_verified_pct >= 80}} +🔶 Epic is MOSTLY COMPLETE ({{epic_missing}} items need attention) +{{else if epic_verified_pct >= 50}} +⚠️ Epic is PARTIALLY COMPLETE (significant gaps remain) +{{else}} +❌ Epic is INCOMPLETE (major rework needed) +{{/if}} + +━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ + + + + Write epic summary to: {sprint_artifacts}/revalidation-epic-{{epic_number}}-{{timestamp}}.md + 📄 Epic report: {{report_path}} + + + + Update sprint-status.yaml with revalidation timestamp and results + Add comment to epic entry: # Revalidated: {{epic_verified_pct}}% verified ({{timestamp}}) + + + + diff --git a/src/modules/bmm/workflows/4-implementation/revalidate-epic/workflow.yaml b/src/modules/bmm/workflows/4-implementation/revalidate-epic/workflow.yaml new file mode 100644 index 00000000..38b7de23 --- /dev/null +++ b/src/modules/bmm/workflows/4-implementation/revalidate-epic/workflow.yaml @@ -0,0 +1,44 @@ +name: revalidate-epic +description: "Batch revalidation of all stories in an epic. Clears checkboxes and re-verifies against codebase with semaphore pattern." +author: "BMad" +version: "1.0.0" + +# Critical variables from config +config_source: "{project-root}/_bmad/bmm/config.yaml" +output_folder: "{config_source}:output_folder" +sprint_artifacts: "{output_folder}/sprint-artifacts" +sprint_status: "{output_folder}/sprint-status.yaml" + +# Input parameters +epic_number: "{epic_number}" # Required: Epic number (e.g., "2" for Epic 2) +fill_gaps: false # Optional: Fill missing items after verification +max_concurrent: 3 # Optional: Max concurrent revalidation agents (default: 3) + +# Verification settings (inherited by story revalidations) +verification: + verify_acceptance_criteria: true + verify_tasks: true + verify_definition_of_done: true + check_for_stubs: true + require_tests: true + +# Gap filling settings +gap_filling: + max_gaps_per_story: 10 # Safety limit per story + require_confirmation_first_story: true # Ask on first story, then auto for rest + run_tests_after_each: true + commit_strategy: "per_gap" # "per_gap" | "per_story" | "all_at_once" + +# Execution settings +execution: + use_semaphore_pattern: true # Constant concurrency (not batch-and-wait) + continue_on_failure: true # Keep processing if one story fails + display_live_progress: true # Show progress updates every 30s + +# Output settings +output: + create_epic_report: true # Generate epic-level summary + create_story_reports: true # Generate per-story reports + update_sprint_status: true # Update progress in sprint-status.yaml + +standalone: true diff --git a/src/modules/bmm/workflows/4-implementation/revalidate-story/instructions.md b/src/modules/bmm/workflows/4-implementation/revalidate-story/instructions.md new file mode 100644 index 00000000..f5135606 --- /dev/null +++ b/src/modules/bmm/workflows/4-implementation/revalidate-story/instructions.md @@ -0,0 +1,510 @@ +# Revalidate Story - Verify Checkboxes Against Codebase Reality + +The workflow execution engine is governed by: {project-root}/_bmad/core/tasks/workflow.xml +You MUST have already loaded and processed: {installed_path}/workflow.yaml + + + + + Verify story_file parameter provided + + + ❌ ERROR: story_file parameter required + +Usage: + /revalidate-story story_file=path/to/story.md + /revalidate-story story_file=path/to/story.md fill_gaps=true + + HALT + + + Read COMPLETE story file: {{story_file}} + Parse sections: Acceptance Criteria, Tasks/Subtasks, Definition of Done, Dev Agent Record + + Extract story_key from filename (e.g., "2-7-image-file-handling") + + Create backup of current checkbox state: + Count currently checked items: + - ac_checked_before = count of [x] in Acceptance Criteria + - tasks_checked_before = count of [x] in Tasks/Subtasks + - dod_checked_before = count of [x] in Definition of Done + - total_checked_before = sum of above + + + +━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ +🔍 STORY REVALIDATION STARTED +━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ +**Story:** {{story_key}} +**File:** {{story_file}} +**Mode:** {{#if fill_gaps}}Verify & Fill Gaps{{else}}Verify Only{{/if}} + +**Current State:** +- Acceptance Criteria: {{ac_checked_before}}/{{ac_total}} checked +- Tasks: {{tasks_checked_before}}/{{tasks_total}} checked +- Definition of Done: {{dod_checked_before}}/{{dod_total}} checked +- **Total:** {{total_checked_before}}/{{total_items}} ({{pct_before}}%) + +**Action:** Clearing all checkboxes and re-verifying against codebase... +━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ + + + + + 🧹 Clearing all checkboxes to start fresh verification... + + Use Edit tool to replace all [x] with [ ] in Acceptance Criteria section + Use Edit tool to replace all [x] with [ ] in Tasks/Subtasks section + Use Edit tool to replace all [x] with [ ] in Definition of Done section + + Save story file with all boxes unchecked + + ✅ All checkboxes cleared. Starting verification from clean slate... + + + + +━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ +📋 VERIFYING ACCEPTANCE CRITERIA ({{ac_total}} items) +━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ + + + Extract all AC items from Acceptance Criteria section + + For each AC item: + + + Extract AC description and identify artifacts: + - File mentions (e.g., "UserProfile component") + - Function names (e.g., "updateUser function") + - Features (e.g., "dark mode toggle") + - Test requirements (e.g., "unit tests covering edge cases") + + + Verifying AC{{@index}}: {{ac_description}} + + + + Use Glob to find relevant files: + - If AC mentions specific file: glob for that file + - If AC mentions component: glob for **/*ComponentName* + - If AC mentions feature: glob for files in related directories + + + Use Grep to search for symbols/functions/features + + Read found files to verify: + - NOT a stub (check for "TODO", "Not implemented", "throw new Error") + - Has actual implementation (not just empty function) + - Tests exist (search for *.test.* or *.spec.* files) + - Tests pass (if --fill-gaps mode, run tests) + + + + + verification_status = VERIFIED + Check box [x] in story file for this AC + Record evidence: "✅ VERIFIED: {{files_found}}, tests: {{test_files}}" + ✅ AC{{@index}}: VERIFIED + + + + verification_status = PARTIAL + Check box [~] in story file for this AC + Record gap: "🔶 PARTIAL: {{what_exists}}, missing: {{what_is_missing}}" + 🔶 AC{{@index}}: PARTIAL ({{what_is_missing}}) + Add to gaps_list with details + + + + verification_status = MISSING + Leave box unchecked [ ] in story file + Record gap: "❌ MISSING: No implementation found for {{ac_description}}" + ❌ AC{{@index}}: MISSING + Add to gaps_list with details + + + + Save story file after each AC verification + + +━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ +Acceptance Criteria Verification Complete +✅ Verified: {{ac_verified}} +🔶 Partial: {{ac_partial}} +❌ Missing: {{ac_missing}} +━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ + + + + + +━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ +📋 VERIFYING TASKS ({{tasks_total}} items) +━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ + + + Extract all Task items from Tasks/Subtasks section + + For each Task item (same verification logic as ACs): + + Parse task description for artifacts + Search codebase with Glob/Grep + Read and verify (check for stubs, tests) + Determine status: VERIFIED | PARTIAL | MISSING + Update checkbox: [x] | [~] | [ ] + Record evidence or gap + Save story file + + +━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ +Tasks Verification Complete +✅ Verified: {{tasks_verified}} +🔶 Partial: {{tasks_partial}} +❌ Missing: {{tasks_missing}} +━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ + + + + + +━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ +📋 VERIFYING DEFINITION OF DONE ({{dod_total}} items) +━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ + + + Extract all DoD items from Definition of Done section + + For each DoD item: + + Parse DoD requirement: + - "Type check passes" → Run type checker + - "Unit tests 90%+ coverage" → Run coverage report + - "Linting clean" → Run linter + - "Build succeeds" → Run build + - "All tests pass" → Run test suite + + + Execute verification for this DoD item + + + Check box [x] + Record: "✅ VERIFIED: {{verification_result}}" + + + + Leave unchecked [ ] or partial [~] + Record gap if applicable + + + +━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ +Definition of Done Verification Complete +✅ Verified: {{dod_verified}} +🔶 Partial: {{dod_partial}} +❌ Missing: {{dod_missing}} +━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ + + + + + Calculate overall completion: + + total_verified = ac_verified + tasks_verified + dod_verified + total_partial = ac_partial + tasks_partial + dod_partial + total_missing = ac_missing + tasks_missing + dod_missing + total_items = ac_total + tasks_total + dod_total + + verified_pct = (total_verified / total_items) × 100 + completion_pct = ((total_verified + total_partial) / total_items) × 100 + + + +━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ +📊 REVALIDATION SUMMARY +━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ +**Story:** {{story_key}} +**File:** {{story_file}} + +**Verification Results:** +- ✅ Verified Complete: {{total_verified}}/{{total_items}} ({{verified_pct}}%) +- 🔶 Partially Complete: {{total_partial}}/{{total_items}} +- ❌ Missing/Incomplete: {{total_missing}}/{{total_items}} + +**Breakdown:** +- Acceptance Criteria: {{ac_verified}}✅ {{ac_partial}}🔶 {{ac_missing}}❌ / {{ac_total}} total +- Tasks: {{tasks_verified}}✅ {{tasks_partial}}🔶 {{tasks_missing}}❌ / {{tasks_total}} total +- Definition of Done: {{dod_verified}}✅ {{dod_partial}}🔶 {{dod_missing}}❌ / {{dod_total}} total + +**Status Assessment:** +{{#if verified_pct >= 95}} +✅ Story is COMPLETE ({{verified_pct}}% verified) +{{else if verified_pct >= 80}} +🔶 Story is MOSTLY COMPLETE ({{verified_pct}}% verified, {{total_missing}} gaps) +{{else if verified_pct >= 50}} +⚠️ Story is PARTIALLY COMPLETE ({{verified_pct}}% verified, {{total_missing}} gaps) +{{else}} +❌ Story is INCOMPLETE ({{verified_pct}}% verified, significant work missing) +{{/if}} + +**Before Revalidation:** {{total_checked_before}}/{{total_items}} checked ({{pct_before}}%) +**After Revalidation:** {{total_verified}}/{{total_items}} verified ({{verified_pct}}%) +**Accuracy:** {{#if pct_before == verified_pct}}Perfect match{{else if pct_before > verified_pct}}{{pct_before - verified_pct}}% over-reported{{else}}{{verified_pct - pct_before}}% under-reported{{/if}} + +{{#if total_missing > 0}} +--- +**Gaps Found ({{total_missing}}):** +{{#each gaps_list}} +{{@index + 1}}. {{item_type}} - {{item_description}} + Status: {{status}} + Missing: {{what_is_missing}} + {{#if evidence}}Evidence checked: {{evidence}}{{/if}} +{{/each}} +--- +{{/if}} +━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ + + + + Write detailed report to: {sprint_artifacts}/revalidation-{{story_key}}-{{timestamp}}.md + Include: verification results, gaps list, evidence for each item, recommendations + 📄 Detailed report: {{report_path}} + + + + + + +✅ Verification complete (verify-only mode) + +{{#if total_missing > 0}} +**To fill the {{total_missing}} gaps, run:** +/revalidate-story story_file={{story_file}} fill_gaps=true +{{else}} +No gaps found - story is complete! +{{/if}} + + Exit workflow + + + + ✅ No gaps to fill - story is already complete! + Exit workflow + + + + + +⚠️ TOO MANY GAPS: {{total_missing}} gaps found (max: {{max_gaps_to_fill}}) + +This story has too many missing items for automatic gap filling. +Consider: +1. Re-implementing the story from scratch with /dev-story +2. Manually implementing the gaps +3. Increasing max_gaps_to_fill in workflow.yaml (use cautiously) + +Gap filling HALTED for safety. + + HALT + + + +━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ +🔧 GAP FILLING MODE ({{total_missing}} gaps to fill) +━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ + + + Continue to Step 8 + + + + + For each gap in gaps_list: + + + + +Fill this gap? + +**Item:** {{item_description}} +**Type:** {{item_type}} ({{section}}) +**Missing:** {{what_is_missing}} + +[Y] Yes - Implement this item +[A] Auto-fill - Implement this and all remaining gaps without asking +[S] Skip - Leave this gap unfilled +[H] Halt - Stop gap filling + +Your choice: + + + + Set require_confirmation = false (auto-fill remaining) + + + + Continue to next gap + + + + Exit gap filling loop + Jump to Step 9 (Summary) + + + + + + 🔧 Implementing: {{item_description}} + + Load story context (Technical Requirements, Architecture Compliance, Dev Notes) + Implement missing item following story specifications + Write tests if required + Run tests to verify implementation + Verify linting/type checking passes + + + Check box [x] for this item in story file + Update File List with new/modified files + Add to Dev Agent Record: "Gap filled: {{item_description}}" + ✅ Implemented and verified + + + Stage files for this gap + Commit: "fix({{story_key}}): fill gap - {{item_description}}" + ✅ Committed + + + + + ❌ Failed to implement: {{error_message}} + Leave box unchecked + Record failure in gaps_list + Add to failed_gaps + + + + After all gaps processed: + +━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ +Gap Filling Complete +✅ Filled: {{gaps_filled}} +❌ Failed: {{gaps_failed}} +⏭️ Skipped: {{gaps_skipped}} +━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ + + + + + + 🔍 Re-verifying filled gaps... + + For each filled gap: + Re-run verification for that item + Ensure still VERIFIED after all changes + + ✅ All filled gaps re-verified + + + Calculate final completion: + + final_verified = count of [x] across all sections + final_partial = count of [~] across all sections + final_missing = count of [ ] across all sections + final_pct = (final_verified / total_items) × 100 + + + + Stage all changed files + Commit: "fix({{story_key}}): fill {{gaps_filled}} gaps from revalidation" + ✅ All gaps committed + + + + Load {sprint_status} file + Update entry with current progress: + Format: {{story_key}}: {{current_status}} # Revalidated: {{final_verified}}/{{total_items}} ({{final_pct}}%) verified + Save sprint-status.yaml + ✅ Sprint status updated with revalidation results + + + + Add to Dev Agent Record in story file: + +## Revalidation Record ({{timestamp}}) + +**Revalidation Mode:** {{#if fill_gaps}}Verify & Fill{{else}}Verify Only{{/if}} + +**Results:** +- Verified: {{final_verified}}/{{total_items}} ({{final_pct}}%) +- Gaps Found: {{total_missing}} +- Gaps Filled: {{gaps_filled}} + +**Evidence:** +{{#each verification_evidence}} +- {{item}}: {{evidence}} +{{/each}} + +{{#if gaps_filled > 0}} +**Gaps Filled:** +{{#each filled_gaps}} +- {{item}}: {{what_was_implemented}} +{{/each}} +{{/if}} + +{{#if failed_gaps.length > 0}} +**Failed to Fill:** +{{#each failed_gaps}} +- {{item}}: {{error}} +{{/each}} +{{/if}} + + Save story file + + + + + +━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ +✅ REVALIDATION COMPLETE +━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ +**Story:** {{story_key}} + +**Final Status:** +- ✅ Verified Complete: {{final_verified}}/{{total_items}} ({{final_pct}}%) +- 🔶 Partially Complete: {{final_partial}}/{{total_items}} +- ❌ Missing/Incomplete: {{final_missing}}/{{total_items}} + +{{#if fill_gaps}} +**Gap Filling Results:** +- Filled: {{gaps_filled}} +- Failed: {{gaps_failed}} +- Skipped: {{gaps_skipped}} +{{/if}} + +**Accuracy Check:** +- Before revalidation: {{pct_before}}% checked +- After revalidation: {{final_pct}}% verified +- Checkbox accuracy: {{#if pct_before == final_pct}}✅ Perfect (0% discrepancy){{else if pct_before > final_pct}}⚠️ {{pct_before - final_pct}}% over-reported (checkboxes were optimistic){{else}}🔶 {{final_pct - pct_before}}% under-reported (work done but not checked){{/if}} + +{{#if final_pct >= 95}} +**Recommendation:** Story is COMPLETE - mark as "done" or "review" +{{else if final_pct >= 80}} +**Recommendation:** Story is mostly complete - finish remaining {{final_missing}} items then mark "review" +{{else if final_pct >= 50}} +**Recommendation:** Story has significant gaps - continue development with /dev-story +{{else}} +**Recommendation:** Story is mostly incomplete - consider re-implementing with /dev-story or /super-dev-pipeline +{{/if}} + +{{#if failed_gaps.length > 0}} +**⚠️ Manual attention needed for {{failed_gaps.length}} items that failed to fill automatically** +{{/if}} + +{{#if create_report}} +**Detailed Report:** {sprint_artifacts}/revalidation-{{story_key}}-{{timestamp}}.md +{{/if}} +━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ + + + + diff --git a/src/modules/bmm/workflows/4-implementation/revalidate-story/workflow.yaml b/src/modules/bmm/workflows/4-implementation/revalidate-story/workflow.yaml new file mode 100644 index 00000000..ecc23f56 --- /dev/null +++ b/src/modules/bmm/workflows/4-implementation/revalidate-story/workflow.yaml @@ -0,0 +1,37 @@ +name: revalidate-story +description: "Clear checkboxes and re-verify story against actual codebase implementation. Identifies gaps and optionally fills them." +author: "BMad" +version: "1.0.0" + +# Critical variables from config +config_source: "{project-root}/_bmad/bmm/config.yaml" +output_folder: "{config_source}:output_folder" +sprint_artifacts: "{output_folder}/sprint-artifacts" + +# Input parameters +story_file: "{story_file}" # Required: Full path to story file +fill_gaps: false # Optional: Fill missing items after verification (default: verify-only) +auto_commit: false # Optional: Auto-commit filled gaps (default: prompt) + +# Verification settings +verification: + verify_acceptance_criteria: true + verify_tasks: true + verify_definition_of_done: true + check_for_stubs: true # Reject stub implementations (TODO, Not implemented, etc.) + require_tests: true # Require tests for code items + +# Gap filling settings (only used if fill_gaps=true) +gap_filling: + max_gaps_to_fill: 10 # Safety limit - HALT if more gaps than this + require_confirmation: true # Ask before filling each gap (false = auto-fill all) + run_tests_after_each: true # Verify each filled gap works + commit_strategy: "per_gap" # "per_gap" | "all_at_once" | "none" + +# Output settings +output: + create_report: true # Generate revalidation-report.md + update_dev_agent_record: true # Add revalidation notes to story + update_sprint_status: true # Update progress in sprint-status.yaml + +standalone: false