bmad-method-test-architecture-enterprise 1.2.0 → 1.2.2

package/docs/how-to/workflows/run-test-review.md

@@ -7,14 +7,17 @@ description: Audit test quality using TEA's comprehensive knowledge base and get
 
 Use TEA's `test-review` workflow to audit test quality with objective scoring and actionable feedback. TEA reviews tests against its knowledge base of best practices.
 
+Coverage scoring is intentionally excluded from `test-review`. Use `trace` for requirements coverage analysis and coverage gate decisions.
+
 ## When to Use This
 
 - Want to validate test quality objectively
-- Need quality metrics for release gates
+- Need quality metrics for test quality gates
 - Preparing for production deployment
 - Reviewing team-written tests
 - Auditing AI-generated tests
 - Onboarding new team members (show good patterns)
+- Validating migration quality before coverage expansion
 
 ## Prerequisites
 
@@ -311,42 +314,34 @@ test('should show validation error for expired card', async ({ page }) => {});
 
 ## Quality Scores by Category
 
-| Category        | Score | Target | Status               |
-| --------------- | ----- | ------ | -------------------- |
-| **Determinism** | 26/35 | 30/35  | ⚠️ Needs Improvement |
-| **Isolation**   | 22/25 | 20/25  | ✅ Good              |
-| **Assertions**  | 18/20 | 16/20  | ✅ Good              |
-| **Structure**   | 7/10  | 8/10   | ⚠️ Minor Issues      |
-| **Performance** | 3/10  | 8/10   | ❌ Critical          |
+| Category            | Score | Target | Status               |
+| ------------------- | ----- | ------ | -------------------- |
+| **Determinism**     | 72    | 80     | ⚠️ Needs Improvement |
+| **Isolation**       | 88    | 80     | ✅ Good              |
+| **Maintainability** | 70    | 80     | ⚠️ Needs Improvement |
+| **Performance**     | 60    | 80     | ❌ Critical          |
 
 ### Scoring Breakdown
 
-**Determinism (35 points max):**
-
-- No hard waits: 0/10 ❌ (found 3 instances)
-- No conditionals: 8/10 ⚠️ (found 2 instances)
-- No try-catch flow control: 10/10 ✅
-- Network-first patterns: 8/15 ⚠️ (some tests missing)
-
-**Isolation (25 points max):**
+**Determinism (30% weight):**
 
-- Self-cleaning: 20/20 ✅
-- No global state: 5/5 ✅
-- Parallel-safe: 0/0 ✅ (not tested)
+- Hard waits and race conditions penalized
+- Unstable control flow patterns penalized
 
-**Assertions (20 points max):**
+**Isolation (30% weight):**
 
-- Explicit in test body: 15/15 ✅
-- Specific and meaningful: 3/5 ⚠️ (some weak assertions)
+- Shared state and order dependency penalized
+- Cleanup and parallel-safety rewarded
 
-**Structure (10 points max):**
+**Maintainability (25% weight):**
 
-- Test size < 300 lines: 5/5 ✅
-- Clear names: 2/5 ⚠️ (some vague names)
+- Overly large files and copy-paste patterns penalized
+- Naming clarity and structure rewarded
 
-**Performance (10 points max):**
+**Performance (15% weight):**
 
-- Execution time < 1.5 min: 3/10 ❌ (3 tests exceed limit)
+- Serial bottlenecks and inefficient setup penalized
+- Parallel-friendly structure rewarded
 
 ## Files Reviewed
 
@@ -402,31 +397,30 @@ TEA reviewed against these patterns:
 
 ### Scoring Criteria
 
-**Determinism (35 points):**
+**Determinism (30%):**
 - Tests produce same result every run
 - No random failures (flakiness)
 - No environment-dependent behavior
 
-**Isolation (25 points):**
+**Isolation (30%):**
 - Tests don't depend on each other
 - Can run in any order
 - Clean up after themselves
 
-**Assertions (20 points):**
-- Verify actual behavior
-- Specific and meaningful
-- Not abstracted away in helpers
-
-**Structure (10 points):**
+**Maintainability (25%):**
 - Readable and maintainable
 - Appropriate size
 - Clear naming
 
-**Performance (10 points):**
+**Performance (15%):**
 - Fast execution
 - Efficient selectors
 - No unnecessary waits
 
+**Coverage:**
+- Not scored in `test-review`
+- Use `trace` for coverage percentage, requirement mapping, and gate decisions
+
 ## What You Get
 
 ### Quality Report
@@ -457,9 +451,9 @@ TEA reviewed against these patterns:
 Make test review part of release checklist:
 
 ```markdown
-## Release Checklist
+## Quality Checklist (Test-Review)
 - [ ] All tests passing
-- [ ] Test review score > 80
+- [ ] Test-review quality score > 80
 - [ ] Critical issues resolved
 - [ ] Performance within budget
 ````
@@ -483,21 +477,23 @@ Use scores as quality gates:
 # .github/workflows/test.yml
 - name: Review test quality
   run: |
-    # Run test review
-    # Parse score from report
+    # Run test-review quality gate
+    # Parse quality score from report
     if [ $SCORE -lt 80 ]; then
-      echo "Test quality below threshold"
+      echo "Test-review quality gate below threshold"
       exit 1
     fi
 ```
 
+Coverage gate checks are handled by `trace`, not `test-review`.
+
 ### Review Regularly
 
 Schedule periodic reviews:
 
 - **Per story:** Optional (spot check new tests)
 - **Per epic:** Recommended (ensure consistency)
-- **Per release:** Recommended for quality gates (required if using formal gate process)
+- **Per release:** Recommended for test quality gates (coverage gates remain in `trace`)
 - **Quarterly:** Audit entire suite
 
 ### Focus Reviews
@@ -619,8 +615,8 @@ Don't try to fix everything at once.
 ## Related Guides
 
 - [How to Run ATDD](/docs/how-to/workflows/run-atdd.md) - Generate tests to review
