@paths.design/caws-cli 9.1.1 → 9.3.0

package/dist/commands/worktree.js

@@ -9,6 +9,7 @@ const {
   createWorktree,
   listWorktrees,
   destroyWorktree,
+  mergeWorktree,
   pruneWorktrees,
 } = require('../worktree/worktree-manager');
 
@@ -26,11 +27,13 @@ async function worktreeCommand(subcommand, options = {}) {
         return handleList();
       case 'destroy':
         return handleDestroy(options);
+      case 'merge':
+        return handleMerge(options);
       case 'prune':
         return handlePrune(options);
       default:
         console.error(chalk.red(`Unknown worktree subcommand: ${subcommand}`));
-        console.log(chalk.blue('Available: create, list, destroy, prune'));
+        console.log(chalk.blue('Available: create, list, destroy, merge, prune'));
         process.exit(1);
     }
   } catch (error) {
@@ -70,30 +73,52 @@ function handleList() {
   }
 
   console.log(chalk.bold.cyan('CAWS Worktrees'));
-  console.log(chalk.cyan('='.repeat(70)));
+  console.log(chalk.cyan('='.repeat(85)));
   console.log(
     chalk.bold(
-      'Name'.padEnd(20) +
+      'Name'.padEnd(18) +
         'Status'.padEnd(12) +
         'Branch'.padEnd(20) +
-        'Scope'
+        'Last Commit'.padEnd(16) +
+        'Owner'
     )
   );
-  console.log(chalk.gray('-'.repeat(70)));
+  console.log(chalk.gray('-'.repeat(85)));
 
   for (const entry of entries) {
     const statusColor =
       entry.status === 'active'
         ? chalk.green
         : entry.status === 'destroyed'
-        ? chalk.gray
-        : chalk.yellow;
+          ? chalk.gray
+          : chalk.yellow;
+
+    // Format last commit age
+    let commitAge = chalk.gray('-');
+    if (entry.lastCommit) {
+      commitAge = chalk.white(entry.lastCommit.age);
+    }
+
+    // Format owner — show truncated session ID or '-'
+    let ownerStr = chalk.gray('-');
+    if (entry.owner) {
+      // Show last 8 chars of session ID for readability
+      const short = entry.owner.length > 8 ? '...' + entry.owner.slice(-8) : entry.owner;
+      ownerStr = chalk.gray(short);
+    }
+
+    // Status suffix for merged branches
+    let statusStr = entry.status;
+    if (entry.merged && entry.status === 'active') {
+      statusStr = 'merged';
+    }
 
     console.log(
-      entry.name.padEnd(20) +
-        statusColor(entry.status.padEnd(12)) +
+      entry.name.padEnd(18) +
+        statusColor(statusStr.padEnd(12)) +
         (entry.branch || '').padEnd(20) +
-        (entry.scope || '-')
+        commitAge.padEnd(16 + 10) + // +10 for chalk color codes
+        ownerStr
     );
   }
 
@@ -117,18 +142,85 @@ function handleDestroy(options) {
   }
 }
 
