@paths.design/caws-cli 3.1.0 → 3.2.0

package/dist/index.js

@@ -7,3018 +7,228 @@
  */
 
 const { Command } = require('commander');
+// eslint-disable-next-line no-unused-vars
 const fs = require('fs-extra');
+// eslint-disable-next-line no-unused-vars
 const path = require('path');
-const inquirer = require('inquirer').default || require('inquirer');
+// eslint-disable-next-line no-unused-vars
 const yaml = require('js-yaml');
 const chalk = require('chalk');
 
-// Import language support (with fallback for when tools aren't available)
-let languageSupport = null;
-try {
-  // Try multiple possible locations for language support
-  const possiblePaths = [
-    path.join(__dirname, '../../caws-template/apps/tools/caws/language-support.js'),
-    path.join(__dirname, '../../../caws-template/apps/tools/caws/language-support.js'),
-    path.join(process.cwd(), 'packages/caws-template/apps/tools/caws/language-support.js'),
-    path.join(process.cwd(), 'caws-template/apps/tools/caws/language-support.js'),
-  ];
-
-  for (const testPath of possiblePaths) {
-    try {
-      languageSupport = require(testPath);
-      // Only log if not running version command
-      if (!process.argv.includes('--version') && !process.argv.includes('-V')) {
-        console.log(`✅ Loaded language support from: ${testPath}`);
-      }
-      break;
-    } catch (pathError) {
-      // Continue to next path
-    }
-  }
-} catch (error) {
-  console.warn(chalk.yellow('⚠️  Language support tools not available'));
-  console.warn(chalk.blue('💡 This may limit language-specific configuration features'));
-  console.warn(chalk.blue('💡 For full functionality, ensure caws-template package is available'));
-}
-
-const program = new Command();
-
-// 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',
-        },
-      ];
-
-      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;
-
-      // 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')
-        );
-      }
-    }
-
-    // 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;
-        }
-
-        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 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!')
-      );
-    }
+// Import configuration and utilities
+const {
+  CLI_VERSION,
+  initializeGlobalSetup,
+  loadProvenanceTools,
+  initializeLanguageSupport,
+} = require('./config');
+
+// Import command handlers
+const { initProject } = require('./commands/init');
+const { validateCommand } = require('./commands/validate');
+const { burnupCommand } = require('./commands/burnup');
+const { testAnalysisCommand } = require('./test-analysis');
+const { provenanceCommand } = require('./commands/provenance');
+const { executeTool } = require('./commands/tool');
+
+// Import scaffold functionality
+const { scaffoldProject, setScaffoldDependencies } = require('./scaffold');
+
+// Import git hooks functionality
+const { scaffoldGitHooks, removeGitHooks, checkGitHooksStatus } = require('./scaffold/git-hooks');
+
+// Import validation functionality
+// eslint-disable-next-line no-unused-vars
+const { validateWorkingSpecWithSuggestions } = require('./validation/spec-validation');
+
+// Import finalization utilities
+const {
+  // eslint-disable-next-line no-unused-vars
+  finalizeProject,
+  // eslint-disable-next-line no-unused-vars
+  continueToSuccess,
+  setFinalizationDependencies,
+} = require('./utils/finalization');
+
+// Import generators
+const { generateWorkingSpec, validateGeneratedSpec } = require('./generators/working-spec');
+
+// Initialize global configuration
+const program = new Command();
 
-    if (options.force) {
-      console.log(chalk.yellow('\n⚠️  Force mode was used - review changes carefully'));
-    }
+// Initialize global state
+const cawsSetup = initializeGlobalSetup();
+const languageSupport = initializeLanguageSupport();
 
-    // 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);
-    }
-  }
-}
+// Set up dependencies for modules that need them
+setScaffoldDependencies({
+  cawsSetup,
+  loadProvenanceTools,
+});
 