-- [How to Run Automate](/docs/how-to/workflows/run-automate.md) - Expand coverage to review
-- [How to Run Trace](/docs/how-to/workflows/run-trace.md) - Coverage complements quality
+- [How to Run Automate](/docs/how-to/workflows/run-automate.md) - Expand and improve tests before review
+- [How to Run Trace](/docs/how-to/workflows/run-trace.md) - Coverage analysis and gate decisions
 
 ## Understanding the Concepts
 

package/docs/how-to/workflows/run-trace.md

@@ -489,7 +489,7 @@ TEA makes evidence-based gate decision and writes to separate file.
 
 | Metric             | Threshold | Actual | Status |
 | ------------------ | --------- | ------ | ------ |
-| P0/P1 Coverage     | >95%      | 100%   | ✅      |
+| P0/P1 Coverage     | P0=100%, P1>=90% | 100% / 100% | ✅      |
 | Test Quality Score | >80       | 84     | ✅      |
 | NFR Status         | PASS      | PASS   | ✅      |
 
@@ -609,7 +609,7 @@ TEA uses deterministic rules when decision_mode = "deterministic":
 
 **Evidence:**
 
-- P0 coverage: 60% (below 95% threshold)
+- P0 coverage: 60% (below required 100%)
 - Critical security vulnerability (CVE-2024-12345)
 - Test quality: 55/100
 
@@ -787,8 +787,16 @@ Use traceability in CI:
   run: |
     # Run trace Phase 1
     # Parse coverage percentages
-    if [ $P0_COVERAGE -lt 95 ]; then
-      echo "P0 coverage below 95%"
+    if [ $P0_COVERAGE -lt 100 ]; then
+      echo "P0 coverage below required 100%"
+      exit 1
+    fi
+    if [ $P1_COVERAGE -lt 80 ]; then
+      echo "P1 coverage below minimum 80%"
+      exit 1
+    fi
+    if [ $OVERALL_COVERAGE -lt 80 ]; then
+      echo "Overall coverage below minimum 80%"
       exit 1
     fi
 ```
@@ -916,7 +924,7 @@ Result: PARTIAL coverage (3/4 criteria)
 
 **Use CONCERNS** ⚠️ if:
 
-- P1 coverage 85-90% (close to threshold)
+- P1 coverage 80-89% (below PASS target, above minimum)
 - Minor quality issues (score 70-79)
 - NFRs have mitigation plans
 - Team agrees risk is acceptable
@@ -924,7 +932,7 @@ Result: PARTIAL coverage (3/4 criteria)
 **Use FAIL** ❌ if:
 
 - P0 coverage <100% (critical path gaps)
-- P1 coverage <85%
+- P1 coverage <80%
 - Critical security/performance issues
 - No mitigation possible
 

package/docs/reference/commands.md

@@ -232,15 +232,15 @@ Quick reference for all 9 TEA (Test Engineering Architect) workflows. For detail
 - `test-review.md` with quality score (0-100)
 - Critical issues with fixes
 - Recommendations
-- Category scores (Determinism, Isolation, Assertions, Structure, Performance)
+- Category scores (Determinism, Isolation, Maintainability, Performance)
+- Coverage guidance is informational only; coverage scoring and gates are handled by `trace`
 
 **Scoring Categories:**
 
-- Determinism: 35 points
-- Isolation: 25 points
-- Assertions: 20 points
-- Structure: 10 points
-- Performance: 10 points
+- Determinism: 30%
+- Isolation: 30%
+- Maintainability: 25%
+- Performance: 15%
 
 **How-To Guide:** [Run Test Review](/docs/how-to/workflows/run-test-review.md)
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "bmad-method-test-architecture-enterprise",
-  "version": "1.2.0",
+  "version": "1.2.2",
   "description": "Master Test Architect for quality strategy, test automation, and release gates",
   "keywords": [
     "bmad",

package/release_notes.md

@@ -1,10 +1,10 @@
-## 🚀 What's New in v1.2.0
+## 🚀 What's New in v1.2.2
 
-### ✨ New Features
-- feat:enhance api-request with operation-based overload and update documentation
+### 🐛 Bug Fixes
+- fix: issue 29
 
 ### 📦 Other Changes
-- Merge pull request #28 from bmad-code-org/feat/knowledge-update-pw-utils-3-14-0
+- Merge pull request #31 from bmad-code-org/fix/issue-29
 
 
 ## 📦 Installation
@@ -14,4 +14,4 @@ npx bmad-method install
 # Select "Test Architect" from module menu
 ```
 
-**Full Changelog**: https://github.com/bmad-code-org/bmad-method-test-architecture-enterprise/compare/v1.1.0...v1.2.0
+**Full Changelog**: https://github.com/bmad-code-org/bmad-method-test-architecture-enterprise/compare/v1.2.1...v1.2.2

package/src/module-help.csv

@@ -1,10 +1,10 @@
 module,phase,name,code,sequence,workflow-file,command,required,agent,options,description,output-location,outputs,
