@paths.design/caws-cli 3.0.0 → 3.1.1

package/dist/index.js

@@ -7,1685 +7,126 @@
  */
 
 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('⚠️  Language support tools not available');
-}
-
+// 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 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();
 
-// 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.resolve(__dirname, '../templates'),
-    path.resolve(__dirname, 'templates'),
-    // Try relative to current working directory (for monorepo setups)
-    path.resolve(cwd, '../caws-template'),
-    path.resolve(cwd, '../../caws-template'),
-    path.resolve(cwd, '../../../caws-template'),
-    path.resolve(cwd, 'packages/caws-template'),
-    path.resolve(cwd, 'caws-template'),
-    // Try relative to CLI location (for installed CLI)
-    path.resolve(__dirname, '../caws-template'),
-    path.resolve(__dirname, '../../caws-template'),
-    path.resolve(__dirname, '../../../caws-template'),
-    // Try absolute paths for CI environments
-    path.resolve(process.cwd(), 'packages/caws-template'),
-    path.resolve(process.cwd(), '../packages/caws-template'),
-    path.resolve(process.cwd(), '../../packages/caws-template'),
-    path.resolve(process.cwd(), '../../../packages/caws-template'),
-    // Try from workspace root
-    path.resolve(process.cwd(), 'caws-template'),
-    // Try various other common locations
-    '/home/runner/work/coding-agent-working-standard/coding-agent-working-standard/packages/caws-template',
-    '/workspace/packages/caws-template',
-    '/caws/packages/caws-template',
-  ];
-
-  for (const testPath of possibleTemplatePaths) {
-    if (fs.existsSync(testPath)) {
-      templateDir = testPath;
-      if (!isQuietCommand) {
-        console.log(`✅ Found template directory: ${testPath}`);
-      }
-      break;
-    }
-  }
-
-  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}`,
-        },
-      ],
-    };
-  }
-};
-
-// 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);
-  }
-}
-
-/**
- * Initialize a new project with CAWS
- */
-async function initProject(projectName, options) {
-  console.log(chalk.cyan(`🚀 Initializing new CAWS project: ${projectName}`));
-
-  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 directory already exists (skip check for current directory)
-    if (!initInCurrentDir && fs.existsSync(projectName)) {
-      console.error(chalk.red(`❌ Directory ${projectName} already exists`));
-      console.error(chalk.blue('💡 Choose a different name or remove the existing directory'));
-      process.exit(1);
-    }
-
-    // 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'));
+// Initialize global state
+const cawsSetup = initializeGlobalSetup();
+const languageSupport = initializeLanguageSupport();
 
-      // 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);
-        }
-      }
-    } else {
-      // Already has CAWS setup
-      console.log(chalk.green('✅ CAWS project detected - skipping template copy'));
-    }
-
-    // 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'));
-
-      // 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() {
-  console.log(chalk.green('\n🎉 Project initialized successfully!'));
-  console.log(`📁 ${chalk.cyan('Project location')}: ${path.resolve(process.cwd())}`);
-  console.log(chalk.bold('\nNext steps:'));
-  console.log('1. Customize .caws/working-spec.yaml');
-  console.log('2. npm install (if using Node.js)');
-  console.log('3. 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);
-
-  console.log(chalk.cyan(`🔧 Enhancing existing project with CAWS: ${projectName}`));
-
-  try {
-    // Detect existing CAWS setup with current directory context
-    const setup = detectCAWSSetup(currentDir);
-
-    // 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!`));
-      }
-    }
-
-    // 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
-    const enhancements = [];
-
-    // Add CAWS tools directory structure (matches test expectations)
-    enhancements.push({
-      name: 'apps/tools/caws',
-      description: 'CAWS tools directory',
-      required: true,
-    });
-
-    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 for setups that need it
-    if (!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');
-      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');
-    }
-
-    if (setup.isEnhanced) {
-      console.log(
-        chalk.blue('\n🎯 Your enhanced CAWS setup has been improved with automated publishing!')
-      );
-    }
-
-    if (options.force) {
-      console.log(chalk.yellow('\n⚠️  Force mode was used - review changes carefully'));
-    }
-
-    // Save provenance manifest if tools are available
-    const tools = loadProvenanceTools();
-    if (tools && typeof tools.saveProvenance === 'function') {
-      await tools.saveProvenance(scaffoldProvenance, '.agent/scaffold-provenance.json');
-      console.log(chalk.green('✅ Scaffolding provenance saved'));
-    } else {
-      console.log(chalk.yellow('⚠️  Provenance tools not available - skipping manifest save'));
-    }
-  } catch (error) {
-    // Handle circular reference errors from Commander.js
-    if (error.message && error.message.includes('Converting circular structure to JSON')) {
-      console.log(
-        chalk.yellow('⚠️  Scaffolding completed with minor issues (circular reference handled)')
-      );
-      console.log(chalk.green('✅ CAWS components scaffolded successfully'));
-    } else {
-      console.error(chalk.red('❌ Error during scaffolding:'), error.message);
-      process.exit(1);
-    }
-  }
-}
+// 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', true)
-  .option('-g, --git', 'Initialize git repository', true)
-  .option('-n, --non-interactive', 'Skip interactive prompts')
-  .option('--no-git', "Don't initialize git repository")
+  .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('-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')
+  .description('Validate CAWS working spec with suggestions')
+  .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
+program
+  .command('provenance')
+  .description('Manage CAWS provenance tracking and audit trails')
+  .argument('<subcommand>', 'Command: update, show, verify, analyze-ai')
+  .option('-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')
+  .action(provenanceCommand);
+
 // Error handling
 program.exitOverride((err) => {
   if (
@@ -1699,7 +140,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();