+function handleMerge(options) {
+  const { name, dryRun, deleteBranch = true, message } = options;
+
+  if (!name) {
+    console.error(chalk.red('Worktree name is required'));
+    console.log(
+      chalk.blue(
+        'Usage: caws worktree merge <name> [--dry-run] [--message "..."] [--no-delete-branch]'
+      )
+    );
+    process.exit(1);
+  }
+
+  if (dryRun) {
+    console.log(chalk.cyan(`Dry-run merge preview for: ${name}`));
+  } else {
+    console.log(chalk.cyan(`Merging worktree: ${name}`));
+  }
+
+  const result = mergeWorktree(name, { dryRun, deleteBranch, message });
+
+  if (dryRun) {
+    if (result.conflicts.length > 0) {
+      console.log(chalk.yellow(`\nConflicts detected (${result.conflicts.length}):`));
+      for (const conflict of result.conflicts) {
+        console.log(chalk.yellow(`   ${conflict}`));
+      }
+      console.log(
+        chalk.blue('\nResolve conflicts in the worktree before merging, or merge manually.')
+      );
+    } else {
+      console.log(chalk.green(`\nNo conflicts detected. Safe to merge.`));
+      console.log(chalk.blue(`Run without --dry-run to merge: caws worktree merge ${name}`));
+    }
+    return;
+  }
+
+  if (result.merged) {
+    console.log(chalk.green(`Worktree '${name}' merged to ${result.baseBranch}`));
+    if (deleteBranch) {
+      console.log(chalk.gray(`   Branch ${result.branch} deleted`));
+    }
+  } else {
+    console.log(chalk.red(`Merge failed for '${name}'`));
+    for (const conflict of result.conflicts) {
+      console.log(chalk.yellow(`   ${conflict}`));
+    }
+    console.log(chalk.blue('\nThe worktree has been destroyed but the merge has conflicts.'));
+    console.log(chalk.blue('Resolve conflicts and commit manually:'));
+    console.log(chalk.gray(`   git merge --no-ff ${result.branch}`));
+    console.log(chalk.gray(`   # resolve conflicts`));
+    console.log(chalk.gray(`   git commit -m "merge(worktree): ${name}"`));
+  }
+}
+
 function handlePrune(options) {
   const maxAge = options.maxAge !== undefined ? parseInt(options.maxAge, 10) : 30;
 
   console.log(chalk.cyan(`Pruning worktrees (max age: ${maxAge} days)`));
-  const pruned = pruneWorktrees({ maxAgeDays: maxAge });
+  const result = pruneWorktrees({ maxAgeDays: maxAge });
+
+  // Handle both old return format (array) and new format (object with pruned/skipped)
+  const pruned = Array.isArray(result) ? result : result.pruned;
+  const skipped = Array.isArray(result) ? [] : result.skipped || [];
 
-  if (pruned.length === 0) {
+  if (pruned.length === 0 && skipped.length === 0) {
     console.log(chalk.gray('Nothing to prune.'));
   } else {
-    console.log(chalk.green(`Pruned ${pruned.length} worktree(s):`));
-    for (const entry of pruned) {
-      console.log(chalk.gray(`   - ${entry.name} (created ${entry.createdAt})`));
+    if (pruned.length > 0) {
+      console.log(chalk.green(`Pruned ${pruned.length} worktree(s):`));
+      for (const entry of pruned) {
+        console.log(chalk.gray(`   - ${entry.name} (created ${entry.createdAt})`));
+      }
+    }
+    if (skipped.length > 0) {
+      console.log(chalk.yellow(`\nSkipped ${skipped.length} worktree(s) with recent activity:`));
+      for (const { name: skName, reason } of skipped) {
+        console.log(chalk.yellow(`   - ${skName}: ${reason}`));
+      }
     }
   }
 }

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');
@@ -380,6 +381,14 @@ worktreeCmd
   .option('--force', 'Force removal even if worktree is dirty', false)
   .action((name, options) => worktreeCommand('destroy', { name, ...options }));
 
+worktreeCmd
+  .command('merge <name>')
+  .description('Merge a worktree branch back to base (destroy + merge + cleanup)')
+  .option('--dry-run', 'Preview conflicts without merging', false)
+  .option('--message <msg>', 'Custom merge commit message')
+  .option('--no-delete-branch', 'Keep the branch after merging')
+  .action((name, options) => worktreeCommand('merge', { name, ...options }));
+
 worktreeCmd
   .command('prune')
   .description('Clean up stale worktree entries')
@@ -455,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));
@@ -482,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]')
@@ -738,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 });
     }

package/dist/scaffold/cursor-hooks.js

@@ -106,7 +106,6 @@ async function scaffoldCursorHooks(projectDir, levels = ['safety', 'quality', 's
         { command: './.cursor/hooks/block-dangerous.sh' },
         { command: './.cursor/hooks/audit.sh' },
       ];
-      hooksConfig.hooks.beforeMCPExecution = [{ command: './.cursor/hooks/audit.sh' }];
       hooksConfig.hooks.beforeReadFile = [{ command: './.cursor/hooks/scan-secrets.sh' }];
     }
 

package/dist/scaffold/git-hooks.js

@@ -408,8 +408,25 @@ elif [ -f "scripts/quality-gates/run-quality-gates.js" ]; then
   fi
 # Option 3: CAWS CLI validation
 elif command -v caws >/dev/null 2>&1; then