-tea,0-learning,Teach Me Testing,TMT,10,_bmad/tea/workflows/testarch/teach-me-testing/workflow.md,bmad_tea_teach-me-testing,false,tea,Create Mode,"Teach testing fundamentals through 7 sessions (TEA Academy)",test_artifacts,"progress file|session notes|certificate",
-tea,3-solutioning,Test Design,TD,10,_bmad/tea/workflows/testarch/test-design/workflow.yaml,bmad_tea_test-design,false,tea,Create Mode,"Risk-based test planning",test_artifacts,"test design document",
-tea,3-solutioning,Test Framework,TF,20,_bmad/tea/workflows/testarch/framework/workflow.yaml,bmad_tea_framework,false,tea,Create Mode,"Initialize production-ready test framework",test_artifacts,"framework scaffold",
-tea,3-solutioning,CI Setup,CI,30,_bmad/tea/workflows/testarch/ci/workflow.yaml,bmad_tea_ci,false,tea,Create Mode,"Configure CI/CD quality pipeline",test_artifacts,"ci config",
-tea,4-implementation,ATDD,AT,10,_bmad/tea/workflows/testarch/atdd/workflow.yaml,bmad_tea_atdd,false,tea,Create Mode,"Generate failing tests (TDD red phase)",test_artifacts,"atdd tests",
-tea,4-implementation,Test Automation,TA,20,_bmad/tea/workflows/testarch/automate/workflow.yaml,bmad_tea_automate,false,tea,Create Mode,"Expand test coverage",test_artifacts,"test suite",
-tea,4-implementation,Test Review,RV,30,_bmad/tea/workflows/testarch/test-review/workflow.yaml,bmad_tea_test-review,false,tea,Validate Mode,"Quality audit (0-100 scoring)",test_artifacts,"review report",
-tea,4-implementation,NFR Assessment,NR,40,_bmad/tea/workflows/testarch/nfr-assess/workflow.yaml,bmad_tea_nfr-assess,false,tea,Create Mode,"Non-functional requirements",test_artifacts,"nfr report",
-tea,4-implementation,Traceability,TR,50,_bmad/tea/workflows/testarch/trace/workflow.yaml,bmad_tea_trace,false,tea,Create Mode,"Coverage traceability and gate",test_artifacts,"traceability matrix|gate decision",
+tea,0-learning,Teach Me Testing,TMT,10,_bmad/tea/workflows/testarch/teach-me-testing/workflow.md,bmad-tea-teach-me-testing,false,tea,Create Mode,"Teach testing fundamentals through 7 sessions (TEA Academy)",test_artifacts,"progress file|session notes|certificate",
+tea,3-solutioning,Test Design,TD,10,_bmad/tea/workflows/testarch/test-design/workflow.yaml,bmad-tea-testarch-test-design,false,tea,Create Mode,"Risk-based test planning",test_artifacts,"test design document",
+tea,3-solutioning,Test Framework,TF,20,_bmad/tea/workflows/testarch/framework/workflow.yaml,bmad-tea-testarch-framework,false,tea,Create Mode,"Initialize production-ready test framework",test_artifacts,"framework scaffold",
+tea,3-solutioning,CI Setup,CI,30,_bmad/tea/workflows/testarch/ci/workflow.yaml,bmad-tea-testarch-ci,false,tea,Create Mode,"Configure CI/CD quality pipeline",test_artifacts,"ci config",
+tea,4-implementation,ATDD,AT,10,_bmad/tea/workflows/testarch/atdd/workflow.yaml,bmad-tea-testarch-atdd,false,tea,Create Mode,"Generate failing tests (TDD red phase)",test_artifacts,"atdd tests",
+tea,4-implementation,Test Automation,TA,20,_bmad/tea/workflows/testarch/automate/workflow.yaml,bmad-tea-testarch-automate,false,tea,Create Mode,"Expand test coverage",test_artifacts,"test suite",
+tea,4-implementation,Test Review,RV,30,_bmad/tea/workflows/testarch/test-review/workflow.yaml,bmad-tea-testarch-test-review,false,tea,Validate Mode,"Quality audit (0-100 scoring)",test_artifacts,"review report",
+tea,4-implementation,NFR Assessment,NR,40,_bmad/tea/workflows/testarch/nfr-assess/workflow.yaml,bmad-tea-testarch-nfr,false,tea,Create Mode,"Non-functional requirements",test_artifacts,"nfr report",
+tea,4-implementation,Traceability,TR,50,_bmad/tea/workflows/testarch/trace/workflow.yaml,bmad-tea-testarch-trace,false,tea,Create Mode,"Coverage traceability and gate",test_artifacts,"traceability matrix|gate decision",

package/src/workflows/testarch/test-review/checklist.md

@@ -7,6 +7,7 @@ Use this checklist to validate that the test quality review workflow completed s
 ## Prerequisites
 
 Note: `test-review` is optional and only audits existing tests; it does not generate tests.
+Coverage analysis is out of scope for this workflow. Use `trace` for coverage metrics and coverage gate decisions.
 
 ### Test File Discovery
 
@@ -72,6 +73,8 @@ Note: `test-review` is optional and only audits existing tests; it does not gene
 
 ### Step 3: Quality Criteria Validation
 
+Coverage criteria are intentionally excluded from this checklist.
+
 **For Each Enabled Criterion:**
 
 #### BDD Format (if `check_given_when_then: true`)

package/src/workflows/testarch/test-review/instructions.md

@@ -9,6 +9,8 @@
 
 Review test quality using TEA knowledge base and produce a 0–100 quality score with actionable findings.
 
+Coverage assessment is intentionally out of scope for this workflow. Use `trace` for requirements coverage and coverage gate decisions.
+
 ---
 
 ## WORKFLOW ARCHITECTURE

package/src/workflows/testarch/test-review/steps-c/step-01-load-context.md

@@ -96,6 +96,8 @@ If available:
 
 Summarize what was found.
 
+Coverage mapping and coverage gates are out of scope in `test-review`. Route those concerns to `trace`.
+
 ---
 
 ## 4. Save Progress

package/src/workflows/testarch/test-review/steps-c/step-03-quality-evaluation.md

@@ -1,6 +1,6 @@
 ---
 name: 'step-03-quality-evaluation'
-description: 'Orchestrate parallel quality dimension checks (5 subprocesses)'
+description: 'Orchestrate parallel quality dimension checks (4 subprocesses)'
 nextStepFile: './step-03f-aggregate-scores.md'
 ---
 
@@ -8,14 +8,21 @@ nextStepFile: './step-03f-aggregate-scores.md'
 
 ## STEP GOAL
 
-Launch 5 parallel subprocesses to evaluate independent quality dimensions simultaneously for maximum performance.
+Launch 4 parallel subprocesses to evaluate test quality dimensions:
+
+- Determinism
+- Isolation
+- Maintainability
+- Performance
+
+Coverage is intentionally excluded from this workflow and handled by `trace`.
 
 ## MANDATORY EXECUTION RULES
 
 - 📖 Read the entire step file before acting
 - ✅ Speak in `{communication_language}`
