@paths.design/caws-cli 8.0.1 → 8.2.0

package/dist/scaffold/claude-hooks.js

@@ -0,0 +1,344 @@
+/**
+ * @fileoverview Claude Code Hooks Scaffolding
+ * Functions for setting up Claude Code hooks for CAWS projects
+ * @author @darianrosebrook
+ */
+
+const fs = require('fs-extra');
+const path = require('path');
+const chalk = require('chalk');
+
+// Import detection utilities
+const { detectCAWSSetup, findPackageRoot } = require('../utils/detection');
+
+/**
+ * Scaffold Claude Code hooks for a CAWS project
+ * Creates .claude/settings.json with hooks and .claude/hooks/ directory with scripts
+ *
+ * @param {string} projectDir - Project directory path
+ * @param {string[]} levels - Hook levels to enable: 'safety', 'quality', 'scope', 'audit'
+ */
+async function scaffoldClaudeHooks(projectDir, levels = ['safety', 'quality', 'scope', 'audit']) {
+  try {
+    const claudeDir = path.join(projectDir, '.claude');
+    const claudeHooksDir = path.join(claudeDir, 'hooks');
+
+    // Create .claude directory structure
+    await fs.ensureDir(claudeDir);
+    await fs.ensureDir(claudeHooksDir);
+
+    // Determine template directory - prefer bundled templates
+    const setup = detectCAWSSetup(projectDir);
+
+    // Find package root using shared utility
+    const packageRoot = findPackageRoot(__dirname);
+
+    // Try templates relative to package root first (works in both dev and global install)
+    const bundledTemplateDir = path.join(packageRoot, 'templates');
+    const fallbackTemplateDir = path.join(__dirname, '../../templates');
+    const templateDir = fs.existsSync(bundledTemplateDir)
+      ? bundledTemplateDir
+      : fs.existsSync(fallbackTemplateDir)
+      ? fallbackTemplateDir
+      : setup.templateDir || path.resolve(__dirname, '../templates');
+
+    const claudeTemplateDir = path.join(templateDir, '.claude');
+    const claudeHooksTemplateDir = path.join(claudeTemplateDir, 'hooks');
+
+    if (!fs.existsSync(claudeTemplateDir)) {
+      console.warn(chalk.yellow('⚠️  Claude Code hooks templates not found'));
+      console.warn(chalk.blue('💡 Skipping Claude Code hooks setup'));
+      return;
+    }
+
+    // Map levels to hook scripts
+    const hookMapping = {
+      safety: ['block-dangerous.sh', 'scan-secrets.sh'],
+      quality: ['quality-check.sh', 'validate-spec.sh'],
+      scope: ['scope-guard.sh', 'naming-check.sh'],
+      audit: ['audit.sh'],
+      lite: ['block-dangerous.sh', 'scope-guard.sh', 'lite-sprawl-check.sh', 'simplification-guard.sh'],
+    };
+
+    // Determine which hooks to enable
+    const enabledHooks = new Set();
+    levels.forEach((level) => {
+      const hooks = hookMapping[level] || [];
+      hooks.forEach((hook) => enabledHooks.add(hook));
+    });
+
+    // Always enable audit.sh if any hooks are enabled
+    if (enabledHooks.size > 0) {
+      enabledHooks.add('audit.sh');
+    }
+
+    // Copy enabled hook scripts
+    const allHookScripts = [
+      'audit.sh',
+      'validate-spec.sh',
+      'quality-check.sh',
+      'scan-secrets.sh',
+      'block-dangerous.sh',
+      'scope-guard.sh',
+      'naming-check.sh',
+      'lite-sprawl-check.sh',
+      'simplification-guard.sh',
+    ];
+
+    for (const script of allHookScripts) {
+      if (enabledHooks.has(script)) {
+        const sourcePath = path.join(claudeHooksTemplateDir, script);
+        const destPath = path.join(claudeHooksDir, script);
+
+        if (fs.existsSync(sourcePath)) {
+          await fs.copy(sourcePath, destPath);
+          // Make executable
+          await fs.chmod(destPath, 0o755);
+        }
+      }
+    }
+
+    // Generate settings.json with hooks configuration
+    const settings = generateClaudeSettings(levels, enabledHooks);
+
+    // Check for existing settings and merge
+    const settingsPath = path.join(claudeDir, 'settings.json');
+    if (fs.existsSync(settingsPath)) {
+      try {
+        const existingSettings = await fs.readJSON(settingsPath);
+        // Merge hooks, preserving existing non-hook settings
+        settings.hooks = {
+          ...existingSettings.hooks,
+          ...settings.hooks,
+        };
+        // Preserve other settings
+        Object.keys(existingSettings).forEach((key) => {
+          if (key !== 'hooks' && !(key in settings)) {
+            settings[key] = existingSettings[key];
+          }
+        });
+      } catch (error) {
+        console.warn(chalk.yellow('⚠️  Could not merge existing settings:'), error.message);
+      }
+    }
+
+    // Write settings.json
+    await fs.writeFile(settingsPath, JSON.stringify(settings, null, 2));
+
+    // Copy README if it exists
+    const readmePath = path.join(claudeTemplateDir, 'README.md');
+    if (fs.existsSync(readmePath)) {
+      await fs.copy(readmePath, path.join(claudeDir, 'README.md'));
+    }
+
+    console.log(chalk.green('✅ Claude Code hooks configured'));
+    console.log(chalk.gray(`   Enabled: ${levels.join(', ')}`));
+    console.log(
+      chalk.gray(`   Scripts: ${Array.from(enabledHooks).length} hook scripts installed`)
+    );
+    console.log(chalk.blue('💡 Hooks will activate on next Claude Code session'));
+  } catch (error) {
+    console.error(chalk.yellow('⚠️  Failed to setup Claude Code hooks:'), error.message);
+    console.log(chalk.blue('💡 You can manually copy .claude/ directory later'));
+  }
+}
+
+/**
+ * Generate Claude Code settings with hooks configuration
+ * @param {string[]} levels - Enabled hook levels
+ * @param {Set<string>} enabledHooks - Set of enabled hook script names
+ * @returns {Object} Settings object for settings.json
+ */
+function generateClaudeSettings(levels, _enabledHooks) {
+  const settings = {
+    hooks: {},
+  };
+
+  // Build hooks configuration based on enabled levels
+  // Claude Code uses different event names and matcher patterns
+
+  if (levels.includes('safety')) {
+    // Block dangerous bash commands
+    settings.hooks.PreToolUse = settings.hooks.PreToolUse || [];
+    settings.hooks.PreToolUse.push({
+      matcher: 'Bash',
+      hooks: [
+        {
+          type: 'command',
+          command: '"$CLAUDE_PROJECT_DIR"/.claude/hooks/block-dangerous.sh',
+          timeout: 10,
+        },
+      ],
+    });
+
+    // Scan for secrets on file read
+    settings.hooks.PreToolUse.push({
+      matcher: 'Read',
+      hooks: [
+        {
+          type: 'command',
+          command: '"$CLAUDE_PROJECT_DIR"/.claude/hooks/scan-secrets.sh',
+          timeout: 10,
+        },
+      ],
+    });
+  }
+
+  if (levels.includes('quality')) {
+    // Run quality checks after file edits
+    settings.hooks.PostToolUse = settings.hooks.PostToolUse || [];
+    settings.hooks.PostToolUse.push({
+      matcher: 'Write|Edit',
+      hooks: [
+        {
+          type: 'command',
+          command: '"$CLAUDE_PROJECT_DIR"/.claude/hooks/quality-check.sh',
+          timeout: 30,
+        },
+        {
+          type: 'command',
+          command: '"$CLAUDE_PROJECT_DIR"/.claude/hooks/validate-spec.sh',
+          timeout: 15,
+        },
+      ],
+    });
+  }
+
+  if (levels.includes('scope')) {
+    // Scope guard before file writes
+    settings.hooks.PreToolUse = settings.hooks.PreToolUse || [];
+    settings.hooks.PreToolUse.push({
+      matcher: 'Write|Edit',
+      hooks: [
+        {
+          type: 'command',
+          command: '"$CLAUDE_PROJECT_DIR"/.claude/hooks/scope-guard.sh',
+          timeout: 10,
+        },
+      ],
+    });
+
+    // Naming check after edits
+    settings.hooks.PostToolUse = settings.hooks.PostToolUse || [];
+    settings.hooks.PostToolUse.push({
+      matcher: 'Write|Edit',
+      hooks: [
+        {
+          type: 'command',
+          command: '"$CLAUDE_PROJECT_DIR"/.claude/hooks/naming-check.sh',
+          timeout: 10,
+        },
+      ],
+    });
+  }
+
+  if (levels.includes('lite')) {
+    // Lite mode: sprawl check on Write, simplification guard on Edit
+    settings.hooks.PreToolUse = settings.hooks.PreToolUse || [];
+    settings.hooks.PreToolUse.push({
+      matcher: 'Write',
+      hooks: [
+        {
+          type: 'command',
+          command: '"$CLAUDE_PROJECT_DIR"/.claude/hooks/lite-sprawl-check.sh',
+          timeout: 10,
+        },
+      ],
+    });
+    settings.hooks.PreToolUse.push({
+      matcher: 'Edit',
+      hooks: [
+        {
+          type: 'command',
+          command: '"$CLAUDE_PROJECT_DIR"/.claude/hooks/simplification-guard.sh',
+          timeout: 10,
+        },
+      ],
+    });
+  }
+
+  if (levels.includes('audit')) {
+    // Session audit logging
+    settings.hooks.SessionStart = settings.hooks.SessionStart || [];
+    settings.hooks.SessionStart.push({
+      hooks: [
+        {
+          type: 'command',
+          command: '"$CLAUDE_PROJECT_DIR"/.claude/hooks/audit.sh session-start',
+          timeout: 5,
+        },
+      ],
+    });
+
+    settings.hooks.Stop = settings.hooks.Stop || [];
+    settings.hooks.Stop.push({
+      hooks: [
+        {
+          type: 'command',
+          command: '"$CLAUDE_PROJECT_DIR"/.claude/hooks/audit.sh stop',
+          timeout: 5,
+        },
+      ],
+    });
+
+    // Audit tool usage
+    settings.hooks.PostToolUse = settings.hooks.PostToolUse || [];
+    settings.hooks.PostToolUse.push({
+      matcher: 'Write|Edit|Bash',
+      hooks: [
+        {
+          type: 'command',
+          command: '"$CLAUDE_PROJECT_DIR"/.claude/hooks/audit.sh tool-use',
+          timeout: 5,
+        },
+      ],
+    });
+  }
+
+  return settings;
+}
+
+/**
+ * Check if Claude Code hooks are already configured
+ * @param {string} projectDir - Project directory
+ * @returns {boolean} True if hooks are configured
+ */
+function hasClaudeHooks(projectDir) {
+  const settingsPath = path.join(projectDir, '.claude', 'settings.json');
+  if (!fs.existsSync(settingsPath)) {
+    return false;
+  }
+
+  try {
+    const settings = fs.readJSONSync(settingsPath);
+    return settings.hooks && Object.keys(settings.hooks).length > 0;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * List configured Claude Code hooks
+ * @param {string} projectDir - Project directory
+ * @returns {Object} Hook configuration or null
+ */
+function getClaudeHooksConfig(projectDir) {
+  const settingsPath = path.join(projectDir, '.claude', 'settings.json');
+  if (!fs.existsSync(settingsPath)) {
+    return null;
+  }
+
+  try {
+    const settings = fs.readJSONSync(settingsPath);
+    return settings.hooks || null;
+  } catch {
+    return null;
+  }
+}
+
+module.exports = {
+  scaffoldClaudeHooks,
+  generateClaudeSettings,
+  hasClaudeHooks,
+  getClaudeHooksConfig,
+};

package/dist/scaffold/index.d.ts

@@ -7,9 +7,11 @@ export function scaffoldIDEIntegrations(targetDir: any, options: any): Promise<{
     added: number;
     skipped: number;
 }>;
+import { scaffoldClaudeHooks } from "./claude-hooks";
 /**
  * Set dependencies for scaffold module
  * @param {Object} deps - Dependencies object
  */
 export function setScaffoldDependencies(deps: any): void;
+export { scaffoldClaudeHooks };
 //# sourceMappingURL=index.d.ts.map

package/dist/scaffold/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/scaffold/index.js"],"names":[],"mappings":"AA6LA;;;GAGG;AACH,6DA6jBC;AA3sBD;;;GA2HC;AAMD;;;GAGG;AACH,yDAGC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/scaffold/index.js"],"names":[],"mappings":"AA8MA;;;GAGG;AACH,6DA6jBC;AAztBD;;;GAyIC;;AAMD;;;GAGG;AACH,yDAGC"}

package/dist/scaffold/index.js

@@ -16,6 +16,12 @@ const { detectsPublishing } = require('../utils/project-analysis');
 const { scaffoldGitHooks } = require('./git-hooks');
 const { updateGitignore } = require('../utils/gitignore-updater');
 
+// Import Claude Code hooks scaffolding
+const { scaffoldClaudeHooks } = require('./claude-hooks');
+
+// Import IDE detection utilities
+const { IDE_REGISTRY, parseIDESelection, getRecommendedIDEs } = require('../utils/ide-detection');
+
 // CLI version from package.json
 const CLI_VERSION = require('../../package.json').version;
 
@@ -52,12 +58,20 @@ function findTemplateDir() {
 async function scaffoldIDEIntegrations(targetDir, options) {
   const templateDir = findTemplateDir() || path.join(__dirname, '../../templates');
 
-  console.log(chalk.cyan('🎨 Setting up IDE integrations...'));
+  // Determine which IDEs to install
+  const selectedIDEs = options.ides || [];
+  if (selectedIDEs.length === 0) {
+    console.log(chalk.gray('Skipping IDE setup (none selected)'));
+    return { added: 0, skipped: 0 };
+  }
+
+  const ideNames = selectedIDEs.map((id) => IDE_REGISTRY[id]?.name || id).join(', ');
+  console.log(chalk.cyan(`Setting up IDE integrations: ${ideNames}`));
 
   let addedCount = 0;
   let skippedCount = 0;
 
-  // Setup git hooks with provenance integration
+  // Setup git hooks with provenance integration (always -- not IDE-specific)
   try {
     const gitHooksResult = await scaffoldGitHooks(targetDir, {
       provenance: true,
@@ -69,106 +83,107 @@ async function scaffoldIDEIntegrations(targetDir, options) {
     addedCount += gitHooksResult.added;
     skippedCount += gitHooksResult.skipped;
   } catch (error) {
-    console.log(chalk.yellow(`⚠️  Git hooks setup failed: ${error.message}`));
+    console.log(chalk.yellow(`Warning: Git hooks setup failed: ${error.message}`));
   }
 
-  // List of IDE integration templates to copy
-  const ideTemplates = [
-    // VS Code
-    {
-      src: '.vscode/settings.json',
-      dest: '.vscode/settings.json',
-      desc: 'VS Code workspace settings',
-    },
-    {
-      src: '.vscode/launch.json',
-      dest: '.vscode/launch.json',
-      desc: 'VS Code debug configurations',
-    },
-
-    // IntelliJ IDEA
-    {
-      src: '.idea/runConfigurations/CAWS_Validate.xml',
-      dest: '.idea/runConfigurations/CAWS_Validate.xml',
-      desc: 'IntelliJ run configuration for CAWS validate',
-    },
-    {
-      src: '.idea/runConfigurations/CAWS_Evaluate.xml',
-      dest: '.idea/runConfigurations/CAWS_Evaluate.xml',
-      desc: 'IntelliJ run configuration for CAWS evaluate',
-    },
-
-    // Windsurf
-    {
-      src: '.windsurf/workflows/caws-guided-development.md',
-      dest: '.windsurf/workflows/caws-guided-development.md',
-      desc: 'Windsurf workflow for CAWS-guided development',
-    },
-
-    // GitHub Copilot
-    {
-      src: '.github/copilot/instructions.md',
-      dest: '.github/copilot/instructions.md',
-      desc: 'GitHub Copilot CAWS integration instructions',
-    },
-
-    // Git hooks are handled separately by scaffoldGitHooks
-
-    // Cursor hooks (already handled by scaffoldCursorHooks, but ensure README is copied)
-    {
-      src: '.cursor/README.md',
-      dest: '.cursor/README.md',
-      desc: 'Cursor integration documentation',
-    },
-  ];
+  // Build IDE templates list dynamically based on selection
+  const ideTemplates = [];
+
+  if (selectedIDEs.includes('vscode')) {
+    ideTemplates.push(
+      { src: '.vscode/settings.json', dest: '.vscode/settings.json', desc: 'VS Code workspace settings' },
+      { src: '.vscode/launch.json', dest: '.vscode/launch.json', desc: 'VS Code debug configurations' }
+    );
+  }
+
+  if (selectedIDEs.includes('intellij')) {
+    ideTemplates.push(
+      { src: '.idea/runConfigurations/CAWS_Validate.xml', dest: '.idea/runConfigurations/CAWS_Validate.xml', desc: 'IntelliJ run configuration for CAWS validate' },
+      { src: '.idea/runConfigurations/CAWS_Evaluate.xml', dest: '.idea/runConfigurations/CAWS_Evaluate.xml', desc: 'IntelliJ run configuration for CAWS evaluate' }
+    );
+  }
+
+  if (selectedIDEs.includes('junie')) {
+    ideTemplates.push(
+      { src: '.junie/guidelines.md', dest: '.junie/guidelines.md', desc: 'JetBrains Junie AI agent guidelines' }
+    );
+  }
+
+  if (selectedIDEs.includes('windsurf')) {
+    ideTemplates.push(
+      { src: '.windsurf/workflows/caws-guided-development.md', dest: '.windsurf/workflows/caws-guided-development.md', desc: 'Windsurf workflow for CAWS-guided development' },
+      { src: '.windsurf/rules/caws-quality-standards.md', dest: '.windsurf/rules/caws-quality-standards.md', desc: 'Windsurf CAWS quality rules' }
+    );
+  }
+
+  if (selectedIDEs.includes('copilot')) {
+    ideTemplates.push(
+      { src: '.github/copilot-instructions.md', dest: '.github/copilot-instructions.md', desc: 'GitHub Copilot CAWS integration instructions' }
+    );
+  }
+
+  if (selectedIDEs.includes('cursor')) {
+    ideTemplates.push(
+      { src: '.cursor/README.md', dest: '.cursor/README.md', desc: 'Cursor integration documentation' }
+    );
+  }
+
+  if (selectedIDEs.includes('claude')) {
+    ideTemplates.push(
+      { src: '.claude/README.md', dest: '.claude/README.md', desc: 'Claude Code integration documentation' },
+      { src: 'CLAUDE.md', dest: 'CLAUDE.md', desc: 'Claude Code project instructions' }
+    );
+
+    // Setup Claude Code hooks
+    try {
+      await scaffoldClaudeHooks(targetDir, ['safety', 'quality', 'scope', 'audit']);
+    } catch (error) {
+      console.log(chalk.yellow(`Warning: Claude Code hooks setup failed: ${error.message}`));
+    }
+  }
 
   for (const template of ideTemplates) {
     const srcPath = path.join(templateDir, template.src);
     const destPath = path.join(targetDir, template.dest);
 
     try {
-      // Check if source exists
       if (!(await fs.pathExists(srcPath))) {
         if (!template.optional) {
-          console.log(chalk.yellow(`⚠️  Template not found: ${template.src}`));
+          console.log(chalk.yellow(`Warning: Template not found: ${template.src}`));
         }
         continue;
       }
 
-      // Check if destination already exists
       const destExists = await fs.pathExists(destPath);
 
       if (destExists && !options.force) {
-        console.log(chalk.gray(`⏭️  Skipped ${template.desc} (already exists)`));
+        console.log(chalk.gray(`Skipped ${template.desc} (already exists)`));
         skippedCount++;
         continue;
       }
 
-      // Ensure destination directory exists
       await fs.ensureDir(path.dirname(destPath));
-
-      // Copy the file
       await fs.copy(srcPath, destPath);
 
-      // Make scripts executable if they're in hooks or cursor directories
-      if (destPath.includes('.git/hooks/') || destPath.includes('.cursor/hooks/')) {
+      if (destPath.includes('.git/hooks/') || destPath.includes('.cursor/hooks/') || destPath.includes('.claude/hooks/')) {
         try {
           await fs.chmod(destPath, '755');
-        } catch (error) {
+        } catch (_) {
           // Ignore chmod errors on some systems
         }
       }
 
-      console.log(chalk.green(`✅ Added ${template.desc}`));
+      console.log(chalk.green(`Added ${template.desc}`));
       addedCount++;
     } catch (error) {
-      console.log(chalk.red(`❌ Failed to add ${template.desc}: ${error.message}`));
+      console.log(chalk.red(`Failed to add ${template.desc}: ${error.message}`));
     }
   }
 
   if (addedCount > 0) {
-    console.log(chalk.green(`\n🎨 IDE integrations: ${addedCount} added, ${skippedCount} skipped`));
-    console.log(chalk.blue('💡 Restart your IDE to activate the new integrations'));
+    console.log(chalk.green(`\nIDE integrations: ${addedCount} added, ${skippedCount} skipped`));
+    console.log(chalk.gray(`   Installed: ${ideNames}`));
+    console.log(chalk.blue('Restart your IDE to activate the new integrations'));
   }
 
   return { added: addedCount, skipped: skippedCount };
@@ -353,15 +368,19 @@ async function scaffoldProject(options) {
       });
     }
 
-    // Add IDE integrations for comprehensive development experience
-    enhancements.push({
-      name: 'ide-integrations',
-      description: 'IDE integrations (VS Code, IntelliJ, Windsurf, Git hooks)',
-      required: false,
-      customHandler: async (targetDir, options) => {
-        return await scaffoldIDEIntegrations(targetDir, options);
-      },
-    });
+    // Add IDE integrations for selected IDEs
+    const selectedIDEs = options.ide ? parseIDESelection(options.ide) : getRecommendedIDEs();
+    if (selectedIDEs.length > 0) {
+      const ideNames = selectedIDEs.map((id) => IDE_REGISTRY[id]?.name || id).join(', ');
+      enhancements.push({
+        name: 'ide-integrations',
+        description: `IDE integrations (${ideNames})`,
+        required: false,
+        customHandler: async (targetDir, opts) => {
+          return await scaffoldIDEIntegrations(targetDir, { ...opts, ides: selectedIDEs });
+        },
+      });
+    }
 
     // Add quality gates package and configuration if requested
     // Note: These are optional - git hooks fall back to CAWS CLI if package isn't installed
@@ -541,7 +560,7 @@ async function scaffoldProject(options) {
       !fs.existsSync(path.join(currentDir, 'caws.md'))
     ) {
       enhancements.push({
-        name: 'agents.md',
+        name: 'AGENTS.md',
         description: 'CAWS agent workflow guide',
         required: false,
       });
@@ -769,5 +788,6 @@ async function scaffoldProject(options) {
 module.exports = {
   scaffoldProject,
   scaffoldIDEIntegrations,
+  scaffoldClaudeHooks,
   setScaffoldDependencies,
 };

package/dist/templates/.caws/schemas/scope.schema.json

@@ -0,0 +1,52 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "title": "CAWS Lite Scope Configuration",
+  "description": "Scope configuration for CAWS lite mode — guardrails without YAML specs",
+  "type": "object",
+  "required": ["version", "allowedDirectories"],
+  "properties": {
+    "version": {
+      "type": "integer",
+      "const": 1,
+      "description": "Schema version"
+    },
+    "allowedDirectories": {
+      "type": "array",
+      "items": { "type": "string" },
+      "minItems": 1,
+      "description": "Directories the agent is allowed to modify (e.g., src/, tests/)"
+    },
+    "bannedPatterns": {
+      "type": "object",
+      "properties": {
+        "files": {
+          "type": "array",
+          "items": { "type": "string" },
+          "description": "Glob patterns for banned file names (e.g., *-enhanced.*, *-final.*)"
+        },
+        "directories": {
+          "type": "array",
+          "items": { "type": "string" },
+          "description": "Glob patterns for banned directory names (e.g., *venv*, .venv)"
+        },
+        "docs": {
+          "type": "array",
+          "items": { "type": "string" },
+          "description": "Glob patterns for banned doc file names (e.g., *-summary.md)"
+        }
+      },
+      "additionalProperties": false
+    },
+    "maxNewFilesPerCommit": {
+      "type": "integer",
+      "minimum": 1,
+      "maximum": 100,
+      "description": "Maximum number of new files allowed per commit (prevents file sprawl)"
+    },
+    "designatedVenvPath": {
+      "type": "string",
+      "description": "The only allowed virtual environment path (e.g., .venv)"
+    }
+  },
+  "additionalProperties": false
+}

package/dist/templates/.caws/schemas/working-spec.schema.json

@@ -16,7 +16,7 @@
     "contracts"
   ],
   "properties": {
-    "id": { "type": "string", "pattern": "^(PROJ|FEAT|FIX|ARCH)-\\d{4}$" },
+    "id": { "type": "string", "pattern": "^[A-Z]{2,6}-\\d{3,4}$" },
     "title": { "type": "string", "minLength": 10, "maxLength": 200 },
     "risk_tier": { "type": ["integer", "string"], "enum": [1, 2, 3, "1", "2", "3"] },
     "mode": { "type": "string", "enum": ["feature", "refactor", "fix", "doc", "chore"] },