-/**
- * 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'));
-// }
+setFinalizationDependencies({
+  languageSupport,
+  loadProvenanceTools,
+});
 
-// CLI Commands
-program
-  .name('caws')
-  .description('CAWS - Coding Agent Workflow System CLI')
-  .version(CLI_VERSION, '-v, --version', 'Show version information');
+// Setup CLI program
+program.name('caws').description('CAWS - Coding Agent Workflow System CLI').version(CLI_VERSION);
 
+// Init command
 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)')
+  .argument('[project-name]', 'Name of the project to create (use "." for current directory)')
+  .option('-i, --interactive', 'Run interactive setup wizard', true)
+  .option('--non-interactive', 'Skip interactive prompts (use defaults)', false)
+  .option('--template <template>', 'Use specific project template')
   .action(initProject);
 
+// Scaffold command
 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)')
+  .option('-f, --force', 'Overwrite existing files', false)
+  .option('--minimal', 'Only essential components', false)
+  .option('--with-codemods', 'Include codemod scripts', false)
+  .option('--with-oidc', 'Include OIDC trusted publisher setup', false)
   .action(scaffoldProject);
 
+// Validate command
 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);
-      }
+  .argument('[spec-file]', 'Path to working spec file (default: .caws/working-spec.yaml)')
+  .option('-q, --quiet', 'Suppress suggestions and warnings', false)
+  .option('--auto-fix', 'Automatically fix safe validation issues', false)
+  .action(validateCommand);
+
+// Tool command
+program
+  .command('tool')
+  .description('Execute CAWS tools programmatically')
+  .argument('<tool-id>', 'ID of the tool to execute')
+  .option('-p, --params <json>', 'Parameters as JSON string', '{}')
+  .option('-t, --timeout <ms>', 'Execution timeout in milliseconds', parseInt, 30000)
+  .action(executeTool);
+
+// Test Analysis command
+program
+  .command('test-analysis <subcommand> [options...]')
+  .description('Statistical analysis for budget prediction and test optimization')
+  .action(testAnalysisCommand);
+
+// Provenance command group
+const provenanceCmd = program
+  .command('provenance')
+  .description('Manage CAWS provenance tracking and audit trails');
+
+// Subcommands
+provenanceCmd
+  .command('update')
+  .description('Add new commit to provenance chain')
+  .requiredOption('-c, --commit <hash>', 'Git commit hash')
+  .option('-m, --message <msg>', 'Commit message')
+  .option('-a, --author <info>', 'Author information')
+  .option('-q, --quiet', 'Suppress output')
+  .option('-o, --output <path>', 'Output path for provenance files', '.caws/provenance')
+  .action(async (options) => {
+    await provenanceCommand('update', options);
+  });
 
-      // Load and parse spec
-      const specContent = fs.readFileSync(specFile, 'utf8');
-      const spec = yaml.load(specContent);
+provenanceCmd
+  .command('show')
+  .description('Display current provenance history')
+  .option('-o, --output <path>', 'Output path for provenance files', '.caws/provenance')
+  .option('--format <type>', 'Output format: text, json, dashboard', 'text')
+  .action(async (options) => {
+    await provenanceCommand('show', options);
+  });
 
-      if (!spec) {
-        console.error(chalk.red('❌ Failed to parse working spec YAML'));
-        process.exit(1);
-      }
+provenanceCmd
+  .command('verify')
+  .description('Validate provenance chain integrity')
+  .option('-o, --output <path>', 'Output path for provenance files', '.caws/provenance')
+  .action(async (options) => {
+    await provenanceCommand('verify', options);
+  });
+
+provenanceCmd
+  .command('analyze-ai')
+  .description('Analyze AI-assisted development patterns')
+  .option('-o, --output <path>', 'Output path for provenance files', '.caws/provenance')
+  .action(async (options) => {
+    await provenanceCommand('analyze-ai', options);
+  });
+
+provenanceCmd
+  .command('init')
+  .description('Initialize provenance tracking for the project')
+  .option('-o, --output <path>', 'Output path for provenance files', '.caws/provenance')
+  .option('--cursor-api <url>', 'Cursor tracking API endpoint')
+  .option('--cursor-key <key>', 'Cursor API key')
+  .action(async (options) => {
+    await provenanceCommand('init', options);
+  });
 
-      // Validate with suggestions
-      const result = validateWorkingSpecWithSuggestions(spec, {
-        autoFix: options.autoFix,
-        suggestions: !options.quiet,
-      });
+// Git hooks command
+const hooksCmd = program
+  .command('hooks')
+  .description('Manage CAWS git hooks for provenance tracking');
+
+hooksCmd
+  .command('install')
+  .description('Install CAWS git hooks')
+  .option('--no-provenance', 'Skip provenance tracking hooks')
+  .option('--no-validation', 'Skip validation hooks')
+  .option('--no-quality-gates', 'Skip quality gate hooks')
+  .option('--force', 'Overwrite existing hooks')
+  .option('--backup', 'Backup existing hooks before replacing')
+  .action(async (options) => {
+    const hookOptions = {
+      provenance: options.provenance !== false,
+      validation: options.validation !== false,
+      qualityGates: options.qualityGates !== false,
+      force: options.force,
+      backup: options.backup,
+    };
 
-      // 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}`));
+    try {
+      const result = await scaffoldGitHooks(process.cwd(), hookOptions);
+      if (result.added > 0) {
+        console.log(`✅ Successfully installed ${result.added} git hooks`);
+        if (result.skipped > 0) {
+          console.log(`⏭️  Skipped ${result.skipped} existing hooks`);
+        }
+      } else {
+        console.log('ℹ️  All hooks already configured');
       }
+    } catch (error) {
+      console.error(`❌ Failed to install git hooks: ${error.message}`);
+      process.exit(1);
+    }
+  });
+
+hooksCmd
+  .command('remove')
+  .description('Remove CAWS git hooks')
+  .action(async () => {
+    try {
+      await removeGitHooks(process.cwd());
+    } catch (error) {
+      console.error(`❌ Failed to remove git hooks: ${error.message}`);
+      process.exit(1);
+    }
+  });
 
-      // Exit with appropriate code
-      process.exit(result.valid ? 0 : 1);
+hooksCmd
+  .command('status')
+  .description('Check git hooks status')
+  .action(async () => {
+    try {
+      await checkGitHooksStatus(process.cwd());
     } catch (error) {
-      console.error(chalk.red('❌ Error during validation:'), error.message);
+      console.error(`❌ Failed to check git hooks status: ${error.message}`);
       process.exit(1);
     }
   });
@@ -3036,7 +246,7 @@ program.exitOverride((err) => {
   process.exit(1);
 });
 
-// Parse and run (only when run directly, not when required as module)
+// Parse and run
 if (require.main === module) {
   try {
     program.parse();