ldy26098
/
BMAD-METHOD
mirror of https://github.com/bmad-code-org/BMAD-METHOD.git
1
0
Fork 0
Code Packages Projects Releases Wiki Activity
BMAD-METHOD/samples/sample-custom-modules/cc-agents-commands/commands/epic-dev-epic-end-tests.md

838 lines
30 KiB
Markdown
Raw Blame History

---
description: "Epic end-of-development test validation: NFR assessment, test quality review, and traceability quality gate"
argument-hint: "<epic-number> [--yolo] [--resume]"
allowed-tools: ["Task", "SlashCommand", "Read", "Write", "Edit", "Bash", "Grep", "Glob", "TodoWrite", "AskUserQuestion"]
---
# Epic End Tests - NFR + Test Review + Quality Gate
Execute the end-of-epic test validation sequence for epic: "$ARGUMENTS"
This command orchestrates three critical BMAD Test Architect workflows in sequence:
1. **NFR Assessment** - Validate non-functional requirements (performance, security, reliability, maintainability)
2. **Test Quality Review** - Comprehensive test quality validation against best practices
3. **Trace Phase 2** - Quality gate decision (PASS/CONCERNS/FAIL/WAIVED)
---
## CRITICAL ORCHESTRATION CONSTRAINTS
**YOU ARE A PURE ORCHESTRATOR - DELEGATION ONLY**
- NEVER execute workflows directly - you are a pure orchestrator
- NEVER use Edit, Write, MultiEdit tools yourself
- NEVER implement fixes or modify code yourself
- NEVER run SlashCommand directly - delegate to subagents
- MUST delegate ALL work to subagents via Task tool
- Your role is ONLY to: read state, delegate tasks, verify completion, update session
**GUARD RAIL CHECK**: Before ANY action ask yourself:
- "Am I about to do work directly?" -> If YES: STOP and delegate via Task instead
- "Am I using Read/Bash to check state?" -> OK to proceed
- "Am I using Task tool to spawn a subagent?" -> Correct approach
**SEQUENTIAL EXECUTION ONLY** - Each phase MUST complete before the next starts:
- Never invoke multiple workflows in parallel
- Wait for each Task to complete before proceeding
- This ensures proper context flow through the 3-phase workflow
---
## MODEL STRATEGY
| # | Phase | Model | Rationale |
|---|-------|-------|-----------|
| 1 | NFR Assessment | `opus` | Comprehensive evidence analysis requires deep understanding |
| 2 | Test Quality Review | `sonnet` | Rule-based quality validation, faster iteration |
| 3 | Trace Phase 2 | `opus` | Quality gate decision requires careful analysis |
---
## STEP 1: Parse Arguments
Parse "$ARGUMENTS" to extract:
- **epic_number** (required): First positional argument (e.g., "1" for Epic 1)
- **--resume**: Continue from last incomplete phase
- **--yolo**: Skip user confirmation pauses between phases
**Validation:**
- epic_number must be a positive integer
- If no epic_number provided, error with: "Usage: /epic-dev-epic_end_tests <epic-number> [--yolo] [--resume]"
---
## STEP 2: Detect BMAD Project
```bash
PROJECT_ROOT=$(pwd)
while [[ ! -d "$PROJECT_ROOT/_bmad" ]] && [[ "$PROJECT_ROOT" != "/" ]]; do
PROJECT_ROOT=$(dirname "$PROJECT_ROOT")
done
if [[ ! -d "$PROJECT_ROOT/_bmad" ]]; then
echo "ERROR: Not a BMAD project. Run /bmad:bmm:workflows:workflow-init first."
exit 1
fi
```
Load sprint artifacts path from `_bmad/bmm/config.yaml` (default: `docs/sprint-artifacts`)
Load output folder from config (default: `docs`)
---
## STEP 3: Verify Epic Readiness
Before running end-of-epic tests, verify:
1. All stories in epic are "done" or "review" status
2. Sprint-status.yaml exists and is readable
3. Epic file exists at `{sprint_artifacts}/epic-{epic_num}.md`
If stories are incomplete:
```
Output: "WARNING: Epic {epic_num} has incomplete stories."
Output: "Stories remaining: {list incomplete stories}"
decision = AskUserQuestion(
question: "Proceed with end-of-epic validation despite incomplete stories?",
header: "Incomplete",
options: [
{label: "Continue anyway", description: "Run validation on current state"},
{label: "Stop", description: "Complete stories first, then re-run"}
]
)
IF decision == "Stop":
HALT with: "Complete remaining stories, then run: /epic-dev-epic_end_tests {epic_num}"
```
---
## STEP 4: Session Management
**Session Schema for 3-Phase Workflow:**
```yaml
epic_end_tests_session:
epic: {epic_num}
phase: "starting" # See PHASE VALUES below
# NFR tracking (Phase 1)
nfr_status: null # PASS | CONCERNS | FAIL
nfr_categories_assessed: 0
nfr_critical_issues: 0
nfr_high_issues: 0
nfr_report_file: null
# Test review tracking (Phase 2)
test_review_status: null # Excellent | Good | Acceptable | Needs Improvement | Critical
test_quality_score: 0
test_files_reviewed: 0
test_critical_issues: 0
test_review_file: null
# Trace tracking (Phase 3)
gate_decision: null # PASS | CONCERNS | FAIL | WAIVED
p0_coverage: 0
p1_coverage: 0
overall_coverage: 0
trace_file: null
# Timestamps
started: "{timestamp}"
last_updated: "{timestamp}"
```
**PHASE VALUES:**
- `starting` - Initial state
- `nfr_assessment` - Phase 1: Running NFR assessment
- `nfr_complete` - Phase 1 complete, proceed to test review
- `test_review` - Phase 2: Running test quality review
- `test_review_complete` - Phase 2 complete, proceed to trace
- `trace_phase2` - Phase 3: Running quality gate decision
- `gate_decision` - Awaiting user decision on gate result
- `complete` - All phases complete
- `error` - Error state
**If --resume AND session exists for this epic:**
- Resume from recorded phase
- Output: "Resuming Epic {epic_num} end tests from phase: {phase}"
**If NOT --resume (fresh start):**
- Clear any existing session
- Create new session with `phase: "starting"`
---
## STEP 5: Execute Phase Loop
### PHASE 1: NFR Assessment (opus)
**Execute when:** `phase == "starting"` OR `phase == "nfr_assessment"`
```
Output: "
================================================================================
[Phase 1/3] NFR ASSESSMENT - Epic {epic_num}
================================================================================
Assessing: Performance, Security, Reliability, Maintainability
Model: opus (comprehensive evidence analysis)
================================================================================
"
Update session:
- phase: "nfr_assessment"
- last_updated: {timestamp}
Write session to sprint-status.yaml
Task(
subagent_type="general-purpose",
model="opus",
description="NFR assessment for Epic {epic_num}",
prompt="NFR ASSESSMENT AGENT - Epic {epic_num}
**Your Mission:** Perform comprehensive NFR assessment for all stories in Epic {epic_num}.
**Context:**
- Epic: {epic_num}
- Sprint artifacts: {sprint_artifacts}
- Output folder: {output_folder}
**Execution Steps:**
1. Read the epic file to understand scope: {sprint_artifacts}/epic-{epic_num}.md
2. Read sprint-status.yaml to identify all completed stories
3. Execute: SlashCommand(command='/bmad:bmm:workflows:testarch-nfr')
4. Follow ALL workflow prompts - provide epic context when asked
5. Assess ALL NFR categories:
- Performance: Response times, throughput, resource usage
- Security: Authentication, authorization, data protection, vulnerabilities
- Reliability: Error handling, availability, fault tolerance
- Maintainability: Code quality, test coverage, documentation
6. Gather evidence from:
- Test results (pytest, vitest reports)
- Coverage reports
- Performance metrics (if available)
- Security scan results (if available)
7. Apply deterministic PASS/CONCERNS/FAIL rules
8. Generate NFR assessment report
**Output Requirements:**
- Save report to: {output_folder}/nfr-assessment-epic-{epic_num}.md
- Include gate YAML snippet
- Include evidence checklist for any gaps
**Output Format (JSON at end):**
{
\"status\": \"PASS|CONCERNS|FAIL\",
\"categories_assessed\": <count>,
\"critical_issues\": <count>,
\"high_issues\": <count>,
\"report_file\": \"path/to/report.md\"
}
Execute immediately and autonomously. Do not ask for confirmation."
)
Parse NFR output JSON
Update session:
- phase: "nfr_complete"
- nfr_status: {status}
- nfr_categories_assessed: {categories_assessed}
- nfr_critical_issues: {critical_issues}
- nfr_high_issues: {high_issues}
- nfr_report_file: {report_file}
Write session to sprint-status.yaml
Output:
───────────────────────────────────────────────────────────────────────────────
NFR ASSESSMENT COMPLETE
───────────────────────────────────────────────────────────────────────────────
Status: {nfr_status}
Categories Assessed: {categories_assessed}
Critical Issues: {critical_issues}
High Issues: {high_issues}
Report: {report_file}
───────────────────────────────────────────────────────────────────────────────
IF nfr_status == "FAIL":
Output: "NFR Assessment FAILED - Critical issues detected."
fail_decision = AskUserQuestion(
question: "NFR Assessment FAILED. How to proceed?",
header: "NFR Failed",
options: [
{label: "Continue to Test Review", description: "Proceed despite NFR failures (will affect final gate)"},
{label: "Stop and remediate", description: "Address NFR issues before continuing"},
{label: "Request waiver", description: "Document business justification for waiver"}
]
)
IF fail_decision == "Stop and remediate":
Output: "Stopping for NFR remediation."
Output: "Address issues in: {report_file}"
Output: "Resume with: /epic-dev-epic_end_tests {epic_num} --resume"
HALT
IF NOT --yolo:
continue_decision = AskUserQuestion(
question: "Phase 1 (NFR Assessment) complete. Continue to Test Review?",
header: "Continue",
options: [
{label: "Continue", description: "Proceed to Phase 2: Test Quality Review"},
{label: "Stop", description: "Save state and exit (resume later with --resume)"}
]
)
IF continue_decision == "Stop":
Output: "Stopping at Phase 1. Resume with: /epic-dev-epic_end_tests {epic_num} --resume"
HALT
PROCEED TO PHASE 2
```
---
### PHASE 2: Test Quality Review (sonnet)
**Execute when:** `phase == "nfr_complete"` OR `phase == "test_review"`
```
Output: "
================================================================================
[Phase 2/3] TEST QUALITY REVIEW - Epic {epic_num}
================================================================================
Reviewing: Test structure, patterns, quality, flakiness risk
Model: sonnet (rule-based quality validation)
================================================================================
"
Update session:
- phase: "test_review"
- last_updated: {timestamp}
Write session to sprint-status.yaml
Task(
subagent_type="general-purpose",
model="sonnet",
description="Test quality review for Epic {epic_num}",
prompt="TEST QUALITY REVIEWER AGENT - Epic {epic_num}
**Your Mission:** Perform comprehensive test quality review for all tests in Epic {epic_num}.
**Context:**
- Epic: {epic_num}
- Sprint artifacts: {sprint_artifacts}
- Output folder: {output_folder}
- Review scope: suite (all tests for this epic)
**Execution Steps:**
1. Read the epic file to understand story scope: {sprint_artifacts}/epic-{epic_num}.md
2. Discover all test files related to epic stories
3. Execute: SlashCommand(command='/bmad:bmm:workflows:testarch-test-review')
4. Follow ALL workflow prompts - specify epic scope when asked
5. Validate each test against quality criteria:
- BDD format (Given-When-Then structure)
- Test ID conventions (traceability)
- Priority markers (P0/P1/P2/P3)
- Hard waits detection (flakiness risk)
- Determinism check (no conditionals/random)
- Isolation validation (cleanup, no shared state)
- Fixture patterns (proper composition)
- Data factories (no hardcoded data)
- Network-first pattern (race condition prevention)
- Assertions (explicit, not hidden)
- Test length (<300 lines)
- Test duration (<1.5 min)
- Flakiness patterns detection
6. Calculate quality score (0-100)
7. Generate comprehensive review report
**Output Requirements:**
- Save report to: {output_folder}/test-review-epic-{epic_num}.md
- Include quality score breakdown
- List critical issues (must fix)
- List recommendations (should fix)
**Output Format (JSON at end):**
{
\"quality_grade\": \"A+|A|B|C|F\",
\"quality_score\": <0-100>,
\"files_reviewed\": <count>,
\"critical_issues\": <count>,
\"recommendations\": <count>,
\"report_file\": \"path/to/report.md\"
}
Execute immediately and autonomously. Do not ask for confirmation."
)
Parse test review output JSON
# Map quality grade to status
IF quality_score >= 90:
test_review_status = "Excellent"
ELSE IF quality_score >= 80:
test_review_status = "Good"
ELSE IF quality_score >= 70:
test_review_status = "Acceptable"
ELSE IF quality_score >= 60:
test_review_status = "Needs Improvement"
ELSE:
test_review_status = "Critical"
Update session:
- phase: "test_review_complete"
- test_review_status: {test_review_status}
- test_quality_score: {quality_score}
- test_files_reviewed: {files_reviewed}
- test_critical_issues: {critical_issues}
- test_review_file: {report_file}
Write session to sprint-status.yaml
Output:
───────────────────────────────────────────────────────────────────────────────
TEST QUALITY REVIEW COMPLETE
───────────────────────────────────────────────────────────────────────────────
Quality Grade: {quality_grade}
Quality Score: {quality_score}/100
Status: {test_review_status}
Files Reviewed: {files_reviewed}
Critical Issues: {critical_issues}
Recommendations: {recommendations}
Report: {report_file}
───────────────────────────────────────────────────────────────────────────────
IF test_review_status == "Critical":
Output: "Test Quality CRITICAL - Major quality issues detected."
quality_decision = AskUserQuestion(
question: "Test quality is CRITICAL ({quality_score}/100). How to proceed?",
header: "Quality Critical",
options: [
{label: "Continue to Quality Gate", description: "Proceed despite quality issues (will affect gate)"},
{label: "Stop and fix", description: "Address test quality issues before gate"},
{label: "Accept current state", description: "Acknowledge issues, proceed to gate"}
]
)
IF quality_decision == "Stop and fix":
Output: "Stopping for test quality remediation."
Output: "Critical issues in: {report_file}"
Output: "Resume with: /epic-dev-epic_end_tests {epic_num} --resume"
HALT
IF NOT --yolo:
continue_decision = AskUserQuestion(
question: "Phase 2 (Test Review) complete. Continue to Quality Gate?",
header: "Continue",
options: [
{label: "Continue", description: "Proceed to Phase 3: Quality Gate Decision"},
{label: "Stop", description: "Save state and exit (resume later with --resume)"}
]
)
IF continue_decision == "Stop":
Output: "Stopping at Phase 2. Resume with: /epic-dev-epic_end_tests {epic_num} --resume"
HALT
PROCEED TO PHASE 3
```
---
### PHASE 3: Trace Phase 2 - Quality Gate Decision (opus)
**Execute when:** `phase == "test_review_complete"` OR `phase == "trace_phase2"`
```
Output: "
================================================================================
[Phase 3/3] QUALITY GATE DECISION - Epic {epic_num}
================================================================================
Analyzing: Coverage, test results, NFR status, quality metrics
Model: opus (careful gate decision analysis)
================================================================================
"
Update session:
- phase: "trace_phase2"
- last_updated: {timestamp}
Write session to sprint-status.yaml
Task(
subagent_type="general-purpose",
model="opus",
description="Quality gate decision for Epic {epic_num}",
prompt="QUALITY GATE AGENT - Epic {epic_num}
**Your Mission:** Make quality gate decision (PASS/CONCERNS/FAIL/WAIVED) for Epic {epic_num}.
**Context:**
- Epic: {epic_num}
- Sprint artifacts: {sprint_artifacts}
- Output folder: {output_folder}
- Gate type: epic
- Decision mode: deterministic
**Previous Phase Results:**
- NFR Assessment Status: {session.nfr_status}
- NFR Report: {session.nfr_report_file}
- Test Quality Score: {session.test_quality_score}/100
- Test Quality Status: {session.test_review_status}
- Test Review Report: {session.test_review_file}
**Execution Steps:**
1. Read the epic file: {sprint_artifacts}/epic-{epic_num}.md
2. Read all story files for this epic
3. Execute: SlashCommand(command='/bmad:bmm:workflows:testarch-trace')
4. When prompted, specify:
- Gate type: epic
- Enable gate decision: true (Phase 2)
5. Load Phase 1 traceability results (auto-generated by workflow)
6. Gather quality evidence:
- Coverage metrics from stories
- Test execution results (CI reports if available)
- NFR assessment results: {session.nfr_report_file}
- Test quality review: {session.test_review_file}
7. Apply deterministic decision rules:
**PASS Criteria (ALL must be true):**
- P0 coverage >= 100%
- P1 coverage >= 90%
- Overall coverage >= 80%
- P0 test pass rate = 100%
- P1 test pass rate >= 95%
- Overall test pass rate >= 90%
- NFR assessment != FAIL
- Test quality score >= 70
**CONCERNS Criteria (ANY):**
- P1 coverage 80-89%
- P1 test pass rate 90-94%
- Overall pass rate 85-89%
- NFR assessment == CONCERNS
- Test quality score 60-69
**FAIL Criteria (ANY):**
- P0 coverage < 100%
- P0 test pass rate < 100%
- P1 coverage < 80%
- P1 test pass rate < 90%
- Overall coverage < 80%
- Overall pass rate < 85%
- NFR assessment == FAIL (unwaived)
- Test quality score < 60
8. Generate comprehensive gate decision document
9. Include evidence from all three phases
**Output Requirements:**
- Save gate decision to: {output_folder}/gate-decision-epic-{epic_num}.md
- Include decision matrix
- Include evidence summary from all phases
- Include next steps
**Output Format (JSON at end):**
{
\"decision\": \"PASS|CONCERNS|FAIL\",
\"p0_coverage\": <percentage>,
\"p1_coverage\": <percentage>,
\"overall_coverage\": <percentage>,
\"rationale\": \"Brief explanation\",
\"gate_file\": \"path/to/gate-decision.md\"
}
Execute immediately and autonomously. Do not ask for confirmation."
)
Parse gate decision output JSON
Update session:
- phase: "gate_decision"
- gate_decision: {decision}
- p0_coverage: {p0_coverage}
- p1_coverage: {p1_coverage}
- overall_coverage: {overall_coverage}
- trace_file: {gate_file}
Write session to sprint-status.yaml
# ═══════════════════════════════════════════════════════════════════════════
# QUALITY GATE DECISION HANDLING
# ═══════════════════════════════════════════════════════════════════════════
Output:
═══════════════════════════════════════════════════════════════════════════════
QUALITY GATE RESULT
═══════════════════════════════════════════════════════════════════════════════
DECISION: {decision}
═══════════════════════════════════════════════════════════════════════════════
COVERAGE METRICS
───────────────────────────────────────────────────────────────────────────────
P0 Coverage (Critical): {p0_coverage}% (required: 100%)
P1 Coverage (Important): {p1_coverage}% (target: 90%)
Overall Coverage: {overall_coverage}% (target: 80%)
───────────────────────────────────────────────────────────────────────────────
PHASE RESULTS
───────────────────────────────────────────────────────────────────────────────
NFR Assessment: {session.nfr_status}
Test Quality: {session.test_review_status} ({session.test_quality_score}/100)
───────────────────────────────────────────────────────────────────────────────
RATIONALE
───────────────────────────────────────────────────────────────────────────────
{rationale}
═══════════════════════════════════════════════════════════════════════════════
IF decision == "PASS":
Output: "Epic {epic_num} PASSED all quality gates!"
Output: "Ready for: deployment / release / next epic"
Update session:
- phase: "complete"
PROCEED TO COMPLETION
ELSE IF decision == "CONCERNS":
Output: "Epic {epic_num} has CONCERNS - minor gaps detected."
concerns_decision = AskUserQuestion(
question: "Quality gate has CONCERNS. How to proceed?",
header: "Gate Decision",
options: [
{label: "Accept and complete", description: "Acknowledge gaps, mark epic done"},
{label: "Address gaps", description: "Stop and fix gaps, re-run validation"},
{label: "Request waiver", description: "Document business justification"}
]
)
IF concerns_decision == "Accept and complete":
Update session:
- phase: "complete"
PROCEED TO COMPLETION
ELSE IF concerns_decision == "Address gaps":
Output: "Stopping to address gaps."
Output: "Review: {trace_file}"
Output: "Re-run after fixes: /epic-dev-epic_end_tests {epic_num}"
HALT
ELSE IF concerns_decision == "Request waiver":
HANDLE WAIVER (see below)
ELSE IF decision == "FAIL":
Output: "Epic {epic_num} FAILED quality gate - blocking issues detected."
fail_decision = AskUserQuestion(
question: "Quality gate FAILED. How to proceed?",
header: "Gate Failed",
options: [
{label: "Address failures", description: "Stop and fix blocking issues"},
{label: "Request waiver", description: "Document business justification (not for P0 gaps)"},
{label: "Force complete", description: "DANGER: Mark complete despite failures"}
]
)
IF fail_decision == "Address failures":
Output: "Stopping to address failures."
Output: "Blocking issues in: {trace_file}"
Output: "Re-run after fixes: /epic-dev-epic_end_tests {epic_num}"
HALT
ELSE IF fail_decision == "Request waiver":
HANDLE WAIVER (see below)
ELSE IF fail_decision == "Force complete":
Output: "WARNING: Forcing completion despite FAIL status."
Output: "This will be recorded in the gate decision document."
Update session:
- gate_decision: "FAIL (FORCED)"
- phase: "complete"
PROCEED TO COMPLETION
```
---
## WAIVER HANDLING
When user requests waiver:
```
Output: "Requesting waiver for quality gate result: {decision}"
waiver_reason = AskUserQuestion(
question: "What is the business justification for waiver?",
header: "Waiver",
options: [
{label: "Time-critical", description: "Deadline requires shipping now"},
{label: "Low risk", description: "Missing coverage is low-risk area"},
{label: "Tech debt", description: "Will address in future sprint"},
{label: "External blocker", description: "External dependency blocking tests"}
]
)
waiver_approver = AskUserQuestion(
question: "Who is approving this waiver?",
header: "Approver",
options: [
{label: "Tech Lead", description: "Engineering team lead approval"},
{label: "Product Manager", description: "Product owner approval"},
{label: "Engineering Manager", description: "Management approval"},
{label: "Self", description: "Self-approved (document risk)"}
]
)
# Update gate decision document with waiver
Task(
subagent_type="general-purpose",
model="haiku",
description="Document waiver for Epic {epic_num}",
prompt="WAIVER DOCUMENTER AGENT
**Mission:** Add waiver documentation to gate decision file.
**Waiver Details:**
- Original Decision: {decision}
- Waiver Reason: {waiver_reason}
- Approver: {waiver_approver}
- Date: {current_date}
**File to Update:** {trace_file}
**Add this section to the gate decision document:**
## Waiver
**Status**: WAIVED
**Original Decision**: {decision}
**Waiver Reason**: {waiver_reason}
**Approver**: {waiver_approver}
**Date**: {current_date}
**Mitigation Plan**: [Add follow-up stories to address gaps]
---
Execute immediately."
)
Update session:
- gate_decision: "WAIVED"
- phase: "complete"
PROCEED TO COMPLETION
```
---
## STEP 6: Completion Summary
```
Output:
════════════════════════════════════════════════════════════════════════════════
EPIC {epic_num} END TESTS COMPLETE
════════════════════════════════════════════════════════════════════════════════
FINAL QUALITY GATE: {session.gate_decision}
────────────────────────────────────────────────────────────────────────────────
PHASE SUMMARY
────────────────────────────────────────────────────────────────────────────────
[1/3] NFR Assessment: {session.nfr_status}
Critical Issues: {session.nfr_critical_issues}
Report: {session.nfr_report_file}
[2/3] Test Quality Review: {session.test_review_status} ({session.test_quality_score}/100)
Files Reviewed: {session.test_files_reviewed}
Critical Issues: {session.test_critical_issues}
Report: {session.test_review_file}
[3/3] Quality Gate: {session.gate_decision}
P0 Coverage: {session.p0_coverage}%
P1 Coverage: {session.p1_coverage}%
Overall Coverage: {session.overall_coverage}%
Decision Document: {session.trace_file}
────────────────────────────────────────────────────────────────────────────────
GENERATED ARTIFACTS
────────────────────────────────────────────────────────────────────────────────
1. {session.nfr_report_file}
2. {session.test_review_file}
3. {session.trace_file}
────────────────────────────────────────────────────────────────────────────────
NEXT STEPS
────────────────────────────────────────────────────────────────────────────────
IF gate_decision == "PASS":
- Ready for deployment/release
- Run retrospective: /bmad:bmm:workflows:retrospective
- Start next epic: /epic-dev <next-epic-number>
ELSE IF gate_decision == "CONCERNS" OR gate_decision == "WAIVED":
- Deploy with monitoring
- Create follow-up stories for gaps
- Schedule tech debt review
- Run retrospective: /bmad:bmm:workflows:retrospective
ELSE IF gate_decision == "FAIL" OR gate_decision == "FAIL (FORCED)":
- Address blocking issues before deployment
- Re-run: /epic-dev-epic_end_tests {epic_num}
- Consider breaking up remaining work
════════════════════════════════════════════════════════════════════════════════
# Clear session
Clear epic_end_tests_session from sprint-status.yaml
```
---
## ERROR HANDLING
On any workflow failure:
```
1. Capture error output
2. Update session:
- phase: "error"
- last_error: "{error_message}"
3. Write session to sprint-status.yaml
4. Display error with phase context:
Output: "ERROR in Phase {current_phase}: {error_message}"
5. Offer recovery options:
error_decision = AskUserQuestion(
question: "How to handle this error?",
header: "Error Recovery",
options: [
{label: "Retry", description: "Re-run the failed phase"},
{label: "Skip phase", description: "Skip to next phase (if safe)"},
{label: "Stop", description: "Save state and exit"}
]
)
6. Handle recovery choice:
- Retry: Reset phase state, re-execute
- Skip phase: Only allowed for Phase 1 or 2 (not Phase 3)
- Stop: HALT with resume instructions
```
---
## EXECUTE NOW
Parse "$ARGUMENTS" and begin the epic end-of-development test validation sequence immediately.
Run in sequence:
1. NFR Assessment (opus)
2. Test Quality Review (sonnet)
3. Quality Gate Decision (opus)
Delegate all work via Task tool. Never execute workflows directly.
View Git Blame Copy Permalink