@paths.design/caws-cli 8.0.0 → 8.1.0

package/dist/commands/quality-gates.js

@@ -212,6 +212,12 @@ async function qualityGatesCommand(options = {}) {
           if (options.fix) {
             npxArgs.push('--fix');
           }
+          // Handle context options: --all-files takes precedence, then --context
+          if (options.allFiles) {
+            npxArgs.push('--context=ci');
+          } else if (options.context && options.context !== 'commit') {
+            npxArgs.push(`--context=${options.context}`);
+          }
 
           Output.progress('Executing quality gates via npx...');
           Output.info(`Command: ${npxArgs.join(' ')}`);
@@ -310,6 +316,13 @@ async function qualityGatesCommand(options = {}) {
         args.push('--fix');
       }
 
+      // Handle context options: --all-files takes precedence, then --context
+      if (options.allFiles) {
+        args.push('--context=ci');
+      } else if (options.context && options.context !== 'commit') {
+        args.push(`--context=${options.context}`);
+      }
+
       // Add CAWS-specific environment variables for integration
       const env = {
         ...process.env,
@@ -326,9 +339,11 @@ async function qualityGatesCommand(options = {}) {
       Output.info(`Command: ${args.join(' ')}`);
 
       // Execute the quality gates runner with timeout
+      // CRITICAL: Must run from projectRoot (user's current directory) so that
+      // git commands resolve correctly to the user's repository, not the CLI installation
       const child = spawn(args[0], args.slice(1), {
         stdio: 'inherit',
-        cwd: packagesDir,
+        cwd: projectRoot,
         env: env,
       });
 
@@ -336,7 +351,47 @@ async function qualityGatesCommand(options = {}) {
       const timeoutMs = options.timeout || (options.ci ? 30 * 60 * 1000 : 10 * 60 * 1000);
 
       const completionPromise = new Promise((resolve, reject) => {
+        let resolved = false;
+
+        // Handle process termination signals
+        const signalHandlers = {
+          SIGINT: () => {
+            if (!resolved && !child.killed && child.pid) {
+              child.kill('SIGINT');
+            }
+          },
+          SIGTERM: () => {
+            if (!resolved && !child.killed && child.pid) {
+              child.kill('SIGTERM');
+            }
+          },
+        };
+
+        process.on('SIGINT', signalHandlers.SIGINT);
+        process.on('SIGTERM', signalHandlers.SIGTERM);
+
+        const cleanup = () => {
+          if (resolved) return;
+          resolved = true;
+
+          // Remove signal handlers
+          try {
+            process.removeListener('SIGINT', signalHandlers.SIGINT);
+            process.removeListener('SIGTERM', signalHandlers.SIGTERM);
+          } catch (e) {
+            // Ignore errors removing listeners
+          }
+
+          // Remove event listeners to prevent memory leaks
+          try {
+            child.removeAllListeners();
+          } catch (e) {
+            // Ignore errors removing listeners
+          }
+        };
+
         child.on('close', (code) => {
+          cleanup();
           if (code === 0) {
             resolve();
           } else {
@@ -345,12 +400,36 @@ async function qualityGatesCommand(options = {}) {
         });
 
         child.on('error', (error) => {
+          cleanup();
           reject(new Error(`Failed to execute quality gates runner: ${error.message}`));
         });
       });
 
-      await withTimeout(completionPromise, timeoutMs, 'Quality gates execution timed out');
-      Output.success('Quality gates completed successfully');
+      try {
+        await withTimeout(completionPromise, timeoutMs, 'Quality gates execution timed out');
+        Output.success('Quality gates completed successfully');
+      } catch (error) {
+        // Ensure child process is killed on timeout or error
+        try {
+          if (!child.killed && child.pid) {
+            child.kill('SIGTERM');
+            // Give it a moment to exit gracefully, then force kill
+            // eslint-disable-next-line no-undef
+            setTimeout(() => {
+              if (!child.killed && child.pid) {
+                try {
+                  child.kill('SIGKILL');
+                } catch (e) {
+                  // Ignore errors killing process
+                }
+              }
+            }, 1000);
+          }
+        } catch (killError) {
+          // Ignore errors killing process
+        }
+        throw error;
+      }
     },
     {
       commandName: 'quality-gates',

package/dist/commands/quality-monitor.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Quality monitor command handler
+ *
+ * @param {string} action - Type of action to monitor
+ * @param {object} options - Command options
+ */
+export function qualityMonitorCommand(action: string, options?: object): Promise<void>;
+/**
+ * Analyze quality impact of an action
+ *
+ * @param {string} action - Type of action (file_saved, code_edited, test_run)
+ * @param {array} files - Files affected by the action
+ * @param {object} context - Additional context information
+ * @returns {object} Quality analysis
+ */
+export function analyzeQualityImpact(action: string, files?: any[], context?: object): object;
+//# sourceMappingURL=quality-monitor.d.ts.map

package/dist/commands/quality-monitor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"quality-monitor.d.ts","sourceRoot":"","sources":["../../src/commands/quality-monitor.js"],"names":[],"mappings":"AAoIA;;;;;GAKG;AACH,8CAHW,MAAM,YACN,MAAM,iBA2HhB;AArPD;;;;;;;GAOG;AACH,6CALW,MAAM,2BAEN,MAAM,GACJ,MAAM,CA8GlB"}

package/dist/commands/specs.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Specs command handler
+ * @param {string} action - Action to perform (list, create, show, update, delete, conflicts, migrate)
+ * @param {Object} options - Command options
+ */
+export function specsCommand(action: string, options?: any): Promise<any>;
+/**
+ * Load specs registry
+ * @returns {Promise<Object>} Registry data
+ */
+export function loadSpecsRegistry(): Promise<any>;
+/**
+ * Save specs registry
+ * @param {Object} registry - Registry data
+ * @returns {Promise<void>}
+ */
+export function saveSpecsRegistry(registry: any): Promise<void>;
+/**
+ * List all spec files in the specs directory
+ * @returns {Promise<Array>} Array of spec file info
+ */
+export function listSpecFiles(): Promise<any[]>;
+/**
+ * Create a new spec file
+ * @param {string} id - Spec identifier
+ * @param {Object} options - Creation options
+ * @returns {Promise<Object>} Created spec info
+ */
+export function createSpec(id: string, options?: any): Promise<any>;
+/**
+ * Load a specific spec file
+ * @param {string} id - Spec identifier
+ * @returns {Promise<Object|null>} Spec data or null
+ */
+export function loadSpec(id: string): Promise<any | null>;
+/**
+ * Update a spec file
+ * @param {string} id - Spec identifier
+ * @param {Object} updates - Updates to apply
+ * @returns {Promise<boolean>} Success status
+ */
+export function updateSpec(id: string, updates?: any): Promise<boolean>;
+/**
+ * Delete a spec file
+ * @param {string} id - Spec identifier
+ * @returns {Promise<boolean>} Success status
+ */
+export function deleteSpec(id: string): Promise<boolean>;
+/**
+ * Display specs in a formatted table
+ * @param {Array} specs - Array of spec objects
+ */
+export function displaySpecsTable(specs: any[]): void;
+/**
+ * Display detailed spec information
+ * @param {Object} spec - Spec object
+ */
+export function displaySpecDetails(spec: any): void;
+/**
+ * Ask user how to resolve spec creation conflicts
+ * @returns {Promise<string>} User's choice: 'cancel', 'rename', 'merge', 'override'
+ */
+export function askConflictResolution(): Promise<string>;
+/**
+ * Specs directory structure
+ */
+export const SPECS_DIR: ".caws/specs";
+export const SPECS_REGISTRY: ".caws/specs/registry.json";
+import { SPEC_TYPES } from "../constants/spec-types";
+export { SPEC_TYPES };
+//# sourceMappingURL=specs.d.ts.map

package/dist/commands/specs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"specs.d.ts","sourceRoot":"","sources":["../../src/commands/specs.js"],"names":[],"mappings":"AAipBA;;;;GAIG;AACH,qCAHW,MAAM,+BA+LhB;AA3zBD;;;GAGG;AACH,qCAFa,OAAO,KAAQ,CAqB3B;AAED;;;;GAIG;AACH,kDAFa,OAAO,CAAC,IAAI,CAAC,CAMzB;AAED;;;GAGG;AACH,iCAFa,OAAO,OAAO,CAmC1B;AAED;;;;;GAKG;AACH,+BAJW,MAAM,kBAEJ,OAAO,KAAQ,CAkO3B;AAED;;;;GAIG;AACH,6BAHW,MAAM,GACJ,OAAO,CAAC,MAAO,IAAI,CAAC,CAiBhC;AAED;;;;;GAKG;AACH,+BAJW,MAAM,kBAEJ,OAAO,CAAC,OAAO,CAAC,CA6B5B;AAED;;;;GAIG;AACH,+BAHW,MAAM,GACJ,OAAO,CAAC,OAAO,CAAC,CAmB5B;AAED;;;GAGG;AACH,sDA2CC;AAED;;;GAGG;AACH,oDAoCC;AAoHD;;;GAGG;AACH,yCAFa,OAAO,CAAC,MAAM,CAAC,CAqC3B;AA9nBD;;GAEG;AACH,wBAAkB,aAAa,CAAC;AAChC,6BAAuB,2BAA2B,CAAC"}

package/dist/commands/specs.js

@@ -164,9 +164,9 @@ async function createSpec(id, options = {}) {
         console.log(chalk.blue(`📝 Creating spec with new name: ${newId}`));
         return await createSpec(newId, { ...options, interactive: false });
       } else if (answer === 'merge') {
-        console.log(chalk.yellow('🔄 Merge functionality not yet implemented.'));
-        console.log(chalk.blue('💡 For now, consider creating with a different name.'));
-        return null;
+        // Merge new spec data with existing spec
+        console.log(chalk.blue('🔄 Merging with existing spec...'));
+        return await mergeSpec(id, options);
       } else if (answer === 'override') {
         console.log(chalk.yellow('⚠️  Overriding existing spec...'));
       }
@@ -385,6 +385,133 @@ async function updateSpec(id, updates = {}) {
   return true;
 }
 
+/**
+ * Merge new spec data with an existing spec
+ * Combines acceptance criteria, updates metadata, preserves history
+ * @param {string} id - Spec identifier
+ * @param {Object} options - Options including new spec data to merge
+ * @returns {Promise<Object>} Merged spec
+ */
+async function mergeSpec(id, options = {}) {
+  const existingSpec = await loadSpec(id);
+  if (!existingSpec) {
+    throw new Error(`Spec '${id}' not found`);
+  }
+
+  console.log(chalk.blue(`\n📋 Merging into existing spec: ${id}`));
+  console.log(chalk.gray('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n'));
+
+  // Show existing spec summary
+  console.log(chalk.gray(`Existing spec:`));
+  console.log(chalk.gray(`   Title: ${existingSpec.title}`));
+  console.log(chalk.gray(`   Status: ${existingSpec.status}`));
+  console.log(
+    chalk.gray(`   Acceptance Criteria: ${existingSpec.acceptance_criteria?.length || 0}`)
+  );
+  console.log('');
+
+  // Prepare merge data from options
+  const {
+    title: newTitle,
+    description: newDescription,
+    acceptance_criteria: newCriteria,
+    mode: newMode,
+    risk_tier: newRiskTier,
+  } = options;
+
+  const mergedSpec = { ...existingSpec };
+
+  // Track what was merged
+  const mergeLog = [];
+
+  // Merge title (prefer new if provided)
+  if (newTitle && newTitle !== existingSpec.title) {
+    mergedSpec.title = newTitle;
+    mergeLog.push(`Title updated: "${existingSpec.title}" → "${newTitle}"`);
+  }
+
+  // Merge description
+  if (newDescription) {
+    if (existingSpec.description) {
+      mergedSpec.description = `${existingSpec.description}\n\n---\n\n${newDescription}`;
+      mergeLog.push('Description appended');
+    } else {
+      mergedSpec.description = newDescription;
+      mergeLog.push('Description added');
+    }
+  }
+
+  // Merge acceptance criteria (append new ones, avoid duplicates)
+  if (newCriteria && Array.isArray(newCriteria) && newCriteria.length > 0) {
+    const existingCriteria = existingSpec.acceptance_criteria || [];
+    const existingIds = new Set(existingCriteria.map((c) => c.id));
+
+    const criteriaToAdd = newCriteria.filter((c) => !existingIds.has(c.id));
+    if (criteriaToAdd.length > 0) {
+      mergedSpec.acceptance_criteria = [...existingCriteria, ...criteriaToAdd];
+      mergeLog.push(`Added ${criteriaToAdd.length} new acceptance criteria`);
+    }
+
+    // Also update the 'acceptance' array if it exists
+    if (existingSpec.acceptance) {
+      const existingAcceptIds = new Set(existingSpec.acceptance.map((a) => a.id));
+      const acceptToAdd = newCriteria.filter((c) => !existingAcceptIds.has(c.id));
+      if (acceptToAdd.length > 0) {
+        mergedSpec.acceptance = [...existingSpec.acceptance, ...acceptToAdd];
+      }
+    }
+  }
+
+  // Merge mode (prefer higher tier if both provided)
+  if (newMode && newMode !== existingSpec.mode) {
+    // Mode priority: crisis > standard > minimal
+    const modePriority = { minimal: 1, standard: 2, crisis: 3 };
+    if ((modePriority[newMode] || 0) > (modePriority[existingSpec.mode] || 0)) {
+      mergedSpec.mode = newMode;
+      mergeLog.push(`Mode upgraded: ${existingSpec.mode} → ${newMode}`);
+    }
+  }
+
+  // Merge risk tier (prefer higher risk if both provided)
+  if (newRiskTier && newRiskTier !== existingSpec.risk_tier) {
+    // Risk priority: T1 > T2 > T3
+    const riskPriority = { T3: 1, T2: 2, T1: 3, 3: 1, 2: 2, 1: 3 };
+    if ((riskPriority[newRiskTier] || 0) > (riskPriority[existingSpec.risk_tier] || 0)) {
+      mergedSpec.risk_tier = newRiskTier;
+      mergeLog.push(`Risk tier updated: ${existingSpec.risk_tier} → ${newRiskTier}`);
+    }
+  }
+
+  // Update metadata
+  mergedSpec.updated_at = new Date().toISOString();
+
+  // Add merge history entry
+  if (!mergedSpec.history) {
+    mergedSpec.history = [];
+  }
+  mergedSpec.history.push({
+    action: 'merge',
+    timestamp: new Date().toISOString(),
+    changes: mergeLog,
+  });
+
+  // Save merged spec
+  await updateSpec(id, mergedSpec);
+
+  // Display merge results
+  console.log(chalk.green('✅ Merge completed:'));
+  if (mergeLog.length > 0) {
+    mergeLog.forEach((change) => {
+      console.log(chalk.gray(`   • ${change}`));
+    });
+  } else {
+    console.log(chalk.gray('   • No changes needed (specs were identical)'));
+  }
+  console.log('');
+
+  return mergedSpec;
+}
+
 /**
  * Delete a spec file
  * @param {string} id - Spec identifier
@@ -544,9 +671,12 @@ async function migrateFromLegacy(options = {}, createSpecFn = createSpec) {
   let selectedFeatures = features;
 
   if (options.interactive) {
-    // For now, just use all suggested features
-    // In a full implementation, this would prompt for selection
-    console.log(chalk.blue('\n📋 Using all suggested features for migration'));
+    selectedFeatures = await selectFeaturesInteractively(features);
+    if (selectedFeatures.length === 0) {
+      console.log(chalk.yellow('⚠️  No features selected. Migration cancelled.'));
+      return { migrated: 0, total: features.length, createdSpecs: [], legacySpec: legacySpec.id };
+    }
+    console.log(chalk.blue(`\n📋 Migrating ${selectedFeatures.length} selected features`));
   }
 
   if (options.features && options.features.length > 0) {
@@ -614,6 +744,54 @@ async function migrateFromLegacy(options = {}, createSpecFn = createSpec) {
   };
 }
 
+/**
+ * Interactive feature selection for migration
+ * @param {Array} features - Array of suggested features
+ * @returns {Promise<Array>} Selected features
+ */
+async function selectFeaturesInteractively(features) {
+  const readline = require('readline');
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+
+  console.log(chalk.cyan('\n📋 Select features to migrate:\n'));
+  features.forEach((f, i) => {
+    const scope = f.scope?.in?.join(', ') || 'N/A';
+    console.log(`  ${chalk.yellow(i + 1)}. ${chalk.bold(f.id || f.name)} - ${f.title || f.description}`);
+    console.log(chalk.gray(`     Scope: ${scope}`));
+  });
+  console.log(chalk.cyan(`\nEnter numbers separated by commas, or 'all' for all features:`));
+  console.log(chalk.gray(`Example: 1,3,5 or all`));
+
+  try {
+    const answer = await question(rl, '> ');
+    const trimmed = answer.trim().toLowerCase();
+
+    if (trimmed === 'all' || trimmed === '*') {
+      return features;
+    }
+
+    if (trimmed === '' || trimmed === 'none' || trimmed === 'q' || trimmed === 'quit') {
+      return [];
+    }
+
+    // Parse comma-separated numbers
+    const indices = trimmed
+      .split(',')
+      .map(n => parseInt(n.trim(), 10) - 1)
+      .filter(i => !isNaN(i) && i >= 0 && i < features.length);
+
+    // Remove duplicates and sort
+    const uniqueIndices = [...new Set(indices)].sort((a, b) => a - b);
+
+    return features.filter((_, i) => uniqueIndices.includes(i));
+  } finally {
+    await closeReadline(rl);
+  }
+}
+
 /**
  * Ask user how to resolve spec creation conflicts
  * @returns {Promise<string>} User's choice: 'cancel', 'rename', 'merge', 'override'

package/dist/commands/status.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Status command handler
+ * @param {Object} options - Command options
+ */
+export function statusCommand(options?: any): Promise<any>;
+/**
+ * Load working specification (legacy single file approach)
+ * @param {string} specPath - Path to working spec
+ * @returns {Promise<Object|null>} Parsed spec or null
+ */
+export function loadWorkingSpec(specPath?: string): Promise<any | null>;
+/**
+ * Check Git hooks status
+ * @returns {Promise<Object>} Hooks status
+ */
+export function checkGitHooks(): Promise<any>;
+/**
+ * Load provenance chain
+ * @returns {Promise<Object>} Provenance status
+ */
+export function loadProvenanceChain(): Promise<any>;
+/**
+ * Load waiver status
+ * @returns {Promise<Object>} Waiver status
+ */
+export function loadWaiverStatus(): Promise<any>;
+/**
+ * Check quality gates status (simplified)
+ * @returns {Promise<Object>} Quality gates status
+ */
+export function checkQualityGates(): Promise<any>;
+/**
+ * Display project status
+ * @param {Object} data - Status data
+ */
+export function displayStatus(data: any): void;
+/**
+ * Generate actionable suggestions based on status and mode
+ * @param {Object} data - Status data
+ * @param {string} currentMode - Current CAWS mode
+ * @returns {string[]} Array of suggestions
+ */
+export function generateSuggestions(data: any, currentMode: string): string[];
+//# sourceMappingURL=status.d.ts.map

package/dist/commands/status.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"status.d.ts","sourceRoot":"","sources":["../../src/commands/status.js"],"names":[],"mappings":"AA02BA;;;GAGG;AACH,2DA+IC;AA/+BD;;;;GAIG;AACH,2CAHW,MAAM,GACJ,OAAO,CAAC,MAAO,IAAI,CAAC,CAahC;AAgBD;;;GAGG;AACH,iCAFa,OAAO,KAAQ,CAgC3B;AAED;;;GAGG;AACH,uCAFa,OAAO,KAAQ,CA+B3B;AAED;;;GAGG;AACH,oCAFa,OAAO,KAAQ,CA0D3B;AAED;;;GAGG;AACH,qCAFa,OAAO,KAAQ,CAO3B;AA8HD;;;GAGG;AACH,+CAgGC;AAED;;;;;GAKG;AACH,4DAHW,MAAM,GACJ,MAAM,EAAE,CAoCpB"}

package/dist/commands/status.js

@@ -8,6 +8,7 @@ const fs = require('fs-extra');
 const path = require('path');
 const yaml = require('js-yaml');
 const chalk = require('chalk');
+// child_process removed - execSync no longer used directly
 const { safeAsync, outputResult } = require('../error-handler');
 const { parallel } = require('../utils/async-utils');
 
@@ -181,14 +182,114 @@ async function loadWaiverStatus() {
  * @returns {Promise<Object>} Quality gates status
  */
 async function checkQualityGates() {
-  // For now, return a placeholder
-  // Quality gates are available via CLI or MCP
   return {
     checked: false,
     message: 'Run: caws quality-gates or use MCP tool caws_quality_gates_run for full gate status',
   };
 }
 
+/**
+ * Get test coverage from coverage reports
+ * Looks for common coverage report locations and formats
+ * @returns {Promise<Object>} Coverage data with percentage and details
+ */
+async function getTestCoverage() {
+  const coverageLocations = [
+    // Jest/Istanbul coverage
+    { path: 'coverage/coverage-summary.json', type: 'istanbul' },
+    { path: 'coverage/lcov-report/index.html', type: 'lcov-html' },
+    { path: 'coverage/coverage-final.json', type: 'istanbul-final' },
+    // NYC coverage
+    { path: '.nyc_output/coverage-summary.json', type: 'nyc' },
+    // C8 coverage
+    { path: 'coverage/c8/coverage-summary.json', type: 'c8' },
+  ];
+
+  try {
+    for (const loc of coverageLocations) {
+      const coveragePath = path.join(process.cwd(), loc.path);
+      if (await fs.pathExists(coveragePath)) {
+        if (loc.type === 'istanbul' || loc.type === 'nyc' || loc.type === 'c8') {
+          const content = await fs.readFile(coveragePath, 'utf8');
+          const data = JSON.parse(content);
+
+          // Istanbul/NYC format has a "total" key with coverage percentages
+          if (data.total) {
+            const lines = data.total.lines?.pct || 0;
+            const statements = data.total.statements?.pct || 0;
+            const branches = data.total.branches?.pct || 0;
+            const functions = data.total.functions?.pct || 0;
+
+            return {
+              available: true,
+              percentage: Math.round((lines + statements + branches + functions) / 4),
+              lines: Math.round(lines),
+              statements: Math.round(statements),
+              branches: Math.round(branches),
+              functions: Math.round(functions),
+              source: loc.path,
+            };
+          }
+        } else if (loc.type === 'istanbul-final') {
+          // coverage-final.json has per-file data, need to aggregate
+          const content = await fs.readFile(coveragePath, 'utf8');
+          const data = JSON.parse(content);
+
+          let totalStatements = 0;
+          let coveredStatements = 0;
+
+          for (const file of Object.values(data)) {
+            const s = file.s || {};
+            for (const count of Object.values(s)) {
+              totalStatements++;
+              if (count > 0) coveredStatements++;
+            }
+          }
+
+          if (totalStatements > 0) {
+            const percentage = Math.round((coveredStatements / totalStatements) * 100);
+            return {
+              available: true,
+              percentage,
+              source: loc.path,
+            };
+          }
+        }
+      }
+    }
+
+    // Try running test coverage command if no reports found
+    try {
+      // Check if package.json has a coverage script
+      const pkgPath = path.join(process.cwd(), 'package.json');
+      if (await fs.pathExists(pkgPath)) {
+        const pkg = JSON.parse(await fs.readFile(pkgPath, 'utf8'));
+        if (pkg.scripts && (pkg.scripts.coverage || pkg.scripts['test:coverage'])) {
+          return {
+            available: false,
+            percentage: null,
+            message: 'Run npm run coverage to generate coverage report',
+          };
+        }
+      }
+    } catch {
+      // Ignore package.json errors
+    }
+
+    return {
+      available: false,
+      percentage: null,
+      message: 'No coverage report found',
+    };
+  } catch (error) {
+    return {
+      available: false,
+      percentage: null,
+      message: `Error reading coverage: ${error.message}`,
+    };
+  }
+}
+
 /**
  * Get time since last update
  * @param {string} timestamp - ISO timestamp
@@ -388,7 +489,7 @@ function getProgressColor(percentage) {
  * @param {Object} data - Status data
  * @param {string} currentMode - Current CAWS mode
  */
-function displayVisualStatus(data, currentMode) {
+async function displayVisualStatus(data, currentMode) {
   const { spec, specs, hooks, provenance, waivers, gates } = data;
   const modes = require('../config/modes');
   const tierConfig = modes.getTier(currentMode);
@@ -497,12 +598,35 @@ function displayVisualStatus(data, currentMode) {
       );
     }
 
-    // Test Coverage (placeholder for now)
-    console.log(
-      chalk.gray(
-        `   Test Coverage: ${chalk.blue('Calculating...')} ${createProgressBar(0, 100)} 0%`
-      )
-    );
+    // Test Coverage
+    const coverage = await getTestCoverage();
+    if (coverage.available && coverage.percentage !== null) {
+      const coverageColor =
+        coverage.percentage >= 80
+          ? chalk.green
+          : coverage.percentage >= 50
+            ? chalk.yellow
+            : chalk.red;
+      const coverageBar = createProgressBar(coverage.percentage, 100);
+      console.log(
+        chalk.gray(
+          `   Test Coverage: ${coverageColor(`${coverage.percentage}%`)} ${coverageBar}`
+        )
+      );
+      if (coverage.lines !== undefined) {
+        console.log(
+          chalk.gray(
+            `                  Lines: ${coverage.lines}% | Branches: ${coverage.branches}% | Functions: ${coverage.functions}%`
+          )
+        );
+      }
+    } else {
+      console.log(
+        chalk.gray(
+          `   Test Coverage: ${chalk.yellow('N/A')} ${createProgressBar(0, 100)} ${chalk.gray(coverage.message || 'No report')}`
+        )
+      );
+    }
 
     // Risk Tier Indicator
     const riskColor =
@@ -839,7 +963,7 @@ async function statusCommand(options = {}) {
           console.log(JSON.stringify(result, null, 2));
         } else {
           // Visual output
-          displayVisualStatus(
+          await displayVisualStatus(
             {
               spec,
               specs,