-- ✅ Launch FIVE subprocesses in PARALLEL
-- ✅ Wait for ALL subprocesses to complete
+- ✅ Launch four subprocesses in PARALLEL
+- ✅ Wait for all subprocesses to complete
 - ❌ Do NOT evaluate quality sequentially (use subprocesses)
 - ❌ Do NOT proceed until all subprocesses finish
 
@@ -57,33 +64,27 @@ const subprocessContext = {
 
 ---
 
-### 2. Launch 5 Parallel Quality Subprocesses
+### 2. Launch 4 Parallel Quality Subprocesses
 
-**Subprocess A: Determinism Check**
+**Subprocess A: Determinism**
 
 - File: `./step-03a-subprocess-determinism.md`
 - Output: `/tmp/tea-test-review-determinism-${timestamp}.json`
 - Status: Running in parallel... ⟳
 
-**Subprocess B: Isolation Check**
+**Subprocess B: Isolation**
 
 - File: `./step-03b-subprocess-isolation.md`
 - Output: `/tmp/tea-test-review-isolation-${timestamp}.json`
 - Status: Running in parallel... ⟳
 
-**Subprocess C: Maintainability Check**
+**Subprocess C: Maintainability**
 
 - File: `./step-03c-subprocess-maintainability.md`
 - Output: `/tmp/tea-test-review-maintainability-${timestamp}.json`
 - Status: Running in parallel... ⟳
 
-**Subprocess D: Coverage Check**
-
-- File: `./step-03d-subprocess-coverage.md`
-- Output: `/tmp/tea-test-review-coverage-${timestamp}.json`
-- Status: Running in parallel... ⟳
-
-**Subprocess E: Performance Check**
+**Subprocess D: Performance**
 
 - File: `./step-03e-subprocess-performance.md`
 - Output: `/tmp/tea-test-review-performance-${timestamp}.json`
@@ -94,22 +95,8 @@ const subprocessContext = {
 ### 3. Wait for All Subprocesses
 
 ```
-⏳ Waiting for 5 quality subprocesses to complete...
-  ├── Subprocess A (Determinism): Running... ⟳
-  ├── Subprocess B (Isolation): Running... ⟳
-  ├── Subprocess C (Maintainability): Running... ⟳
-  ├── Subprocess D (Coverage): Running... ⟳
-  └── Subprocess E (Performance): Running... ⟳
-
-[... time passes ...]
-
-  ├── Subprocess A (Determinism): Complete ✅
-  ├── Subprocess B (Isolation): Complete ✅
-  ├── Subprocess C (Maintainability): Complete ✅
-  ├── Subprocess D (Coverage): Complete ✅
-  └── Subprocess E (Performance): Complete ✅
-
-✅ All 5 quality subprocesses completed successfully!
+⏳ Waiting for 4 quality subprocesses to complete...
+✅ All 4 quality subprocesses completed successfully!
 ```
 
 ---
@@ -117,7 +104,7 @@ const subprocessContext = {
 ### 4. Verify All Outputs Exist
 
 ```javascript
-const outputs = ['determinism', 'isolation', 'maintainability', 'coverage', 'performance'].map(
+const outputs = ['determinism', 'isolation', 'maintainability', 'performance'].map(
   (dim) => `/tmp/tea-test-review-${dim}-${timestamp}.json`,
 );
 
@@ -134,7 +121,7 @@ outputs.forEach((output) => {
 
 ```
 🚀 Performance Report:
-- Execution Mode: PARALLEL (5 subprocesses)
+- Execution Mode: PARALLEL (4 subprocesses)
 - Total Elapsed: ~max(all subprocesses) minutes
 - Sequential Would Take: ~sum(all subprocesses) minutes
 - Performance Gain: ~60-70% faster!
@@ -144,11 +131,13 @@ outputs.forEach((output) => {
 
 ### 6. Proceed to Aggregation
 
+Pass the same `timestamp` value to Step 3F (do not regenerate it). Step 3F must read the exact temp files written in this step.
+
 Load next step: `{nextStepFile}`
 
 The aggregation step (3F) will:
 
-- Read all 5 subprocess outputs
+- Read all 4 subprocess outputs
 - Calculate weighted overall score (0-100)
 - Aggregate violations by severity
 - Generate review report with top suggestions
@@ -159,7 +148,7 @@ The aggregation step (3F) will:
 
 Proceed to Step 3F when:
 
-- ✅ All 5 subprocesses completed successfully
+- ✅ All 4 subprocesses completed successfully
 - ✅ All output files exist and are valid JSON
 - ✅ Performance metrics displayed
 
@@ -171,7 +160,7 @@ Proceed to Step 3F when:
 
 ### ✅ SUCCESS:
 
-- All 5 subprocesses launched and completed
+- All 4 subprocesses launched and completed
 - Output files generated and valid
 - Parallel execution achieved ~60% performance gain
 

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

@@ -9,7 +9,7 @@ outputFile: '{test_artifacts}/test-review.md'
 
 ## STEP GOAL
 
-Read outputs from 5 parallel quality subprocesses, calculate weighted overall score (0-100), and aggregate violations for report generation.
+Read outputs from 4 quality subprocesses, calculate weighted overall score (0-100), and aggregate violations for report generation.
 
 ---
 
@@ -17,7 +17,7 @@ Read outputs from 5 parallel quality subprocesses, calculate weighted overall sc
 
 - 📖 Read the entire step file before acting
 - ✅ Speak in `{communication_language}`
-- ✅ Read all 5 subprocess outputs
+- ✅ Read all 4 subprocess outputs
 - ✅ Calculate weighted overall score
 - ✅ Aggregate violations by severity
 - ❌ Do NOT re-evaluate quality (use subprocess outputs)
@@ -37,11 +37,16 @@ Read outputs from 5 parallel quality subprocesses, calculate weighted overall sc
 ### 1. Read All Subprocess Outputs
 
 ```javascript
-const dimensions = ['determinism', 'isolation', 'maintainability', 'coverage', 'performance'];
+// Use the SAME timestamp generated in Step 3 (do not regenerate).
+const timestamp = subprocessContext?.timestamp;
+if (!timestamp) {
+  throw new Error('Missing timestamp from Step 3 context. Pass Step 3 timestamp into Step 3F.');
+}
+const dimensions = ['determinism', 'isolation', 'maintainability', 'performance'];
 const results = {};
 
 dimensions.forEach((dim) => {
-  const outputPath = `/tmp/tea-test-review-${dim}-{{timestamp}}.json`;
+  const outputPath = `/tmp/tea-test-review-${dim}-${timestamp}.json`;
   results[dim] = JSON.parse(fs.readFileSync(outputPath, 'utf8'));
 });
 ```
@@ -63,11 +68,10 @@ if (!allSucceeded) {
 
 ```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
+  determinism: 0.3, // 30% - Reliability and flake prevention
+  isolation: 0.3, // 30% - Parallel safety and independence
+  maintainability: 0.25, // 25% - Readability and long-term health
+  performance: 0.15, // 15% - Speed and execution efficiency
 };
 ```
 
@@ -157,7 +161,6 @@ const reviewSummary = {
     determinism: results.determinism.score,
     isolation: results.isolation.score,
     maintainability: results.maintainability.score,
-    coverage: results.coverage.score,
     performance: results.performance.score,
   },
 
@@ -165,7 +168,6 @@ const reviewSummary = {
     determinism: results.determinism.grade,
     isolation: results.isolation.grade,
     maintainability: results.maintainability.grade,
-    coverage: results.coverage.grade,
     performance: results.performance.grade,
   },
 
@@ -177,12 +179,12 @@ const reviewSummary = {
 
   top_10_recommendations: prioritizedRecommendations,
 
-  subprocess_execution: 'PARALLEL (5 quality dimensions)',
+  subprocess_execution: 'PARALLEL (4 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');
+fs.writeFileSync(`/tmp/tea-test-review-summary-${timestamp}.json`, JSON.stringify(reviewSummary, null, 2), 'utf8');
 ```
 
 ---
@@ -198,9 +200,10 @@ fs.writeFileSync('/tmp/tea-test-review-summary-{{timestamp}}.json', JSON.stringi
 - 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})
 
+ℹ️ Coverage is excluded from `test-review` scoring. Use `trace` for coverage analysis and gates.
+
 ⚠️ Violations Found:
 - HIGH:   {high_count} violations
 - MEDIUM: {medium_count} violations
@@ -260,7 +263,7 @@ Load next step: `{nextStepFile}`
 
 ### ✅ SUCCESS:
 
-- All 5 subprocess outputs read and parsed
+- All 4 subprocess outputs read and parsed
 - Overall score calculated with proper weights
 - Violations aggregated correctly
 - Summary complete and saved
@@ -271,4 +274,4 @@ Load next step: `{nextStepFile}`
 - Score calculation incorrect
 - Summary missing or incomplete
 
-**Master Rule:** All 5 quality dimensions MUST be aggregated for accurate overall score.
+**Master Rule:** Aggregate determinism, isolation, maintainability, and performance only.

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

@@ -42,6 +42,7 @@ Use `test-review-template.md` to produce `{outputFile}` including:
 - Critical findings with fixes
 - Warnings and recommendations
 - Context references (story/test-design if available)
+- Coverage boundary note: `test-review` does not score coverage. Direct coverage findings to `trace`.
 
 ---
 

package/src/workflows/testarch/test-review/test-review-template.md

@@ -14,6 +14,7 @@ lastSaved: ''
 ---
 
 Note: This review audits existing tests; it does not generate tests.
+Coverage mapping and coverage gates are out of scope here. Use `trace` for coverage decisions.
 
 ## Executive Summary
 
@@ -216,7 +217,7 @@ Grade:                   {grade}
 - **Fixtures Used**: {fixture_count} ({fixture_names})
 - **Data Factories Used**: {factory_count} ({factory_names})
 
-### Test Coverage Scope
+### Test Scope
 
 - **Test IDs**: {test_id_list}
 - **Priority Distribution**:
@@ -241,7 +242,6 @@ Grade:                   {grade}
 {If story file found:}
 
 - **Story File**: [{story_filename}]({story_path})
-- **Acceptance Criteria Mapped**: {ac_mapped}/{ac_total} ({ac_coverage}%)
 
 {If test-design found:}
 
@@ -249,18 +249,6 @@ Grade:                   {grade}
 - **Risk Assessment**: {risk_level}
 - **Priority Framework**: P0-P3 applied
 
-### Acceptance Criteria Validation
-
-{If story file available, map tests to ACs:}
-
-| Acceptance Criterion | Test ID   | Status                     | Notes   |
-| -------------------- | --------- | -------------------------- | ------- |
-| {AC_1}               | {test_id} | {✅ Covered \| ❌ Missing} | {notes} |
-| {AC_2}               | {test_id} | {✅ Covered \| ❌ Missing} | {notes} |
-| {AC_3}               | {test_id} | {✅ Covered \| ❌ Missing} | {notes} |
-
-**Coverage**: {covered_count}/{total_count} criteria covered ({coverage_percentage}%)
-
 ---
 
 ## Knowledge Base References
@@ -276,7 +264,8 @@ This review consulted the following knowledge base fragments:
 - **[selective-testing.md](../../../testarch/knowledge/selective-testing.md)** - Duplicate coverage detection
 - **[ci-burn-in.md](../../../testarch/knowledge/ci-burn-in.md)** - Flakiness detection patterns (10-iteration loop)
 - **[test-priorities.md](../../../testarch/knowledge/test-priorities.md)** - P0/P1/P2/P3 classification framework
-- **[traceability.md](../../../testarch/knowledge/traceability.md)** - Requirements-to-tests mapping
+
+For coverage mapping, consult `trace` workflow outputs.
 
 See [tea-index.csv](../../../testarch/tea-index.csv) for complete knowledge base.
 

package/src/workflows/testarch/trace/checklist.md

@@ -95,6 +95,10 @@ This checklist covers **two sequential phases**:
   - [ ] Criteria with PARTIAL status
   - [ ] Criteria with UNIT-ONLY status
   - [ ] Criteria with INTEGRATION-ONLY status
+- [ ] Coverage heuristics gaps identified:
+  - [ ] Endpoints referenced in requirements but not covered by API tests
+  - [ ] Auth/authz criteria missing denied/invalid path tests
+  - [ ] Criteria with happy-path-only coverage (missing error scenarios)
 - [ ] Gaps prioritized by risk level using test-priorities framework:
   - [ ] **CRITICAL** - P0 criteria without FULL coverage (BLOCKER)
   - [ ] **HIGH** - P1 criteria without FULL coverage (PR blocker)
@@ -306,9 +310,10 @@ Knowledge fragments referenced:
 **P1 Criteria Evaluation:**
 
 - [ ] P1 test pass rate evaluated (threshold: min_p1_pass_rate)
-- [ ] P1 acceptance criteria coverage evaluated (threshold: 95%)
+- [ ] P1 acceptance criteria coverage evaluated (PASS >=90%, CONCERNS 80-89%, FAIL <80%)
 - [ ] Overall test pass rate evaluated (threshold: min_overall_pass_rate)
-- [ ] Code coverage evaluated (threshold: min_coverage)
+- [ ] Overall requirements coverage evaluated (threshold: >=80%)
+- [ ] Code coverage considered if available (informational unless explicitly required by policy)
 - [ ] P1 decision recorded: PASS or CONCERNS
 
 **P2/P3 Criteria Evaluation:**

package/src/workflows/testarch/trace/steps-c/step-02-discover-tests.md

@@ -58,7 +58,25 @@ Record test IDs, describe blocks, and priority markers if present.
 
 ---
 
-### 3. Save Progress
+## 3. Build Coverage Heuristics Inventory
+
+Capture explicit coverage signals so Phase 1 can detect common blind spots:
+
+- API endpoint coverage
+  - Inventory endpoints referenced by requirements/specs and endpoints exercised by API tests
+  - Mark endpoints with no direct tests
+- Authentication/authorization coverage
+  - Detect tests for login/session/token flows and permission-denied paths
+  - Mark auth/authz requirements with missing negative-path tests
+- Error-path coverage
+  - Detect validation, timeout, network-failure, and server-error scenarios
+  - Mark criteria with happy-path-only tests
+
+Record these findings in step output as `coverage_heuristics` for Step 3/4.
+
+---
+
+### 4. Save Progress
 
 **Save this step's accumulated work to `{outputFile}`.**
 

package/src/workflows/testarch/trace/steps-c/step-03-map-criteria.md

@@ -42,6 +42,10 @@ For each acceptance criterion:
 - Map to matching tests
 - Mark coverage status: FULL / PARTIAL / NONE / UNIT-ONLY / INTEGRATION-ONLY
 - Record test level and priority
+- Record heuristic signals:
+  - Endpoint coverage present/missing (for API-impacting criteria)
+  - Auth/authz coverage present/missing (positive and negative paths)
+  - Error-path coverage present/missing (validation, timeout, network/server failures)
 
 ---
 
@@ -51,6 +55,9 @@ Ensure:
 
 - P0/P1 criteria have coverage
 - No duplicate coverage across levels without justification
+- Criteria are not happy-path-only when requirements imply error handling
+- API criteria are not marked FULL if endpoint-level checks are missing
+- Auth/authz criteria include at least one denied/invalid-path test where applicable
 
 ---
 

package/src/workflows/testarch/trace/steps-c/step-04-analyze-gaps.md

@@ -10,7 +10,7 @@ tempOutputFile: '/tmp/tea-trace-coverage-matrix-{{timestamp}}.json'
 
 ## STEP GOAL
 
-**Phase 1 Final Step:** Analyze coverage gaps, generate recommendations, and output complete coverage matrix to temp file for Phase 2 (gate decision).
+**Phase 1 Final Step:** Analyze coverage gaps (including endpoint/auth/error-path blind spots), generate recommendations, and output complete coverage matrix to temp file for Phase 2 (gate decision).
 
 ---
 
@@ -60,7 +60,27 @@ const lowGaps = uncoveredRequirements.filter((req) => req.priority === 'P3');
 
 ---
 
-### 2. Generate Recommendations
+### 2. Coverage Heuristics Checks
+
+Use the heuristics inventory from Step 2 and mapped criteria from Step 3 to flag common coverage blind spots:
+
+```javascript
+const endpointCoverageGaps = coverageHeuristics?.endpoints_without_tests || [];
+const authCoverageGaps = coverageHeuristics?.auth_missing_negative_paths || [];
+const errorPathGaps = coverageHeuristics?.criteria_happy_path_only || [];
+
+const heuristicGapCounts = {
+  endpoints_without_tests: endpointCoverageGaps.length,
+  auth_missing_negative_paths: authCoverageGaps.length,
+  happy_path_only_criteria: errorPathGaps.length,
+};
+```
+
+Heuristics are advisory but must influence gap severity and recommendations, especially for P0/P1 criteria.
+
+---
+
+### 3. Generate Recommendations
 
 **Based on gap analysis:**
 
@@ -94,6 +114,30 @@ if (partialCoverage.length > 0) {
   });
 }
 
+if (endpointCoverageGaps.length > 0) {
+  recommendations.push({
+    priority: 'HIGH',
+    action: `Add API tests for ${endpointCoverageGaps.length} uncovered endpoint(s)`,
+    requirements: endpointCoverageGaps.map((r) => r.id || r.endpoint || 'unknown'),
+  });
+}
+
+if (authCoverageGaps.length > 0) {
+  recommendations.push({
+    priority: 'HIGH',
+    action: `Add negative-path auth/authz tests for ${authCoverageGaps.length} requirement(s)`,
+    requirements: authCoverageGaps.map((r) => r.id || 'unknown'),
+  });
+}
+
+if (errorPathGaps.length > 0) {
+  recommendations.push({
+    priority: 'MEDIUM',
+    action: `Add error/edge scenario tests for ${errorPathGaps.length} happy-path-only criterion/criteria`,
+    requirements: errorPathGaps.map((r) => r.id || 'unknown'),
+  });
+}
+
 // Quality issues
 recommendations.push({
   priority: 'LOW',
@@ -104,24 +148,35 @@ recommendations.push({
 
 ---
 
-### 3. Calculate Coverage Statistics
+### 4. 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);
+const safePct = (covered, total) => (total > 0 ? Math.round((covered / total) * 100) : 100);
+const coveragePercentage = safePct(fullyCovered, totalRequirements);
 
 // 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);
+const p1Total = traceabilityMatrix.filter((r) => r.priority === 'P1').length;
+const p1Covered = traceabilityMatrix.filter((r) => r.priority === 'P1' && r.coverage === 'FULL').length;
+const p2Total = traceabilityMatrix.filter((r) => r.priority === 'P2').length;
+const p2Covered = traceabilityMatrix.filter((r) => r.priority === 'P2' && r.coverage === 'FULL').length;
+const p3Total = traceabilityMatrix.filter((r) => r.priority === 'P3').length;
+const p3Covered = traceabilityMatrix.filter((r) => r.priority === 'P3' && r.coverage === 'FULL').length;
+
+const p0CoveragePercentage = safePct(p0Covered, p0Total);
+const p1CoveragePercentage = safePct(p1Covered, p1Total);
+const p2CoveragePercentage = safePct(p2Covered, p2Total);
+const p3CoveragePercentage = safePct(p3Covered, p3Total);
 ```
 
 ---
 
-### 4. Generate Complete Coverage Matrix
+### 5. Generate Complete Coverage Matrix
 
 **Compile all Phase 1 outputs:**
 
@@ -141,15 +196,9 @@ const coverageMatrix = {
 
     priority_breakdown: {
       P0: { total: p0Total, covered: p0Covered, percentage: p0CoveragePercentage },
-      P1: {
-        /* calculate */
-      },
-      P2: {
-        /* calculate */
-      },
-      P3: {
-        /* calculate */
-      },
+      P1: { total: p1Total, covered: p1Covered, percentage: p1CoveragePercentage },
+      P2: { total: p2Total, covered: p2Covered, percentage: p2CoveragePercentage },
+      P3: { total: p3Total, covered: p3Covered, percentage: p3CoveragePercentage },
     },
   },
 
@@ -162,13 +211,20 @@ const coverageMatrix = {
     unit_only_items: unitOnlyCoverage,
   },
 
+  coverage_heuristics: {
+    endpoint_gaps: endpointCoverageGaps,
+    auth_negative_path_gaps: authCoverageGaps,
+    happy_path_only_gaps: errorPathGaps,
+    counts: heuristicGapCounts,
+  },
+
   recommendations: recommendations,
 };
 ```
 
 ---
 
-### 5. Output Coverage Matrix to Temp File
+### 6. Output Coverage Matrix to Temp File
 
 **Write to temp file for Phase 2:**
 
@@ -181,7 +237,7 @@ console.log(`✅ Phase 1 Complete: Coverage matrix saved to ${outputPath}`);
 
 ---
 
-### 6. Display Phase 1 Summary
+### 7. Display Phase 1 Summary
 
 ```
 ✅ Phase 1 Complete: Coverage Matrix Generated
@@ -194,9 +250,9 @@ console.log(`✅ Phase 1 Complete: Coverage matrix saved to ${outputPath}`);
 
 🎯 Priority Coverage:
 - P0: {p0Covered}/{p0Total} ({p0CoveragePercentage}%)
-- P1: {p1Coverage}%
-- P2: {p2Coverage}%
-- P3: {p3Coverage}%
+- P1: {p1Covered}/{p1Total} ({p1CoveragePercentage}%)
+- P2: {p2Covered}/{p2Total} ({p2CoveragePercentage}%)
+- P3: {p3Covered}/{p3Total} ({p3CoveragePercentage}%)
 
 ⚠️ Gaps Identified:
 - Critical (P0): {criticalGaps.length}
@@ -204,6 +260,11 @@ console.log(`✅ Phase 1 Complete: Coverage matrix saved to ${outputPath}`);
 - Medium (P2): {mediumGaps.length}
 - Low (P3): {lowGaps.length}
 
+🔍 Coverage Heuristics:
+- Endpoints without tests: {endpointCoverageGaps.length}
+- Auth negative-path gaps: {authCoverageGaps.length}
+- Happy-path-only criteria: {errorPathGaps.length}
+
 📝 Recommendations: {recommendations.length}
 
 🔄 Phase 2: Gate decision (next step)
@@ -225,7 +286,7 @@ console.log(`✅ Phase 1 Complete: Coverage matrix saved to ${outputPath}`);
 
 ---
 
-### 7. Save Progress
+### 8. Save Progress
 
 **Save this step's accumulated work to `{outputFile}`.**
 

package/src/workflows/testarch/trace/steps-c/step-05-gate-decision.md

@@ -64,6 +64,9 @@ if (coverageMatrix.phase !== 'PHASE_1_COMPLETE') {
 ```javascript
 const stats = coverageMatrix.coverage_statistics;
 const p0Coverage = stats.priority_breakdown.P0.percentage;
+const p1Coverage = stats.priority_breakdown.P1.percentage;
+const hasP1Requirements = (stats.priority_breakdown.P1.total || 0) > 0;
+const effectiveP1Coverage = hasP1Requirements ? p1Coverage : 100;
 const overallCoverage = stats.overall_coverage_percentage;
 const criticalGaps = coverageMatrix.gap_analysis.critical_gaps.length;
 
@@ -75,23 +78,34 @@ if (p0Coverage < 100) {
   gateDecision = 'FAIL';
   rationale = `P0 coverage is ${p0Coverage}% (required: 100%). ${criticalGaps} critical requirements uncovered.`;
 }
-// Rule 2: Overall coverage >= 90% with P0 at 100% → PASS
-else if (overallCoverage >= 90) {
+// Rule 2: Overall coverage must be >= 80%
+else if (overallCoverage < 80) {
+  gateDecision = 'FAIL';
+  rationale = `Overall coverage is ${overallCoverage}% (minimum: 80%). Significant gaps exist.`;
+}
+// Rule 3: P1 coverage < 80% → FAIL
+else if (effectiveP1Coverage < 80) {
+  gateDecision = 'FAIL';
+  rationale = hasP1Requirements
+    ? `P1 coverage is ${effectiveP1Coverage}% (minimum: 80%). High-priority gaps must be addressed.`
+    : `P1 requirements are not present; continuing with remaining gate criteria.`;
+}
+// Rule 4: P1 coverage >= 90% and overall >= 80% with P0 at 100% → PASS
+else if (effectiveP1Coverage >= 90) {
   gateDecision = 'PASS';
-  rationale = `P0 coverage is 100% and overall coverage is ${overallCoverage}% (target: 90%).`;
+  rationale = hasP1Requirements
+    ? `P0 coverage is 100%, P1 coverage is ${effectiveP1Coverage}% (target: 90%), and overall coverage is ${overallCoverage}% (minimum: 80%).`
+    : `P0 coverage is 100% and overall coverage is ${overallCoverage}% (minimum: 80%). No P1 requirements detected.`;
 }
-// Rule 3: Overall coverage >= 75% with P0 at 100% → CONCERNS
-else if (overallCoverage >= 75) {
+// Rule 5: P1 coverage 80-89% with P0 at 100% and overall >= 80% → CONCERNS
+else if (effectiveP1Coverage >= 80) {
   gateDecision = 'CONCERNS';
-  rationale = `P0 coverage is 100% but overall coverage is ${overallCoverage}% (target: 90%). Consider expanding coverage.`;
-}
-// Rule 4: P0 at 100% but overall < 75% → FAIL
-else {
-  gateDecision = 'FAIL';
-  rationale = `Overall coverage is ${overallCoverage}% (minimum: 75%). Significant gaps exist.`;
+  rationale = hasP1Requirements
+    ? `P0 coverage is 100% and overall coverage is ${overallCoverage}% (minimum: 80%), but P1 coverage is ${effectiveP1Coverage}% (target: 90%).`
+    : `P0 coverage is 100% and overall coverage is ${overallCoverage}% (minimum: 80%), but additional non-P1 gaps need mitigation.`;
 }
 
-// Rule 5: Manual waiver option
+// Rule 6: Manual waiver option
 const manualWaiver = false; // Can be set via config or user input
 if (manualWaiver) {
   gateDecision = 'WAIVED';
@@ -116,9 +130,14 @@ const gateReport = {
     p0_coverage_actual: `${p0Coverage}%`,
     p0_status: p0Coverage === 100 ? 'MET' : 'NOT MET',
 
-    overall_coverage_target: '90%',
+    p1_coverage_target_pass: '90%',
+    p1_coverage_minimum: '80%',
+    p1_coverage_actual: `${effectiveP1Coverage}%`,
+    p1_status: effectiveP1Coverage >= 90 ? 'MET' : effectiveP1Coverage >= 80 ? 'PARTIAL' : 'NOT MET',
+
+    overall_coverage_minimum: '80%',
     overall_coverage_actual: `${overallCoverage}%`,
-    overall_status: overallCoverage >= 90 ? 'MET' : overallCoverage >= 75 ? 'PARTIAL' : 'NOT MET',
+    overall_status: overallCoverage >= 80 ? 'MET' : 'NOT MET',
   },
 
   uncovered_requirements: coverageMatrix.gap_analysis.critical_gaps.concat(coverageMatrix.gap_analysis.high_gaps),
@@ -174,7 +193,8 @@ fs.writeFileSync('{outputFile}', reportContent, 'utf8');
 
 📊 Coverage Analysis:
 - P0 Coverage: {p0Coverage}% (Required: 100%) → {p0_status}
-- Overall Coverage: {overallCoverage}% (Target: 90%) → {overall_status}
+- P1 Coverage: {effectiveP1Coverage}% (PASS target: 90%, minimum: 80%) → {p1_status}
+- Overall Coverage: {overallCoverage}% (Minimum: 80%) → {overall_status}
 
 ✅ Decision Rationale:
 {rationale}
@@ -243,4 +263,4 @@ Then append the gate decision summary (from section 5 above) to the end of the e
 - Gate decision logic incorrect
 - Report missing or incomplete
 
-**Master Rule:** Gate decision MUST be deterministic based on clear criteria (P0 100%, overall 90/75%).
+**Master Rule:** Gate decision MUST be deterministic based on clear criteria (P0 100%, P1 90/80, overall >=80).

package/src/workflows/testarch/trace/trace-template.md

@@ -136,6 +136,31 @@ Note: This workflow does not generate tests. If gaps exist, run `*atdd` or `*aut
 
 ---
 
+### Coverage Heuristics Findings
+
+#### Endpoint Coverage Gaps
+
+- Endpoints without direct API tests: {endpoint_gap_count}
+- Examples:
+  - {endpoint_gap_1}
+  - {endpoint_gap_2}
+
+#### Auth/Authz Negative-Path Gaps
+
+- Criteria missing denied/invalid-path tests: {auth_negative_gap_count}
+- Examples:
+  - {auth_gap_1}
+  - {auth_gap_2}
+
+#### Happy-Path-Only Criteria
+
+- Criteria missing error/edge scenarios: {happy_path_only_gap_count}
+- Examples:
+  - {happy_path_gap_1}
+  - {happy_path_gap_2}
+
+---
+
 ### Quality Assessment
 
 #### Tests with Issues

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

@@ -1,111 +0,0 @@
----
-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.**