@paths.design/caws-cli 9.2.0 → 9.3.1

package/dist/commands/specs.js

@@ -14,10 +14,19 @@ const { SPEC_TYPES } = require('../constants/spec-types');
 
 // Import suggestFeatureBreakdown from spec-resolver
 const { suggestFeatureBreakdown } = require('../utils/spec-resolver');
+const { findProjectRoot } = require('../utils/detection');
 
 /**
- * Specs directory structure
+ * Specs directory structure — anchored to the CAWS project root,
+ * not process.cwd(), so the CLI works from subdirectories and monorepos.
  */
+function getSpecsDir() {
+  return path.join(findProjectRoot(), '.caws', 'specs');
+}
+function getSpecsRegistry() {
+  return path.join(findProjectRoot(), '.caws', 'specs', 'registry.json');
+}
+// Legacy constants kept for backward compatibility in tests
 const SPECS_DIR = '.caws/specs';
 const SPECS_REGISTRY = '.caws/specs/registry.json';
 
@@ -27,7 +36,8 @@ const SPECS_REGISTRY = '.caws/specs/registry.json';
  */
 async function loadSpecsRegistry() {
   try {
-    if (!(await fs.pathExists(SPECS_REGISTRY))) {
+    const registryPath = getSpecsRegistry();
+    if (!(await fs.pathExists(registryPath))) {
       return {
         version: '1.0.0',
         specs: {},
@@ -35,7 +45,7 @@ async function loadSpecsRegistry() {
       };
     }
 
-    const registry = JSON.parse(await fs.readFile(SPECS_REGISTRY, 'utf8'));
+    const registry = JSON.parse(await fs.readFile(registryPath, 'utf8'));
     return registry;
   } catch (error) {
     return {
@@ -52,9 +62,10 @@ async function loadSpecsRegistry() {
  * @returns {Promise<void>}
  */
 async function saveSpecsRegistry(registry) {
-  await fs.ensureDir(path.dirname(SPECS_REGISTRY));
+  const registryPath = getSpecsRegistry();
+  await fs.ensureDir(path.dirname(registryPath));
   registry.lastUpdated = new Date().toISOString();
-  await fs.writeFile(SPECS_REGISTRY, JSON.stringify(registry, null, 2));
+  await fs.writeFile(registryPath, JSON.stringify(registry, null, 2));
 }
 
 /**
@@ -62,16 +73,17 @@ async function saveSpecsRegistry(registry) {
  * @returns {Promise<Array>} Array of spec file info
  */
 async function listSpecFiles() {
-  if (!(await fs.pathExists(SPECS_DIR))) {
+  const specsDir = getSpecsDir();
+  if (!(await fs.pathExists(specsDir))) {
     return [];
   }
 
-  const files = await fs.readdir(SPECS_DIR, { recursive: true });
+  const files = await fs.readdir(specsDir, { recursive: true });
   const yamlFiles = files.filter((file) => file.endsWith('.yaml') || file.endsWith('.yml'));
 
   const specs = [];
   for (const file of yamlFiles) {
-    const filePath = path.join(SPECS_DIR, file);
+    const filePath = path.join(specsDir, file);
     try {
       const content = await fs.readFile(filePath, 'utf8');
       const spec = yaml.load(content);
@@ -121,7 +133,8 @@ async function createSpec(id, options = {}) {
   }
 
   // Check for existing spec
-  const existingSpecPath = path.join(SPECS_DIR, `${id}.yaml`);
+  const specsDir = getSpecsDir();
+  const existingSpecPath = path.join(specsDir, `${id}.yaml`);
   const specExists = await fs.pathExists(existingSpecPath);
 
   // Handle conflict resolution
@@ -185,7 +198,7 @@ async function createSpec(id, options = {}) {
   }
 
   // Ensure specs directory exists
-  await fs.ensureDir(SPECS_DIR);
+  await fs.ensureDir(specsDir);
 
   // Generate spec content with all required fields
   // Merge template carefully to preserve required fields and structure
@@ -260,7 +273,7 @@ async function createSpec(id, options = {}) {
 
   // Create file path
   const fileName = `${id}.yaml`;
-  const filePath = path.join(SPECS_DIR, fileName);
+  const filePath = path.join(specsDir, fileName);
 
   // Write spec file
   const yamlContent = yaml.dump(specContent, { indent: 2 });
@@ -340,7 +353,7 @@ async function loadSpec(id) {
     return null;
   }
 
-  const specPath = path.join(SPECS_DIR, registry.specs[id].path);
+  const specPath = path.join(getSpecsDir(), registry.specs[id].path);
 
   try {
     const content = await fs.readFile(specPath, 'utf8');
@@ -389,7 +402,7 @@ async function updateSpec(id, updates = {}) {
   await saveSpecsRegistry(registry);
 
   // Write back to file
-  const specPath = path.join(SPECS_DIR, registry.specs[id].path);
+  const specPath = path.join(getSpecsDir(), registry.specs[id].path);
   await fs.writeFile(specPath, yaml.dump(updatedSpec, { indent: 2 }));
 
   return true;
@@ -534,7 +547,7 @@ async function deleteSpec(id) {
     return false;
   }
 
-  const specPath = path.join(SPECS_DIR, registry.specs[id].path);
+  const specPath = path.join(getSpecsDir(), registry.specs[id].path);
 
   // Remove file
   await fs.remove(specPath);
@@ -673,7 +686,7 @@ async function migrateFromLegacy(options = {}, createSpecFn = createSpec) {
   const yaml = require('js-yaml');
   const chalk = require('chalk');
 
-  const legacyPath = path.join(process.cwd(), '.caws', 'working-spec.yaml');
+  const legacyPath = path.join(findProjectRoot(), '.caws', 'working-spec.yaml');
 
   if (!(await fs.pathExists(legacyPath))) {
     throw new Error('No legacy working-spec.yaml found to migrate');

package/dist/commands/status.js

@@ -184,7 +184,7 @@ async function loadWaiverStatus() {
 async function checkQualityGates() {
   return {
     checked: false,
-    message: 'Run: caws quality-gates or use MCP tool caws_quality_gates_run for full gate status',
+    message: 'Run: caws quality-gates for full gate status',
   };
 }
 

package/dist/commands/verify-acs.js

@@ -0,0 +1,471 @@
+/**
+ * @fileoverview Verify Acceptance Criteria Command
+ * Mechanically verifies that ACs in CAWS specs are backed by real test evidence.
+ * Language-agnostic: detects test runner from project structure.
+ * @author @darianrosebrook
+ */
+
+const fs = require('fs-extra');
+const path = require('path');
+const yaml = require('js-yaml');
+const chalk = require('chalk');
+const { execFileSync } = require('child_process');
+const { findProjectRoot } = require('../utils/detection');
+
+const SPECS_DIR = '.caws/specs';
+const TERMINAL_STATUSES = new Set(['completed', 'closed', 'archived']);
+
+/**
+ * Detect the project's test runner from config files.
+ * Returns a runner ID used to determine collect/run commands.
+ * @param {string} projectRoot
+ * @returns {'pytest'|'jest'|'vitest'|'cargo'|'go'|'unknown'}
+ */
+function detectTestRunner(projectRoot) {
+  const checks = [
+    { files: ['pytest.ini', 'conftest.py', 'setup.cfg'], content: [['pyproject.toml', '[tool.pytest']], runner: 'pytest' },
+    { files: ['vitest.config.ts', 'vitest.config.js', 'vitest.config.mts'], runner: 'vitest' },
+    { files: ['jest.config.js', 'jest.config.ts', 'jest.config.mjs', 'jest.config.cjs'], content: [['package.json', '"jest"']], runner: 'jest' },
+    { files: ['Cargo.toml'], runner: 'cargo' },
+    { files: ['go.mod'], runner: 'go' },
+  ];
+
+  for (const check of checks) {
+    for (const f of (check.files || [])) {
+      if (fs.existsSync(path.join(projectRoot, f))) return check.runner;
+    }
+    for (const [f, needle] of (check.content || [])) {
+      const fp = path.join(projectRoot, f);
+      if (fs.existsSync(fp)) {
+        try {
+          if (fs.readFileSync(fp, 'utf8').includes(needle)) return check.runner;
+        } catch (_) { /* ignore unreadable config */ }
+      }
+    }
+  }
+  return 'unknown';
+}
+
+/**
+ * Collect (verify existence of) a test nodeid.
+ * @param {string} nodeid
+ * @param {string} runner
+ * @param {string} projectRoot
+ * @returns {{found: boolean, detail: string}}
+ */
+function collectNodeid(nodeid, runner, projectRoot) {
+  try {
+    switch (runner) {
+      case 'pytest': {
+        const out = execFileSync('python3', ['-m', 'pytest', '--collect-only', '-q', nodeid], {
+          cwd: projectRoot, encoding: 'utf8', timeout: 30000, stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        const lines = out.trim().split('\n').filter(l => l && !l.startsWith('='));
+        return { found: lines.length > 0, detail: `${lines.length} test(s) collected` };
+      }
+      case 'jest':
+      case 'vitest': {
+        // For jest/vitest, split nodeid into file path and optional test name
+        const parts = nodeid.split('::');
+        const testFile = parts[0];
+        if (!fs.existsSync(path.join(projectRoot, testFile))) {
+          return { found: false, detail: `test file not found: ${testFile}` };
+        }
+        if (parts.length > 1) {
+          const content = fs.readFileSync(path.join(projectRoot, testFile), 'utf8');
+          const testName = parts[parts.length - 1];
+          if (!content.includes(testName)) {
+            return { found: false, detail: `test name '${testName}' not found in ${testFile}` };
+          }
+        }
+        return { found: true, detail: `test file exists: ${testFile}` };
+      }
+      case 'cargo': {
+        execFileSync('cargo', ['test', nodeid, '--no-run'], {
+          cwd: projectRoot, encoding: 'utf8', timeout: 60000, stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        return { found: true, detail: 'compiled successfully' };
+      }
+      case 'go': {
+        const parts = nodeid.split('::');
+        const pkg = parts[0] || './...';
+        const testName = parts[1] || '';
+        const args = ['test', '-list', testName || '.*', pkg];
+        const out = execFileSync('go', args, {
+          cwd: projectRoot, encoding: 'utf8', timeout: 30000, stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        const found = testName ? out.includes(testName) : out.trim().length > 0;
+        return { found, detail: found ? 'test found' : 'test not found' };
+      }
+      default: {
+        // Unknown runner — check if the file exists
+        const testFile = nodeid.split('::')[0];
+        if (fs.existsSync(path.join(projectRoot, testFile))) {
+          return { found: true, detail: 'test file exists (runner unknown, cannot collect)' };
+        }
+        return { found: false, detail: `test file not found: ${testFile}` };
+      }
+    }
+  } catch (err) {
+    const msg = err.stderr ? err.stderr.toString().split('\n')[0] : err.message;
+    return { found: false, detail: msg.slice(0, 120) };
+  }
+}
+
+/**
+ * Run a test nodeid and check if it passes.
+ * @param {string} nodeid
+ * @param {string} runner
+ * @param {string} projectRoot
+ * @returns {{passed: boolean, detail: string}}
+ */
+function runNodeid(nodeid, runner, projectRoot) {
+  try {
+    switch (runner) {
+      case 'pytest': {
+        execFileSync('python3', ['-m', 'pytest', '-x', '--tb=short', nodeid], {
+          cwd: projectRoot, encoding: 'utf8', timeout: 120000, stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        return { passed: true, detail: 'tests passed' };
+      }
+      case 'jest': {
+        const parts = nodeid.split('::');
+        const args = ['jest', '--testPathPattern', parts[0]];
+        if (parts.length > 1) args.push('--testNamePattern', parts[parts.length - 1]);
+        execFileSync('npx', args, {
+          cwd: projectRoot, encoding: 'utf8', timeout: 120000, stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        return { passed: true, detail: 'tests passed' };
+      }
+      case 'vitest': {
+        const parts = nodeid.split('::');
+        const args = ['vitest', 'run', parts[0]];
+        if (parts.length > 1) args.push('--testNamePattern', parts[parts.length - 1]);
+        execFileSync('npx', args, {
+          cwd: projectRoot, encoding: 'utf8', timeout: 120000, stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        return { passed: true, detail: 'tests passed' };
+      }
+      case 'cargo': {
+        execFileSync('cargo', ['test', nodeid], {
+          cwd: projectRoot, encoding: 'utf8', timeout: 120000, stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        return { passed: true, detail: 'tests passed' };
+      }
+      case 'go': {
+        const parts = nodeid.split('::');
+        const pkg = parts[0] || './...';
+        const testName = parts[1] || '.*';
+        execFileSync('go', ['test', '-run', testName, '-v', pkg], {
+          cwd: projectRoot, encoding: 'utf8', timeout: 120000, stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        return { passed: true, detail: 'tests passed' };
+      }
+      default:
+        return { passed: false, detail: 'unknown test runner — cannot execute' };
+    }
+  } catch (err) {
+    const msg = err.stderr ? err.stderr.toString().split('\n').slice(-3).join(' ') : err.message;
+    return { passed: false, detail: msg.slice(0, 200) };
+  }
+}
+
+/**
+ * Run a test_command and check exit code.
+ * @param {string} command
+ * @param {string} projectRoot
+ * @returns {{passed: boolean, detail: string}}
+ */
+function runTestCommand(command, projectRoot) {
+  try {
+    execFileSync('sh', ['-c', command], {
+      cwd: projectRoot, encoding: 'utf8', timeout: 120000, stdio: ['pipe', 'pipe', 'pipe'],
+    });
+    return { passed: true, detail: 'exit code 0' };
+  } catch (err) {
+    const msg = err.stderr ? err.stderr.toString().split('\n').slice(-2).join(' ') : err.message;
+    return { passed: false, detail: `exit code ${err.status || 'unknown'}: ${msg.slice(0, 150)}` };
+  }
+}
+
+/**
+ * Check if an evidence artifact exists.
+ * @param {string} evidence
+ * @param {string} projectRoot
+ * @returns {{found: boolean, detail: string}}
+ */
+function checkEvidence(evidence, projectRoot) {
+  // If it looks like a file path, check directly
+  if (evidence.includes('/') || evidence.includes('.')) {
+    const fp = path.join(projectRoot, evidence);
+    if (fs.existsSync(fp)) {
+      return { found: true, detail: `artifact found: ${evidence}` };
+    }
+  }
+
+  // Search for the evidence ID in common test output directories
+  const searchDirs = ['test-results', 'test-scenarios', 'coverage', '.caws/evidence'];
+  for (const dir of searchDirs) {
+    const dp = path.join(projectRoot, dir);
+    if (fs.existsSync(dp)) {
+      try {
+        const files = execFileSync('find', [dp, '-name', `*${evidence}*`, '-type', 'f'], {
+          encoding: 'utf8', timeout: 5000, stdio: ['pipe', 'pipe', 'pipe'],
+        }).trim();
+        if (files) {
+          return { found: true, detail: `found: ${files.split('\n')[0]}` };
+        }
+      } catch (_) { /* ignore unreadable config */ }
+    }
+  }
+
+  return { found: false, detail: `artifact not found for: ${evidence}` };
+}
+
+/**
+ * Extract and merge acceptance criteria from a spec.
+ * Handles both `acceptance` and `acceptance_criteria` fields.
+ * @param {Object} spec
+ * @returns {Array<{id: string, description: string, test_nodeids?: string[], test_command?: string, evidence?: string, narrative?: string}>}
+ */
+function extractACs(spec) {
+  const byId = new Map();
+
+  // Load from `acceptance` field (given/when/then format)
+  for (const ac of (spec.acceptance || [])) {
+    if (!ac.id) continue;
+    const entry = {
+      id: ac.id,
+      description: ac.then || ac.description || '',
+      test_nodeids: ac.test_nodeids || null,
+      test_command: ac.test_command || null,
+      evidence: ac.evidence || null,
+      narrative: ac.test || (ac.given ? `Given ${ac.given}, when ${ac.when}, then ${ac.then}` : null),
+    };
+    byId.set(ac.id, entry);
+  }
+
+  // Load from `acceptance_criteria` field (id/description format) — overrides mechanical fields
+  for (const ac of (spec.acceptance_criteria || [])) {
+    if (!ac.id) continue;
+    const existing = byId.get(ac.id) || { id: ac.id };
+    existing.description = ac.description || existing.description || '';
+    if (ac.test_nodeids) existing.test_nodeids = ac.test_nodeids;
+    if (ac.test_command) existing.test_command = ac.test_command;
+    if (ac.evidence) existing.evidence = ac.evidence;
+    if (ac.test) existing.narrative = ac.test;
+    byId.set(ac.id, existing);
+  }
+
+  return Array.from(byId.values());
+}
+
+/**
+ * Verify all ACs in a spec.
+ * @param {Object} spec
+ * @param {string} projectRoot
+ * @param {Object} options
+ * @param {boolean} options.run - Actually run tests (vs collect-only)
+ * @param {string} options.runner - Test runner override
+ * @returns {{specId: string, title: string, results: Array}}
+ */
+function verifySpec(spec, projectRoot, options = {}) {
+  const runner = options.runner || detectTestRunner(projectRoot);
+  const acs = extractACs(spec);
+  const results = [];
+
+  for (const ac of acs) {
+    const result = { id: ac.id, description: ac.description, method: null, status: null, detail: '' };
+
+    if (ac.test_command) {
+      result.method = 'test_command';
+      const { passed, detail } = runTestCommand(ac.test_command, projectRoot);
+      result.status = passed ? 'PASS' : 'FAIL';
+      result.detail = detail;
+    } else if (ac.test_nodeids && ac.test_nodeids.length > 0) {
+      result.method = 'test_nodeids';
+      const nodeResults = [];
+      for (const nodeid of ac.test_nodeids) {
+        if (options.run) {
+          nodeResults.push(runNodeid(nodeid, runner, projectRoot));
+        } else {
+          const { found, detail } = collectNodeid(nodeid, runner, projectRoot);
+          nodeResults.push({ passed: found, detail });
+        }
+      }
+      const allOk = nodeResults.every(r => r.passed);
+      result.status = allOk ? 'PASS' : 'FAIL';
+      result.detail = nodeResults.map(r => r.detail).join('; ');
+    } else if (ac.evidence) {
+      result.method = 'evidence';
+      const { found, detail } = checkEvidence(ac.evidence, projectRoot);
+      result.status = found ? 'PASS' : 'FAIL';
+      result.detail = detail;
+    } else {
+      result.method = 'narrative';
+      result.status = 'unchecked';
+      result.detail = ac.narrative || 'no mechanical verification available';
+    }
+
+    results.push(result);
+  }
+
+  return {
+    specId: spec.id || 'unknown',
+    title: spec.title || '',
+    runner,
+    results,
+  };
+}
+
+/**
+ * Load all active specs from .caws/specs/
+ * @param {string} projectRoot
+ * @param {string} [targetSpecId] - If provided, only load this spec
+ * @returns {Array<{path: string, spec: Object}>}
+ */
+function loadSpecs(projectRoot, targetSpecId) {
+  const specs = [];
+  const specsDir = path.join(projectRoot, SPECS_DIR);
+
+  if (targetSpecId) {
+    const specPath = path.join(specsDir, `${targetSpecId}.yaml`);
+    if (!fs.existsSync(specPath)) {
+      const ymlPath = path.join(specsDir, `${targetSpecId}.yml`);
+      if (!fs.existsSync(ymlPath)) {
+        throw new Error(`Spec '${targetSpecId}' not found at ${specPath}`);
+      }
+      specs.push({ path: ymlPath, spec: yaml.load(fs.readFileSync(ymlPath, 'utf8')) });
+    } else {
+      specs.push({ path: specPath, spec: yaml.load(fs.readFileSync(specPath, 'utf8')) });
+    }
+    return specs;
+  }
+
+  // Also check working-spec.yaml
+  const workingSpec = path.join(projectRoot, '.caws/working-spec.yaml');
+  if (fs.existsSync(workingSpec)) {
+    try {
+      const s = yaml.load(fs.readFileSync(workingSpec, 'utf8'));
+      if (s && !TERMINAL_STATUSES.has(s.status)) {
+        specs.push({ path: workingSpec, spec: s });
+      }
+    } catch (_) { /* ignore unreadable config */ }
+  }
+
+  if (fs.existsSync(specsDir)) {
+    for (const f of fs.readdirSync(specsDir).filter(f => f.endsWith('.yaml') || f.endsWith('.yml'))) {
+      try {
+        const s = yaml.load(fs.readFileSync(path.join(specsDir, f), 'utf8'));
+        if (s && !TERMINAL_STATUSES.has(s.status)) {
+          specs.push({ path: path.join(specsDir, f), spec: s });
+        }
+      } catch (_) { /* ignore unreadable config */ }
+    }
+  }
+
+  return specs;
+}
+
+/**
+ * Main command handler
+ */
+async function verifyAcsCommand(options = {}) {
+  const projectRoot = findProjectRoot();
+
+  // Check for CAWS project
+  if (!fs.existsSync(path.join(projectRoot, '.caws'))) {
+    console.error(chalk.red('Not a CAWS project (no .caws/ directory found)'));
+    process.exit(1);
+  }
+
+  const specs = loadSpecs(projectRoot, options.specId);
+
+  if (specs.length === 0) {
+    console.log(chalk.yellow('No active specs found.'));
+    return;
+  }
+
+  const allResults = [];
+  let totalAcs = 0, totalMechanical = 0, totalPass = 0, totalFail = 0, totalUnchecked = 0;
+
+  for (const { spec } of specs) {
+    const acs = extractACs(spec);
+    if (acs.length === 0) continue;
+
+    const result = verifySpec(spec, projectRoot, {
+      run: options.run || false,
+      runner: options.runner,
+    });
+    allResults.push(result);
+
+    // Tally
+    for (const r of result.results) {
+      totalAcs++;
+      if (r.status === 'PASS') { totalPass++; totalMechanical++; }
+      else if (r.status === 'FAIL') { totalFail++; totalMechanical++; }
+      else { totalUnchecked++; }
+    }
+  }
+
+  // Output
+  if (options.format === 'json') {
+    console.log(JSON.stringify({
+      summary: { total: totalAcs, mechanical: totalMechanical, pass: totalPass, fail: totalFail, unchecked: totalUnchecked },
+      specs: allResults,
+    }, null, 2));
+    process.exit(totalFail > 0 ? 1 : 0);
+    return;
+  }
+
+  // Table output
+  for (const result of allResults) {
+    console.log(chalk.cyan(`\n## ${result.specId} — ${result.title}`));
+    console.log(chalk.gray(`   Test runner: ${result.runner} | Mode: ${options.run ? 'run' : 'collect-only'}`));
+    console.log();
+
+    const widths = { id: 8, desc: 40, method: 14, status: 10 };
+    console.log(
+      chalk.gray(
+        `  ${'AC'.padEnd(widths.id)}${'Description'.padEnd(widths.desc)}${'Method'.padEnd(widths.method)}${'Status'.padEnd(widths.status)}Detail`
+      )
+    );
+    console.log(chalk.gray('  ' + '-'.repeat(widths.id + widths.desc + widths.method + widths.status + 20)));
+
+    for (const r of result.results) {
+      const statusColor = r.status === 'PASS' ? chalk.green : r.status === 'FAIL' ? chalk.red : chalk.yellow;
+      const desc = r.description.length > widths.desc - 2
+        ? r.description.slice(0, widths.desc - 5) + '...'
+        : r.description;
+      const detail = r.detail.length > 60 ? r.detail.slice(0, 57) + '...' : r.detail;
+
+      console.log(
+        `  ${chalk.white(r.id.padEnd(widths.id))}${desc.padEnd(widths.desc)}${(r.method || '').padEnd(widths.method)}${statusColor(r.status.padEnd(widths.status))}${chalk.gray(detail)}`
+      );
+    }
+  }
+
+  // Summary
+  console.log(chalk.cyan('\n## Summary'));
+  console.log(`  Total ACs: ${totalAcs} | Mechanical: ${totalMechanical} | ${chalk.green(`Pass: ${totalPass}`)} | ${chalk.red(`Fail: ${totalFail}`)} | ${chalk.yellow(`Unchecked: ${totalUnchecked}`)}`);
+
+  if (totalFail > 0) {
+    console.log(chalk.red('\n  Some acceptance criteria failed verification.'));
+    process.exit(1);
+  } else if (totalMechanical === 0 && totalAcs > 0) {
+    console.log(chalk.yellow('\n  No ACs have mechanical verification. Consider adding test_nodeids or test_command.'));
+  } else {
+    console.log(chalk.green('\n  All mechanically-verifiable ACs passed.'));
+  }
+}
+
+module.exports = {
+  verifyAcsCommand,
+  verifySpec,
+  extractACs,
+  detectTestRunner,
+  collectNodeid,
+  runNodeid,
+  runTestCommand,
+  checkEvidence,
+};

package/dist/index.js

@@ -52,6 +52,7 @@ const { planCommand } = require('./commands/plan');
 const { worktreeCommand } = require('./commands/worktree');
 const { sessionCommand } = require('./commands/session');
 const { parallelCommand } = require('./commands/parallel');
+const { verifyAcsCommand } = require('./commands/verify-acs');
 
 // Import scaffold functionality
 const { scaffoldProject, setScaffoldDependencies } = require('./scaffold');
@@ -463,7 +464,7 @@ parallelCmd
 parallelCmd
   .command('merge')
   .description('Merge all parallel branches back to base')
-  .option('--strategy <strategy>', 'Merge strategy: rebase, merge, or squash', 'merge')
+  .option('--strategy <strategy>', 'Merge strategy: merge or squash', 'merge')
   .option('--dry-run', 'Preview merge without executing', false)
   .option('--force', 'Force merge even with detected conflicts', false)
   .action((options) => parallelCommand('merge', options));
@@ -490,6 +491,16 @@ program
   .option('--fix', 'Apply automatic fixes', false)
   .action(diagnoseCommand);
 
+// Verify Acceptance Criteria command
+program
+  .command('verify-acs')
+  .description('Verify acceptance criteria in specs are backed by test evidence')
+  .option('--spec-id <id>', 'Verify only this spec')
+  .option('--run', 'Actually run tests (default: collect-only)', false)
+  .option('--runner <runner>', 'Force test runner (pytest, jest, vitest, cargo, go)')
+  .option('--format <format>', 'Output format (text, json)', 'text')
+  .action(verifyAcsCommand);
+
 // Evaluate command
 program
   .command('evaluate [spec-file]')
@@ -746,6 +757,7 @@ program.exitOverride((err) => {
       'worktree',
       'session',
       'parallel',
+      'verify-acs',
     ];
     const similar = findSimilarCommand(commandName, validCommands);
 

package/dist/parallel/parallel-manager.js

@@ -20,7 +20,9 @@ const {
 // session-manager available if needed: require('../session/session-manager')
 
 const PARALLEL_REGISTRY = '.caws/parallel.json';
-const VALID_STRATEGIES = ['merge', 'rebase', 'squash'];
+// 'rebase' removed: it rewrites branch history, which is unsafe when
+// worktrees are still active and other agents may depend on those commits.
+const VALID_STRATEGIES = ['merge', 'squash'];
 const NAME_REGEX = /^[a-zA-Z0-9_-]+$/;
 
 /**
@@ -353,12 +355,7 @@ function mergeParallel(options = {}) {
 
   for (const agent of activeAgents) {
     try {
-      if (strategy === 'rebase') {
-        execFileSync('git', ['rebase', agent.branch], {
-          cwd: root,
-          stdio: 'pipe',
-        });
-      } else if (strategy === 'squash') {
+      if (strategy === 'squash') {
         execFileSync('git', ['merge', '--squash', agent.branch], {
           cwd: root,
           stdio: 'pipe',
@@ -380,11 +377,7 @@ function mergeParallel(options = {}) {
       try {
         execFileSync('git', ['merge', '--abort'], { cwd: root, stdio: 'pipe' });
       } catch {
-        try {
-          execFileSync('git', ['rebase', '--abort'], { cwd: root, stdio: 'pipe' });
-        } catch {
-          // Already clean
-        }
+        // Already clean
       }
       failed.push({ name: agent.name, error: err.message });
     }