bmm-opencode 1.4.3 → 1.6.0

package/_bmad/tea/workflows/testarch/trace/instructions.md

@@ -0,0 +1,36 @@
+# Requirements Traceability & Quality Gate
+
+**Workflow:** `testarch-trace`
+**Version:** 5.0 (Step-File Architecture)
+
+---
+
+## Overview
+
+Create a requirements-to-tests traceability matrix, analyze coverage gaps, and optionally make a gate decision (PASS/CONCERNS/FAIL/WAIVED) based on evidence.
+
+---
+
+## WORKFLOW ARCHITECTURE
+
+This workflow uses **step-file architecture**:
+
+- **Micro-file Design**: Each step is self-contained
+- **JIT Loading**: Only the current step file is in memory
+- **Sequential Enforcement**: Execute steps in order
+
+---
+
+## INITIALIZATION SEQUENCE
+
+### 1. Configuration Loading
+
+From `workflow.yaml`, resolve:
+
+- `config_source`, `output_folder`, `user_name`, `communication_language`, `document_output_language`, `date`
+- `test_dir`, `source_dir`, `coverage_levels`, `gate_type`, `decision_mode`
+
+### 2. First Step
+
+Load, read completely, and execute:
+`{project-root}/_bmad/tea/workflows/testarch/trace/steps-c/step-01-load-context.md`

package/_bmad/tea/workflows/testarch/trace/steps-c/step-01-load-context.md

@@ -0,0 +1,80 @@
+---
+name: 'step-01-load-context'
+description: 'Load requirements, knowledge base, and related artifacts'
+nextStepFile: './step-02-discover-tests.md'
+knowledgeIndex: '{project-root}/_bmad/tea/testarch/tea-index.csv'
+---
+
+# Step 1: Load Context & Knowledge Base
+
+## STEP GOAL
+
+Gather acceptance criteria, priorities, and supporting artifacts for traceability.
+
+## 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. Prerequisites
+
+- Acceptance criteria available (story or provided inline)
+- Tests exist OR gaps explicitly acknowledged
+
+If acceptance criteria are missing, **HALT** and request them.
+
+---
+
+## 2. Load Knowledge Base
+
+From `{knowledgeIndex}` load:
+
+- `test-priorities-matrix.md`
+- `risk-governance.md`
+- `probability-impact.md`
+- `test-quality.md`
+- `selective-testing.md`
+
+---
+
+## 3. Load Artifacts
+
+If available:
+
+- Story file and acceptance criteria
+- Test design doc (priorities)
+- Tech spec / PRD
+
+Summarize what was found.
+
+Load next step: `{nextStepFile}`
+
+## 🚨 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/trace/steps-c/step-02-discover-tests.md

@@ -0,0 +1,69 @@
+---
+name: 'step-02-discover-tests'
+description: 'Discover and catalog tests by level'
+nextStepFile: './step-03-map-criteria.md'
+---
+
+# Step 2: Discover & Catalog Tests
+
+## STEP GOAL
+
+Identify tests relevant to the requirements and classify by test level.
+
+## 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. Discover Tests
+
+Search `{test_dir}` for:
+
+- Test IDs (e.g., `1.3-E2E-001`)
+- Feature name matches
+- Spec patterns (`*.spec.*`, `*.test.*`)
+
+---
+
+## 2. Categorize by Level
+
+Classify as:
+
+- E2E
+- API
+- Component
+- Unit
+
+Record test IDs, describe blocks, and priority markers if present.
+
+Load next step: `{nextStepFile}`
+
+## 🚨 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/trace/steps-c/step-03-map-criteria.md

@@ -0,0 +1,65 @@
+---
+name: 'step-03-map-criteria'
+description: 'Map acceptance criteria to tests and build traceability matrix'
+nextStepFile: './step-04-analyze-gaps.md'
+---
+
+# Step 3: Map Criteria to Tests
+
+## STEP GOAL
+
+Create the traceability matrix linking requirements to tests.
+
+## 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. Build Matrix
+
+For each acceptance criterion:
+
+- Map to matching tests
+- Mark coverage status: FULL / PARTIAL / NONE / UNIT-ONLY / INTEGRATION-ONLY
+- Record test level and priority
+
+---
+
+## 2. Validate Coverage Logic
+
+Ensure:
+
+- P0/P1 criteria have coverage
+- No duplicate coverage across levels without justification
+
+Load next step: `{nextStepFile}`
+
+## 🚨 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/trace/steps-c/step-04-analyze-gaps.md

