@paths.design/caws-cli 3.1.1 → 3.2.0

package/dist/index.js.backup

@@ -1,4711 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * @fileoverview CAWS CLI - Scaffolding tool for Coding Agent Workflow System
- * Provides commands to initialize new projects and scaffold existing ones with CAWS
- * @author @darianrosebrook
- */
-
-const { Command } = require('commander');
-const fs = require('fs-extra');
-const path = require('path');
-const yaml = require('js-yaml');
-const chalk = require('chalk');
-
-// Import configuration and utilities
-const {
-  CLI_VERSION,
-  initializeGlobalSetup,
-  loadProvenanceTools,
-  initializeLanguageSupport,
-  getGlobalCAWSSetup,
-} = require('./config');
-
-// Import command handlers
-const { initProject } = require('./commands/init');
-
-// Import scaffold functionality
-const { scaffoldProject, setScaffoldDependencies } = require('./scaffold');
-
-// Import validation functionality
-const { validateWorkingSpecWithSuggestions } = require('./validation/spec-validation');
-
-// Import finalization utilities
-const { finalizeProject, continueToSuccess, setFinalizationDependencies } = require('./utils/finalization');
-
-// Import generators
-const { generateWorkingSpec, validateGeneratedSpec } = require('./generators/working-spec');
-
-// Import tool system
-const ToolLoader = require('./tool-loader');
-const ToolValidator = require('./tool-validator');
-
-// Initialize global configuration
-const program = new Command();
-
-// Initialize global state
-const cawsSetup = initializeGlobalSetup();
-const languageSupport = initializeLanguageSupport();
-
-// Set up dependencies for modules that need them
-setScaffoldDependencies({
-  cawsSetup,
-  loadProvenanceTools,
-});
-
-setFinalizationDependencies({
-  languageSupport,
-  loadProvenanceTools,
-});
-
-// Tool system state
-let toolLoader = null;
-let toolValidator = null;
-
-// CAWS Detection and Configuration
-function detectCAWSSetup(cwd = process.cwd()) {
-  // Skip logging for version/help commands
-  const isQuietCommand =
-    process.argv.includes('--version') ||
-    process.argv.includes('-V') ||
-    process.argv.includes('--help');
-
-  if (!isQuietCommand) {
-    console.log(chalk.blue('🔍 Detecting CAWS setup...'));
-  }
-
-  // Check for existing CAWS setup
-  const cawsDir = path.join(cwd, '.caws');
-  const hasCAWSDir = fs.existsSync(cawsDir);
-
-  if (!hasCAWSDir) {
-    if (!isQuietCommand) {
-      console.log(chalk.gray('ℹ️  No .caws directory found - new project setup'));
-    }
-    return {
-      type: 'new',
-      hasCAWSDir: false,
-      cawsDir: null,
-      capabilities: [],
-      hasTemplateDir: false,
-      templateDir: null,
-    };
-  }
-
-  // Analyze existing setup
-  const files = fs.readdirSync(cawsDir);
-  const hasWorkingSpec = fs.existsSync(path.join(cawsDir, 'working-spec.yaml'));
-  const hasValidateScript = fs.existsSync(path.join(cawsDir, 'validate.js'));
-  const hasPolicy = fs.existsSync(path.join(cawsDir, 'policy'));
-  const hasSchemas = fs.existsSync(path.join(cawsDir, 'schemas'));
-  const hasTemplates = fs.existsSync(path.join(cawsDir, 'templates'));
-
-  // Check for multiple spec files (enhanced project pattern)
-  const specFiles = files.filter((f) => f.endsWith('-spec.yaml'));
-  const hasMultipleSpecs = specFiles.length > 1;
-
-  // Check for tools directory (enhanced setup)
-  const toolsDir = path.join(cwd, 'apps/tools/caws');
-  const hasTools = fs.existsSync(toolsDir);
-
-  // Determine setup type
-  let setupType = 'basic';
-  let capabilities = [];
-
-  if (hasMultipleSpecs && hasWorkingSpec) {
-    setupType = 'enhanced';
-    capabilities.push('multiple-specs', 'working-spec', 'domain-specific');
-  } else if (hasWorkingSpec) {
-    setupType = 'standard';
-    capabilities.push('working-spec');
-  }
-
-  if (hasValidateScript) {
-    capabilities.push('validation');
-  }
-  if (hasPolicy) {
-    capabilities.push('policies');
-  }
-  if (hasSchemas) {
-    capabilities.push('schemas');
-  }
-  if (hasTemplates) {
-    capabilities.push('templates');
-  }
-  if (hasTools) {
-    capabilities.push('tools');
-  }
-
-  if (!isQuietCommand) {
-    console.log(chalk.green(`✅ Detected ${setupType} CAWS setup`));
-    console.log(chalk.gray(`   Capabilities: ${capabilities.join(', ')}`));
-  }
-
-  // Check for template directory - try multiple possible locations
-  let templateDir = null;
-  const possibleTemplatePaths = [
-    // FIRST: Try bundled templates (for npm-installed CLI)
-    { path: path.resolve(__dirname, '../templates'), source: 'bundled with CLI' },
-    { path: path.resolve(__dirname, 'templates'), source: 'bundled with CLI (fallback)' },
-    // Try relative to current working directory (for monorepo setups)
-    { path: path.resolve(cwd, '../caws-template'), source: 'monorepo parent directory' },
-    { path: path.resolve(cwd, '../../caws-template'), source: 'monorepo grandparent' },
-    { path: path.resolve(cwd, '../../../caws-template'), source: 'workspace root' },
-    { path: path.resolve(cwd, 'packages/caws-template'), source: 'packages/ subdirectory' },
-    { path: path.resolve(cwd, 'caws-template'), source: 'caws-template/ subdirectory' },
-    // Try relative to CLI location (for installed CLI)
-    { path: path.resolve(__dirname, '../caws-template'), source: 'CLI installation' },
-    { path: path.resolve(__dirname, '../../caws-template'), source: 'CLI parent directory' },
-    { path: path.resolve(__dirname, '../../../caws-template'), source: 'CLI workspace root' },
-    // Try absolute paths for CI environments
-    { path: path.resolve(process.cwd(), 'packages/caws-template'), source: 'current packages/' },
-    { path: path.resolve(process.cwd(), '../packages/caws-template'), source: 'parent packages/' },
-    {
-      path: path.resolve(process.cwd(), '../../packages/caws-template'),
-      source: 'grandparent packages/',
-    },
-    {
-      path: path.resolve(process.cwd(), '../../../packages/caws-template'),
-      source: 'workspace packages/',
-    },
-    // Try from workspace root
-    { path: path.resolve(process.cwd(), 'caws-template'), source: 'workspace caws-template/' },
-    // Try various other common locations
-    {
-      path: '/home/runner/work/coding-agent-working-standard/coding-agent-working-standard/packages/caws-template',
-      source: 'GitHub Actions CI',
-    },
-    { path: '/workspace/packages/caws-template', source: 'Docker workspace' },
-    { path: '/caws/packages/caws-template', source: 'Container workspace' },
-  ];
-
-  for (const { path: testPath, source } of possibleTemplatePaths) {
-    if (fs.existsSync(testPath)) {
-      templateDir = testPath;
-      if (!isQuietCommand) {
-        console.log(`✅ Found CAWS templates in ${source}:`);
-        console.log(`   ${chalk.gray(testPath)}`);
-      }
-      break;
-    }
-  }
-
-  if (!templateDir && !isQuietCommand) {
-    console.warn(chalk.yellow('⚠️  CAWS templates not found in standard locations'));
-    console.warn(chalk.blue('💡 This may limit available scaffolding features'));
-    console.warn(
-      chalk.blue('💡 For full functionality, ensure caws-template package is available')
-    );
-  }
-
-  const hasTemplateDir = templateDir !== null;
-
-  return {
-    type: setupType,
-    hasCAWSDir: true,
-    cawsDir,
-    hasWorkingSpec,
-    hasMultipleSpecs,
-    hasValidateScript,
-    hasPolicy,
-    hasSchemas,
-    hasTemplates,
-    hasTools,
-    hasTemplateDir,
-    templateDir,
-    capabilities,
-    isEnhanced: setupType === 'enhanced',
-    isAdvanced: hasTools || hasValidateScript,
-  };
-}
-
-let cawsSetup = null;
-
-// Initialize global setup detection
-try {
-  cawsSetup = detectCAWSSetup();
-
-  // If no template dir found in current directory, check CLI installation location
-  if (!cawsSetup.hasTemplateDir) {
-    const cliTemplatePaths = [
-      path.resolve(__dirname, '../templates'),
-      path.resolve(__dirname, 'templates'),
-    ];
-
-    for (const testPath of cliTemplatePaths) {
-      if (fs.existsSync(testPath)) {
-        cawsSetup.templateDir = testPath;
-        cawsSetup.hasTemplateDir = true;
-        break;
-      }
-    }
-  }
-} catch (error) {
-  console.warn('⚠️  Failed to detect CAWS setup globally:', error.message);
-  cawsSetup = {
-    type: 'unknown',
-    hasCAWSDir: false,
-    cawsDir: null,
-    hasWorkingSpec: false,
-    hasMultipleSpecs: false,
-    hasValidateScript: false,
-    hasPolicy: false,
-    hasSchemas: false,
-    hasTemplates: false,
-    hasTools: false,
-    hasTemplateDir: false,
-    templateDir: null,
-    capabilities: [],
-    isEnhanced: false,
-    isAdvanced: false,
-  };
-}
-
-// Dynamic imports based on setup
-let provenanceTools = null;
-
-// Function to load provenance tools dynamically
-function loadProvenanceTools() {
-  if (provenanceTools) return provenanceTools; // Already loaded
-
-  try {
-    const setup = detectCAWSSetup();
-    if (setup?.hasTemplateDir && setup?.templateDir) {
-      const { generateProvenance, saveProvenance } = require(
-        path.join(setup.templateDir, 'apps/tools/caws/provenance.js')
-      );
-      provenanceTools = { generateProvenance, saveProvenance };
-      console.log('✅ Loaded provenance tools from:', setup.templateDir);
-    }
-  } catch (error) {
-    // Fallback for environments without template
-    provenanceTools = null;
-    console.warn('⚠️  Provenance tools not available:', error.message);
-  }
-
-  return provenanceTools;
-}
-
-const CLI_VERSION = require('../package.json').version;
-
-// Initialize JSON Schema validator - using simplified validation for CLI stability
-const validateWorkingSpec = (spec) => {
-  try {
-    // Basic structural validation for essential fields
-    const requiredFields = [
-      'id',
-      'title',
-      'risk_tier',
-      'mode',
-      'change_budget',
-      'blast_radius',
-      'operational_rollback_slo',
-      'scope',
-      'invariants',
-      'acceptance',
-      'non_functional',
-      'contracts',
-    ];
-
-    for (const field of requiredFields) {
-      if (!spec[field]) {
-        return {
-          valid: false,
-          errors: [
-            {
-              instancePath: `/${field}`,
-              message: `Missing required field: ${field}`,
-            },
-          ],
-        };
-      }
-    }
-
-    // Validate specific field formats
-    if (!/^[A-Z]+-\d+$/.test(spec.id)) {
-      return {
-        valid: false,
-        errors: [
-          {
-            instancePath: '/id',
-            message: 'Project ID should be in format: PREFIX-NUMBER (e.g., FEAT-1234)',
-          },
-        ],
-      };
-    }
-
-    // Validate experimental mode
-    if (spec.experimental_mode) {
-      if (typeof spec.experimental_mode !== 'object') {
-        return {
-          valid: false,
-          errors: [
-            {
-              instancePath: '/experimental_mode',
-              message:
-                'Experimental mode must be an object with enabled, rationale, and expires_at fields',
-            },
-          ],
-        };
-      }
-
-      const requiredExpFields = ['enabled', 'rationale', 'expires_at'];
-      for (const field of requiredExpFields) {
-        if (!(field in spec.experimental_mode)) {
-          return {
-            valid: false,
-            errors: [
-              {
-                instancePath: `/experimental_mode/${field}`,
-                message: `Missing required experimental mode field: ${field}`,
-              },
-            ],
-          };
-        }
-      }
-
-      if (spec.experimental_mode.enabled && spec.risk_tier < 3) {
-        return {
-          valid: false,
-          errors: [
-            {
-              instancePath: '/experimental_mode',
-              message: 'Experimental mode can only be used with Tier 3 (low risk) changes',
-            },
-          ],
-        };
-      }
-    }
-
-    if (spec.risk_tier < 1 || spec.risk_tier > 3) {
-      return {
-        valid: false,
-        errors: [
-          {
-            instancePath: '/risk_tier',
-            message: 'Risk tier must be 1, 2, or 3',
-          },
-        ],
-      };
-    }
-
-    if (!spec.scope || !spec.scope.in || spec.scope.in.length === 0) {
-      return {
-        valid: false,
-        errors: [
-          {
-            instancePath: '/scope/in',
-            message: 'Scope IN must not be empty',
-          },
-        ],
-      };
-    }
-
-    return { valid: true };
-  } catch (error) {
-    return {
-      valid: false,
-      errors: [
-        {
-          instancePath: '',
-          message: `Validation error: ${error.message}`,
-        },
-      ],
-    };
-  }
-};
-
-/**
- * Enhanced validation with suggestions and auto-fix
- */
-function validateWorkingSpecWithSuggestions(spec, options = {}) {
-  const { autoFix = false, suggestions = true } = options;
-
-  try {
-    // Basic structural validation for essential fields
-    const requiredFields = [
-      'id',
-      'title',
-      'risk_tier',
-      'mode',
-      'change_budget',
-      'blast_radius',
-      'operational_rollback_slo',
-      'scope',
-      'invariants',
-      'acceptance',
-      'non_functional',
-      'contracts',
-    ];
-
-    let errors = [];
-    let warnings = [];
-    let fixes = [];
-
-    for (const field of requiredFields) {
-      if (!spec[field]) {
-        errors.push({
-          instancePath: `/${field}`,
-          message: `Missing required field: ${field}`,
-          suggestion: getFieldSuggestion(field, spec),
-          canAutoFix: canAutoFixField(field, spec),
-        });
-      }
-    }
-
-    // Validate specific field formats
-    if (spec.id && !/^[A-Z]+-\d+$/.test(spec.id)) {
-      errors.push({
-        instancePath: '/id',
-        message: 'Project ID should be in format: PREFIX-NUMBER (e.g., FEAT-1234)',
-        suggestion: 'Use format like: PROJ-001, FEAT-002, FIX-003',
-        canAutoFix: false,
-      });
-    }
-
-    // Validate risk tier
-    if (spec.risk_tier !== undefined && (spec.risk_tier < 1 || spec.risk_tier > 3)) {
-      errors.push({
-        instancePath: '/risk_tier',
-        message: 'Risk tier must be 1, 2, or 3',
-        suggestion:
-          'Tier 1: Critical (auth, billing), Tier 2: Standard (features), Tier 3: Low risk (UI)',
-        canAutoFix: true,
-      });
-      fixes.push({ field: 'risk_tier', value: Math.max(1, Math.min(3, spec.risk_tier || 2)) });
-    }
-
-    // Validate scope.in is not empty
-    if (!spec.scope || !spec.scope.in || spec.scope.in.length === 0) {
-      errors.push({
-        instancePath: '/scope/in',
-        message: 'Scope IN must not be empty',
-        suggestion: 'Specify directories/files that are included in changes',
-        canAutoFix: false,
-      });
-    }
-
-    // Check for common issues
-    if (!spec.invariants || spec.invariants.length === 0) {
-      warnings.push({
-        instancePath: '/invariants',
-        message: 'No system invariants defined',
-        suggestion: 'Add 1-3 statements about what must always remain true',
-      });
-    }
-
-    if (!spec.acceptance || spec.acceptance.length === 0) {
-      warnings.push({
-        instancePath: '/acceptance',
-        message: 'No acceptance criteria defined',
-        suggestion: 'Add acceptance criteria in GIVEN/WHEN/THEN format',
-      });
-    }
-
-    // Validate experimental mode
-    if (spec.experimental_mode) {
-      if (typeof spec.experimental_mode !== 'object') {
-        errors.push({
-          instancePath: '/experimental_mode',
-          message:
-            'Experimental mode must be an object with enabled, rationale, and expires_at fields',
-          suggestion: 'Fix experimental_mode structure',
-          canAutoFix: false,
-        });
-      } else {
-        const requiredExpFields = ['enabled', 'rationale', 'expires_at'];
-        for (const field of requiredExpFields) {
-          if (!(field in spec.experimental_mode)) {
-            errors.push({
-              instancePath: `/experimental_mode/${field}`,
-              message: `Missing required experimental mode field: ${field}`,
-              suggestion: `Add ${field} to experimental_mode`,
-              canAutoFix: field === 'enabled' ? true : false,
-            });
-            if (field === 'enabled') {
-              fixes.push({ field: `experimental_mode.${field}`, value: true });
-            }
-          }
-        }
-
-        if (spec.experimental_mode.enabled && spec.risk_tier < 3) {
-          warnings.push({
-            instancePath: '/experimental_mode',
-            message: 'Experimental mode can only be used with Tier 3 (low risk) changes',
-            suggestion: 'Either set risk_tier to 3 or disable experimental mode',
-          });
-        }
-      }
-    }
-
-    // Apply auto-fixes if requested
-    if (autoFix && fixes.length > 0) {
-      console.log(chalk.cyan('🔧 Applying auto-fixes...'));
-      for (const fix of fixes) {
-        if (fix.field.includes('.')) {
-          const [parent, child] = fix.field.split('.');
-          if (!spec[parent]) spec[parent] = {};
-          spec[parent][child] = fix.value;
-        } else {
-          spec[fix.field] = fix.value;
-        }
-        console.log(`   Fixed: ${fix.field} = ${JSON.stringify(fix.value)}`);
-      }
-    }
-
-    // Display results
-    if (errors.length > 0) {
-      console.error(chalk.red('❌ Validation failed with errors:'));
-      errors.forEach((error, index) => {
-        console.error(`${index + 1}. ${error.instancePath || 'root'}: ${error.message}`);
-        if (suggestions && error.suggestion) {
-          console.error(`   💡 ${error.suggestion}`);
-        }
-        if (error.canAutoFix) {
-          console.error(`   🔧 Can auto-fix: ${autoFix ? 'applied' : 'run with --auto-fix'}`);
-        }
-      });
-      return { valid: false, errors, warnings };
-    }
-
-    if (warnings.length > 0 && suggestions) {
-      console.warn(chalk.yellow('⚠️  Validation passed with warnings:'));
-      warnings.forEach((warning, index) => {
-        console.warn(`${index + 1}. ${warning.instancePath || 'root'}: ${warning.message}`);
-        if (warning.suggestion) {
-          console.warn(`   💡 ${warning.suggestion}`);
-        }
-      });
-    }
-
-    console.log(chalk.green('✅ Working specification is valid'));
-    return { valid: true, errors: [], warnings };
-  } catch (error) {
-    console.error(chalk.red('❌ Error during validation:'), error.message);
-    return {
-      valid: false,
-      errors: [{ instancePath: '', message: `Validation error: ${error.message}` }],
-      warnings: [],
-    };
-  }
-}
-
-function getFieldSuggestion(field, _spec) {
-  const suggestions = {
-    id: 'Use format like: PROJ-001, FEAT-002, FIX-003',
-    title: 'Add a descriptive project title',
-    risk_tier: 'Choose: 1 (critical), 2 (standard), or 3 (low risk)',
-    mode: 'Choose: feature, refactor, fix, doc, or chore',
-    change_budget: 'Set max_files and max_loc based on risk tier',
-    blast_radius: 'List affected modules and data migration needs',
-    operational_rollback_slo: 'Choose: 1m, 5m, 15m, or 1h',
-    scope: "Define what's included (in) and excluded (out) from changes",
-    invariants: 'Add 1-3 statements about what must always remain true',
-    acceptance: 'Add acceptance criteria in GIVEN/WHEN/THEN format',
-    non_functional: 'Define accessibility, performance, and security requirements',
-    contracts: 'Specify API contracts (OpenAPI, GraphQL, etc.)',
-  };
-  return suggestions[field] || `Add the ${field} field`;
-}
-
-function canAutoFixField(field, _spec) {
-  const autoFixable = ['risk_tier'];
-  return autoFixable.includes(field);
-}
-
-/**
- * Generate a getting started guide based on project analysis
- */
-function generateGettingStartedGuide(analysis) {
-  const { projectType, packageJson, hasTests, hasLinting } = analysis;
-
-  const projectName = packageJson.name || 'your-project';
-  const capitalizedType = projectType.charAt(0).toUpperCase() + projectType.slice(1);
-
-  let guide = `# Getting Started with CAWS - ${capitalizedType} Project
-
-**Project**: ${projectName}  
-**Type**: ${capitalizedType}  
-**Generated**: ${new Date().toLocaleDateString()}
-
----
-
-## Phase 1: Setup Verification (15 mins)
-
-Complete these steps to ensure your CAWS setup is working:
-
-### ✅ Already Done
-- [x] Initialize CAWS project
-- [x] Generate working spec
-- [x] Set up basic structure
-
-### Next Steps
-- [ ] Review \`.caws/working-spec.yaml\` - customize for your needs
-- [ ] Run validation: \`caws validate --suggestions\`
-- [ ] Review tier policy in \`.caws/policy/\` (if applicable)
-- [ ] Update \`.caws/templates/\` with project-specific examples
-
----
-
-## Phase 2: First Feature (30 mins)
-
-Time to create your first CAWS-managed feature:
-
-### Steps
-1. **Copy a template**:
-   \`\`\`bash
-   cp .caws/templates/feature.plan.md docs/plans/FEATURE-001.md
-   \`\`\`
-
-2. **Customize the plan**:
-   - Update title and description
-   - Fill in acceptance criteria (GIVEN/WHEN/THEN format)
-   - Set appropriate risk tier
-   - Define scope and invariants
-
-3. **Write tests first** (TDD approach):
-   \`\`\`bash
-   # For ${projectType} projects, focus on:
-   ${getTestingGuidance(projectType)}
-   \`\`\`
-
-4. **Implement the feature**:
-   - Stay within change budget limits
-   - Follow acceptance criteria
-   - Maintain system invariants
-
-5. **Run full verification**:
-   \`\`\`bash
-   caws validate --suggestions
-   ${hasTests ? 'npm test' : '# Add tests when ready'}
-   ${hasLinting ? 'npm run lint' : '# Add linting when ready'}
-   \`\`\`
-
----
-
-## Phase 3: CI/CD Setup (20 mins)
-
-Set up automated quality gates:
-
-### GitHub Actions (Recommended)
-1. **Create workflow**: \`.github/workflows/caws.yml\`
-   \`\`\`yaml
-   name: CAWS Quality Gates
-   on: [pull_request]
-
-   jobs:
-     validate:
-       runs-on: ubuntu-latest
-       steps:
-         - uses: actions/checkout@v4
-         - uses: actions/setup-node@v4
-           with:
-             node-version: '18'
-         - run: npm ci
-         - run: npx caws validate --quiet
-         - run: npm test  # Add when ready
-   \`\`\`
-
-2. **Configure branch protection**:
-   - Require PR validation
-   - Require tests to pass
-   - Require CAWS spec validation
-
-### Other CI Systems
-- **GitLab CI**: Use \`caws validate\` in \`.gitlab-ci.yml\`
-- **Jenkins**: Add validation step to pipeline
-- **CircleCI**: Include in \`.circleci/config.yml\`
-
----
-
-## Phase 4: Team Onboarding (ongoing)
-
-### For Team Members
-1. **Read the basics**: Start with this guide
-2. **Learn by example**: Review completed features
-3. **Practice**: Create small features following the process
-4. **Contribute**: Help improve templates and processes
-
-### For Project Leads
-1. **Customize templates**: Adapt to team preferences
-2. **Set standards**: Define project-specific conventions
-3. **Monitor quality**: Review metrics and adjust gates
-4. **Scale practices**: Apply CAWS to more complex work
-
----
-
-## Key Concepts Quick Reference
-
-### Risk Tiers
-- **Tier 1**: Critical (auth, billing, migrations) - Max rigor
-- **Tier 2**: Standard (features, APIs) - Standard rigor  
-- **Tier 3**: Low risk (UI, tooling) - Basic rigor
-
-### Change Budget
-- Limits help maintain quality and reviewability
-- Adjust based on risk tier and team experience
-- Track actual vs. budgeted changes
-
-### System Invariants
-- Core guarantees that must always hold true
-- Examples: "Data integrity maintained", "API contracts honored"
-- Define 2-4 key invariants for your system
-
-### Acceptance Criteria
-- Use GIVEN/WHEN/THEN format
-- Focus on observable behavior
-- Include edge cases and error conditions
-
----
-
-## Common Pitfalls to Avoid
-
-### For ${capitalizedType} Projects
-${getProjectSpecificPitfalls(projectType)}
-
-### General Issues
-1. **Over-customization**: Start with defaults, customize gradually
-2. **Missing invariants**: Define what must never break
-3. **Vague acceptance**: Make criteria measurable and testable
-4. **Large changes**: Break big features into smaller, reviewable pieces
-
----
-
-## Resources
-
-### Documentation
-- **Quick Reference**: This guide
-- **Templates**: \`.caws/templates/\`
-- **Examples**: \`.caws/examples/\` (when available)
-
-### Commands
-- \`caws validate --suggestions\` - Get help with issues
-- \`caws validate --auto-fix\` - Fix safe problems automatically
-- \`caws init --interactive\` - Customize existing setup
-
-### Community
-- **GitHub Issues**: Report problems and request features
-- **Discussions**: Share experiences and best practices
-- **Wiki**: Growing collection of examples and guides
-
----
-
-## Next Steps
-
-1. **Right now**: Review your working spec and customize it
-2. **Today**: Create your first feature plan
-3. **This week**: Set up CI/CD and branch protection
-4. **Ongoing**: Refine processes based on team feedback
-
-Remember: CAWS is a framework, not a straightjacket. Adapt it to your team's needs while maintaining the core principles of determinism and quality.
-
-**Happy coding! 🎯**
-`;
-
-  return guide;
-}
-
-function getTestingGuidance(projectType) {
-  const guidance = {
-    extension: `- Webview rendering tests\n- Command registration tests\n- Extension activation tests`,
-    library: `- Component rendering tests\n- API function tests\n- Type export tests`,
-    api: `- Endpoint response tests\n- Error handling tests\n- Authentication tests`,
-    cli: `- Command parsing tests\n- Output formatting tests\n- Error code tests`,
-    monorepo: `- Cross-package integration tests\n- Shared module tests\n- Build pipeline tests`,
-    application: `- User interaction tests\n- State management tests\n- Integration tests`,
-  };
-  return (
-    guidance[projectType] || `- Unit tests for core functions\n- Integration tests for workflows`
-  );
-}
-
-function getProjectSpecificPitfalls(projectType) {
-  const pitfalls = {
-    extension: `1. **Webview security**: Never use \`vscode.executeCommand\` from untrusted content
-2. **Activation timing**: Test cold start performance
-3. **API compatibility**: Check VS Code API version compatibility`,
-    library: `1. **Bundle size**: Monitor and limit package size
-2. **Type exports**: Ensure all public APIs are typed
-3. **Peer dependencies**: Handle React/Angular versions carefully`,
-    api: `1. **Backward compatibility**: Version APIs carefully
-2. **Rate limiting**: Test and document limits
-3. **Data validation**: Validate all inputs thoroughly`,
-    cli: `1. **Exit codes**: Use standard codes (0=success, 1=error)
-2. **Help text**: Keep it concise and helpful
-3. **Error messages**: Make them actionable`,
-    monorepo: `1. **Dependency cycles**: Avoid circular imports
-2. **Version consistency**: Keep package versions aligned
-3. **Build order**: Ensure correct build dependencies`,
-    application: `1. **State consistency**: Prevent invalid state transitions
-2. **Performance**: Monitor and optimize critical paths
-3. **Accessibility**: Test with screen readers and keyboard navigation`,
-  };
-  return (
-    pitfalls[projectType] ||
-    `1. **Test coverage**: Maintain adequate test coverage
-2. **Documentation**: Keep code and APIs documented
-3. **Dependencies**: Review and update regularly`
-  );
-}
-
-/**
- * Generate smart .gitignore patterns for CAWS projects
- */
-function generateGitignorePatterns(existingGitignore = '') {
-  const cawsPatterns = `
-# CAWS Configuration (tracked - these should be versioned)
-# Note: .caws/ and .agent/ are tracked for provenance
-# But we exclude temporary/generated files:
-
-# CAWS temporary files (ignored)
-.agent/temp/
-.agent/cache/
-.caws/.cache/
-.caws/tmp/
-
-# Build outputs (common patterns)
-dist/
-build/
-*.tsbuildinfo
-.next/
-.nuxt/
-.vite/
-
-# Dependencies
-node_modules/
-.pnpm-store/
-
-# Environment files
-.env
-.env.local
-.env.development.local
-.env.test.local
-.env.production.local
-
-# IDE files
-.vscode/settings.json
-.idea/
-*.swp
-*.swo
-
-# OS files
-.DS_Store
-Thumbs.db
-
-# Logs
-logs/
-*.log
-npm-debug.log*
-yarn-debug.log*
-yarn-error.log*
-
-# Coverage reports
-coverage/
-.nyc_output/
-
-# Test results
-test-results/
-playwright-report/
-`;
-
-  // If there's an existing .gitignore, merge intelligently
-  if (existingGitignore.trim()) {
-    // Check if CAWS patterns are already present
-    if (existingGitignore.includes('# CAWS Configuration')) {
-      console.log(chalk.blue('ℹ️  .gitignore already contains CAWS patterns - skipping'));
-      return existingGitignore;
-    }
-
-    // Append CAWS patterns to existing .gitignore
-    return existingGitignore.trim() + '\n\n' + cawsPatterns.trim() + '\n';
-  }
-
-  return cawsPatterns.trim();
-}
-
-// Only log schema validation if not running quiet commands
-if (!process.argv.includes('--version') && !process.argv.includes('-V')) {
-  console.log(chalk.green('✅ Schema validation initialized successfully'));
-}
-
-/**
- * Generate working spec YAML with user input
- * @param {Object} answers - User responses
- * @returns {string} - Generated YAML content
- */
-function generateWorkingSpec(answers) {
-  const template = {
-    id: answers.projectId,
-    title: answers.projectTitle,
-    risk_tier: answers.riskTier,
-    mode: answers.projectMode,
-    change_budget: {
-      max_files: answers.maxFiles,
-      max_loc: answers.maxLoc,
-    },
-    blast_radius: {
-      modules: answers.blastModules
-        .split(',')
-        .map((m) => m.trim())
-        .filter((m) => m),
-      data_migration: answers.dataMigration,
-    },
-    operational_rollback_slo: answers.rollbackSlo,
-    threats: (answers.projectThreats || '')
-      .split('\n')
-      .map((t) => t.trim())
-      .filter((t) => t && !t.startsWith('-') === false), // Allow lines starting with -
-    scope: {
-      in: (answers.scopeIn || '')
-        .split(',')
-        .map((s) => s.trim())
-        .filter((s) => s),
-      out: (answers.scopeOut || '')
-        .split(',')
-        .map((s) => s.trim())
-        .filter((s) => s),
-    },
-    invariants: (answers.projectInvariants || '')
-      .split('\n')
-      .map((i) => i.trim())
-      .filter((i) => i),
-    acceptance: answers.acceptanceCriteria
-      .split('\n')
-      .filter((a) => a.trim())
-      .map((criteria, index) => {
-        const id = `A${index + 1}`;
-        const upperCriteria = criteria.toUpperCase();
-
-        // Try different variations of the format
-        let given = '';
-        let when = '';
-        let then = '';
-
-        if (
-          upperCriteria.includes('GIVEN') &&
-          upperCriteria.includes('WHEN') &&
-          upperCriteria.includes('THEN')
-        ) {
-          given = criteria.split(/WHEN/i)[0]?.replace(/GIVEN/i, '').trim() || '';
-          const whenThen = criteria.split(/WHEN/i)[1];
-          when = whenThen?.split(/THEN/i)[0]?.trim() || '';
-          then = whenThen?.split(/THEN/i)[1]?.trim() || '';
-        } else {
-          // Fallback: just split by lines and create simple criteria
-          given = 'Current system state';
-          when = criteria.replace(/^(GIVEN|WHEN|THEN)/i, '').trim();
-          then = 'Expected behavior occurs';
-        }
-
-        return {
-          id,
-          given: given || 'Current system state',
-          when: when || criteria,
-          then: then || 'Expected behavior occurs',
-        };
-      }),
-    non_functional: {
-      a11y: answers.a11yRequirements
-        .split(',')
-        .map((a) => a.trim())
-        .filter((a) => a),
-      perf: { api_p95_ms: answers.perfBudget },
-      security: answers.securityRequirements
-        .split(',')
-        .map((s) => s.trim())
-        .filter((s) => s),
-    },
-    contracts: [
-      {
-        type: answers.contractType,
-        path: answers.contractPath,
-      },
-    ],
-    observability: {
-      logs: answers.observabilityLogs
-        .split(',')
-        .map((l) => l.trim())
-        .filter((l) => l),
-      metrics: answers.observabilityMetrics
-        .split(',')
-        .map((m) => m.trim())
-        .filter((m) => m),
-      traces: answers.observabilityTraces
-        .split(',')
-        .map((t) => t.trim())
-        .filter((t) => t),
-    },
-    migrations: (answers.migrationPlan || '')
-      .split('\n')
-      .map((m) => m.trim())
-      .filter((m) => m),
-    rollback: (answers.rollbackPlan || '')
-      .split('\n')
-      .map((r) => r.trim())
-      .filter((r) => r),
-    human_override: answers.needsOverride
-      ? {
-          enabled: true,
-          approver: answers.overrideApprover,
-          rationale: answers.overrideRationale,
-          waived_gates: answers.waivedGates,
-          approved_at: new Date().toISOString(),
-          expires_at: new Date(
-            Date.now() + answers.overrideExpiresDays * 24 * 60 * 60 * 1000
-          ).toISOString(),
-        }
-      : undefined,
-    experimental_mode: answers.isExperimental
-      ? {
-          enabled: true,
-          rationale: answers.experimentalRationale,
-          expires_at: new Date(
-            Date.now() + answers.experimentalExpiresDays * 24 * 60 * 60 * 1000
-          ).toISOString(),
-          sandbox_location: answers.experimentalSandbox,
-        }
-      : undefined,
-    ai_assessment: {
-      confidence_level: answers.aiConfidence,
-      uncertainty_areas: answers.uncertaintyAreas
-        .split(',')
-        .map((a) => a.trim())
-        .filter((a) => a),
-      complexity_factors: answers.complexityFactors
-        .split(',')
-        .map((f) => f.trim())
-        .filter((f) => f),
-      risk_factors: [], // Could be populated by AI analysis
-    },
-  };
-
-  return yaml.dump(template, { indent: 2 });
-}
-
-/**
- * Validate generated working spec against JSON schema
- * @param {string} specContent - YAML spec content
- * @param {Object} answers - User responses for error context
- */
-function validateGeneratedSpec(specContent, _answers) {
-  try {
-    const spec = yaml.load(specContent);
-
-    const isValid = validateWorkingSpec(spec);
-
-    if (!isValid) {
-      console.error(chalk.red('❌ Generated working spec failed validation:'));
-      validateWorkingSpec.errors.forEach((error) => {
-        console.error(`   - ${error.instancePath || 'root'}: ${error.message}`);
-      });
-
-      // Provide helpful guidance
-      console.log(chalk.blue('\n💡 Validation Tips:'));
-      console.log('   - Ensure risk_tier is 1, 2, or 3');
-      console.log('   - Check that scope.in is not empty');
-      console.log('   - Verify invariants and acceptance criteria are provided');
-      console.log('   - For tier 1 and 2, ensure contracts are specified');
-
-      process.exit(1);
-    }
-
-    console.log(chalk.green('✅ Generated working spec passed validation'));
-  } catch (error) {
-    console.error(chalk.red('❌ Error validating working spec:'), error.message);
-    process.exit(1);
-  }
-}
-
-/**
- * Detect project type from existing files and structure
- */
-function detectProjectType(cwd = process.cwd()) {
-  const files = fs.readdirSync(cwd);
-
-  // Check for various project indicators
-  const hasPackageJson = files.includes('package.json');
-  const hasPnpm = files.includes('pnpm-workspace.yaml');
-  const hasYarn = files.includes('yarn.lock');
-
-  let packageJson = {};
-  if (hasPackageJson) {
-    try {
-      packageJson = JSON.parse(fs.readFileSync(path.join(cwd, 'package.json'), 'utf8'));
-    } catch (e) {
-      // Ignore parse errors
-    }
-  }
-
-  // VS Code Extension detection
-  const isVscodeExtension =
-    packageJson.engines?.vscode ||
-    packageJson.contributes ||
-    packageJson.activationEvents ||
-    packageJson.main?.includes('extension.js');
-
-  // Monorepo detection
-  const isMonorepo = hasPnpm || hasYarn || files.includes('packages') || files.includes('apps');
-
-  // Library detection
-  const isLibrary = packageJson.main || packageJson.module || packageJson.exports;
-
-  // CLI detection
-  const isCli = packageJson.bin || packageJson.name?.startsWith('@') === false;
-
-  // API detection
-  const isApi =
-    packageJson.scripts?.start ||
-    packageJson.dependencies?.express ||
-    packageJson.dependencies?.fastify ||
-    packageJson.dependencies?.['@types/express'];
-
-  // Determine primary type
-  if (isVscodeExtension) return 'extension';
-  if (isMonorepo) return 'monorepo';
-  if (isApi) return 'api';
-  if (isLibrary) return 'library';
-  if (isCli) return 'cli';
-
-  // Default fallback
-  return 'application';
-}
-
-/**
- * Generate working spec from project analysis
- */
-function generateWorkingSpecFromAnalysis(analysis) {
-  const { projectType, packageJson } = analysis;
-
-  const templates = {
-    extension: {
-      risk_tier: 2,
-      mode: 'feature',
-      change_budget: { max_files: 25, max_loc: 1000 },
-      invariants: [
-        'Webview only accesses workspace files via VS Code API',
-        'Extension activates in <1s on typical machine',
-        'All commands have keyboard shortcuts',
-      ],
-      scope: {
-        in: ['src/', 'package.json', 'tsconfig.json'],
-        out: ['node_modules/', '*.vsix'],
-      },
-      acceptance: [
-        {
-          id: 'A1',
-          given: 'User has workspace open',
-          when: 'Extension activates',
-          then: 'Webview loads within 1 second',
-        },
-      ],
-      non_functional: {
-        a11y: ['keyboard navigation', 'screen reader support', 'high contrast theme'],
-        perf: { api_p95_ms: 100 },
-        security: ['CSP enforcement for webviews', 'No arbitrary filesystem access'],
-      },
-    },
-    library: {
-      risk_tier: 2,
-      mode: 'feature',
-      change_budget: { max_files: 20, max_loc: 800 },
-      invariants: [
-        'No runtime dependencies except React',
-        'Tree-shakeable exports',
-        'TypeScript types exported',
-      ],
-      scope: {
-        in: ['src/', 'lib/', 'package.json'],
-        out: ['examples/', 'docs/', 'node_modules/'],
-      },
-      acceptance: [
-        {
-          id: 'A1',
-          given: 'Library is imported',
-          when: 'Component is rendered',
-          then: 'No runtime errors occur',
-        },
-      ],
-      non_functional: {
-        a11y: ['WCAG 2.1 AA compliance', 'Semantic HTML'],
-        perf: { bundle_size_kb: 50 },
-        security: ['Input validation', 'XSS prevention'],
-      },
-    },
-    api: {
-      risk_tier: 1,
-      mode: 'feature',
-      change_budget: { max_files: 40, max_loc: 1500 },
-      invariants: [
-        'API maintains backward compatibility',
-        'All endpoints respond within 100ms',
-        'Data consistency maintained across requests',
-      ],
-      scope: {
-        in: ['src/', 'routes/', 'models/', 'tests/'],
-        out: ['node_modules/', 'logs/', 'temp/'],
-      },
-      acceptance: [
-        {
-          id: 'A1',
-          given: 'Valid request is made',
-          when: 'Endpoint is called',
-          then: 'Correct response returned within SLO',
-        },
-      ],
-      non_functional: {
-        a11y: ['API documentation accessible'],
-        perf: { api_p95_ms: 100 },
-        security: ['Input validation', 'Rate limiting', 'Authentication'],
-      },
-    },
-    cli: {
-      risk_tier: 3,
-      mode: 'feature',
-      change_budget: { max_files: 15, max_loc: 600 },
-      invariants: [
-        'CLI exits with appropriate codes',
-        'Help text is informative',
-        'Error messages are clear',
-      ],
-      scope: {
-        in: ['src/', 'bin/', 'lib/', 'tests/'],
-        out: ['node_modules/', 'dist/'],
-      },
-      acceptance: [
-        {
-          id: 'A1',
-          given: 'User runs command with --help',
-          when: 'Help flag is provided',
-          then: 'Help text displays clearly',
-        },
-      ],
-      non_functional: {
-        a11y: ['Color contrast in terminal output'],
-        perf: { api_p95_ms: 50 },
-        security: ['Input validation', 'No arbitrary execution'],
-      },
-    },
-    monorepo: {
-      risk_tier: 1,
-      mode: 'feature',
-      change_budget: { max_files: 50, max_loc: 2000 },
-      invariants: [
-        'All packages remain compatible',
-        'Cross-package dependencies work',
-        'Build system remains stable',
-      ],
-      scope: {
-        in: ['packages/', 'apps/', 'tools/', 'scripts/'],
-        out: ['node_modules/', 'dist/', 'build/'],
-      },
-      acceptance: [
-        {
-          id: 'A1',
-          given: 'Change is made to shared package',
-          when: 'All dependent packages build',
-          then: 'No breaking changes introduced',
-        },
-      ],
-      non_functional: {
-        a11y: ['Documentation accessible across packages'],
-        perf: { api_p95_ms: 200 },
-        security: ['Dependency audit passes', 'No vulnerable packages'],
-      },
-    },
-    application: {
-      risk_tier: 2,
-      mode: 'feature',
-      change_budget: { max_files: 30, max_loc: 1200 },
-      invariants: [
-        'Application remains functional',
-        'User data is preserved',
-        'Performance does not degrade',
-      ],
-      scope: {
-        in: ['src/', 'components/', 'pages/', 'lib/'],
-        out: ['node_modules/', 'build/', 'dist/'],
-      },
-      acceptance: [
-        {
-          id: 'A1',
-          given: 'User interacts with application',
-          when: 'Feature is used',
-          then: 'Expected behavior occurs',
-        },
-      ],
-      non_functional: {
-        a11y: ['WCAG 2.1 AA compliance', 'Keyboard navigation'],
-        perf: { api_p95_ms: 250 },
-        security: ['Input validation', 'Authentication', 'Authorization'],
-      },
-    },
-  };
-
-  const baseSpec = templates[projectType] || templates.application;
-
-  return {
-    id: `${packageJson.name?.toUpperCase().replace(/[^A-Z0-9]/g, '-') || 'PROJECT'}-001`,
-    title: packageJson.name || 'Project',
-    risk_tier: baseSpec.risk_tier,
-    mode: baseSpec.mode,
-    change_budget: baseSpec.change_budget,
-    blast_radius: {
-      modules: ['core', 'api', 'ui'],
-      data_migration: false,
-    },
-    operational_rollback_slo: '5m',
-    scope: baseSpec.scope,
-    invariants: baseSpec.invariants,
-    acceptance: baseSpec.acceptance,
-    non_functional: baseSpec.non_functional,
-    contracts: [
-      {
-        type: projectType === 'api' ? 'openapi' : 'none',
-        path: projectType === 'api' ? 'docs/api.yaml' : '',
-      },
-    ],
-    observability: {
-      logs: ['error', 'warn', 'info'],
-      metrics: ['requests_total', 'errors_total'],
-      traces: ['request_flow'],
-    },
-    ai_assessment: {
-      confidence_level: 8,
-      uncertainty_areas: [],
-      complexity_factors: [],
-      risk_factors: [],
-    },
-  };
-}
-
-/**
- * Detect if current directory appears to be a project that should be initialized directly
- */
-function shouldInitInCurrentDirectory(projectName, currentDir) {
-  // If explicitly '.', always init in current directory
-  if (projectName === '.') return true;
-
-  // Check for common project indicators
-  const projectIndicators = [
-    'package.json',
-    'tsconfig.json',
-    'jest.config.js',
-    'eslint.config.js',
-    'README.md',
-    'src/',
-    'lib/',
-    'app/',
-    'packages/',
-    '.git/',
-    'node_modules/', // Even if empty, suggests intent to be a project
-  ];
-
-  const files = fs.readdirSync(currentDir);
-  const hasProjectIndicators = projectIndicators.some((indicator) => {
-    if (indicator.endsWith('/')) {
-      return files.includes(indicator.slice(0, -1));
-    }
-    return files.includes(indicator);
-  });
-
-  return hasProjectIndicators;
-}
-
-/**
- * Initialize a new project with CAWS
- */
-async function initProject(projectName, options) {
-  const currentDir = process.cwd();
-  const isCurrentDirInit = shouldInitInCurrentDirectory(projectName, currentDir);
-
-  if (!isCurrentDirInit && projectName !== '.') {
-    console.log(chalk.cyan(`🚀 Initializing new CAWS project: ${projectName}`));
-    console.log(chalk.gray(`   (Creating subdirectory: ${projectName}/)`));
-  } else {
-    console.log(
-      chalk.cyan(`🚀 Initializing CAWS in current project: ${path.basename(currentDir)}`)
-    );
-    console.log(chalk.gray(`   (Adding CAWS files to existing project)`));
-  }
-
-  let answers; // Will be set either interactively or with defaults
-
-  try {
-    // Validate project name
-    if (!projectName || projectName.trim() === '') {
-      console.error(chalk.red('❌ Project name is required'));
-      console.error(chalk.blue('💡 Usage: caws init <project-name>'));
-      process.exit(1);
-    }
-
-    // Special case: '.' means current directory, don't sanitize
-    if (projectName !== '.') {
-      // Sanitize project name
-      const sanitizedName = projectName.replace(/[^a-zA-Z0-9-_]/g, '-').toLowerCase();
-      if (sanitizedName !== projectName) {
-        console.warn(chalk.yellow(`⚠️  Project name sanitized to: ${sanitizedName}`));
-        projectName = sanitizedName;
-      }
-    }
-
-    // Validate project name length
-    if (projectName.length > 50) {
-      console.error(chalk.red('❌ Project name is too long (max 50 characters)'));
-      console.error(chalk.blue('💡 Usage: caws init <project-name>'));
-      process.exit(1);
-    }
-
-    // Validate project name format
-    if (projectName.length === 0) {
-      console.error(chalk.red('❌ Project name cannot be empty'));
-      console.error(chalk.blue('💡 Usage: caws init <project-name>'));
-      process.exit(1);
-    }
-
-    // Check for invalid characters that should cause immediate failure
-    if (projectName.includes('/') || projectName.includes('\\') || projectName.includes('..')) {
-      console.error(chalk.red('❌ Project name contains invalid characters'));
-      console.error(chalk.blue('💡 Usage: caws init <project-name>'));
-      console.error(chalk.blue('💡 Project name should not contain: / \\ ..'));
-      process.exit(1);
-    }
-
-    // Determine if initializing in current directory
-    const initInCurrentDir = projectName === '.';
-    const targetDir = initInCurrentDir ? process.cwd() : path.resolve(process.cwd(), projectName);
-
-    // Check if target directory already exists and has content (skip check for current directory)
-    if (!initInCurrentDir && fs.existsSync(projectName)) {
-      const existingFiles = fs.readdirSync(projectName);
-      if (existingFiles.length > 0) {
-        console.error(chalk.red(`❌ Directory '${projectName}' already exists and contains files`));
-        console.error(chalk.blue('💡 To initialize CAWS in current directory instead:'));
-        console.error(`   ${chalk.cyan('caws init .')}`);
-        console.error(chalk.blue('💡 Or choose a different name/remove existing directory'));
-        process.exit(1);
-      }
-    }
-
-    // Check if current directory has project files when trying to init in subdirectory
-    if (!initInCurrentDir) {
-      const currentDirFiles = fs.readdirSync(process.cwd());
-      const hasProjectFiles = currentDirFiles.some(
-        (file) => !file.startsWith('.') && file !== 'node_modules' && file !== '.git'
-      );
-
-      if (hasProjectFiles) {
-        console.warn(chalk.yellow('⚠️  Current directory contains project files'));
-        console.warn(
-          chalk.blue('💡 You might want to initialize CAWS in current directory instead:')
-        );
-        console.warn(`   ${chalk.cyan('caws init .')}`);
-        console.warn(chalk.blue('   Or continue to create subdirectory (Ctrl+C to cancel)'));
-      }
-    }
-
-    // Save the original template directory before changing directories
-    const originalTemplateDir = cawsSetup?.hasTemplateDir ? cawsSetup.templateDir : null;
-
-    // Check for existing agents.md/caws.md in target directory
-    const existingAgentsMd = fs.existsSync(path.join(targetDir, 'agents.md'));
-    const existingCawsMd = fs.existsSync(path.join(targetDir, 'caws.md'));
-
-    // Create project directory and change to it (unless already in current directory)
-    if (!initInCurrentDir) {
-      await fs.ensureDir(projectName);
-      process.chdir(projectName);
-      console.log(chalk.green(`📁 Created project directory: ${projectName}`));
-    } else {
-      console.log(chalk.green(`📁 Initializing in current directory`));
-    }
-
-    // Detect and adapt to existing setup
-    const currentSetup = detectCAWSSetup(process.cwd());
-
-    if (currentSetup.type === 'new') {
-      // Create minimal CAWS structure
-      await fs.ensureDir('.caws');
-      await fs.ensureDir('.agent');
-      console.log(chalk.blue('ℹ️  Created basic CAWS structure'));
-
-      // Copy agents.md guide if templates are available
-      if (originalTemplateDir) {
-        try {
-          const agentsMdSource = path.join(originalTemplateDir, 'agents.md');
-          let targetFile = 'agents.md';
-
-          if (fs.existsSync(agentsMdSource)) {
-            // Use the pre-checked values for conflicts
-            if (existingAgentsMd) {
-              // Conflict: user already has agents.md
-              if (options.interactive && !options.nonInteractive) {
-                // Interactive mode: ask user
-                const overwriteAnswer = await inquirer.prompt([
-                  {
-                    type: 'confirm',
-                    name: 'overwrite',
-                    message: '⚠️  agents.md already exists. Overwrite with CAWS guide?',
-                    default: false,
-                  },
-                ]);
-
-                if (overwriteAnswer.overwrite) {
-                  targetFile = 'agents.md';
-                } else {
-                  targetFile = 'caws.md';
-                }
-              } else {
-                // Non-interactive mode: use caws.md instead
-                targetFile = 'caws.md';
-                console.log(chalk.blue('ℹ️  agents.md exists, using caws.md for CAWS guide'));
-              }
-            }
-
-            // If caws.md also exists and that's our target, skip
-            if (targetFile === 'caws.md' && existingCawsMd) {
-              console.log(
-                chalk.yellow('⚠️  Both agents.md and caws.md exist, skipping guide copy')
-              );
-            } else {
-              const agentsMdDest = path.join(process.cwd(), targetFile);
-              await fs.copyFile(agentsMdSource, agentsMdDest);
-              console.log(chalk.green(`✅ Added ${targetFile} guide`));
-            }
-          }
-        } catch (templateError) {
-          console.warn(chalk.yellow('⚠️  Could not copy agents guide:'), templateError.message);
-          console.warn(
-            chalk.blue('💡 You can manually copy the guide from the caws-template package')
-          );
-        }
-      }
-    } else {
-      // Already has CAWS setup
-      console.log(chalk.green('✅ CAWS project detected - skipping template copy'));
-    }
-
-    // Handle interactive wizard or template-based setup
-    if (options.interactive && !options.nonInteractive) {
-      console.log(chalk.cyan('🎯 CAWS Interactive Setup Wizard'));
-      console.log(chalk.blue('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━'));
-      console.log(chalk.gray('This wizard will guide you through creating a CAWS working spec\n'));
-
-      // Detect project type
-      const detectedType = detectProjectType(process.cwd());
-      console.log(chalk.blue(`📦 Detected project type: ${chalk.cyan(detectedType)}`));
-
-      // Get package.json info if available
-      let packageJson = {};
-      try {
-        packageJson = JSON.parse(fs.readFileSync(path.join(process.cwd(), 'package.json'), 'utf8'));
-      } catch (e) {
-        // No package.json, that's fine
-      }
-
-      const wizardQuestions = [
-        {
-          type: 'list',
-          name: 'projectType',
-          message: '❓ What type of project is this?',
-          choices: [
-            {
-              name: '🔌 VS Code Extension (webview, commands, integrations)',
-              value: 'extension',
-              short: 'VS Code Extension',
-            },
-            {
-              name: '📚 Library/Package (reusable components, utilities)',
-              value: 'library',
-              short: 'Library',
-            },
-            {
-              name: '🌐 API Service (REST, GraphQL, microservices)',
-              value: 'api',
-              short: 'API Service',
-            },
-            {
-              name: '💻 CLI Tool (command-line interface)',
-              value: 'cli',
-              short: 'CLI Tool',
-            },
-            {
-              name: '🏗️  Monorepo (multiple packages/apps)',
-              value: 'monorepo',
-              short: 'Monorepo',
-            },
-            {
-              name: '📱 Application (standalone app)',
-              value: 'application',
-              short: 'Application',
-            },
-          ],
-          default: detectedType,
-        },
-        {
-          type: 'input',
-          name: 'projectTitle',
-          message: '📝 Project Title (descriptive name):',
-          default:
-            packageJson.name ||
-            projectName.charAt(0).toUpperCase() + projectName.slice(1).replace(/-/g, ' '),
-        },
-        {
-          type: 'list',
-          name: 'riskTier',
-          message: '⚠️  Risk Tier (higher tier = more rigor):',
-          choices: [
-            {
-              name: '🔴 Tier 1 - Critical (auth, billing, migrations) - Max rigor',
-              value: 1,
-              short: 'Critical',
-            },
-            {
-              name: '🟡 Tier 2 - Standard (features, APIs) - Standard rigor',
-              value: 2,
-              short: 'Standard',
-            },
-            {
-              name: '🟢 Tier 3 - Low Risk (UI, tooling) - Basic rigor',
-              value: 3,
-              short: 'Low Risk',
-            },
-          ],
-          default: (answers) => {
-            const typeDefaults = {
-              extension: 2,
-              library: 2,
-              api: 1,
-              cli: 3,
-              monorepo: 1,
-              application: 2,
-            };
-            return typeDefaults[answers.projectType] || 2;
-          },
-        },
-        {
-          type: 'list',
-          name: 'projectMode',
-          message: '🎯 Primary development mode:',
-          choices: [
-            { name: '✨ feature (new functionality)', value: 'feature' },
-            { name: '🔄 refactor (code restructuring)', value: 'refactor' },
-            { name: '🐛 fix (bug fixes)', value: 'fix' },
-            { name: '📚 doc (documentation)', value: 'doc' },
-            { name: '🧹 chore (maintenance)', value: 'chore' },
-          ],
-          default: 'feature',
-        },
-        {
-          type: 'number',
-          name: 'maxFiles',
-          message: '📊 Max files to change per feature:',
-          default: (answers) => {
-            const tierDefaults = { 1: 40, 2: 25, 3: 15 };
-            const typeAdjustments = {
-              extension: -5,
-              library: -10,
-              api: 10,
-              cli: -10,
-              monorepo: 25,
-              application: 0,
-            };
-            return Math.max(
-              5,
-              tierDefaults[answers.riskTier] + (typeAdjustments[answers.projectType] || 0)
-            );
-          },
-        },
-        {
-          type: 'number',
-          name: 'maxLoc',
-          message: '📏 Max lines of code to change per feature:',
-          default: (answers) => {
-            const tierDefaults = { 1: 1500, 2: 1000, 3: 600 };
-            const typeAdjustments = {
-              extension: -200,
-              library: -300,
-              api: 500,
-              cli: -400,
-              monorepo: 1000,
-              application: 0,
-            };
-            return Math.max(
-              50,
-              tierDefaults[answers.riskTier] + (typeAdjustments[answers.projectType] || 0)
-            );
-          },
-        },
-        {
-          type: 'input',
-          name: 'blastModules',
-          message: '💥 Affected modules (comma-separated):',
-          default: (answers) => {
-            const typeDefaults = {
-              extension: 'core,webview',
-              library: 'components,utils',
-              api: 'routes,models,controllers',
-              cli: 'commands,utils',
-              monorepo: 'shared,packages',
-              application: 'ui,logic,data',
-            };
-            return typeDefaults[answers.projectType] || 'core,ui';
-          },
-        },
-        {
-          type: 'confirm',
-          name: 'dataMigration',
-          message: '🗄️  Requires data migration?',
-          default: false,
-        },
-        {
-          type: 'list',
-          name: 'rollbackSlo',
-          message: '⏱️  Operational rollback SLO:',
-          choices: [
-            { name: '⚡ 1 minute (critical systems)', value: '1m' },
-            { name: '🟡 5 minutes (standard)', value: '5m' },
-            { name: '🟠 15 minutes (complex)', value: '15m' },
-            { name: '🔴 1 hour (data migration)', value: '1h' },
-          ],
-          default: '5m',
-        },
-        {
-          type: 'confirm',
-          name: 'enableCursorHooks',
-          message: '📌 Enable Cursor hooks for real-time quality gates?',
-          default: true,
-        },
-        {
-          type: 'checkbox',
-          name: 'cursorHookLevels',
-          message: '📌 Which Cursor hooks should be enabled?',
-          when: (answers) => answers.enableCursorHooks,
-          choices: [
-            { name: 'Safety (secrets, PII, dangerous commands)', value: 'safety', checked: true },
-            { name: 'Quality (formatting, linting, validation)', value: 'quality', checked: true },
-            {
-              name: 'Scope guards (file scope, naming conventions)',
-              value: 'scope',
-              checked: true,
-            },
-            { name: 'Audit trail (provenance tracking)', value: 'audit', checked: true },
-          ],
-          default: ['safety', 'quality', 'scope', 'audit'],
-        },
-        {
-          type: 'confirm',
-          name: 'configureGit',
-          message: '🔧 Configure git author information for commits?',
-          default: true,
-        },
-        {
-          type: 'input',
-          name: 'gitAuthorName',
-          message: '👤 Git author name:',
-          when: (answers) => answers.configureGit,
-          default: () => {
-            try {
-              return require('child_process')
-                .execSync('git config user.name', { encoding: 'utf8' })
-                .trim();
-            } catch {
-              return '';
-            }
-          },
-          validate: (input) => input.length > 0 || 'Git author name is required',
-        },
-        {
-          type: 'input',
-          name: 'gitAuthorEmail',
-          message: '📧 Git author email:',
-          when: (answers) => answers.configureGit,
-          default: () => {
-            try {
-              return require('child_process')
-                .execSync('git config user.email', { encoding: 'utf8' })
-                .trim();
-            } catch {
-              return '';
-            }
-          },
-          validate: (input) => {
-            const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
-            return emailRegex.test(input) || 'Please enter a valid email address';
-          },
-        },
-      ];
-
-      console.log(chalk.cyan('⏳ Gathering project requirements...'));
-
-      let wizardAnswers;
-      try {
-        wizardAnswers = await inquirer.prompt(wizardQuestions);
-      } catch (error) {
-        if (error.isTtyError) {
-          console.error(chalk.red('❌ Interactive prompts not supported in this environment'));
-          console.error(chalk.blue('💡 Run with --non-interactive flag to use defaults'));
-          process.exit(1);
-        } else {
-          console.error(chalk.red('❌ Error during interactive setup:'), error.message);
-          process.exit(1);
-        }
-      }
-
-      console.log(chalk.green('✅ Project requirements gathered successfully!'));
-
-      // Show summary before generating spec
-      console.log(chalk.bold('\n📋 Configuration Summary:'));
-      console.log(`   ${chalk.cyan('Type')}: ${wizardAnswers.projectType}`);
-      console.log(`   ${chalk.cyan('Project')}: ${wizardAnswers.projectTitle}`);
-      console.log(
-        `   ${chalk.cyan('Mode')}: ${wizardAnswers.projectMode} | ${chalk.cyan('Tier')}: ${wizardAnswers.riskTier}`
-      );
-      console.log(
-        `   ${chalk.cyan('Budget')}: ${wizardAnswers.maxFiles} files, ${wizardAnswers.maxLoc} lines`
-      );
-      console.log(
-        `   ${chalk.cyan('Data Migration')}: ${wizardAnswers.dataMigration ? 'Yes' : 'No'}`
-      );
-      console.log(`   ${chalk.cyan('Rollback SLO')}: ${wizardAnswers.rollbackSlo}`);
-
-      // Generate working spec using the template system
-      const analysis = {
-        projectType: wizardAnswers.projectType,
-        packageJson: { name: wizardAnswers.projectTitle },
-        hasTests: false,
-        hasLinting: false,
-        hasCi: false,
-      };
-
-      const workingSpecContent = yaml.dump(generateWorkingSpecFromAnalysis(analysis));
-
-      // Override template-generated values with wizard answers
-      const spec = yaml.load(workingSpecContent);
-      spec.title = wizardAnswers.projectTitle;
-      spec.risk_tier = wizardAnswers.riskTier;
-      spec.mode = wizardAnswers.projectMode;
-      spec.change_budget = {
-        max_files: wizardAnswers.maxFiles,
-        max_loc: wizardAnswers.maxLoc,
-      };
-      spec.blast_radius = {
-        modules: wizardAnswers.blastModules
-          .split(',')
-          .map((m) => m.trim())
-          .filter((m) => m),
-        data_migration: wizardAnswers.dataMigration,
-      };
-      spec.operational_rollback_slo = wizardAnswers.rollbackSlo;
-
-      // Add git configuration if provided
-      if (
-        wizardAnswers.configureGit &&
-        wizardAnswers.gitAuthorName &&
-        wizardAnswers.gitAuthorEmail
-      ) {
-        spec.git_config = {
-          author_name: wizardAnswers.gitAuthorName,
-          author_email: wizardAnswers.gitAuthorEmail,
-        };
-      }
-
-      // Validate the generated spec
-      validateGeneratedSpec(yaml.dump(spec), wizardAnswers);
-
-      // Save the working spec
-      await fs.writeFile('.caws/working-spec.yaml', yaml.dump(spec, { indent: 2 }));
-
-      console.log(chalk.green('✅ Working spec generated and validated'));
-
-      // Generate getting started guide
-      const wizardAnalysis = {
-        projectType: wizardAnswers.projectType,
-        packageJson: { name: wizardAnswers.projectTitle },
-        hasTests: false,
-        hasLinting: false,
-        hasCi: false,
-      };
-
-      const guideContent = generateGettingStartedGuide(wizardAnalysis);
-      await fs.writeFile('.caws/GETTING_STARTED.md', guideContent);
-      console.log(chalk.green('✅ Getting started guide created'));
-
-      // Generate or update .gitignore with CAWS patterns
-      const existingGitignore = fs.existsSync('.gitignore')
-        ? fs.readFileSync('.gitignore', 'utf8')
-        : '';
-
-      const updatedGitignore = generateGitignorePatterns(existingGitignore);
-      if (updatedGitignore !== existingGitignore) {
-        await fs.writeFile('.gitignore', updatedGitignore);
-        const action = existingGitignore.trim() ? 'updated' : 'created';
-        console.log(chalk.green(`✅ .gitignore ${action} with CAWS patterns`));
-      }
-
-      // Finalize project with provenance and git initialization
-      await finalizeProject(projectName, options, wizardAnswers);
-
-      continueToSuccess();
-      return;
-    }
-
-    // Handle template-based setup
-    if (options.template) {
-      console.log(chalk.cyan(`🎯 Using ${options.template} template`));
-
-      const validTemplates = ['extension', 'library', 'api', 'cli', 'monorepo'];
-      if (!validTemplates.includes(options.template)) {
-        console.error(chalk.red(`❌ Invalid template: ${options.template}`));
-        console.error(chalk.blue(`💡 Valid templates: ${validTemplates.join(', ')}`));
-        process.exit(1);
-      }
-
-      const analysis = {
-        projectType: options.template,
-        packageJson: { name: projectName },
-        hasTests: false,
-        hasLinting: false,
-        hasCi: false,
-      };
-
-      const workingSpecContent = yaml.dump(generateWorkingSpecFromAnalysis(analysis));
-
-      // Validate the generated spec
-      validateGeneratedSpec(workingSpecContent, { projectType: options.template });
-
-      // Save the working spec
-      await fs.writeFile('.caws/working-spec.yaml', workingSpecContent);
-
-      console.log(chalk.green('✅ Working spec generated from template'));
-
-      // Generate getting started guide
-      const templateAnalysis = {
-        projectType: options.template,
-        packageJson: { name: projectName },
-        hasTests: false,
-        hasLinting: false,
-        hasCi: false,
-      };
-
-      const guideContent = generateGettingStartedGuide(templateAnalysis);
-      await fs.writeFile('.caws/GETTING_STARTED.md', guideContent);
-      console.log(chalk.green('✅ Getting started guide created'));
-
-      // Generate or update .gitignore with CAWS patterns
-      const existingGitignore = fs.existsSync('.gitignore')
-        ? fs.readFileSync('.gitignore', 'utf8')
-        : '';
-
-      const updatedGitignore = generateGitignorePatterns(existingGitignore);
-      if (updatedGitignore !== existingGitignore) {
-        await fs.writeFile('.gitignore', updatedGitignore);
-        const action = existingGitignore.trim() ? 'updated' : 'created';
-        console.log(chalk.green(`✅ .gitignore ${action} with CAWS patterns`));
-      }
-
-      // Finalize project
-      await finalizeProject(projectName, options, { projectType: options.template });
-
-      continueToSuccess();
-      return;
-    }
-
-    // Set default answers for non-interactive mode
-    if (!options.interactive || options.nonInteractive) {
-      // Use directory name for current directory init
-      const displayName = initInCurrentDir ? path.basename(process.cwd()) : projectName;
-
-      answers = {
-        projectId: displayName.toUpperCase().replace(/[^A-Z0-9]/g, '-') + '-001',
-        projectTitle: displayName.charAt(0).toUpperCase() + displayName.slice(1).replace(/-/g, ' '),
-        riskTier: 2,
-        projectMode: 'feature',
-        maxFiles: 25,
-        maxLoc: 1000,
-        blastModules: 'core,ui',
-        dataMigration: false,
-        rollbackSlo: '5m',
-        projectThreats: 'Standard project threats',
-        scopeIn: 'project files',
-        scopeOut: 'external dependencies',
-        projectInvariants: 'System maintains consistency',
-        acceptanceCriteria: 'GIVEN current state WHEN action THEN expected result',
-        a11yRequirements: 'keyboard navigation, screen reader support',
-        perfBudget: 250,
-        securityRequirements: 'input validation, authentication',
-        contractType: 'openapi',
-        contractPath: 'apps/contracts/api.yaml',
-        observabilityLogs: 'auth.success,api.request',
-        observabilityMetrics: 'requests_total',
-        observabilityTraces: 'api_flow',
-        migrationPlan: 'Standard deployment process',
-        rollbackPlan: 'Feature flag disable and rollback',
-        needsOverride: false,
-        overrideRationale: '',
-        overrideApprover: '',
-        waivedGates: [],
-        overrideExpiresDays: 7,
-        isExperimental: false,
-        experimentalRationale: '',
-        experimentalSandbox: 'experimental/',
-        experimentalExpiresDays: 14,
-        aiConfidence: 7,
-        uncertaintyAreas: '',
-        complexityFactors: '',
-      };
-
-      // Generate working spec for non-interactive mode
-      const workingSpecContent = generateWorkingSpec(answers);
-
-      // Validate the generated spec
-      validateGeneratedSpec(workingSpecContent, answers);
-
-      // Save the working spec
-      await fs.writeFile('.caws/working-spec.yaml', workingSpecContent);
-
-      console.log(chalk.green('✅ Working spec generated and validated'));
-
-      // Generate getting started guide (detect project type)
-      const detectedType = detectProjectType(process.cwd());
-      const defaultAnalysis = {
-        projectType: detectedType,
-        packageJson: { name: displayName },
-        hasTests: false,
-        hasLinting: false,
-        hasCi: false,
-      };
-
-      const guideContent = generateGettingStartedGuide(defaultAnalysis);
-      await fs.writeFile('.caws/GETTING_STARTED.md', guideContent);
-      console.log(chalk.green('✅ Getting started guide created'));
-
-      // Generate or update .gitignore with CAWS patterns
-      const existingGitignore = fs.existsSync('.gitignore')
-        ? fs.readFileSync('.gitignore', 'utf8')
-        : '';
-
-      const updatedGitignore = generateGitignorePatterns(existingGitignore);
-      if (updatedGitignore !== existingGitignore) {
-        await fs.writeFile('.gitignore', updatedGitignore);
-        const action = existingGitignore.trim() ? 'updated' : 'created';
-        console.log(chalk.green(`✅ .gitignore ${action} with CAWS patterns`));
-      }
-
-      // Finalize project with provenance and git initialization
-      await finalizeProject(projectName, options, answers);
-
-      continueToSuccess();
-      return;
-    }
-
-    if (options.interactive && !options.nonInteractive) {
-      // Interactive setup with enhanced prompts
-      console.log(chalk.cyan('🔧 Starting interactive project configuration...'));
-      console.log(chalk.blue('💡 Press Ctrl+C at any time to exit and use defaults'));
-
-      const questions = [
-        {
-          type: 'input',
-          name: 'projectId',
-          message: '📋 Project ID (e.g., FEAT-1234, AUTH-456):',
-          default: projectName.toUpperCase().replace(/[^A-Z0-9]/g, '-') + '-001',
-          validate: (input) => {
-            if (!input.trim()) return 'Project ID is required';
-            const pattern = /^[A-Z]+-\d+$/;
-            if (!pattern.test(input)) {
-              return 'Project ID should be in format: PREFIX-NUMBER (e.g., FEAT-1234)';
-            }
-            return true;
-          },
-        },
-        {
-          type: 'input',
-          name: 'projectTitle',
-          message: '📝 Project Title (descriptive name):',
-          default: projectName.charAt(0).toUpperCase() + projectName.slice(1).replace(/-/g, ' '),
-          validate: (input) => {
-            if (!input.trim()) return 'Project title is required';
-            if (input.trim().length < 8) {
-              return 'Project title should be at least 8 characters long';
-            }
-            return true;
-          },
-        },
-        {
-          type: 'list',
-          name: 'riskTier',
-          message: '⚠️  Risk Tier (higher tier = more rigor):',
-          choices: [
-            {
-              name: '🔴 Tier 1 - Critical (auth, billing, migrations) - Max rigor',
-              value: 1,
-            },
-            {
-              name: '🟡 Tier 2 - Standard (features, APIs) - Standard rigor',
-              value: 2,
-            },
-            {
-              name: '🟢 Tier 3 - Low Risk (UI, tooling) - Basic rigor',
-              value: 3,
-            },
-          ],
-          default: 2,
-        },
-        {
-          type: 'list',
-          name: 'projectMode',
-          message: '🎯 Project Mode:',
-          choices: [
-            { name: '✨ feature (new functionality)', value: 'feature' },
-            { name: '🔄 refactor (code restructuring)', value: 'refactor' },
-            { name: '🐛 fix (bug fixes)', value: 'fix' },
-            { name: '📚 doc (documentation)', value: 'doc' },
-            { name: '🧹 chore (maintenance)', value: 'chore' },
-          ],
-          default: 'feature',
-        },
-        {
-          type: 'number',
-          name: 'maxFiles',
-          message: '📊 Max files to change:',
-          default: (answers) => {
-            // Dynamic defaults based on risk tier
-            switch (answers.riskTier) {
-              case 1:
-                return 40;
-              case 2:
-                return 25;
-              case 3:
-                return 15;
-              default:
-                return 25;
-            }
-          },
-          validate: (input) => {
-            if (input < 1) return 'Must change at least 1 file';
-            return true;
-          },
-        },
-        {
-          type: 'number',
-          name: 'maxLoc',
-          message: '📏 Max lines of code to change:',
-          default: (answers) => {
-            // Dynamic defaults based on risk tier
-            switch (answers.riskTier) {
-              case 1:
-                return 1500;
-              case 2:
-                return 1000;
-              case 3:
-                return 600;
-              default:
-                return 1000;
-            }
-          },
-          validate: (input) => {
-            if (input < 1) return 'Must change at least 1 line';
-            return true;
-          },
-        },
-        {
-          type: 'input',
-          name: 'blastModules',
-          message: '💥 Blast Radius - Affected modules (comma-separated):',
-          default: 'core,api',
-          validate: (input) => {
-            if (!input.trim()) return 'At least one module must be specified';
-            return true;
-          },
-        },
-        {
-          type: 'confirm',
-          name: 'dataMigration',
-          message: '🗄️  Requires data migration?',
-          default: false,
-        },
-        {
-          type: 'input',
-          name: 'rollbackSlo',
-          message: '⏱️  Operational rollback SLO (e.g., 5m, 1h, 24h):',
-          default: '5m',
-          validate: (input) => {
-            const pattern = /^([0-9]+m|[0-9]+h|[0-9]+d)$/;
-            if (!pattern.test(input)) {
-              return 'SLO should be in format: NUMBER + m/h/d (e.g., 5m, 1h, 24h)';
-            }
-            return true;
-          },
-        },
-        {
-          type: 'editor',
-          name: 'projectThreats',
-          message: '⚠️  Project Threats & Risks (one per line, ESC to finish):',
-          default: (answers) => {
-            const baseThreats =
-              '- Race condition in concurrent operations\n- Performance degradation under load';
-            if (answers.dataMigration) {
-              return baseThreats + '\n- Data migration failure\n- Inconsistent data state';
-            }
-            return baseThreats;
-          },
-        },
-        {
-          type: 'input',
-          name: 'scopeIn',
-          message: "🎯 Scope IN - What's included (comma-separated):",
-          default: (answers) => {
-            if (answers.projectMode === 'feature') return 'user authentication, api endpoints';
-            if (answers.projectMode === 'refactor') return 'authentication module, user service';
-            if (answers.projectMode === 'fix') return 'error handling, validation';
-            return 'project files';
-          },
-          validate: (input) => {
-            if (!input.trim()) return 'At least one scope item must be specified';
-            return true;
-          },
-        },
-        {
-          type: 'input',
-          name: 'scopeOut',
-          message: "🚫 Scope OUT - What's excluded (comma-separated):",
-          default: (answers) => {
-            if (answers.projectMode === 'feature')
-              return 'legacy authentication, deprecated endpoints';
-            if (answers.projectMode === 'refactor')
-              return 'external dependencies, configuration files';
-            return 'unrelated features';
-          },
-        },
-        {
-          type: 'editor',
-          name: 'projectInvariants',
-          message: '🛡️  System Invariants (one per line, ESC to finish):',
-          default:
-            '- System remains available\n- Data consistency maintained\n- User sessions preserved',
-        },
-        {
-          type: 'editor',
-          name: 'acceptanceCriteria',
-          message: '✅ Acceptance Criteria (GIVEN...WHEN...THEN, one per line, ESC to finish):',
-          default: (answers) => {
-            if (answers.projectMode === 'feature') {
-              return 'GIVEN user is authenticated WHEN accessing protected endpoint THEN access is granted\nGIVEN invalid credentials WHEN attempting login THEN access is denied';
-            }
-            if (answers.projectMode === 'fix') {
-              return 'GIVEN existing functionality WHEN applying fix THEN behavior is preserved\nGIVEN error condition WHEN fix is applied THEN error is resolved';
-            }
-            return 'GIVEN current system state WHEN change is applied THEN expected behavior occurs';
-          },
-          validate: (input) => {
-            if (!input.trim()) return 'At least one acceptance criterion is required';
-            const lines = input
-              .trim()
-              .split('\n')
-              .filter((line) => line.trim());
-            if (lines.length === 0) return 'At least one acceptance criterion is required';
-            return true;
-          },
-        },
-        {
-          type: 'input',
-          name: 'a11yRequirements',
-          message: '♿ Accessibility Requirements (comma-separated):',
-          default: 'keyboard navigation, screen reader support, color contrast',
-        },
-        {
-          type: 'number',
-          name: 'perfBudget',
-          message: '⚡ Performance Budget (API p95 latency in ms):',
-          default: 250,
-          validate: (input) => {
-            if (input < 1) return 'Performance budget must be at least 1ms';
-            if (input > 10000) return 'Performance budget seems too high (max 10s)';
-            return true;
-          },
-        },
-        {
-          type: 'input',
-          name: 'securityRequirements',
-          message: '🔒 Security Requirements (comma-separated):',
-          default: 'input validation, rate limiting, authentication, authorization',
-        },
-        {
-          type: 'list',
-          name: 'contractType',
-          message: '📄 Contract Type:',
-          choices: [
-            { name: 'OpenAPI (REST APIs)', value: 'openapi' },
-            { name: 'GraphQL Schema', value: 'graphql' },
-            { name: 'Protocol Buffers', value: 'proto' },
-            { name: 'Pact (consumer-driven)', value: 'pact' },
-          ],
-          default: 'openapi',
-        },
-        {
-          type: 'input',
-          name: 'contractPath',
-          message: '📁 Contract File Path:',
-          default: (answers) => {
-            if (answers.contractType === 'openapi') return 'apps/contracts/api.yaml';
-            if (answers.contractType === 'graphql') return 'apps/contracts/schema.graphql';
-            if (answers.contractType === 'proto') return 'apps/contracts/service.proto';
-            if (answers.contractType === 'pact') return 'apps/contracts/pacts/';
-            return 'apps/contracts/api.yaml';
-          },
-        },
-        {
-          type: 'input',
-          name: 'observabilityLogs',
-          message: '📝 Observability - Log Events (comma-separated):',
-          default: 'auth.success, auth.failure, api.request, api.response',
-        },
-        {
-          type: 'input',
-          name: 'observabilityMetrics',
-          message: '📊 Observability - Metrics (comma-separated):',
-          default: 'auth_attempts_total, auth_success_total, api_requests_total, api_errors_total',
-        },
-        {
-          type: 'input',
-          name: 'observabilityTraces',
-          message: '🔍 Observability - Traces (comma-separated):',
-          default: 'auth_flow, api_request',
-        },
-        {
-          type: 'editor',
-          name: 'migrationPlan',
-          message: '🔄 Migration Plan (one per line, ESC to finish):',
-          default: (answers) => {
-            if (answers.dataMigration) {
-              return '- Create new database schema\n- Add new auth table\n- Migrate existing users\n- Validate data integrity';
-            }
-            return '- Deploy feature flags\n- Roll out gradually\n- Monitor metrics';
-          },
-          validate: (input) => {
-            if (!input.trim()) return 'Migration plan is required';
-            return true;
-          },
-        },
-        {
-          type: 'editor',
-          name: 'rollbackPlan',
-          message: '🔙 Rollback Plan (one per line, ESC to finish):',
-          default: (answers) => {
-            if (answers.dataMigration) {
-              return '- Feature flag kill-switch\n- Database rollback script\n- Restore from backup\n- Verify system state';
-            }
-            return '- Feature flag disable\n- Deploy previous version\n- Monitor for issues';
-          },
-          validate: (input) => {
-            if (!input.trim()) return 'Rollback plan is required';
-            return true;
-          },
-        },
-        {
-          type: 'confirm',
-          name: 'needsOverride',
-          message: '🚨 Need human override for urgent/low-risk change?',
-          default: false,
-        },
-        {
-          type: 'input',
-          name: 'overrideRationale',
-          message: '📝 Override rationale (urgency, low risk, etc.):',
-          when: (answers) => answers.needsOverride,
-          validate: (input) => {
-            if (!input.trim()) return 'Rationale is required for override';
-            return true;
-          },
-        },
-        {
-          type: 'input',
-          name: 'overrideApprover',
-          message: '👤 Override approver (GitHub username or email):',
-          when: (answers) => answers.needsOverride,
-          validate: (input) => {
-            if (!input.trim()) return 'Approver is required for override';
-            return true;
-          },
-        },
-        {
-          type: 'checkbox',
-          name: 'waivedGates',
-          message: '⚠️  Gates to waive (select with space):',
-          choices: [
-            { name: 'Coverage testing', value: 'coverage' },
-            { name: 'Mutation testing', value: 'mutation' },
-            { name: 'Contract testing', value: 'contracts' },
-            { name: 'Manual review', value: 'manual_review' },
-            { name: 'Trust score check', value: 'trust_score' },
-          ],
-          when: (answers) => answers.needsOverride,
-          validate: (input) => {
-            if (input.length === 0) return 'At least one gate must be waived';
-            return true;
-          },
-        },
-        {
-          type: 'number',
-          name: 'overrideExpiresDays',
-          message: '⏰ Override expires in how many days?',
-          default: 7,
-          when: (answers) => answers.needsOverride,
-          validate: (input) => {
-            if (input < 1) return 'Must expire in at least 1 day';
-            if (input > 30) return 'Cannot exceed 30 days';
-            return true;
-          },
-        },
-        {
-          type: 'confirm',
-          name: 'isExperimental',
-          message: '🧪 Experimental/Prototype mode? (Reduced requirements for sandbox code)',
-          default: false,
-        },
-        {
-          type: 'input',
-          name: 'experimentalRationale',
-          message: '🔬 Experimental rationale (what are you exploring?):',
-          when: (answers) => answers.isExperimental,
-          validate: (input) => {
-            if (!input.trim()) return 'Rationale is required for experimental mode';
-            return true;
-          },
-        },
-        {
-          type: 'input',
-          name: 'experimentalSandbox',
-          message: '📁 Sandbox location (directory or feature flag):',
-          default: 'experimental/',
-          when: (answers) => answers.isExperimental,
-          validate: (input) => {
-            if (!input.trim()) return 'Sandbox location is required';
-            return true;
-          },
-        },
-        {
-          type: 'number',
-          name: 'experimentalExpiresDays',
-          message: '⏰ Experimental code expires in how many days?',
-          default: 14,
-          when: (answers) => answers.isExperimental,
-          validate: (input) => {
-            if (input < 1) return 'Must expire in at least 1 day';
-            if (input > 90) return 'Cannot exceed 90 days for experimental code';
-            return true;
-          },
-        },
-        {
-          type: 'number',
-          name: 'aiConfidence',
-          message: '🤖 AI confidence level (1-10, 10 = very confident):',
-          default: 7,
-          validate: (input) => {
-            if (input < 1 || input > 10) return 'Must be between 1 and 10';
-            return true;
-          },
-        },
-        {
-          type: 'input',
-          name: 'uncertaintyAreas',
-          message: '❓ Areas of uncertainty (comma-separated):',
-          default: '',
-        },
-        {
-          type: 'input',
-          name: 'complexityFactors',
-          message: '🔧 Complexity factors (comma-separated):',
-          default: '',
-        },
-      ];
-
-      console.log(chalk.cyan('⏳ Gathering project requirements...'));
-
-      let answers;
-      try {
-        answers = await inquirer.prompt(questions);
-      } catch (error) {
-        if (error.isTtyError) {
-          console.error(chalk.red('❌ Interactive prompts not supported in this environment'));
-          console.error(chalk.blue('💡 Run with --non-interactive flag to use defaults'));
-          process.exit(1);
-        } else {
-          console.error(chalk.red('❌ Error during interactive setup:'), error.message);
-          process.exit(1);
-        }
-      }
-
-      console.log(chalk.green('✅ Project requirements gathered successfully!'));
-
-      // Show summary before generating spec
-      console.log(chalk.bold('\n📋 Configuration Summary:'));
-      console.log(`   ${chalk.cyan('Project')}: ${answers.projectTitle} (${answers.projectId})`);
-      console.log(
-        `   ${chalk.cyan('Mode')}: ${answers.projectMode} | ${chalk.cyan('Tier')}: ${answers.riskTier}`
-      );
-      console.log(`   ${chalk.cyan('Budget')}: ${answers.maxFiles} files, ${answers.maxLoc} lines`);
-      console.log(`   ${chalk.cyan('Data Migration')}: ${answers.dataMigration ? 'Yes' : 'No'}`);
-      console.log(`   ${chalk.cyan('Rollback SLO')}: ${answers.rollbackSlo}`);
-
-      // Generate working spec
-      const workingSpecContent = generateWorkingSpec(answers);
-
-      // Validate the generated spec
-      validateGeneratedSpec(workingSpecContent, answers);
-
-      // Save the working spec
-      await fs.writeFile('.caws/working-spec.yaml', workingSpecContent);
-
-      console.log(chalk.green('✅ Working spec generated and validated'));
-
-      // Finalize project with provenance and git initialization
-      await finalizeProject(projectName, options, answers);
-
-      continueToSuccess();
-    }
-  } catch (error) {
-    console.error(chalk.red('❌ Error during project initialization:'), error.message);
-
-    // Cleanup on error
-    if (fs.existsSync(projectName)) {
-      console.log(chalk.cyan('🧹 Cleaning up failed initialization...'));
-      try {
-        await fs.remove(projectName);
-        console.log(chalk.green('✅ Cleanup completed'));
-      } catch (cleanupError) {
-        console.warn(
-          chalk.yellow('⚠️  Could not clean up:'),
-          cleanupError?.message || cleanupError
-        );
-      }
-    }
-
-    process.exit(1);
-  }
-}
-
-// Generate provenance manifest and git initialization (for both modes)
-async function finalizeProject(projectName, options, answers) {
-  try {
-    // Detect and configure language support
-    if (languageSupport) {
-      console.log(chalk.cyan('🔍 Detecting project language...'));
-      const detectedLanguage = languageSupport.detectProjectLanguage();
-
-      if (detectedLanguage !== 'unknown') {
-        console.log(chalk.green(`✅ Detected language: ${detectedLanguage}`));
-
-        // Generate language-specific configuration
-        try {
-          const langConfig = languageSupport.generateLanguageConfig(
-            detectedLanguage,
-            '.caws/language-config.json'
-          );
-
-          console.log(chalk.green('✅ Generated language-specific configuration'));
-          console.log(`   Language: ${langConfig.name}`);
-          console.log(`   Tier: ${langConfig.tier}`);
-          console.log(
-            `   Thresholds: Branch ≥${langConfig.thresholds.min_branch * 100}%, Mutation ≥${langConfig.thresholds.min_mutation * 100}%`
-          );
-        } catch (langError) {
-          console.warn(chalk.yellow('⚠️  Could not generate language config:'), langError.message);
-        }
-      } else {
-        console.log(
-          chalk.blue('ℹ️  Could not detect project language - using default configuration')
-        );
-      }
-    }
-
-    // Setup Cursor hooks if enabled
-    if (answers && answers.enableCursorHooks) {
-      console.log(chalk.cyan('📌 Setting up Cursor hooks...'));
-      await scaffoldCursorHooks(
-        process.cwd(),
-        answers.cursorHookLevels || ['safety', 'quality', 'scope', 'audit']
-      );
-    }
-
-    // Generate provenance manifest
-    console.log(chalk.cyan('📦 Generating provenance manifest...'));
-
-    const provenanceData = {
-      agent: 'caws-cli',
-      model: 'cli-interactive',
-      modelHash: CLI_VERSION,
-      toolAllowlist: [
-        'node',
-        'npm',
-        'git',
-        'fs-extra',
-        'inquirer',
-        'commander',
-        'js-yaml',
-        'ajv',
-        'chalk',
-      ],
-      prompts: Object.keys(answers),
-      commit: null, // Will be set after git init
-      artifacts: ['.caws/working-spec.yaml'],
-      results: {
-        project_id: answers.projectId,
-        project_title: answers.projectTitle,
-        risk_tier: answers.riskTier,
-        mode: answers.projectMode,
-        change_budget: {
-          max_files: answers.maxFiles,
-          max_loc: answers.maxLoc,
-        },
-      },
-      approvals: [],
-    };
-
-    // Generate provenance if tools are available
-    const tools = loadProvenanceTools();
-    if (
-      tools &&
-      typeof tools.generateProvenance === 'function' &&
-      typeof tools.saveProvenance === 'function'
-    ) {
-      const provenance = tools.generateProvenance(provenanceData);
-      await tools.saveProvenance(provenance, '.agent/provenance.json');
-      console.log(chalk.green('✅ Provenance manifest generated'));
-    } else {
-      console.log(
-        chalk.yellow('⚠️  Provenance tools not available - skipping manifest generation')
-      );
-    }
-
-    // Initialize git repository
-    if (options.git) {
-      try {
-        console.log(chalk.cyan('🔧 Initializing git repository...'));
-
-        // Check if git is available
-        try {
-          require('child_process').execSync('git --version', { stdio: 'ignore' });
-        } catch (error) {
-          console.warn(chalk.yellow('⚠️  Git not found. Skipping git initialization.'));
-          console.warn(chalk.blue('💡 Install git to enable automatic repository setup.'));
-          return;
-        }
-
-        // Configure git author information
-        const gitConfig = answers.git_config || {};
-        const authorName = process.env.GIT_AUTHOR_NAME || gitConfig.author_name;
-        const authorEmail = process.env.GIT_AUTHOR_EMAIL || gitConfig.author_email;
-
-        if (authorName && authorEmail) {
-          require('child_process').execSync(`git config user.name "${authorName}"`, {
-            stdio: 'inherit',
-          });
-          require('child_process').execSync(`git config user.email "${authorEmail}"`, {
-            stdio: 'inherit',
-          });
-          console.log(chalk.green(`✅ Git configured: ${authorName} <${authorEmail}>`));
-        }
-
-        require('child_process').execSync('git init', { stdio: 'inherit' });
-        require('child_process').execSync('git add .', { stdio: 'inherit' });
-        require('child_process').execSync('git commit -m "Initial CAWS project setup"', {
-          stdio: 'inherit',
-        });
-        console.log(chalk.green('✅ Git repository initialized'));
-
-        // Update provenance with commit hash
-        const commitHash = require('child_process')
-          .execSync('git rev-parse HEAD', { encoding: 'utf8' })
-          .trim();
-        const currentProvenance = JSON.parse(fs.readFileSync('.agent/provenance.json', 'utf8'));
-        currentProvenance.commit = commitHash;
-        currentProvenance.hash = require('crypto')
-          .createHash('sha256')
-          .update(JSON.stringify(currentProvenance, Object.keys(currentProvenance).sort()))
-          .digest('hex');
-        await fs.writeFile('.agent/provenance.json', JSON.stringify(currentProvenance, null, 2));
-
-        console.log(chalk.green('✅ Provenance updated with commit hash'));
-      } catch (error) {
-        console.warn(
-          chalk.yellow('⚠️  Failed to initialize git repository:'),
-          error?.message || String(error)
-        );
-        console.warn(chalk.blue('💡 You can initialize git manually later with:'));
-        console.warn("   git init && git add . && git commit -m 'Initial CAWS project setup'");
-      }
-    }
-  } catch (error) {
-    console.error(
-      chalk.red('❌ Error during project finalization:'),
-      error?.message || String(error)
-    );
-  }
-}
-
-function continueToSuccess() {
-  const isCurrentDir =
-    process.cwd() ===
-    path.resolve(process.argv[3] === '.' ? process.cwd() : process.argv[3] || 'caws-project');
-
-  console.log(chalk.green('\n🎉 CAWS project initialized successfully!'));
-
-  if (isCurrentDir) {
-    console.log(
-      `📁 ${chalk.cyan('Initialized in current directory')}: ${path.resolve(process.cwd())}`
-    );
-    console.log(chalk.gray('   (CAWS files added to your existing project)'));
-  } else {
-    console.log(`📁 ${chalk.cyan('Project location')}: ${path.resolve(process.cwd())}`);
-    console.log(chalk.gray('   (New subdirectory created with CAWS structure)'));
-  }
-
-  console.log(chalk.bold('\nNext steps:'));
-  console.log('1. Customize .caws/working-spec.yaml');
-  console.log('2. Review added CAWS tools and documentation');
-  if (!isCurrentDir) {
-    console.log('3. Move CAWS files to your main project if needed');
-  }
-  console.log('4. npm install (if using Node.js)');
-  console.log('5. Set up your CI/CD pipeline');
-  console.log(chalk.blue('\nFor help: caws --help'));
-}
-
-/**
- * Scaffold Cursor hooks for a CAWS project
- *
- * @param {string} projectDir - Project directory path
- * @param {string[]} levels - Hook levels to enable (safety, quality, scope, audit)
- * @author @darianrosebrook
- */
-async function scaffoldCursorHooks(projectDir, levels = ['safety', 'quality', 'scope', 'audit']) {
-  try {
-    const cursorDir = path.join(projectDir, '.cursor');
-    const cursorHooksDir = path.join(cursorDir, 'hooks');
-
-    // Create .cursor directory structure
-    await fs.ensureDir(cursorDir);
-    await fs.ensureDir(cursorHooksDir);
-    await fs.ensureDir(path.join(cursorDir, 'logs'));
-
-    // Determine template directory
-    const setup = detectCAWSSetup(projectDir);
-    const templateDir = setup.templateDir || path.resolve(__dirname, '../templates');
-
-    const cursorTemplateDir = path.join(templateDir, '.cursor');
-    const cursorHooksTemplateDir = path.join(cursorTemplateDir, 'hooks');
-
-    if (!fs.existsSync(cursorTemplateDir)) {
-      console.warn(chalk.yellow('⚠️  Cursor hooks templates not found'));
-      console.warn(chalk.blue('💡 Skipping Cursor hooks setup'));
-      return;
-    }
-
-    // Map levels to hook scripts
-    const hookMapping = {
-      safety: ['scan-secrets.sh', 'block-dangerous.sh'],
-      quality: ['format.sh', 'validate-spec.sh'],
-      scope: ['scope-guard.sh', 'naming-check.sh'],
-      audit: ['audit.sh'],
-    };
-
-    // Determine which hooks to enable
-    const enabledHooks = new Set();
-    levels.forEach((level) => {
-      const hooks = hookMapping[level] || [];
-      hooks.forEach((hook) => enabledHooks.add(hook));
-    });
-
-    // Always enable audit.sh if any hooks are enabled
-    if (enabledHooks.size > 0) {
-      enabledHooks.add('audit.sh');
-    }
-
-    // Copy enabled hook scripts
-    const allHookScripts = [
-      'audit.sh',
-      'validate-spec.sh',
-      'format.sh',
-      'scan-secrets.sh',
-      'block-dangerous.sh',
-      'scope-guard.sh',
-      'naming-check.sh',
-    ];
-
-    for (const script of allHookScripts) {
-      if (enabledHooks.has(script)) {
-        const sourcePath = path.join(cursorHooksTemplateDir, script);
-        const destPath = path.join(cursorHooksDir, script);
-
-        if (fs.existsSync(sourcePath)) {
-          await fs.copy(sourcePath, destPath);
-          // Make executable
-          await fs.chmod(destPath, 0o755);
-        }
-      }
-    }
-
-    // Generate hooks.json based on enabled hooks
-    const hooksConfig = {
-      version: 1,
-      hooks: {},
-    };
-
-    // Build hooks configuration based on enabled levels
-    if (levels.includes('safety')) {
-      hooksConfig.hooks.beforeShellExecution = [
-        { 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' }];
-    }
-
-    if (levels.includes('quality')) {
-      hooksConfig.hooks.afterFileEdit = hooksConfig.hooks.afterFileEdit || [];
-      hooksConfig.hooks.afterFileEdit.push(
-        { command: './.cursor/hooks/format.sh' },
-        { command: './.cursor/hooks/validate-spec.sh' }
-      );
-    }
-
-    if (levels.includes('scope')) {
-      hooksConfig.hooks.afterFileEdit = hooksConfig.hooks.afterFileEdit || [];
-      hooksConfig.hooks.afterFileEdit.push({ command: './.cursor/hooks/naming-check.sh' });
-      hooksConfig.hooks.beforeSubmitPrompt = [
-        { command: './.cursor/hooks/scope-guard.sh' },
-        { command: './.cursor/hooks/audit.sh' },
-      ];
-    }
-
-    if (levels.includes('audit')) {
-      // Add audit to all events
-      if (!hooksConfig.hooks.afterFileEdit) {
-        hooksConfig.hooks.afterFileEdit = [];
-      }
-      hooksConfig.hooks.afterFileEdit.push({ command: './.cursor/hooks/audit.sh' });
-
-      hooksConfig.hooks.stop = [{ command: './.cursor/hooks/audit.sh' }];
-    }
-
-    // Write hooks.json
-    await fs.writeFile(path.join(cursorDir, 'hooks.json'), JSON.stringify(hooksConfig, null, 2));
-
-    // Copy README
-    const readmePath = path.join(cursorTemplateDir, 'README.md');
-    if (fs.existsSync(readmePath)) {
-      await fs.copy(readmePath, path.join(cursorDir, 'README.md'));
-    }
-
-    console.log(chalk.green('✅ Cursor hooks configured'));
-    console.log(chalk.gray(`   Enabled: ${levels.join(', ')}`));
-    console.log(
-      chalk.gray(`   Scripts: ${Array.from(enabledHooks).length} hook scripts installed`)
-    );
-    console.log(chalk.blue('💡 Restart Cursor to activate hooks'));
-  } catch (error) {
-    console.error(chalk.yellow('⚠️  Failed to setup Cursor hooks:'), error.message);
-    console.log(chalk.blue('💡 You can manually copy .cursor/ directory later'));
-  }
-}
-
-/**
- * Scaffold existing project with CAWS components
- */
-async function scaffoldProject(options) {
-  const currentDir = process.cwd();
-  const projectName = path.basename(currentDir);
-
-  try {
-    // Detect existing CAWS setup FIRST before any logging
-    const setup = detectCAWSSetup(currentDir);
-
-    // Check for CAWS setup immediately and exit with helpful message if not found
-    if (!setup.hasCAWSDir) {
-      console.log(chalk.red('❌ CAWS not initialized in this project'));
-      console.log(chalk.blue('\n💡 To get started:'));
-      console.log(`   1. Initialize CAWS: ${chalk.cyan('caws init <project-name>')}`);
-      console.log(`   2. Or initialize in current directory: ${chalk.cyan('caws init .')}`);
-      console.log(chalk.blue('\n📚 For more help:'));
-      console.log(`   ${chalk.cyan('caws --help')}`);
-      process.exit(1);
-    }
-
-    console.log(chalk.cyan(`🔧 Enhancing existing CAWS project: ${projectName}`));
-
-    // Preserve the original template directory from global cawsSetup
-    // (needed because detectCAWSSetup from within a new project won't find the template)
-    if (cawsSetup?.templateDir && !setup.templateDir) {
-      setup.templateDir = cawsSetup.templateDir;
-      setup.hasTemplateDir = true;
-    } else if (!setup.templateDir) {
-      // Try to find template directory using absolute paths that work in CI
-      const possiblePaths = [
-        '/home/runner/work/coding-agent-working-standard/coding-agent-working-standard/packages/caws-template',
-        '/workspace/packages/caws-template',
-        '/caws/packages/caws-template',
-        path.resolve(process.cwd(), '../../../packages/caws-template'),
-        path.resolve(process.cwd(), '../../packages/caws-template'),
-        path.resolve(process.cwd(), '../packages/caws-template'),
-      ];
-
-      for (const testPath of possiblePaths) {
-        if (fs.existsSync(testPath)) {
-          setup.templateDir = testPath;
-          setup.hasTemplateDir = true;
-          break;
-        }
-      }
-
-      if (!setup.templateDir) {
-        console.log(chalk.red(`❌ No template directory available!`));
-        console.log(chalk.blue('💡 To fix this issue:'));
-        console.log(`   1. Ensure caws-template package is installed`);
-        console.log(`   2. Run from the monorepo root directory`);
-        console.log(`   3. Check that CAWS CLI was installed correctly`);
-        console.log(chalk.blue('\n📚 For installation help:'));
-        console.log(`   ${chalk.cyan('npm install -g @paths.design/caws-cli')}`);
-      }
-    }
-
-    // Override global cawsSetup with current context for scaffold operations
-    cawsSetup = setup;
-
-    if (!setup.hasCAWSDir) {
-      console.error(chalk.red('❌ No .caws directory found'));
-      console.error(chalk.blue('💡 Run "caws init <project-name>" first to create a CAWS project'));
-      process.exit(1);
-    }
-
-    // Adapt behavior based on setup type
-    if (setup.isEnhanced) {
-      console.log(chalk.green('🎯 Enhanced CAWS detected - adding automated publishing'));
-    } else if (setup.isAdvanced) {
-      console.log(chalk.blue('🔧 Advanced CAWS detected - adding missing capabilities'));
-    } else {
-      console.log(chalk.blue('📋 Basic CAWS detected - enhancing with additional tools'));
-    }
-
-    // Generate provenance for scaffolding operation
-    const scaffoldProvenance = {
-      agent: 'caws-cli',
-      model: 'cli-scaffold',
-      modelHash: CLI_VERSION,
-      toolAllowlist: ['node', 'fs-extra'],
-      prompts: ['scaffold', options.force ? 'force' : 'normal'],
-      commit: null,
-      artifacts: [],
-      results: {
-        operation: 'scaffold',
-        force_mode: options.force,
-        target_directory: currentDir,
-      },
-      approvals: [],
-      timestamp: new Date().toISOString(),
-      version: CLI_VERSION,
-    };
-
-    // Calculate hash after object is fully defined
-    scaffoldProvenance.hash = require('crypto')
-      .createHash('sha256')
-      .update(JSON.stringify(scaffoldProvenance))
-      .digest('hex');
-
-    // Determine what enhancements to add based on setup type and options
-    const enhancements = [];
-
-    // Add CAWS tools directory structure (matches test expectations)
-    enhancements.push({
-      name: 'apps/tools/caws',
-      description: 'CAWS tools directory',
-      required: true,
-    });
-
-    // Add codemods if requested or not minimal
-    if (options.withCodemods || (!options.minimal && !options.withCodemods)) {
-      enhancements.push({
-        name: 'codemod',
-        description: 'Codemod transformation scripts',
-        required: true,
-      });
-    }
-
-    // Also add automated publishing for enhanced setups
-    if (setup.isEnhanced) {
-      enhancements.push({
-        name: '.github/workflows/release.yml',
-        description: 'GitHub Actions workflow for automated publishing',
-        required: true,
-      });
-
-      enhancements.push({
-        name: '.releaserc.json',
-        description: 'semantic-release configuration',
-        required: true,
-      });
-    }
-
-    // Add commit conventions for setups that don't have them
-    if (!setup.hasTemplates || !fs.existsSync(path.join(currentDir, 'COMMIT_CONVENTIONS.md'))) {
-      enhancements.push({
-        name: 'COMMIT_CONVENTIONS.md',
-        description: 'Commit message guidelines',
-        required: false,
-      });
-    }
-
-    // Add OIDC setup guide if requested or not minimal
-    if (
-      (options.withOidc || (!options.minimal && !options.withOidc)) &&
-      (!setup.isEnhanced || !fs.existsSync(path.join(currentDir, 'OIDC_SETUP.md')))
-    ) {
-      enhancements.push({
-        name: 'OIDC_SETUP.md',
-        description: 'OIDC trusted publisher setup guide',
-        required: false,
-      });
-    }
-
-    // For enhanced setups, preserve existing tools
-    if (setup.isEnhanced) {
-      console.log(chalk.blue('ℹ️  Preserving existing sophisticated CAWS tools'));
-    }
-
-    let addedCount = 0;
-    let skippedCount = 0;
-    const addedFiles = [];
-
-    for (const enhancement of enhancements) {
-      if (!setup?.templateDir) {
-        console.warn(
-          chalk.yellow(`⚠️  Template directory not available for enhancement: ${enhancement.name}`)
-        );
-        continue;
-      }
-      const sourcePath = path.join(setup.templateDir, enhancement.name);
-      const destPath = path.join(currentDir, enhancement.name);
-
-      if (!fs.existsSync(destPath)) {
-        if (fs.existsSync(sourcePath)) {
-          try {
-            await fs.copy(sourcePath, destPath);
-            console.log(chalk.green(`✅ Added ${enhancement.description}`));
-            addedCount++;
-            addedFiles.push(enhancement.name);
-          } catch (copyError) {
-            console.warn(chalk.yellow(`⚠️  Failed to add ${enhancement.name}:`), copyError.message);
-          }
-        } else {
-          // If source doesn't exist in template, create the directory structure
-          try {
-            await fs.ensureDir(destPath);
-            console.log(chalk.green(`✅ Created ${enhancement.description}`));
-            addedCount++;
-            addedFiles.push(enhancement.name);
-          } catch (createError) {
-            console.warn(
-              chalk.yellow(`⚠️  Failed to create ${enhancement.name}:`),
-              createError.message
-            );
-          }
-        }
-      } else {
-        if (options.force) {
-          try {
-            await fs.remove(destPath);
-            if (fs.existsSync(sourcePath)) {
-              await fs.copy(sourcePath, destPath);
-            } else {
-              await fs.ensureDir(destPath);
-            }
-            console.log(chalk.blue(`🔄 Updated ${enhancement.description}`));
-            addedCount++;
-            addedFiles.push(enhancement.name);
-          } catch (overwriteError) {
-            console.warn(
-              chalk.yellow(`⚠️  Failed to update ${enhancement.name}:`),
-              overwriteError.message
-            );
-          }
-        } else {
-          console.log(`⏭️  Skipped ${enhancement.name} (already exists)`);
-          skippedCount++;
-        }
-      }
-    }
-
-    // Update provenance with results
-    scaffoldProvenance.artifacts = addedFiles;
-    scaffoldProvenance.results.files_added = addedCount;
-    scaffoldProvenance.results.files_skipped = skippedCount;
-
-    // Show summary
-    console.log(chalk.green(`\n🎉 Enhancement completed!`));
-    console.log(chalk.bold(`📊 Summary: ${addedCount} added, ${skippedCount} skipped`));
-
-    if (addedCount > 0) {
-      console.log(chalk.bold('\n📝 Next steps:'));
-      console.log('1. Review the added files');
-
-      // Check if OIDC was added
-      const oidcAdded = addedFiles.some((file) => file.includes('OIDC_SETUP'));
-      if (oidcAdded) {
-        console.log('2. Set up OIDC trusted publisher (see OIDC_SETUP.md)');
-        console.log('3. Push to trigger automated publishing');
-        console.log('4. Your existing CAWS tools remain unchanged');
-      } else {
-        console.log('2. Customize your working spec in .caws/working-spec.yaml');
-        console.log('3. Run validation: caws validate --suggestions');
-        console.log('4. Your existing CAWS tools remain unchanged');
-      }
-    }
-
-    if (setup.isEnhanced) {
-      console.log(
-        chalk.blue('\n🎯 Your enhanced CAWS setup has been improved with automated publishing!')
-      );
-    }
-
-    if (options.force) {
-      console.log(chalk.yellow('\n⚠️  Force mode was used - review changes carefully'));
-    }
-
-    // Save provenance manifest if tools are available
-    const tools = loadProvenanceTools();
-    if (tools && typeof tools.saveProvenance === 'function') {
-      await tools.saveProvenance(scaffoldProvenance, '.agent/scaffold-provenance.json');
-      console.log(chalk.green('✅ Scaffolding provenance saved'));
-    } else {
-      console.log(chalk.yellow('⚠️  Provenance tools not available - skipping manifest save'));
-    }
-  } catch (error) {
-    // Handle circular reference errors from Commander.js
-    if (error.message && error.message.includes('Converting circular structure to JSON')) {
-      console.log(
-        chalk.yellow('⚠️  Scaffolding completed with minor issues (circular reference handled)')
-      );
-      console.log(chalk.green('✅ CAWS components scaffolded successfully'));
-    } else {
-      console.error(chalk.red('❌ Error during scaffolding:'), error.message);
-      process.exit(1);
-    }
-  }
-}
-
-/**
- * Show version information
- */
-// function showVersion() {
-//   console.log(chalk.bold(`CAWS CLI v${CLI_VERSION}`));
-//   console.log(chalk.cyan('Coding Agent Workflow System - Scaffolding Tool'));
-//   console.log(chalk.gray('Author: @darianrosebrook'));
-//   console.log(chalk.gray('License: MIT'));
-// }
-
-// Initialize CAWS Tool System
-let toolLoader = null;
-let toolValidator = null;
-
-async function initializeToolSystem() {
-  if (toolLoader) return toolLoader; // Already initialized
-
-  try {
-    toolLoader = new ToolLoader({
-      toolsDir: path.join(process.cwd(), 'apps/tools/caws'),
-    });
-
-    toolValidator = new ToolValidator();
-
-    // Set up event listeners for tool system
-    toolLoader.on('discovery:complete', ({ tools: _tools, count }) => {
-      if (count > 0) {
-        console.log(chalk.blue(`🔧 Discovered ${count} tools`));
-      }
-    });
-
-    toolLoader.on('tool:loaded', ({ id, metadata }) => {
-      console.log(chalk.gray(`  ✓ Loaded tool: ${metadata.name} (${id})`));
-    });
-
-    toolLoader.on('tool:error', ({ id, error }) => {
-      console.warn(chalk.yellow(`⚠️  Failed to load tool ${id}: ${error}`));
-    });
-
-    // Auto-discover tools on initialization
-    await toolLoader.discoverTools();
-
-    return toolLoader;
-  } catch (error) {
-    console.warn(chalk.yellow('⚠️  Tool system initialization failed:'), error.message);
-    console.warn(chalk.blue('💡 Continuing without dynamic tools'));
-    return null;
-  }
-}
-
-// Agent-oriented helper functions
-async function runQualityGatesForSpec(spec, strictMode = false) {
-  const loader = await initializeToolSystem();
-  const WaiversManager = require('./waivers-manager');
-  const waiversManager = new WaiversManager();
-
-  const criteria = [];
-  let overallScore = 0;
-  let totalWeight = 0;
-
-  // Spec completeness criteria
-  const specScore = calculateSpecCompleteness(spec);
-  criteria.push({
-    id: 'spec_completeness',
-    name: 'Specification Completeness',
-    status: specScore >= 0.8 ? 'passed' : 'failed',
-    score: specScore,
-    weight: 0.2,
-    feedback: `Spec completeness: ${(specScore * 100).toFixed(1)}%`,
-  });
-  overallScore += specScore * 0.2;
-  totalWeight += 0.2;
-
-  // Risk-appropriate quality thresholds
-  const tierThresholds = {
-    1: { coverage: 0.9, mutation: 0.7, contracts: true },
-    2: { coverage: 0.8, mutation: 0.5, contracts: true },
-    3: { coverage: 0.7, mutation: 0.3, contracts: false },
-  };
-
-  const thresholds = tierThresholds[spec.risk_tier] || tierThresholds[2];
-  const appliedThresholds = strictMode
-    ? {
-        coverage: thresholds.coverage,
-        mutation: thresholds.mutation,
-        contracts: thresholds.contracts,
-      }
-    : {
-        coverage: Math.max(0.6, thresholds.coverage - 0.2),
-        mutation: Math.max(0.2, thresholds.mutation - 0.2),
-        contracts: thresholds.contracts,
-      };
-
-  // Tool-based quality gates
-  if (loader) {
-    const tools = loader.getAllTools();
-
-    for (const [toolId, tool] of tools) {
-      if (
-        tool.metadata.capabilities?.includes('quality-gates') ||
-        tool.metadata.capabilities?.includes('validation')
-      ) {
-        const gateName = `gate_${toolId}`;
-        let gateScore = 0.0;
-        let gateStatus = 'failed';
-        let gateFeedback = '';
-        let weight = toolId === 'validate' ? 0.3 : 0.15;
-
-        // Check if this gate is waived
-        const waiverCoverage = await waiversManager.checkWaiverCoverage([gateName]);
-
-        if (waiverCoverage.allCovered) {
-          // Gate is waived - mark as passed but note the waiver
-          gateScore = 1.0;
-          gateStatus = 'waived';
-          const waiver = waiverCoverage.waiverDetails[0];
-          gateFeedback = `WAIVED: ${waiver.waiver_id} (${waiver.reason}) - Expires: ${waiver.expires_at}`;
-          weight = weight * 0.8; // Reduce weight for waived gates
-        } else {
-          // Run the gate normally
-          try {
-            const result = await tool.module.execute(
-              {},
-              {
-                workingDirectory: process.cwd(),
-                spec: spec,
-              }
-            );
-
-            gateScore = result.success ? 1.0 : 0.0;
-            gateStatus = result.success ? 'passed' : 'failed';
-            gateFeedback = result.success
-              ? `${tool.metadata.name} passed`
-              : `Failed: ${result.errors?.join(', ') || 'Unknown error'}`;
-          } catch (error) {
-            gateStatus = 'error';
-            gateScore = 0;
-            gateFeedback = `Gate execution failed: ${error.message}`;
-            weight = 0.1;
-          }
-        }
-
-        criteria.push({
-          id: gateName,
-          name: `${tool.metadata.name} Gate`,
-          status: gateStatus,
-          score: gateScore,
-          weight: weight,
-          feedback: gateFeedback,
-        });
-
-        overallScore += gateScore * weight;
-        totalWeight += weight;
-      }
-    }
-  }
-
-  // Contract compliance (if applicable)
-  if (spec.contracts && spec.contracts.length > 0) {
-    const contractScore = spec.contracts.length > 0 ? 1.0 : 0.0;
-    criteria.push({
-      id: 'contract_compliance',
-      name: 'Contract Compliance',
-      status: contractScore >= (appliedThresholds.contracts ? 1.0 : 0.5) ? 'passed' : 'failed',
-      score: contractScore,
-      weight: 0.2,
-      feedback: `${spec.contracts.length} contracts defined`,
-    });
-    overallScore += contractScore * 0.2;
-    totalWeight += 0.2;
-  }
-
-  const finalScore = totalWeight > 0 ? overallScore / totalWeight : 0;
-  const overallPassed = finalScore >= 0.75; // 75% quality threshold
-
-  // Generate next actions based on results
-  const nextActions = [];
-  const failedCriteria = criteria.filter((c) => c.status === 'failed');
-
-  if (failedCriteria.length > 0) {
-    nextActions.push('Address failed quality criteria:');
-    failedCriteria.forEach((criterion) => {
-      nextActions.push(`  - ${criterion.name}: ${criterion.feedback}`);
-    });
-  } else if (overallPassed) {
-    nextActions.push('All quality gates passed! Ready for integration.');
-    nextActions.push('Consider: code review, additional testing, documentation updates');
-  } else {
-    nextActions.push('Improve overall quality score through:');
-    nextActions.push('  - Better test coverage and mutation scores');
-    nextActions.push('  - Contract testing implementation');
-    nextActions.push('  - Tool-based quality gate compliance');
-  }
-
-  return {
-    overall_passed: overallPassed,
-    quality_score: Number(finalScore.toFixed(3)),
-    summary: overallPassed
-      ? `Quality standards met (${(finalScore * 100).toFixed(1)}% score)`
-      : `Quality standards not met (${(finalScore * 100).toFixed(1)}% score)`,
-    criteria,
-    progress_indicators: {
-      spec_complete: specScore >= 0.8,
-      quality_gates: criteria.filter((c) => c.id.startsWith('gate_') && c.status === 'passed')
-        .length,
-      contracts_ready: spec.contracts && spec.contracts.length > 0,
-      risk_appropriate: spec.risk_tier <= 2 || finalScore >= 0.6,
-    },
-    next_actions: nextActions,
-    risk_assessment: {
-      tier: spec.risk_tier,
-      applied_thresholds: appliedThresholds,
-      risk_level: spec.risk_tier === 1 ? 'high' : spec.risk_tier === 2 ? 'medium' : 'low',
-      recommendations: generateRiskRecommendations(spec, finalScore),
-    },
-  };
-}
-
-function calculateSpecCompleteness(spec) {
-  let score = 0;
-  let totalChecks = 0;
-
-  // Required fields
-  const requiredFields = [
-    'id',
-    'title',
-    'risk_tier',
-    'mode',
-    'change_budget',
-    'scope',
-    'invariants',
-    'acceptance',
-  ];
-  requiredFields.forEach((field) => {
-    totalChecks++;
-    if (spec[field]) score++;
-  });
-
-  // Scope completeness
-  totalChecks++;
-  if (spec.scope && spec.scope.in && spec.scope.out) score++;
-
-  // Acceptance criteria quality
-  totalChecks++;
-  if (spec.acceptance && spec.acceptance.length >= 1) {
-    const validCriteria = spec.acceptance.filter((a) => a.id && a.given && a.when && a.then);
-    score += validCriteria.length / Math.max(spec.acceptance.length, 1);
-  }
-
-  // Invariants presence
-  totalChecks++;
-  if (spec.invariants && spec.invariants.length >= 2) score++;
-
-  // Contracts for T1/T2
-  if (spec.risk_tier <= 2) {
-    totalChecks++;
-    if (spec.contracts && spec.contracts.length > 0) score++;
-  }
-
-  return score / totalChecks;
-}
-
-function generateRiskRecommendations(spec, qualityScore) {
-  const recommendations = [];
-
-  if (spec.risk_tier === 1 && qualityScore < 0.9) {
-    recommendations.push('High-risk feature requires exceptional quality (>90%)');
-    recommendations.push('Consider breaking into smaller, lower-risk changes');
-  }
-
-  if (spec.mode === 'feature' && (!spec.contracts || spec.contracts.length === 0)) {
-    recommendations.push('Features should define contracts before implementation');
-  }
-
-  if (spec.change_budget && spec.change_budget.max_files > 25) {
-    recommendations.push('Large change budgets increase risk - consider splitting');
-  }
-
-  return recommendations;
-}
-
-async function generateIterativeGuidance(spec, currentState) {
-  const guidance = {
-    guidance: '',
-    next_steps: [],
-    confidence: 0,
-    focus_areas: [],
-    risk_mitigation: [],
-  };
-
-  // Analyze current implementation state
-  const implementationStage = analyzeImplementationStage(spec, currentState);
-  guidance.guidance = getStageGuidance(implementationStage);
-
-  // Generate specific next steps based on spec requirements
-  guidance.next_steps = generateNextSteps(spec, implementationStage, currentState);
-
-  // Calculate confidence based on progress
-  guidance.confidence = calculateImplementationConfidence(spec, currentState);
-
-  // Identify focus areas
-  guidance.focus_areas = identifyFocusAreas(spec, currentState);
-
-  // Risk mitigation suggestions
-  guidance.risk_mitigation = generateRiskMitigation(spec, currentState);
-
-  return guidance;
-}
-
-function analyzeImplementationStage(spec, currentState) {
-  // Simple heuristic based on current state description
-  const stateDesc = currentState.description || '';
-
-  if (stateDesc.includes('started') || stateDesc.includes('initial')) return 'planning';
-  if (stateDesc.includes('prototype') || stateDesc.includes('draft')) return 'prototyping';
-  if (stateDesc.includes('core') || stateDesc.includes('basic')) return 'core_implementation';
-  if (stateDesc.includes('testing') || stateDesc.includes('test')) return 'testing';
-  if (stateDesc.includes('integration') || stateDesc.includes('integrate')) return 'integration';
-  if (stateDesc.includes('complete') || stateDesc.includes('done')) return 'polishing';
-
-  return 'early_planning';
-}
-
-function getStageGuidance(stage) {
-  const guidance = {
-    early_planning: 'Focus on understanding requirements and creating a solid implementation plan.',
-    planning: 'Break down the feature into manageable tasks and establish success criteria.',
-    prototyping:
-      'Build a working prototype to validate the approach and identify technical challenges.',
-    core_implementation:
-      'Implement the core functionality with proper error handling and edge cases.',
-    testing: 'Add comprehensive tests and validate against acceptance criteria.',
-    integration: 'Ensure the feature integrates well with existing systems and contracts.',
-    polishing: 'Refine the implementation, add documentation, and optimize performance.',
-  };
-
-  return guidance[stage] || 'Continue systematic implementation following the working spec.';
-}
-
-function generateNextSteps(spec, stage, _currentState) {
-  const steps = [];
-
-  switch (stage) {
-    case 'early_planning':
-      steps.push('Review and validate working spec completeness');
-      steps.push('Create detailed implementation plan');
-      steps.push('Set up development environment and dependencies');
-      break;
-
-    case 'planning':
-      steps.push('Implement core functionality skeleton');
-      steps.push('Add basic error handling');
-      steps.push('Create initial test structure');
-      break;
-
-    case 'prototyping':
-      steps.push('Refine core algorithms and logic');
-      steps.push('Add comprehensive input validation');
-      steps.push('Implement basic integration points');
-      break;
-
-    case 'core_implementation':
-      steps.push('Add comprehensive test coverage');
-      steps.push('Implement contract testing if applicable');
-      steps.push('Add performance optimizations');
-      break;
-
-    case 'testing':
-      steps.push('Run full quality gate evaluation');
-      steps.push('Address any failing tests or gates');
-      steps.push('Add integration tests');
-      break;
-
-    case 'integration':
-      steps.push('Test with dependent systems');
-      steps.push('Validate contract compliance');
-      steps.push('Perform load and stress testing');
-      break;
-
-    case 'polishing':
-      steps.push('Add comprehensive documentation');
-      steps.push('Final performance optimization');
-      steps.push('Code review and final validation');
-      break;
-  }
-
-  // Add spec-specific steps
-  if (spec.mode === 'feature' && spec.contracts) {
-    steps.push('Ensure contract definitions are complete and tested');
-  }
-
-  if (spec.risk_tier === 1) {
-    steps.push('Prioritize security and reliability measures');
-  }
-
-  return steps;
-}
-
-function calculateImplementationConfidence(spec, currentState) {
-  // Simple confidence calculation based on described progress
-  let confidence = 0.5; // Base confidence
-
-  const stateDesc = (currentState.description || '').toLowerCase();
-
-  if (stateDesc.includes('complete') || stateDesc.includes('done')) confidence += 0.3;
-  if (stateDesc.includes('tested') || stateDesc.includes('working')) confidence += 0.2;
-  if (stateDesc.includes('prototype') || stateDesc.includes('basic')) confidence += 0.1;
-
-  if (stateDesc.includes('blocked') || stateDesc.includes('stuck')) confidence -= 0.2;
-  if (stateDesc.includes('issues') || stateDesc.includes('problems')) confidence -= 0.1;
-
-  return Math.max(0, Math.min(1, confidence));
-}
-
-function identifyFocusAreas(spec, _currentState) {
-  const areas = [];
-
-  // Always include quality gates
-  areas.push('Quality Gates Compliance');
-
-  if (spec.contracts && spec.contracts.length > 0) {
-    areas.push('Contract Implementation');
-  }
-
-  if (spec.risk_tier <= 2) {
-    areas.push('Security & Reliability');
-  }
-
-  if (spec.acceptance && spec.acceptance.length > 0) {
-    areas.push('Acceptance Criteria Validation');
-  }
-
-  return areas;
-}
-
-function generateRiskMitigation(spec, _currentState) {
-  const mitigation = [];
-
-  if (spec.risk_tier === 1) {
-    mitigation.push('Implement comprehensive error handling');
-    mitigation.push('Add extensive logging and monitoring');
-    mitigation.push('Consider feature flags for gradual rollout');
-  }
-
-  if (spec.change_budget && spec.change_budget.max_files > 15) {
-    mitigation.push('Regular commits and incremental validation');
-    mitigation.push('Consider breaking into smaller PRs');
-  }
-
-  if (spec.mode === 'feature') {
-    mitigation.push('Validate contracts before full implementation');
-    mitigation.push('Implement feature flags for safe deployment');
-  }
-
-  return mitigation;
-}
-
-// CLI Commands
-program
-  .name('caws')
-  .description('CAWS - Coding Agent Workflow System CLI')
-  .version(CLI_VERSION, '-v, --version', 'Show version information');
-
-program
-  .command('init')
-  .alias('i')
-  .description('Initialize a new project with CAWS')
-  .argument('<project-name>', 'Name of the new project')
-  .option('-i, --interactive', 'Run interactive setup wizard')
-  .option('-g, --git', 'Initialize git repository', true)
-  .option('-n, --non-interactive', 'Skip interactive prompts')
-  .option('--no-git', "Don't initialize git repository")
-  .option('-t, --template <type>', 'Use project template (extension|library|api|cli|monorepo)')
-  .action(initProject);
-
-program
-  .command('scaffold')
-  .alias('s')
-  .description('Add CAWS components to existing project')
-  .option('-f, --force', 'Overwrite existing files')
-  .option('--with-oidc', 'Include OIDC trusted publisher setup')
-  .option('--with-codemods', 'Include codemod transformation scripts')
-  .option('--minimal', 'Only essential components (no OIDC, no codemods)')
-  .action(scaffoldProject);
-
-program
-  .command('validate')
-  .alias('v')
-  .description('Validate CAWS working spec with suggestions')
-  .argument('[spec-file]', 'Path to working spec file', '.caws/working-spec.yaml')
-  .option('-s, --suggestions', 'Show helpful suggestions for issues', true)
-  .option('-f, --auto-fix', 'Automatically fix safe issues', false)
-  .option('-q, --quiet', 'Only show errors, no suggestions', false)
-  .action(async (specFile, options) => {
-    try {
-      // Check if spec file exists
-      if (!fs.existsSync(specFile)) {
-        console.error(chalk.red(`❌ Working spec file not found: ${specFile}`));
-        console.error(chalk.blue('💡 Initialize CAWS first:'));
-        console.error(`   ${chalk.cyan('caws init .')}`);
-        process.exit(1);
-      }
-
-      // Load and parse spec
-      const specContent = fs.readFileSync(specFile, 'utf8');
-      const spec = yaml.load(specContent);
-
-      if (!spec) {
-        console.error(chalk.red('❌ Failed to parse working spec YAML'));
-        process.exit(1);
-      }
-
-      // Validate spec with suggestions
-      const result = validateWorkingSpecWithSuggestions(spec, {
-        autoFix: options.autoFix,
-        suggestions: !options.quiet,
-      });
-
-      // Save auto-fixed spec if changes were made
-      if (options.autoFix && result.errors.length === 0) {
-        const fixedContent = yaml.dump(spec, { indent: 2 });
-        fs.writeFileSync(specFile, fixedContent);
-        console.log(chalk.green(`✅ Saved auto-fixed spec to ${specFile}`));
-      }
-
-      // Execute quality gate tools if validation passed
-      if (result.valid && !options.quiet) {
-        console.log('');
-        console.log(chalk.blue('🔍 Running quality gates...'));
-
-        const loader = await initializeToolSystem();
-        if (loader) {
-          await loader.loadAllTools();
-          const tools = loader.getAllTools();
-
-          let gatesPassed = 0;
-          let gatesTotal = 0;
-
-          for (const [, tool] of tools) {
-            // Only run tools with quality-gates capability
-            if (
-              tool.metadata.capabilities?.includes('quality-gates') ||
-              tool.metadata.capabilities?.includes('validation')
-            ) {
-              gatesTotal++;
-              console.log(chalk.gray(`  Running ${tool.metadata.name}...`));
-
-              try {
-                const gateResult = await tool.module.execute(
-                  {},
-                  {
-                    workingDirectory: process.cwd(),
-                    spec: spec,
-                  }
-                );
-
-                if (gateResult.success) {
-                  console.log(chalk.green(`    ✅ ${tool.metadata.name} passed`));
-                  gatesPassed++;
-                } else {
-                  console.log(chalk.red(`    ❌ ${tool.metadata.name} failed`));
-                  gateResult.errors?.forEach((error) => {
-                    console.log(chalk.red(`       ${error}`));
-                  });
-                }
-              } catch (error) {
-                console.log(chalk.red(`    ❌ ${tool.metadata.name} error: ${error.message}`));
-              }
-            }
-          }
-
-          if (gatesTotal > 0) {
-            console.log('');
-            console.log(chalk.blue(`🎯 Quality Gates: ${gatesPassed}/${gatesTotal} passed`));
-
-            if (gatesPassed < gatesTotal) {
-              console.log(chalk.yellow('⚠️  Some quality gates failed - review output above'));
-              process.exit(1);
-            } else {
-              console.log(chalk.green('🎉 All quality gates passed!'));
-            }
-          }
-        }
-      }
-
-      // Exit with appropriate code
-      process.exit(result.valid ? 0 : 1);
-    } catch (error) {
-      console.error(chalk.red('❌ Error during validation:'), error.message);
-      process.exit(1);
-    }
-  });
-
-program
-  .command('agent')
-  .description('Agent-oriented commands for programmatic evaluation')
-  .addCommand(
-    new Command('evaluate')
-      .description('Evaluate work against CAWS quality standards')
-      .argument('<spec-file>', 'Path to working spec file')
-      .option('--json', 'Output results as structured JSON for agent parsing')
-      .option('--strict', 'Apply strict quality thresholds (for production use)')
-      .option('--feedback-only', 'Only return actionable feedback, no execution')
-      .action(async (specFile, options) => {
-        // Quiet mode for agent commands - suppress human-readable output
-        const _originalLog = console.log;
-        const _originalWarn = console.warn;
-        const _originalError = console.error;
-
-        try {
-          if (!options.json) {
-            // Only suppress if not explicitly requesting JSON
-            console.log = () => {};
-            console.warn = () => {};
-            console.error = () => {};
-          }
-
-          await initializeToolSystem();
-
-          if (!fs.existsSync(specFile)) {
-            const result = {
-              success: false,
-              evaluation: {
-                overall_status: 'error',
-                message: `Working spec file not found: ${specFile}`,
-                criteria: [],
-                next_actions: [`Create working spec at ${specFile}`],
-              },
-            };
-            console.log(JSON.stringify(result, null, 2));
-            process.exit(1);
-          }
-
-          const specContent = fs.readFileSync(specFile, 'utf8');
-          const spec = yaml.load(specContent);
-
-          if (!spec) {
-            const result = {
-              success: false,
-              evaluation: {
-                overall_status: 'error',
-                message: 'Invalid YAML in working spec',
-                criteria: [],
-                next_actions: ['Fix YAML syntax in working spec'],
-              },
-            };
-            console.log(JSON.stringify(result, null, 2));
-            process.exit(1);
-          }
-
-          // Validate spec structure
-          const validationResult = validateWorkingSpecWithSuggestions(spec, {
-            suggestions: false,
-            autoFix: false,
-          });
-
-          if (!validationResult.valid) {
-            const result = {
-              success: false,
-              evaluation: {
-                overall_status: 'spec_invalid',
-                message: 'Working spec validation failed',
-                criteria: [
-                  {
-                    id: 'spec_validity',
-                    name: 'Working Spec Validity',
-                    status: 'failed',
-                    score: 0,
-                    weight: 1.0,
-                    feedback: validationResult.errors.join('; '),
-                  },
-                ],
-                next_actions: [
-                  'Fix working spec validation errors',
-                  'Run: caws validate --auto-fix for automatic fixes',
-                ],
-              },
-            };
-            console.log(JSON.stringify(result, null, 2));
-            process.exit(1);
-          }
-
-          // If feedback-only, just return spec evaluation
-          if (options.feedbackOnly) {
-            const result = {
-              success: true,
-              evaluation: {
-                overall_status: 'spec_valid',
-                message: 'Working spec is valid and ready for implementation',
-                criteria: [
-                  {
-                    id: 'spec_completeness',
-                    name: 'Specification Completeness',
-                    status: 'passed',
-                    score: 1.0,
-                    weight: 1.0,
-                    feedback: `Valid ${spec.mode} spec for ${spec.title} (${spec.risk_tier})`,
-                  },
-                ],
-                spec_summary: {
-                  id: spec.id,
-                  mode: spec.mode,
-                  tier: spec.risk_tier,
-                  title: spec.title,
-                  acceptance_criteria: spec.acceptance?.length || 0,
-                  invariants: spec.invariants?.length || 0,
-                },
-                next_actions: [
-                  `Begin ${spec.mode} implementation`,
-                  'Run: caws agent evaluate <spec> to check progress',
-                  'Run: caws agent iterate <spec> for guided development',
-                ],
-              },
-            };
-            console.log(JSON.stringify(result, null, 2));
-            return;
-          }
-
-          // Run quality gates
-          const qualityGates = await runQualityGatesForSpec(spec, options.strict);
-
-          const result = {
-            success: qualityGates.overall_passed,
-            evaluation: {
-              overall_status: qualityGates.overall_passed ? 'quality_passed' : 'quality_failed',
-              message: qualityGates.summary,
-              criteria: qualityGates.criteria,
-              spec_summary: {
-                id: spec.id,
-                mode: spec.mode,
-                tier: spec.risk_tier,
-                title: spec.title,
-                progress_indicators: qualityGates.progress_indicators,
-              },
-              next_actions: qualityGates.next_actions,
-              quality_score: qualityGates.quality_score,
-              risk_assessment: qualityGates.risk_assessment,
-            },
-          };
-
-          console.log(JSON.stringify(result, null, 2));
-          process.exit(qualityGates.overall_passed ? 0 : 1);
-        } catch (error) {
-          // Restore console functions for error output
-          console.log = _originalLog;
-          console.warn = _originalWarn;
-          console.error = _originalError;
-
-          const result = {
-            success: false,
-            evaluation: {
-              overall_status: 'error',
-              message: `Evaluation failed: ${error.message}`,
-              criteria: [],
-              next_actions: ['Check CAWS setup and try again'],
-            },
-          };
-          console.log(JSON.stringify(result, null, 2));
-          process.exit(1);
-        }
-      })
-  )
-  .addCommand(
-    new Command('iterate')
-      .description('Provide iterative development guidance based on current progress')
-      .argument('<spec-file>', 'Path to working spec file')
-      .option('--current-state <json>', 'JSON description of current implementation state')
-      .option('--json', 'Output as structured JSON')
-      .action(async (specFile, options) => {
-        // Quiet mode for agent commands - suppress human-readable output
-        const _originalLog = console.log;
-        const _originalWarn = console.warn;
-        const _originalError = console.error;
-
-        try {
-          console.log = () => {};
-          console.warn = () => {};
-          console.error = () => {};
-
-          await initializeToolSystem();
-
-          if (!fs.existsSync(specFile)) {
-            const result = {
-              success: false,
-              iteration: {
-                guidance: 'Working spec not found',
-                next_steps: [`Create working spec at ${specFile}`],
-                confidence: 0,
-              },
-            };
-            console.log(JSON.stringify(result, null, 2));
-            process.exit(1);
-          }
-
-          const specContent = fs.readFileSync(specFile, 'utf8');
-          const spec = yaml.load(specContent);
-
-          let currentState = {};
-          if (options.currentState) {
-            try {
-              currentState = JSON.parse(options.currentState);
-            } catch (error) {
-              currentState = { description: options.currentState };
-            }
-          }
-
-          const guidance = await generateIterativeGuidance(spec, currentState);
-
-          const result = {
-            success: true,
-            iteration: guidance,
-          };
-
-          console.log(JSON.stringify(result, null, 2));
-        } catch (error) {
-          // Restore console functions for error output
-          console.log = _originalLog;
-          console.warn = _originalWarn;
-          console.error = _originalError;
-
-          const result = {
-            success: false,
-            iteration: {
-              guidance: 'Iteration guidance failed',
-              error: error.message,
-              next_steps: ['Check CAWS setup and working spec validity'],
-            },
-          };
-          console.log(JSON.stringify(result, null, 2));
-          process.exit(1);
-        }
-      })
-  );
-
-program
-  .command('cicd')
-  .description('CI/CD pipeline optimization and generation')
-  .addCommand(
-    new Command('analyze')
-      .description('Analyze project and recommend CI/CD optimizations')
-      .argument('[spec-file]', 'Path to working spec file', '.caws/working-spec.yaml')
-      .action(async (specFile) => {
-        try {
-          const CICDOptimizer = require('./cicd-optimizer');
-          const optimizer = new CICDOptimizer();
-
-          console.log('🔍 Analyzing project for CI/CD optimizations...\n');
-
-          const analysis = await optimizer.analyzeProject(specFile);
-
-          console.log(`📊 Project Tier: ${analysis.project_tier}`);
-          console.log(
-            `⏱️  Estimated Savings: ${analysis.estimated_savings.savings_percent}% faster builds`
-          );
-          console.log(
-            `💰 Monthly Time Savings: ${analysis.estimated_savings.monthly_savings_hours} hours\n`
-          );
-
-          console.log('🎯 Recommended Optimizations:');
-          analysis.recommended_optimizations.forEach((opt, i) => {
-            console.log(`   ${i + 1}. ${opt.description}`);
-            console.log(`      Impact: ${opt.impact} | Effort: ${opt.effort}`);
-          });
-
-          console.log('\n⚙️  Conditional Execution Rules:');
-          Object.entries(analysis.conditional_execution).forEach(([rule, enabled]) => {
-            console.log(`   ${enabled ? '✅' : '❌'} ${rule.replace(/_/g, ' ')}`);
-          });
-
-          console.log('\n📦 Cache Strategy:');
-          Object.entries(analysis.cache_strategy).forEach(([cache, config]) => {
-            console.log(`   ${cache}: ${config.paths.join(', ')}`);
-          });
-
-          console.log('\n🔄 Parallel Execution Groups:');
-          analysis.parallel_groups.forEach((group) => {
-            console.log(
-              `   ${group.name}: ${group.jobs.join(', ')} (max ${group.max_parallel} parallel, ${group.timeout}min timeout)`
-            );
-          });
-        } catch (error) {
-          console.error('❌ Failed to analyze CI/CD optimizations:', error.message);
-          process.exit(1);
-        }
-      })
-  )
-  .addCommand(
-    new Command('generate')
-      .description('Generate optimized CI/CD configuration')
-      .argument('[platform]', 'CI/CD platform (github, gitlab, jenkins)', 'github')
-      .option('-o, --output <file>', 'Output file path')
-      .action(async (platform, options) => {
-        try {
-          const CICDOptimizer = require('./cicd-optimizer');
-          const optimizer = new CICDOptimizer();
-
-          console.log(`🔧 Generating optimized ${platform} CI/CD configuration...\n`);
-
-          const config = await optimizer.generateOptimizedConfig(platform);
-
-          if (options.output) {
-            const fs = require('fs');
-            const yaml = require('js-yaml');
-
-            if (platform === 'github') {
-              // GitHub Actions uses YAML
-              const yamlConfig = yaml.dump(config, { indent: 2 });
-              fs.writeFileSync(options.output, yamlConfig);
-              console.log(`✅ Generated GitHub Actions workflow: ${options.output}`);
-            } else if (platform === 'gitlab') {
-              // GitLab CI uses YAML
-              const yamlConfig = yaml.dump(config, { indent: 2 });
-              fs.writeFileSync(options.output, yamlConfig);
-              console.log(`✅ Generated GitLab CI config: ${options.output}`);
-            } else if (platform === 'jenkins') {
-              // Jenkins uses Groovy
-              fs.writeFileSync(options.output, config);
-              console.log(`✅ Generated Jenkins pipeline: ${options.output}`);
-            }
-          } else {
-            // Print to console
-            console.log('Generated configuration:');
-            console.log('='.repeat(50));
-            if (platform === 'github' || platform === 'gitlab') {
-              console.log(JSON.stringify(config, null, 2));
-            } else {
-              console.log(config);
-            }
-          }
-        } catch (error) {
-          console.error('❌ Failed to generate CI/CD config:', error.message);
-          process.exit(1);
-        }
-      })
-  )
-  .addCommand(
-    new Command('test-selection')
-      .description('Analyze changed files and recommend test execution')
-      .option('--changed-files <files>', 'Comma-separated list of changed files')
-      .option('--from-commit <commit>', 'Analyze changes from specific commit')
-      .action(async (options) => {
-        try {
-          const CICDOptimizer = require('./cicd-optimizer');
-          const optimizer = new CICDOptimizer();
-
-          let changedFiles = [];
-
-          if (options.changedFiles) {
-            changedFiles = options.changedFiles.split(',').map((f) => f.trim());
-          } else if (options.fromCommit) {
-            // Use git to get changed files
-            const { execSync } = require('child_process');
-            try {
-              const output = execSync(`git diff --name-only ${options.fromCommit}`, {
-                encoding: 'utf8',
-              });
-              changedFiles = output
-                .trim()
-                .split('\n')
-                .filter((f) => f.length > 0);
-            } catch (error) {
-              console.error('❌ Failed to get changed files from git:', error.message);
-              process.exit(1);
-            }
-          } else {
-            console.error('❌ Must specify either --changed-files or --from-commit');
-            process.exit(1);
-          }
-
-          console.log(`🔍 Analyzing ${changedFiles.length} changed files...\n`);
-
-          const affectedTests = await optimizer.analyzeChangedFiles(changedFiles);
-
-          console.log('📋 Recommended Test Execution:');
-
-          if (affectedTests.unit.length > 0) {
-            console.log('🧪 Unit Tests:');
-            affectedTests.unit.forEach((test) => console.log(`   • ${test}`));
-          }
-
-          if (affectedTests.integration.length > 0) {
-            console.log('🔗 Integration Tests:');
-            affectedTests.integration.forEach((test) => console.log(`   • ${test}`));
-          }
-
-          if (affectedTests.contract.length > 0) {
-            console.log('📄 Contract Tests:');
-            affectedTests.contract.forEach((test) => console.log(`   • ${test}`));
-          }
-
-          if (affectedTests.e2e.length > 0) {
-            console.log('🌐 E2E Tests:');
-            affectedTests.e2e.forEach((test) => console.log(`   • ${test}`));
-          }
-
-          const totalTests = Object.values(affectedTests).flat().length;
-          console.log(`\n📊 Total recommended tests: ${totalTests}`);
-
-          if (totalTests === 0) {
-            console.log('ℹ️  No specific tests recommended - consider running full test suite');
-          }
-        } catch (error) {
-          console.error('❌ Failed to analyze test selection:', error.message);
-          process.exit(1);
-        }
-      })
-  );
-
-program
-  .command('experimental')
-  .description('Experimental features and dry-run capabilities')
-  .option('--dry-run', 'Run in dry-run mode without making actual changes', false)
-  .addCommand(
-    new Command('validate')
-      .description('Validate working spec with experimental features')
-      .argument('<spec-file>', 'Path to working spec file')
-      .option('--enhanced-analysis', 'Use enhanced analysis features', false)
-      .option('--predictive-scoring', 'Enable predictive quality scoring', false)
-      .action(async (specFile, options, cmd) => {
-        const isDryRun = cmd.parent.opts().dryRun;
-
-        if (isDryRun) {
-          console.log('🏜️  EXPERIMENTAL MODE - DRY RUN');
-          console.log('No actual validation will be performed\n');
-        }
-
-        console.log('🧪 Experimental Features Enabled:');
-        if (options.enhancedAnalysis) console.log('  • Enhanced analysis features');
-        if (options.predictiveScoring) console.log('  • Predictive quality scoring');
-        console.log('');
-
-        if (isDryRun) {
-          console.log('📋 Would validate:', specFile);
-          console.log('🎯 Would check enhanced analysis:', options.enhancedAnalysis);
-          console.log('🔮 Would enable predictive scoring:', options.predictiveScoring);
-          console.log('\n✅ Dry run completed - no changes made');
-          return;
-        }
-
-        // Implement experimental validation logic here
-        try {
-          console.log('🔬 Running experimental validation...');
-
-          // For now, fall back to standard validation
-          const result = await validateWorkingSpec(specFile);
-
-          if (result.valid) {
-            console.log('✅ Experimental validation passed');
-            if (options.enhancedAnalysis) {
-              console.log('🧪 Enhanced analysis: Spec structure is optimal');
-            }
-            if (options.predictiveScoring) {
-              console.log('🔮 Predictive score: High confidence in success');
-            }
-          } else {
-            console.log('❌ Experimental validation failed');
-            result.errors.forEach((error) => console.log(`   ${error}`));
-          }
-        } catch (error) {
-          console.error('❌ Experimental validation error:', error.message);
-          process.exit(1);
-        }
-      })
-  )
-  .addCommand(
-    new Command('quality-gates')
-      .description('Run quality gates with experimental features')
-      .argument('<spec-file>', 'Path to working spec file')
-      .option('--smart-selection', 'Use smart test selection based on changes', false)
-      .option('--parallel-execution', 'Enable parallel gate execution', false)
-      .option('--predictive-failures', 'Predict and skip likely failures', false)
-      .action(async (specFile, options, cmd) => {
-        const isDryRun = cmd.parent.opts().dryRun;
-
-        if (isDryRun) {
-          console.log('🏜️  EXPERIMENTAL MODE - DRY RUN');
-          console.log('No quality gates will actually execute\n');
-        }
-
-        console.log('🧪 Experimental Quality Gate Features:');
-        if (options.smartSelection) console.log('  • Smart test selection');
-        if (options.parallelExecution) console.log('  • Parallel execution');
-        if (options.predictiveFailures) console.log('  • Predictive failure detection');
-        console.log('');
-
-        if (isDryRun) {
-          console.log('🎯 Would run quality gates for:', specFile);
-          console.log('🧠 Smart selection:', options.smartSelection);
-          console.log('⚡ Parallel execution:', options.parallelExecution);
-          console.log('🔮 Predictive failures:', options.predictiveFailures);
-          console.log('\n✅ Dry run completed - no gates executed');
-          return;
-        }
-
-        // Implement experimental quality gate logic
-        try {
-          console.log('🚀 Running experimental quality gates...');
-
-          // For now, fall back to standard quality gates
-          await runQualityGatesForSpec(require('fs').readFileSync(specFile, 'utf8'), false);
-
-          console.log('✅ Experimental quality gates completed');
-          if (options.parallelExecution) {
-            console.log('⚡ Parallel execution: Simulated parallel processing');
-          }
-          if (options.smartSelection) {
-            console.log('🧠 Smart selection: Optimized test execution');
-          }
-        } catch (error) {
-          console.error('❌ Experimental quality gates failed:', error.message);
-          process.exit(1);
-        }
-      })
-  );
-
-program
-  .command('waivers')
-  .description('Manage CAWS waivers (fast-lane escape hatches)')
-  .addCommand(
-    new Command('create')
-      .description('Create a new waiver')
-      .requiredOption('-t, --title <title>', 'Waiver title (10-200 characters)')
-      .requiredOption(
-        '-r, --reason <reason>',
-        'Waiver reason (emergency_hotfix, legacy_integration, experimental_feature, third_party_constraint, performance_critical, security_patch, infrastructure_limitation, other)'
-      )
-      .requiredOption('-d, --description <desc>', 'Detailed description (50-1000 characters)')
-      .requiredOption('-g, --gates <gates>', 'Comma-separated list of gates to waive')
-      .requiredOption('--expires-at <datetime>', 'Expiration date (ISO 8601 format)')
-      .requiredOption('--approved-by <approver>', 'Person/entity approving the waiver')
-      .requiredOption('--impact-level <level>', 'Risk impact level (low, medium, high, critical)')
-      .requiredOption('--mitigation-plan <plan>', 'Risk mitigation plan (50+ characters)')
-      .option('--review-required', 'Flag waiver as requiring manual review', false)
-      .option('--environment <env>', 'Environment restriction (development, staging, production)')
-      .option('--urgency <level>', 'Urgency level (low, normal, high, critical)', 'normal')
-      .option('--related-pr <pr>', 'Related pull request URL')
-      .option('--related-issue <issue>', 'Related issue URL')
-      .action(async (options) => {
-        try {
-          const WaiversManager = require('./waivers-manager');
-          const waiversManager = new WaiversManager();
-
-          const waiverData = {
-            title: options.title,
-            reason: options.reason,
-            description: options.description,
-            gates: options.gates.split(',').map((g) => g.trim()),
-            expires_at: options.expiresAt,
-            approved_by: options.approvedBy,
-            risk_assessment: {
-              impact_level: options.impactLevel,
-              mitigation_plan: options.mitigationPlan,
-              review_required: options.reviewRequired || false,
-            },
-            metadata: {
-              environment: options.environment,
-              urgency: options.urgency,
-              related_pr: options.relatedPr,
-              related_issue: options.relatedIssue,
-            },
-          };
-
-          const waiver = await waiversManager.createWaiver(waiverData);
-
-          console.log(`✅ Waiver created successfully: ${waiver.id}`);
-          console.log(`📋 Title: ${waiver.title}`);
-          console.log(`⏰ Expires: ${waiver.expires_at}`);
-          console.log(`🎯 Gates waived: ${waiver.gates.join(', ')}`);
-
-          if (
-            waiver.risk_assessment.impact_level === 'critical' ||
-            waiver.risk_assessment.review_required
-          ) {
-            console.log('\n⚠️  HIGH RISK WAIVER - Manual review required');
-            console.log(`📄 Review file created: .caws/waivers/review-${waiver.id}.md`);
-            console.log('🔍 Please have code owners review this waiver before use');
-          }
-        } catch (error) {
-          console.error('❌ Failed to create waiver:', error.message);
-          process.exit(1);
-        }
-      })
-  )
-  .addCommand(
-    new Command('list')
-      .alias('ls')
-      .description('List active waivers')
-      .option('-v, --verbose', 'Show detailed waiver information')
-      .option('--expiring-soon', 'Show only waivers expiring within 7 days')
-      .option('--high-risk', 'Show only high/critical risk waivers')
-      .action(async (options) => {
-        try {
-          const WaiversManager = require('./waivers-manager');
-          const waiversManager = new WaiversManager();
-
-          let waivers = await waiversManager.getActiveWaivers();
-
-          // Apply filters
-          if (options.expiringSoon) {
-            const sevenDaysFromNow = new Date(Date.now() + 7 * 24 * 60 * 60 * 1000);
-            waivers = waivers.filter((w) => new Date(w.expires_at) <= sevenDaysFromNow);
-          }
-
-          if (options.highRisk) {
-            waivers = waivers.filter(
-              (w) =>
-                w.risk_assessment.impact_level === 'high' ||
-                w.risk_assessment.impact_level === 'critical'
-            );
-          }
-
-          if (waivers.length === 0) {
-            console.log('ℹ️  No active waivers found');
-            return;
-          }
-
-          console.log(`📋 Active waivers: ${waivers.length}`);
-          console.log('');
-
-          for (const waiver of waivers) {
-            const expiresAt = new Date(waiver.expires_at);
-            const now = new Date();
-            const daysRemaining = Math.ceil((expiresAt - now) / (24 * 60 * 60 * 1000));
-
-            console.log(`🔖 ${waiver.id}: ${waiver.title}`);
-            console.log(`   ⏰ Expires: ${waiver.expires_at} (${daysRemaining} days remaining)`);
-            console.log(`   🎯 Gates: ${waiver.gates.join(', ')}`);
-            console.log(`   ⚠️  Risk: ${waiver.risk_assessment.impact_level}`);
-            console.log(`   👤 Approved by: ${waiver.approved_by}`);
-
-            if (options.verbose) {
-              console.log(`   📝 Reason: ${waiver.reason}`);
-              console.log(
-                `   📄 Description: ${waiver.description.substring(0, 100)}${waiver.description.length > 100 ? '...' : ''}`
-              );
-              console.log(
-                `   🛡️  Mitigation: ${waiver.risk_assessment.mitigation_plan.substring(0, 100)}${waiver.risk_assessment.mitigation_plan.length > 100 ? '...' : ''}`
-              );
-
-              if (waiver.metadata) {
-                const metadata = [];
-                if (waiver.metadata.environment)
-                  metadata.push(`Env: ${waiver.metadata.environment}`);
-                if (waiver.metadata.urgency) metadata.push(`Urgency: ${waiver.metadata.urgency}`);
-                if (waiver.metadata.related_pr) metadata.push(`PR: ${waiver.metadata.related_pr}`);
-                if (metadata.length > 0) {
-                  console.log(`   📊 Metadata: ${metadata.join(', ')}`);
-                }
-              }
-            }
-
-            console.log('');
-          }
-        } catch (error) {
-          console.error('❌ Failed to list waivers:', error.message);
-          process.exit(1);
-        }
-      })
-  )
-  .addCommand(
-    new Command('revoke')
-      .description('Revoke an active waiver')
-      .argument('<waiver-id>', 'Waiver ID to revoke')
-      .option('-r, --reason <reason>', 'Reason for revocation', 'Manual revocation')
-      .action(async (waiverId, options) => {
-        try {
-          const WaiversManager = require('./waivers-manager');
-          const waiversManager = new WaiversManager();
-
-          const waiver = await waiversManager.revokeWaiver(waiverId, options.reason);
-
-          console.log(`✅ Waiver revoked: ${waiverId}`);
-          console.log(`📝 Reason: ${options.reason}`);
-          console.log(`🎯 Gates no longer waived: ${waiver.gates.join(', ')}`);
-        } catch (error) {
-          console.error('❌ Failed to revoke waiver:', error.message);
-          process.exit(1);
-        }
-      })
-  )
-  .addCommand(
-    new Command('extend')
-      .description('Extend waiver expiration date')
-      .argument('<waiver-id>', 'Waiver ID to extend')
-      .requiredOption('--new-expiry <datetime>', 'New expiration date (ISO 8601 format)')
-      .requiredOption('--approved-by <approver>', 'Person approving the extension')
-      .action(async (waiverId, options) => {
-        try {
-          const WaiversManager = require('./waivers-manager');
-          const waiversManager = new WaiversManager();
-
-          const waiver = await waiversManager.extendWaiver(
-            waiverId,
-            options.newExpiry,
-            options.approvedBy
-          );
-
-          console.log(`✅ Waiver extended: ${waiverId}`);
-          console.log(`⏰ New expiry: ${waiver.expires_at}`);
-          console.log(`👤 Extended by: ${options.approvedBy}`);
-        } catch (error) {
-          console.error('❌ Failed to extend waiver:', error.message);
-          process.exit(1);
-        }
-      })
-  )
-  .addCommand(
-    new Command('stats')
-      .description('Show waiver statistics and health metrics')
-      .action(async () => {
-        try {
-          const WaiversManager = require('./waivers-manager');
-          const waiversManager = new WaiversManager();
-
-          const stats = await waiversManager.getWaiverStats();
-
-          console.log('📊 Waiver Statistics');
-          console.log('==================');
-
-          console.log(`📋 Total active waivers: ${stats.total_active}`);
-          console.log(`🎯 Total gates waived: ${stats.total_gates_waived}`);
-          console.log(`📅 Average lifespan: ${stats.average_lifespan_days.toFixed(1)} days`);
-
-          if (stats.expiring_soon.length > 0) {
-            console.log(`\n⏰ Expiring soon (${stats.expiring_soon.length}):`);
-            stats.expiring_soon.forEach((w) => {
-              console.log(`   ${w.id}: ${w.days_remaining} days (${w.title.substring(0, 50)}...)`);
-            });
-          }
-
-          if (stats.high_risk.length > 0) {
-            console.log(`\n⚠️  High risk waivers (${stats.high_risk.length}):`);
-            stats.high_risk.forEach((w) => {
-              console.log(
-                `   ${w.id}: ${w.risk_level} - ${w.reason} (${w.title.substring(0, 40)}...)`
-              );
-            });
-          }
-
-          console.log(`\n📈 By reason:`);
-          Object.entries(stats.by_reason).forEach(([reason, count]) => {
-            console.log(`   ${reason}: ${count}`);
-          });
-
-          console.log(`\n⚠️  By risk level:`);
-          Object.entries(stats.by_risk_level).forEach(([level, count]) => {
-            console.log(`   ${level}: ${count}`);
-          });
-        } catch (error) {
-          console.error('❌ Failed to get waiver stats:', error.message);
-          process.exit(1);
-        }
-      })
-  );
-
-program
-  .command('tools')
-  .description('Manage CAWS tools')
-  .addCommand(
-    new Command('list')
-      .alias('ls')
-      .description('List available tools')
-      .option('-v, --verbose', 'Show detailed tool information')
-      .action(async (options) => {
-        try {
-          const loader = await initializeToolSystem();
-          if (!loader) {
-            console.error(chalk.red('❌ Tool system not available'));
-            process.exit(1);
-          }
-
-          const tools = loader.getAllTools();
-
-          if (tools.size === 0) {
-            console.log(chalk.yellow('⚠️  No tools loaded'));
-            console.log(chalk.blue('💡 Add tools to apps/tools/caws/ directory'));
-            return;
-          }
-
-          console.log(chalk.blue(`🔧 Available Tools (${tools.size}):`));
-          console.log('');
-
-          for (const [id, tool] of tools) {
-            const metadata = tool.metadata;
-            console.log(chalk.green(`📦 ${metadata.name} (${id})`));
-            console.log(`   ${metadata.description || 'No description'}`);
-            if (metadata.version) {
-              console.log(chalk.gray(`   Version: ${metadata.version}`));
-            }
-            if (metadata.capabilities && metadata.capabilities.length > 0) {
-              console.log(chalk.gray(`   Capabilities: ${metadata.capabilities.join(', ')}`));
-            }
-            if (options.verbose && metadata.dependencies) {
-              console.log(chalk.gray(`   Dependencies: ${metadata.dependencies.join(', ')}`));
-            }
-            console.log('');
-          }
-        } catch (error) {
-          console.error(chalk.red('❌ Error listing tools:'), error.message);
-          process.exit(1);
-        }
-      })
-  )
-  .addCommand(
-    new Command('run')
-      .description('Execute a specific tool')
-      .argument('<tool-id>', 'Tool identifier to execute')
-      .option('-p, --params <json>', 'JSON parameters for tool execution')
-      .option('-t, --timeout <ms>', 'Execution timeout in milliseconds', parseInt, 30000)
-      .action(async (toolId, options) => {
-        try {
-          const loader = await initializeToolSystem();
-          if (!loader) {
-            console.error(chalk.red('❌ Tool system not available'));
-            process.exit(1);
-          }
-
-          // Load all tools first
-          await loader.loadAllTools();
-          const tool = loader.getTool(toolId);
-
-          if (!tool) {
-            console.error(chalk.red(`❌ Tool '${toolId}' not found`));
-            console.log(chalk.blue('💡 Available tools:'));
-            const tools = loader.getAllTools();
-            for (const [id, t] of tools) {
-              console.log(`   - ${id}: ${t.metadata.name}`);
-            }
-            process.exit(1);
-          }
-
-          // Validate tool before execution
-          const validation = await toolValidator.validateTool(tool);
-          if (!validation.valid) {
-            console.error(chalk.red('❌ Tool validation failed:'));
-            validation.errors.forEach((error) => {
-              console.error(`   ${chalk.red('✗')} ${error}`);
-            });
-            process.exit(1);
-          }
-
-          // Parse parameters
-          let params = {};
-          if (options.params) {
-            try {
-              params = JSON.parse(options.params);
-            } catch (error) {
-              console.error(chalk.red('❌ Invalid JSON parameters:'), error.message);
-              process.exit(1);
-            }
-          }
-
-          console.log(chalk.blue(`🚀 Executing tool: ${tool.metadata.name}`));
-
-          // Execute tool
-          const result = await tool.module.execute(params, {
-            workingDirectory: process.cwd(),
-            timeout: options.timeout,
-          });
-
-          // Display results
-          if (result.success) {
-            console.log(chalk.green('✅ Tool execution successful'));
-            if (result.output && typeof result.output === 'object') {
-              console.log(chalk.gray('Output:'), JSON.stringify(result.output, null, 2));
-            }
-          } else {
-            console.error(chalk.red('❌ Tool execution failed'));
-            result.errors.forEach((error) => {
-              console.error(`   ${chalk.red('✗')} ${error}`);
-            });
-            process.exit(1);
-          }
-        } catch (error) {
-          console.error(chalk.red(`❌ Error executing tool ${toolId}:`), error.message);
-          process.exit(1);
-        }
-      })
-  );
-
-// Error handling
-program.exitOverride((err) => {
-  if (
-    err.code === 'commander.help' ||
-    err.code === 'commander.version' ||
-    err.message.includes('outputHelp')
-  ) {
-    process.exit(0);
-  }
-  console.error(chalk.red('❌ Error:'), err.message);
-  process.exit(1);
-});
-
-// Parse and run (only when run directly, not when required as module)
-if (require.main === module) {
-  try {
-    program.parse();
-  } catch (error) {
-    if (
-      error.code === 'commander.help' ||
-      error.code === 'commander.version' ||
-      error.message.includes('outputHelp')
-    ) {
-      process.exit(0);
-    } else {
-      console.error(chalk.red('❌ Error:'), error.message);
-      process.exit(1);
-    }
-  }
-}
-
-// Export functions for testing
-module.exports = {
-  generateWorkingSpec,
-  validateGeneratedSpec,
-};