bmm-opencode 1.4.3 → 1.6.0

package/_bmad/tea/workflows/testarch/test-review/steps-c/step-03d-subprocess-coverage.md

@@ -0,0 +1,111 @@
+---
+name: 'step-03d-subprocess-coverage'
+description: 'Subprocess: Check test coverage (completeness, edge cases)'
+subprocess: true
+outputFile: '/tmp/tea-test-review-coverage-{{timestamp}}.json'
+---
+
+# Subprocess 3D: Coverage Quality Check
+
+## SUBPROCESS CONTEXT
+
+This is an **isolated subprocess** running in parallel with other quality dimension checks.
+
+**Your task:** Analyze test files for COVERAGE violations only.
+
+---
+
+## MANDATORY EXECUTION RULES
+
+- ✅ Check COVERAGE only (not other quality dimensions)
+- ✅ Output structured JSON to temp file
+- ❌ Do NOT check determinism, isolation, maintainability, or performance
+
+---
+
+## SUBPROCESS TASK
+
+### 1. Identify Coverage Violations
+
+**HIGH SEVERITY Violations**:
+
+- Critical user paths not tested (P0 functionality missing)
+- API endpoints without tests
+- Error handling not tested (no negative test cases)
+- Missing authentication/authorization tests
+
+**MEDIUM SEVERITY Violations**:
+
+- Edge cases not covered (boundary values, null/empty inputs)
+- Only happy path tested (no error scenarios)
+- Missing integration tests (only unit or only E2E)
+- Insufficient assertion coverage (tests don't verify important outcomes)
+
+**LOW SEVERITY Violations**:
+
+- Could benefit from additional test cases
+- Minor edge cases not covered
+- Documentation incomplete
+
+### 2. Calculate Coverage Score
+
+```javascript
+const criticalGaps = violations.filter((v) => v.severity === 'HIGH').length;
+const score = criticalGaps === 0 ? Math.max(0, 100 - violations.length * 5) : Math.max(0, 50 - criticalGaps * 10); // Heavy penalty for critical gaps
+```
+
+---
+
+## OUTPUT FORMAT
+
+```json
+{
+  "dimension": "coverage",
+  "score": 70,
+  "max_score": 100,
+  "grade": "C",
+  "violations": [
+    {
+      "file": "tests/api/",
+      "severity": "HIGH",
+      "category": "missing-endpoint-tests",
+      "description": "API endpoint /api/users/delete not tested",
+      "suggestion": "Add tests for user deletion including error scenarios"
+    },
+    {
+      "file": "tests/e2e/checkout.spec.ts",
+      "line": 25,
+      "severity": "MEDIUM",
+      "category": "missing-error-case",
+      "description": "Only happy path tested - no error handling tests",
+      "suggestion": "Add tests for payment failure, network errors, validation failures"
+    }
+  ],
+  "passed_checks": 8,
+  "failed_checks": 4,
+  "violation_summary": {
+    "HIGH": 1,
+    "MEDIUM": 2,
+    "LOW": 1
+  },
+  "coverage_gaps": {
+    "untested_endpoints": ["/api/users/delete", "/api/orders/cancel"],
+    "untested_user_paths": ["Password reset flow"],
+    "missing_error_scenarios": ["Payment failures", "Network timeouts"]
+  },
+  "recommendations": [
+    "Add tests for all CRUD operations (especially DELETE)",
+    "Test error scenarios for each user path",
+    "Add integration tests between API and E2E layers"
+  ],
+  "summary": "Coverage has critical gaps - 4 violations (1 HIGH critical endpoint missing)"
+}
+```
+
+---
+
+## EXIT CONDITION
+
+Subprocess completes when JSON output written to temp file.
+
+**Subprocess terminates here.**

package/_bmad/tea/workflows/testarch/test-review/steps-c/step-03e-subprocess-performance.md

@@ -0,0 +1,117 @@
+---
+name: 'step-03e-subprocess-performance'
+description: 'Subprocess: Check test performance (speed, efficiency, parallelization)'
+subprocess: true
+outputFile: '/tmp/tea-test-review-performance-{{timestamp}}.json'
+---
+
+# Subprocess 3E: Performance Quality Check
+
+## SUBPROCESS CONTEXT
+
+This is an **isolated subprocess** running in parallel with other quality dimension checks.
+
+**Your task:** Analyze test files for PERFORMANCE violations only.
+
+---
+
+## MANDATORY EXECUTION RULES
+
+- ✅ Check PERFORMANCE only (not other quality dimensions)
+- ✅ Output structured JSON to temp file
+- ❌ Do NOT check determinism, isolation, maintainability, or coverage
+
+---
+
+## SUBPROCESS TASK
+
+### 1. Identify Performance Violations
+
+**HIGH SEVERITY Violations**:
+
+- Tests not parallelizable (using test.describe.serial unnecessarily)
+- Slow setup/teardown (creating fresh DB for every test)
+- Excessive navigation (reloading pages unnecessarily)
+- No fixture reuse (repeating expensive operations)
+
+**MEDIUM SEVERITY Violations**:
+
+- Hard waits >2 seconds (waitForTimeout(5000))
+- Inefficient selectors (page.$$ instead of locators)
+- Large data sets in tests without pagination
+- Missing performance optimizations
+
+**LOW SEVERITY Violations**:
+
+- Could use parallelization (test.describe.configure({ mode: 'parallel' }))
+- Minor inefficiencies
+- Excessive logging
+
+### 2. Calculate Performance Score
+
+```javascript
+const severityWeights = { HIGH: 10, MEDIUM: 5, LOW: 2 };
+const totalPenalty = violations.reduce((sum, v) => sum + severityWeights[v.severity], 0);
+const score = Math.max(0, 100 - totalPenalty);
+```
+
+---
+
+## OUTPUT FORMAT
+
+```json
+{
+  "dimension": "performance",
+  "score": 80,
+  "max_score": 100,
+  "grade": "B",
+  "violations": [
+    {
+      "file": "tests/e2e/search.spec.ts",
+      "line": 10,
+      "severity": "HIGH",
+      "category": "not-parallelizable",
+      "description": "Tests use test.describe.serial unnecessarily - reduces parallel execution",
+      "suggestion": "Remove .serial unless tests truly share state",
+      "code_snippet": "test.describe.serial('Search tests', () => { ... });"
+    },
+    {
+      "file": "tests/api/bulk-operations.spec.ts",
+      "line": 35,
+      "severity": "MEDIUM",
+      "category": "slow-setup",
+      "description": "Test creates 1000 records in setup - very slow",
+      "suggestion": "Use smaller data sets or fixture factories",
+      "code_snippet": "beforeEach(async () => { for (let i=0; i<1000; i++) { ... } });"
+    }
+  ],
+  "passed_checks": 13,
+  "failed_checks": 2,
+  "violation_summary": {
+    "HIGH": 1,
+    "MEDIUM": 1,
+    "LOW": 0
+  },
+  "performance_metrics": {
+    "parallelizable_tests": 80,
+    "serial_tests": 20,
+    "avg_test_duration_estimate": "~2 seconds",
+    "slow_tests": ["bulk-operations.spec.ts (>30s)"]
+  },
+  "recommendations": [
+    "Enable parallel mode where possible",
+    "Reduce setup data to minimum needed",
+    "Use fixtures to share expensive setup across tests",
+    "Remove unnecessary .serial constraints"
+  ],
+  "summary": "Good performance with 2 violations - 80% tests can run in parallel"
+}
+```
+
+---
+
+## EXIT CONDITION
+
+Subprocess completes when JSON output written to temp file.
+
+**Subprocess terminates here.**

package/_bmad/tea/workflows/testarch/test-review/steps-c/step-03f-aggregate-scores.md

@@ -0,0 +1,246 @@
+---
+name: 'step-03f-aggregate-scores'
+description: 'Aggregate quality dimension scores into overall 0-100 score'
+nextStepFile: './step-04-generate-report.md'
+---
+
+# Step 3F: Aggregate Quality Scores
+
+## STEP GOAL
+
+Read outputs from 5 parallel quality subprocesses, calculate weighted overall score (0-100), and aggregate violations for report generation.
+
+---
+
+## MANDATORY EXECUTION RULES
+
+- 📖 Read the entire step file before acting
+- ✅ Speak in `{communication_language}`
+- ✅ Read all 5 subprocess outputs
+- ✅ Calculate weighted overall score
+- ✅ Aggregate violations by severity
+- ❌ Do NOT re-evaluate quality (use subprocess outputs)
+
+---
+
+## EXECUTION PROTOCOLS:
+
+- 🎯 Follow the MANDATORY SEQUENCE exactly
+- 💾 Record outputs before proceeding
+- 📖 Load the next step only when instructed
+
+---
+
+## MANDATORY SEQUENCE
+
+### 1. Read All Subprocess Outputs
+
+```javascript
+const dimensions = ['determinism', 'isolation', 'maintainability', 'coverage', 'performance'];
+const results = {};
+
+dimensions.forEach((dim) => {
+  const outputPath = `/tmp/tea-test-review-${dim}-{{timestamp}}.json`;
+  results[dim] = JSON.parse(fs.readFileSync(outputPath, 'utf8'));
+});
+```
+
+**Verify all succeeded:**
+
+```javascript
+const allSucceeded = dimensions.every((dim) => results[dim].score !== undefined);
+if (!allSucceeded) {
+  throw new Error('One or more quality subprocesses failed!');
+}
+```
+
+---
+
+### 2. Calculate Weighted Overall Score
+
+**Dimension Weights** (based on TEA quality priorities):
+
+```javascript
+const weights = {
+  determinism: 0.25, // 25% - Most critical for reliability
+  isolation: 0.25, // 25% - Critical for parallel execution
+  maintainability: 0.2, // 20% - Important for long-term health
+  coverage: 0.15, // 15% - Important but can be improved iteratively
+  performance: 0.15, // 15% - Important but less critical than correctness
+};
+```
+
+**Calculate overall score:**
+
+```javascript
+const overallScore = dimensions.reduce((sum, dim) => {
+  return sum + results[dim].score * weights[dim];
+}, 0);
+
+const roundedScore = Math.round(overallScore);
+```
+
+**Determine grade:**
+
+```javascript
+const getGrade = (score) => {
+  if (score >= 90) return 'A';
+  if (score >= 80) return 'B';
+  if (score >= 70) return 'C';
+  if (score >= 60) return 'D';
+  return 'F';
+};
+
+const overallGrade = getGrade(roundedScore);
+```
+
+---
+
+### 3. Aggregate Violations by Severity
+
+**Collect all violations from all dimensions:**
+
+```javascript
+const allViolations = dimensions.flatMap((dim) =>
+  results[dim].violations.map((v) => ({
+    ...v,
+    dimension: dim,
+  })),
+);
+
+// Group by severity
+const highSeverity = allViolations.filter((v) => v.severity === 'HIGH');
+const mediumSeverity = allViolations.filter((v) => v.severity === 'MEDIUM');
+const lowSeverity = allViolations.filter((v) => v.severity === 'LOW');
+
+const violationSummary = {
+  total: allViolations.length,
+  HIGH: highSeverity.length,
+  MEDIUM: mediumSeverity.length,
+  LOW: lowSeverity.length,
+};
+```
+
+---
+
+### 4. Prioritize Recommendations
+
+**Extract recommendations from all dimensions:**
+
+```javascript
+const allRecommendations = dimensions.flatMap((dim) =>
+  results[dim].recommendations.map((rec) => ({
+    dimension: dim,
+    recommendation: rec,
+    impact: results[dim].score < 70 ? 'HIGH' : 'MEDIUM',
+  })),
+);
+
+// Sort by impact (HIGH first)
+const prioritizedRecommendations = allRecommendations.sort((a, b) => (a.impact === 'HIGH' ? -1 : 1)).slice(0, 10); // Top 10 recommendations
+```
+
+---
+
+### 5. Create Review Summary Object
+
+**Aggregate all results:**
+
+```javascript
+const reviewSummary = {
+  overall_score: roundedScore,
+  overall_grade: overallGrade,
+  quality_assessment: getQualityAssessment(roundedScore),
+
+  dimension_scores: {
+    determinism: results.determinism.score,
+    isolation: results.isolation.score,
+    maintainability: results.maintainability.score,
+    coverage: results.coverage.score,
+    performance: results.performance.score,
+  },
+
+  dimension_grades: {
+    determinism: results.determinism.grade,
+    isolation: results.isolation.grade,
+    maintainability: results.maintainability.grade,
+    coverage: results.coverage.grade,
+    performance: results.performance.grade,
+  },
+
+  violations_summary: violationSummary,
+
+  all_violations: allViolations,
+
+  high_severity_violations: highSeverity,
+
+  top_10_recommendations: prioritizedRecommendations,
+
+  subprocess_execution: 'PARALLEL (5 quality dimensions)',
+  performance_gain: '~60% faster than sequential',
+};
+
+// Save for Step 4 (report generation)
+fs.writeFileSync('/tmp/tea-test-review-summary-{{timestamp}}.json', JSON.stringify(reviewSummary, null, 2), 'utf8');
+```
+
+---
+
+### 6. Display Summary to User
+
+```
+✅ Quality Evaluation Complete (Parallel Execution)
+
+📊 Overall Quality Score: {roundedScore}/100 (Grade: {overallGrade})
+
+📈 Dimension Scores:
+- Determinism:      {determinism_score}/100 ({determinism_grade})
+- Isolation:        {isolation_score}/100 ({isolation_grade})
+- Maintainability:  {maintainability_score}/100 ({maintainability_grade})
+- Coverage:         {coverage_score}/100 ({coverage_grade})
+- Performance:      {performance_score}/100 ({performance_grade})
+
+⚠️ Violations Found:
+- HIGH:   {high_count} violations
+- MEDIUM: {medium_count} violations
+- LOW:    {low_count} violations
+- TOTAL:  {total_count} violations
+
+🚀 Performance: Parallel execution ~60% faster than sequential
+
+✅ Ready for report generation (Step 4)
+```
+
+---
+
+## EXIT CONDITION
+
+Proceed to Step 4 when:
+
+- ✅ All subprocess outputs read successfully
+- ✅ Overall score calculated
+- ✅ Violations aggregated
+- ✅ Recommendations prioritized
+- ✅ Summary saved to temp file
+- ✅ Output displayed to user
+
+Load next step: `{nextStepFile}`
+
+---
+
+## 🚨 SYSTEM SUCCESS METRICS
+
+### ✅ SUCCESS:
+
+- All 5 subprocess outputs read and parsed
+- Overall score calculated with proper weights
+- Violations aggregated correctly
+- Summary complete and saved
+
+### ❌ FAILURE:
+
+- Failed to read one or more subprocess outputs
+- Score calculation incorrect
+- Summary missing or incomplete
+
+**Master Rule:** All 5 quality dimensions MUST be aggregated for accurate overall score.

package/_bmad/tea/workflows/testarch/test-review/steps-c/step-04-generate-report.md

@@ -0,0 +1,72 @@
+---
+name: 'step-04-generate-report'
+description: 'Create test-review report and validate'
+outputFile: '{output_folder}/test-review.md'
+---
+
+# Step 4: Generate Report & Validate
+
+## STEP GOAL
+
+Produce the test-review report and validate against checklist.
+
+## MANDATORY EXECUTION RULES
+
+- 📖 Read the entire step file before acting
+- ✅ Speak in `{communication_language}`
+
+---
+
+## EXECUTION PROTOCOLS:
+
+- 🎯 Follow the MANDATORY SEQUENCE exactly
+- 💾 Record outputs before proceeding
+- 📖 Load the next step only when instructed
+
+## CONTEXT BOUNDARIES:
+
+- Available context: config, loaded artifacts, and knowledge fragments
+- Focus: this step's goal only
+- Limits: do not execute future steps
+- Dependencies: prior steps' outputs (if any)
+
+## MANDATORY SEQUENCE
+
+**CRITICAL:** Follow this sequence exactly. Do not skip, reorder, or improvise.
+
+## 1. Report Generation
+
+Use `test-review-template.md` to produce `{outputFile}` including:
+
+- Score summary
+- Critical findings with fixes
+- Warnings and recommendations
+- Context references (story/test-design if available)
+
+---
+
+## 2. Validation
+
+Validate against `checklist.md` and fix any gaps.
+
+---
+
+## 3. Completion Summary
+
+Report:
+
+- Scope reviewed
+- Overall score
+- Critical blockers
+- Next recommended workflow (e.g., `automate` or `trace`)
+
+## 🚨 SYSTEM SUCCESS/FAILURE METRICS:
+
+### ✅ SUCCESS:
+
+- Step completed in full with required outputs
+
+### ❌ SYSTEM FAILURE:
+
+- Skipped sequence steps or missing outputs
+  **Master Rule:** Skipping steps is FORBIDDEN.

package/_bmad/tea/workflows/testarch/test-review/steps-e/step-01-assess.md

@@ -0,0 +1,65 @@
+---
+name: 'step-01-assess'
+description: 'Load an existing output for editing'
+nextStepFile: './step-02-apply-edit.md'
+---
+
+# Step 1: Assess Edit Target
+
+## STEP GOAL:
+
+Identify which output should be edited and load it.
+
+## MANDATORY EXECUTION RULES (READ FIRST):
+
+### Universal Rules:
+
+- 📖 Read the complete step file before taking any action
+- ✅ Speak in `{communication_language}`
+
+### Role Reinforcement:
+
+- ✅ You are the Master Test Architect
+
+### Step-Specific Rules:
+
+- 🎯 Ask the user which output file to edit
+- 🚫 Do not edit until target is confirmed
+
+## EXECUTION PROTOCOLS:
+
+- 🎯 Follow the MANDATORY SEQUENCE exactly
+
+## CONTEXT BOUNDARIES:
+
+- Available context: existing outputs
+- Focus: select edit target
+- Limits: no edits yet
+
+## MANDATORY SEQUENCE
+
+**CRITICAL:** Follow this sequence exactly.
+
+### 1. Identify Target
+
+Ask the user to provide the output file path or select from known outputs.
+
+### 2. Load Target
+
+Read the provided output file in full.
+
+### 3. Confirm
+
+Confirm the target and proceed to edit.
+
+Load next step: `{nextStepFile}`
+
+## 🚨 SYSTEM SUCCESS/FAILURE METRICS:
+
+### ✅ SUCCESS:
+
+- Target identified and loaded
+
+### ❌ SYSTEM FAILURE:
+
+- Proceeding without a confirmed target

package/_bmad/tea/workflows/testarch/test-review/steps-e/step-02-apply-edit.md

@@ -0,0 +1,60 @@
+---
+name: 'step-02-apply-edit'
+description: 'Apply edits to the selected output'
+---
+
+# Step 2: Apply Edits
+
+## STEP GOAL:
+
+Apply the requested edits to the selected output and confirm changes.
+
+## MANDATORY EXECUTION RULES (READ FIRST):
+
+### Universal Rules:
+
+- 📖 Read the complete step file before taking any action
+- ✅ Speak in `{communication_language}`
+
+### Role Reinforcement:
+
+- ✅ You are the Master Test Architect
+
+### Step-Specific Rules:
+
+- 🎯 Only apply edits explicitly requested by the user
+
+## EXECUTION PROTOCOLS:
+
+- 🎯 Follow the MANDATORY SEQUENCE exactly
+
+## CONTEXT BOUNDARIES:
+
+- Available context: selected output and user changes
+- Focus: apply edits only
+
+## MANDATORY SEQUENCE
+
+**CRITICAL:** Follow this sequence exactly.
+
+### 1. Confirm Requested Changes
+
+Restate what will be changed and confirm.
+
+### 2. Apply Changes
+
+Update the output file accordingly.
+
+### 3. Report
+
+Summarize the edits applied.
+
+## 🚨 SYSTEM SUCCESS/FAILURE METRICS:
+
+### ✅ SUCCESS:
+
+- Changes applied and confirmed
+
+### ❌ SYSTEM FAILURE:
+
+- Unconfirmed edits or missing update