+  # In a worktree, validate only the associated spec to avoid false positives
+  CAWS_VALIDATE_ARGS="--quiet"
+  WORKTREE_BRANCH=$(git rev-parse --abbrev-ref HEAD 2>/dev/null || echo "")
+  if [ -f ".caws/worktrees.json" ] && command -v node >/dev/null 2>&1; then
+    SPEC_ID=$(node -e "
+      try {
+        var reg = JSON.parse(require('fs').readFileSync('.caws/worktrees.json', 'utf8'));
+        var wt = Object.values(reg.worktrees || {}).find(function(w) {
+          return w.branch === '$WORKTREE_BRANCH';
+        });
+        if (wt && wt.specId) console.log(wt.specId);
+      } catch(e) {}
+    " 2>/dev/null || echo "")
+    if [ -n "$SPEC_ID" ]; then
+      CAWS_VALIDATE_ARGS="--quiet --spec-id $SPEC_ID"
+    fi
+  fi
   echo "Running CAWS CLI validation..."
-  if caws validate --quiet 2>/dev/null; then
+  if caws validate $CAWS_VALIDATE_ARGS 2>/dev/null; then
     echo "CAWS validation passed"
     QUALITY_GATES_RAN=true
   else

package/dist/templates/.caws/tools/README.md

@@ -4,18 +4,15 @@ This directory contains CAWS-specific tools that aren't available in the CLI.
 
 ## scope-guard.js
 
-Enforces that experimental code stays within designated sandbox areas. Used by Cursor hooks for scope validation.
+Checks whether a file is within scope of active working-spec and feature specs. Used by Cursor hooks for scope validation on file attachments.
 
 ```bash
-# Validate experimental code containment
-node .caws/tools/scope-guard.js validate
+# Check if a file is in scope
+node .caws/tools/scope-guard.js check src/index.js
 
-# Check containment status
-node .caws/tools/scope-guard.js check .caws/working-spec.yaml
+# Exit code 0 = in scope, 1 = out of scope
 ```
 
 **Usage in Cursor Hooks:**
 
 The `.cursor/hooks/scope-guard.sh` hook automatically uses this tool to validate file attachments against working spec scope boundaries.
-
-

package/dist/templates/.caws/tools/scope-guard.js

@@ -1,208 +1,152 @@
 #!/usr/bin/env node
 
 /**
- * @fileoverview CAWS Scope Guard
- * Enforces that experimental code stays within designated sandbox areas
+ * @fileoverview CAWS Scope Guard (file-level)
+ * Checks whether a given file path is within scope of active specs.
+ * Used by Cursor hooks for scope validation on file attachments.
  * @author @darianrosebrook
  */
 
 const fs = require('fs');
-const { execSync } = require('child_process');
+const path = require('path');
 
 /**
- * Check if experimental code is properly contained
- * @param {string} workingSpecPath - Path to working spec file
- * @returns {Object} Scope validation results
+ * Convert a glob pattern to a RegExp, handling **, *, ?, [abc], {a,b}
  */
-function checkExperimentalContainment(workingSpecPath = '.caws/working-spec.yaml') {
-  try {
-    if (!fs.existsSync(workingSpecPath)) {
-      console.error('❌ Working spec not found:', workingSpecPath);
-      return { valid: false, errors: ['Working spec not found'] };
-    }
-
-    const yaml = require('js-yaml');
-    const spec = yaml.load(fs.readFileSync(workingSpecPath, 'utf8'));
-
-    const results = {
-      valid: true,
-      errors: [],
-      warnings: [],
-      experimentalFiles: [],
-      nonExperimentalFiles: [],
-    };
-
-    // Only check if experimental mode is enabled
-    if (!spec.experimental_mode?.enabled) {
-      console.log('ℹ️  Experimental mode not enabled - skipping containment check');
-      return results;
+function globToRegex(pattern) {
+  let i = 0, re = '';
+  while (i < pattern.length) {
+    const c = pattern[i];
+    if (c === '*' && pattern[i + 1] === '*') {
+      re += '.*'; i += 2;
+      if (pattern[i] === '/') i++; // skip trailing slash after **
+    } else if (c === '*') {
+      re += '[^/]*'; i++;
+    } else if (c === '?') {
+      re += '[^/]'; i++;
+    } else if (c === '[') {
+      const end = pattern.indexOf(']', i);
+      if (end > i) { re += pattern.slice(i, end + 1); i = end + 1; }
+      else { re += '\\['; i++; }
+    } else if (c === '{') {
+      const end = pattern.indexOf('}', i);
+      if (end > i) {
+        const alts = pattern.slice(i + 1, end).split(',').map(a => a.trim());
+        re += '(?:' + alts.join('|') + ')'; i = end + 1;
+      } else { re += '\\{'; i++; }
+    } else if ('.+^$|()'.includes(c)) {
+      re += '\\' + c; i++;
+    } else {
+      re += c; i++;
     }
+  }
+  return new RegExp(re);
+}
 
-    const sandboxLocation = spec.experimental_mode.sandbox_location || 'experimental/';
-    console.log(`🔍 Checking containment for experimental code in: ${sandboxLocation}`);
+const TERMINAL = new Set(['completed', 'closed', 'archived']);
 
-    // Get list of changed files (this would typically come from git diff)
-    const changedFiles = getChangedFiles();
+/**
+ * Check if a file is within scope of active specs.
+ * @param {string} filePath - Relative path from project root
+ * @param {string} projectDir - Project root directory
+ * @returns {{inScope: boolean, reason: string}}
+ */
+function checkFileScope(filePath, projectDir) {
+  // Smart allowlist: root-level files, .caws/, .claude/ always pass
+  if (!filePath.includes('/') || filePath.startsWith('.caws/') || filePath.startsWith('.claude/')) {
+    return { inScope: true, reason: 'allowlisted path' };
+  }
 
-    if (changedFiles.length === 0) {
-      console.log('ℹ️  No files changed - skipping scope check');
-      return results;
-    }
+  const specFile = path.join(projectDir, '.caws/working-spec.yaml');
+  const specsDir = path.join(projectDir, '.caws/specs');
 
-    // Check each changed file
-    changedFiles.forEach((file) => {
-      const isInSandbox =
-        file.startsWith(sandboxLocation) ||
-        file.includes(`/${sandboxLocation}`) ||
-        file.includes(sandboxLocation);
-
-      if (isInSandbox) {
-        results.experimentalFiles.push(file);
-        console.log(`✅ Experimental file properly contained: ${file}`);
-      } else {
-        results.nonExperimentalFiles.push(file);
-        results.valid = false;
-        results.errors.push(`Experimental code found outside sandbox: ${file}`);
-        console.error(`❌ Experimental code outside sandbox: ${file}`);
-      }
-    });
-
-    // Check if experimental files actually exist
-    results.experimentalFiles.forEach((file) => {
-      if (!fs.existsSync(file)) {
-        results.warnings.push(`Experimental file not found (may have been deleted): ${file}`);
-        console.warn(`⚠️  Experimental file not found: ${file}`);
-      }
-    });
+  if (!fs.existsSync(specFile) && !fs.existsSync(specsDir)) {
+    return { inScope: true, reason: 'no specs found' };
+  }
 
-    return results;
-  } catch (error) {
-    console.error('❌ Error checking experimental containment:', error.message);
-    return { valid: false, errors: [error.message] };
+  // Load all active specs
+  let yaml;
+  try { yaml = require('js-yaml'); } catch (_) {
+    return { inScope: true, reason: 'js-yaml not available' };
   }
-}
 
-/**
- * Get list of changed files from git
- * @returns {Array} List of changed file paths
- */
-function getChangedFiles() {
-  try {
-    // Get files that are staged or modified
-    const staged = execSync('git diff --cached --name-only', { encoding: 'utf8' })
-      .split('\n')
-      .filter((file) => file.trim());
-
-    const modified = execSync('git diff --name-only', { encoding: 'utf8' })
-      .split('\n')
-      .filter((file) => file.trim());
-
-    // Combine and deduplicate
-    const allFiles = [...new Set([...staged, ...modified])];
-
-    // Filter out deleted files (they might still be in the diff)
-    return allFiles.filter((file) => {
-      try {
-        return fs.existsSync(file);
-      } catch {
-        return false;
+  const specs = [];
+
+  if (fs.existsSync(specFile)) {
+    try {
+      const s = yaml.load(fs.readFileSync(specFile, 'utf8'));
+      if (s && !TERMINAL.has(s.status)) {
+        specs.push({ source: 'working-spec', spec: s });
       }
-    });
-  } catch (error) {
-    console.warn('⚠️  Could not get changed files from git:', error.message);
-    return [];
+    } catch (_) {}
   }
-}
 
-/**
- * Validate that experimental code follows containment rules
- * @param {string} workingSpecPath - Path to working spec file
- */
-function validateExperimentalScope(workingSpecPath = '.caws/working-spec.yaml') {
-  console.log('🔍 Validating experimental code containment...');
-
-  const results = checkExperimentalContainment(workingSpecPath);
-
-  if (!results.valid) {
-    console.error('\n❌ Experimental containment validation failed:');
-    results.errors.forEach((error) => {
-      console.error(`   - ${error}`);
-    });
-
-    if (results.warnings.length > 0) {
-      console.warn('\n⚠️  Warnings:');
-      results.warnings.forEach((warning) => {
-        console.warn(`   - ${warning}`);
-      });
+  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.has(s.status)) {
+          specs.push({ source: f, spec: s });
+        }
+      } catch (_) {}
     }
+  }
 
-    console.error('\n💡 To fix containment issues:');
-    console.error('   1. Move experimental code to the designated sandbox location');
-    console.error('   2. Update the sandbox_location in your working spec');
-    console.error('   3. Or disable experimental mode if this is production code');
+  if (specs.length === 0) {
+    return { inScope: true, reason: 'no active specs' };
+  }
 
-    process.exit(1);
+  // Check scope.out — any match blocks
+  for (const { source, spec } of specs) {
+    for (const pattern of (spec.scope?.out || [])) {
+      if (globToRegex(pattern).test(filePath)) {
+        return { inScope: false, reason: `out-of-scope in ${source} (pattern: ${pattern})` };
+      }
+    }
   }
 
-  if (results.warnings.length > 0) {
-    console.warn('\n⚠️  Experimental containment warnings:');
-    results.warnings.forEach((warning) => {
-      console.warn(`   - ${warning}`);
-    });
+  // Union all scope.in — must match at least one
+  const allIn = specs.flatMap(({ spec }) => spec.scope?.in || []);
+  if (allIn.length > 0) {
+    const found = allIn.some(pattern => globToRegex(pattern).test(filePath));
+    if (!found) {
+      return { inScope: false, reason: 'not in any active spec scope.in' };
+    }
   }
 
-  console.log('✅ Experimental code containment validated');
-  console.log(`   - Files in sandbox: ${results.experimentalFiles.length}`);
-  console.log(`   - Files outside sandbox: ${results.nonExperimentalFiles.length}`);
+  return { inScope: true, reason: 'in scope' };
 }
 
 // CLI interface
 if (require.main === module) {
   const command = process.argv[2];
-  const specPath = process.argv[3] || '.caws/working-spec.yaml';
-
-  switch (command) {
-    case 'validate':
-      validateExperimentalScope(specPath);
-      break;
-
-    case 'check':
-      const results = checkExperimentalContainment(specPath);
-      console.log('\n📊 Containment Check Results:');
-      console.log(`   Valid: ${results.valid}`);
-      console.log(`   Experimental files: ${results.experimentalFiles.length}`);
-      console.log(`   Non-experimental files: ${results.nonExperimentalFiles.length}`);
-      console.log(`   Errors: ${results.errors.length}`);
-      console.log(`   Warnings: ${results.warnings.length}`);
-
-      if (results.errors.length > 0) {
-        console.log('\n❌ Errors:');
-        results.errors.forEach((error) => console.log(`   - ${error}`));
-      }
-
-      if (results.warnings.length > 0) {
-        console.log('\n⚠️  Warnings:');
-        results.warnings.forEach((warning) => console.log(`   - ${warning}`));
-      }
-
-      process.exit(results.valid ? 0 : 1);
-      break;
-
-    default:
-      console.log('CAWS Scope Guard');
-      console.log('Usage:');
-      console.log('  node scope-guard.js validate [spec-path]');
-      console.log('  node scope-guard.js check [spec-path]');
-      console.log('');
-      console.log('Examples:');
-      console.log('  node scope-guard.js validate');
-      console.log('  node scope-guard.js check .caws/working-spec.yaml');
+  const filePath = process.argv[3];
+
+  if (command === 'check' && filePath) {
+    // Resolve relative to cwd
+    const projectDir = process.cwd();
+    const rel = filePath.startsWith(projectDir)
+      ? filePath.slice(projectDir.length + 1)
+      : filePath;
+
+    const result = checkFileScope(rel, projectDir);
+    if (result.inScope) {
+      console.log(`in_scope: ${result.reason}`);
+      process.exit(0);
+    } else {
+      console.error(`out_of_scope: ${result.reason}`);
       process.exit(1);
+    }
+  } else {
+    console.log('CAWS Scope Guard');
+    console.log('Usage:');
+    console.log('  node scope-guard.js check <file-path>');
+    console.log('');
+    console.log('Examples:');
+    console.log('  node scope-guard.js check src/index.js');
+    console.log('  node scope-guard.js check packages/cli/lib/main.ts');
+    process.exit(1);
   }
 }
 
-module.exports = {
-  checkExperimentalContainment,
-  validateExperimentalScope,
-  getChangedFiles,
-};
+module.exports = { checkFileScope, globToRegex };