@@ -0,0 +1,244 @@
+---
+name: 'step-04-analyze-gaps'
+description: 'Complete Phase 1: Generate coverage matrix with gap analysis'
+nextStepFile: './step-05-gate-decision.md'
+outputFile: '/tmp/tea-trace-coverage-matrix-{{timestamp}}.json'
+---
+
+# Step 4: Complete Phase 1 - Coverage Matrix Generation
+
+## STEP GOAL
+
+**Phase 1 Final Step:** Analyze coverage gaps, generate recommendations, and output complete coverage matrix to temp file for Phase 2 (gate decision).
+
+---
+
+## MANDATORY EXECUTION RULES
+
+- 📖 Read the entire step file before acting
+- ✅ Speak in `{communication_language}`
+- ✅ Output coverage matrix to temp file
+- ❌ Do NOT make gate decision (that's Phase 2 - Step 5)
+
+---
+
+## EXECUTION PROTOCOLS:
+
+- 🎯 Follow the MANDATORY SEQUENCE exactly
+- 💾 Record outputs before proceeding
+- 📖 Load the next step only when instructed
+
+## CONTEXT BOUNDARIES:
+
+- Available context: requirements from Step 1, tests from Step 2, traceability matrix from Step 3
+- Focus: gap analysis and matrix completion
+- Limits: do not make gate decision (Phase 2 responsibility)
+
+---
+
+## MANDATORY SEQUENCE
+
+### 1. Gap Analysis
+
+**Identify uncovered requirements:**
+
+```javascript
+const uncoveredRequirements = traceabilityMatrix.filter((req) => req.coverage === 'NONE');
+const partialCoverage = traceabilityMatrix.filter((req) => req.coverage === 'PARTIAL');
+const unitOnlyCoverage = traceabilityMatrix.filter((req) => req.coverage === 'UNIT-ONLY');
+```
+
+**Prioritize gaps by risk:**
+
+```javascript
+const criticalGaps = uncoveredRequirements.filter((req) => req.priority === 'P0');
+const highGaps = uncoveredRequirements.filter((req) => req.priority === 'P1');
+const mediumGaps = uncoveredRequirements.filter((req) => req.priority === 'P2');
+const lowGaps = uncoveredRequirements.filter((req) => req.priority === 'P3');
+```
+
+---
+
+### 2. Generate Recommendations
+
+**Based on gap analysis:**
+
+```javascript
+const recommendations = [];
+
+// Critical gaps (P0)
+if (criticalGaps.length > 0) {
+  recommendations.push({
+    priority: 'URGENT',
+    action: `Run /bmad:tea:atdd for ${criticalGaps.length} P0 requirements`,
+    requirements: criticalGaps.map((r) => r.id),
+  });
+}
+
+// High priority gaps (P1)
+if (highGaps.length > 0) {
+  recommendations.push({
+    priority: 'HIGH',
+    action: `Run /bmad:tea:automate to expand coverage for ${highGaps.length} P1 requirements`,
+    requirements: highGaps.map((r) => r.id),
+  });
+}
+
+// Partial coverage
+if (partialCoverage.length > 0) {
+  recommendations.push({
+    priority: 'MEDIUM',
+    action: `Complete coverage for ${partialCoverage.length} partially covered requirements`,
+    requirements: partialCoverage.map((r) => r.id),
+  });
+}
+
+// Quality issues
+recommendations.push({
+  priority: 'LOW',
+  action: 'Run /bmad:tea:test-review to assess test quality',
+  requirements: [],
+});
+```
+
+---
+
+### 3. Calculate Coverage Statistics
+
+```javascript
+const totalRequirements = traceabilityMatrix.length;
+const coveredRequirements = traceabilityMatrix.filter((r) => r.coverage === 'FULL' || r.coverage === 'PARTIAL').length;
+const fullyCovered = traceabilityMatrix.filter((r) => r.coverage === 'FULL').length;
+
+const coveragePercentage = Math.round((fullyCovered / totalRequirements) * 100);
+
+// Priority-specific coverage
+const p0Total = traceabilityMatrix.filter((r) => r.priority === 'P0').length;
+const p0Covered = traceabilityMatrix.filter((r) => r.priority === 'P0' && r.coverage === 'FULL').length;
+const p0CoveragePercentage = Math.round((p0Covered / p0Total) * 100);
+```
+
+---
+
+### 4. Generate Complete Coverage Matrix
+
+**Compile all Phase 1 outputs:**
+
+```javascript
+const coverageMatrix = {
+  phase: 'PHASE_1_COMPLETE',
+  generated_at: new Date().toISOString(),
+
+  requirements: traceabilityMatrix, // Full matrix from Step 3
+
+  coverage_statistics: {
+    total_requirements: totalRequirements,
+    fully_covered: fullyCovered,
+    partially_covered: partialCoverage.length,
+    uncovered: uncoveredRequirements.length,
+    overall_coverage_percentage: coveragePercentage,
+
+    priority_breakdown: {
+      P0: { total: p0Total, covered: p0Covered, percentage: p0CoveragePercentage },
+      P1: {
+        /* calculate */
+      },
+      P2: {
+        /* calculate */
+      },
+      P3: {
+        /* calculate */
+      },
+    },
+  },
+
+  gap_analysis: {
+    critical_gaps: criticalGaps,
+    high_gaps: highGaps,
+    medium_gaps: mediumGaps,
+    low_gaps: lowGaps,
+    partial_coverage_items: partialCoverage,
+    unit_only_items: unitOnlyCoverage,
+  },
+
+  recommendations: recommendations,
+};
+```
+
+---
+
+### 5. Output Coverage Matrix to Temp File
+
+**Write to temp file for Phase 2:**
+
+```javascript
+const outputPath = '/tmp/tea-trace-coverage-matrix-{{timestamp}}.json';
+fs.writeFileSync(outputPath, JSON.stringify(coverageMatrix, null, 2), 'utf8');
+
+console.log(`✅ Phase 1 Complete: Coverage matrix saved to ${outputPath}`);
+```
+
+---
+
+### 6. Display Phase 1 Summary
+
+```
+✅ Phase 1 Complete: Coverage Matrix Generated
+
+📊 Coverage Statistics:
+- Total Requirements: {totalRequirements}
+- Fully Covered: {fullyCovered} ({coveragePercentage}%)
+- Partially Covered: {partialCoverage.length}
+- Uncovered: {uncoveredRequirements.length}
+
+🎯 Priority Coverage:
+- P0: {p0Covered}/{p0Total} ({p0CoveragePercentage}%)
+- P1: {p1Coverage}%
+- P2: {p2Coverage}%
+- P3: {p3Coverage}%
+
+⚠️ Gaps Identified:
+- Critical (P0): {criticalGaps.length}
+- High (P1): {highGaps.length}
+- Medium (P2): {mediumGaps.length}
+- Low (P3): {lowGaps.length}
+
+📝 Recommendations: {recommendations.length}
+
+🔄 Phase 2: Gate decision (next step)
+```
+
+---
+
+## EXIT CONDITION
+
+**PHASE 1 COMPLETE when:**
+
+- ✅ Gap analysis complete
+- ✅ Recommendations generated
+- ✅ Coverage statistics calculated
+- ✅ Coverage matrix saved to temp file
+- ✅ Summary displayed
+
+**Proceed to Phase 2 (Step 5: Gate Decision)**
+
+Load next step: `{nextStepFile}`
+
+---
+
+## 🚨 PHASE 1 SUCCESS METRICS
+
+### ✅ SUCCESS:
+
+- Coverage matrix complete and accurate
+- All gaps identified and prioritized
+- Recommendations actionable
+- Temp file output valid JSON
+
+### ❌ FAILURE:
+
+- Coverage matrix incomplete
+- Gap analysis missing
+- Invalid JSON output
+
+**Master Rule:** Phase 1 MUST output complete coverage matrix to temp file before Phase 2 can proceed.