@paths.design/caws-cli 3.5.0 → 4.1.0

package/dist/policy/PolicyManager.d.ts

@@ -0,0 +1,104 @@
+/**
+ * Policy Manager - Handles policy loading with intelligent caching
+ *
+ * Features:
+ * - TTL-based caching for performance
+ * - Graceful fallback to defaults when policy.yaml missing
+ * - Cache inspection and management API
+ * - Waiver validation and delta application
+ */
+export class PolicyManager {
+    constructor(options?: {});
+    enableCaching: any;
+    cacheTTL: any;
+    policyCache: Map<any, any>;
+    /**
+     * Load CAWS policy from policy.yaml with caching
+     *
+     * @param {string} projectRoot - Project root directory
+     * @param {Object} options - Loading options
+     * @param {boolean} options.useCache - Use cache if available (default: true)
+     * @param {number} options.cacheTTL - Cache TTL override in milliseconds
+     * @returns {Promise<Object>} Policy object
+     */
+    loadPolicy(projectRoot: string, options?: {
+        useCache: boolean;
+        cacheTTL: number;
+    }): Promise<any>;
+    /**
+     * Load a waiver document by ID
+     *
+     * @param {string} waiverId - Waiver ID (e.g., WV-0001)
+     * @param {string} projectRoot - Project root directory
+     * @returns {Promise<Object|null>} Waiver document or null if not found
+     */
+    loadWaiver(waiverId: string, projectRoot: string): Promise<any | null>;
+    /**
+     * Check if a waiver is currently valid
+     *
+     * @param {Object} waiver - Waiver document
+     * @returns {boolean} True if waiver is valid and active
+     */
+    isWaiverValid(waiver: any): boolean;
+    /**
+     * Apply waivers to baseline budget
+     *
+     * @param {Object} baseline - Baseline budget from policy
+     * @param {string[]} waiverIds - Array of waiver IDs to apply
+     * @param {string} projectRoot - Project root directory
+     * @returns {Promise<Object>} Effective budget with waivers applied
+     */
+    applyWaivers(baseline: any, waiverIds: string[], projectRoot: string): Promise<any>;
+    /**
+     * Validate policy structure
+     *
+     * @param {Object} policy - Policy to validate
+     * @throws {Error} If policy is invalid
+     */
+    validatePolicy(policy: any): void;
+    /**
+     * Get default CAWS policy
+     *
+     * Returns sensible defaults when policy.yaml doesn't exist.
+     *
+     * @returns {Object} Default policy configuration
+     */
+    getDefaultPolicy(): any;
+    /**
+     * Clear policy cache
+     *
+     * @param {string} [projectRoot] - Specific project to clear, or all if omitted
+     */
+    clearCache(projectRoot?: string): void;
+    /**
+     * Get cache status for a project
+     *
+     * @param {string} projectRoot - Project root directory
+     * @returns {Object} Cache status information
+     */
+    getCacheStatus(projectRoot: string): any;
+    /**
+     * Reload policy from disk (bypassing cache)
+     *
+     * @param {string} projectRoot - Project root directory
+     * @returns {Promise<Object>} Fresh policy
+     */
+    reloadPolicy(projectRoot: string): Promise<any>;
+    /**
+     * Get all cached projects
+     *
+     * @returns {string[]} Array of project roots with cached policies
+     */
+    getCachedProjects(): string[];
+    /**
+     * Get cache statistics
+     *
+     * @returns {Object} Cache statistics
+     */
+    getCacheStats(): any;
+}
+export const defaultPolicyManager: PolicyManager;
+export declare function loadPolicy(projectRoot: any, options: any): Promise<any>;
+export declare function clearCache(projectRoot: any): void;
+export declare function getCacheStatus(projectRoot: any): any;
+//# sourceMappingURL=PolicyManager.d.ts.map

package/dist/policy/PolicyManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PolicyManager.d.ts","sourceRoot":"","sources":["../../src/policy/PolicyManager.js"],"names":[],"mappings":"AAWA;;;;;;;;GAQG;AACH;IACE,0BAIC;IAHC,mBAAkD;IAClD,cAA0C;IAC1C,2BAA4B;IAG9B;;;;;;;;OAQG;IACH,wBANW,MAAM,YAEd;QAAyB,QAAQ,EAAzB,OAAO;QACS,QAAQ,EAAxB,MAAM;KACd,GAAU,OAAO,KAAQ,CAuE3B;IAED;;;;;;OAMG;IACH,qBAJW,MAAM,eACN,MAAM,GACJ,OAAO,CAAC,MAAO,IAAI,CAAC,CAchC;IAED;;;;;OAKG;IACH,4BAFa,OAAO,CA2BnB;IAED;;;;;;;OAOG;IACH,uCAJW,MAAM,EAAE,eACR,MAAM,GACJ,OAAO,KAAQ,CA2B3B;IAED;;;;;OAKG;IACH,kCA8BC;IAED;;;;;;OAMG;IACH,wBAoDC;IAED;;;;OAIG;IACH,yBAFW,MAAM,QAQhB;IAED;;;;;OAKG;IACH,4BAHW,MAAM,OAmBhB;IAED;;;;;OAKG;IACH,0BAHW,MAAM,GACJ,OAAO,KAAQ,CAK3B;IAED;;;;OAIG;IACH,qBAFa,MAAM,EAAE,CAIpB;IAED;;;;OAIG;IACH,qBA2BC;CACF;AAGD,iDAAiD;AAOnC,iFAA+E;AAC/E,2DAA6D;AACzD,8DAAiE"}

package/dist/policy/PolicyManager.js

@@ -0,0 +1,399 @@
+/**
+ * @fileoverview Policy Manager with Intelligent Caching
+ * Manages policy.yaml loading with caching, default fallback, and waiver validation.
+ * Ported from agent-agency v2 CAWS integration patterns.
+ * @author @darianrosebrook
+ */
+
+const fs = require('fs-extra');
+const path = require('path');
+const yaml = require('js-yaml');
+
+/**
+ * Policy Manager - Handles policy loading with intelligent caching
+ *
+ * Features:
+ * - TTL-based caching for performance
+ * - Graceful fallback to defaults when policy.yaml missing
+ * - Cache inspection and management API
+ * - Waiver validation and delta application
+ */
+class PolicyManager {
+  constructor(options = {}) {
+    this.enableCaching = options.enableCaching ?? true;
+    this.cacheTTL = options.cacheTTL ?? 300000; // 5 minutes default
+    this.policyCache = new Map(); // projectRoot -> { policy, cachedAt, ttl }
+  }
+
+  /**
+   * Load CAWS policy from policy.yaml with caching
+   *
+   * @param {string} projectRoot - Project root directory
+   * @param {Object} options - Loading options
+   * @param {boolean} options.useCache - Use cache if available (default: true)
+   * @param {number} options.cacheTTL - Cache TTL override in milliseconds
+   * @returns {Promise<Object>} Policy object
+   */
+  async loadPolicy(projectRoot, options = {}) {
+    const useCache = options.useCache ?? this.enableCaching;
+    const cacheTTL = options.cacheTTL ?? this.cacheTTL;
+    const startTime = Date.now();
+
+    try {
+      // Check cache first
+      if (useCache && this.policyCache.has(projectRoot)) {
+        const cached = this.policyCache.get(projectRoot);
+        const cacheAge = Date.now() - cached.cachedAt;
+
+        if (cacheAge < cacheTTL) {
+          return {
+            ...cached.policy,
+            _cacheHit: true,
+            _loadDuration: Date.now() - startTime,
+          };
+        }
+      }
+
+      // Load from file
+      const policyPath = path.join(projectRoot, '.caws', 'policy.yaml');
+
+      try {
+        const content = await fs.readFile(policyPath, 'utf-8');
+        const policy = yaml.load(content);
+
+        // Validate policy structure
+        this.validatePolicy(policy);
+
+        // Update cache
+        if (this.enableCaching) {
+          this.policyCache.set(projectRoot, {
+            policy,
+            cachedAt: Date.now(),
+            ttl: cacheTTL,
+          });
+        }
+
+        return {
+          ...policy,
+          _cacheHit: false,
+          _loadDuration: Date.now() - startTime,
+        };
+      } catch (error) {
+        if (error.code === 'ENOENT') {
+          // Policy file doesn't exist - use default
+          const defaultPolicy = this.getDefaultPolicy();
+
+          if (this.enableCaching) {
+            this.policyCache.set(projectRoot, {
+              policy: defaultPolicy,
+              cachedAt: Date.now(),
+              ttl: cacheTTL,
+            });
+          }
+
+          return {
+            ...defaultPolicy,
+            _isDefault: true,
+            _cacheHit: false,
+            _loadDuration: Date.now() - startTime,
+          };
+        }
+        throw error;
+      }
+    } catch (error) {
+      throw new Error(`Policy load failed: ${error.message}`);
+    }
+  }
+
+  /**
+   * Load a waiver document by ID
+   *
+   * @param {string} waiverId - Waiver ID (e.g., WV-0001)
+   * @param {string} projectRoot - Project root directory
+   * @returns {Promise<Object|null>} Waiver document or null if not found
+   */
+  async loadWaiver(waiverId, projectRoot) {
+    try {
+      const waiverPath = path.join(projectRoot, '.caws', 'waivers', `${waiverId}.yaml`);
+
+      const content = await fs.readFile(waiverPath, 'utf-8');
+      return yaml.load(content);
+    } catch (error) {
+      if (error.code === 'ENOENT') {
+        return null;
+      }
+      throw new Error(`Failed to load waiver ${waiverId}: ${error.message}`);
+    }
+  }
+
+  /**
+   * Check if a waiver is currently valid
+   *
+   * @param {Object} waiver - Waiver document
+   * @returns {boolean} True if waiver is valid and active
+   */
+  isWaiverValid(waiver) {
+    if (!waiver) {
+      return false;
+    }
+
+    // Check status
+    if (waiver.status !== 'active') {
+      return false;
+    }
+
+    // Check expiry
+    if (waiver.expires_at) {
+      const expiryDate = new Date(waiver.expires_at);
+      const now = new Date();
+      if (now > expiryDate) {
+        return false;
+      }
+    }
+
+    // Check if it has required approvals
+    if (!waiver.approvers || waiver.approvers.length === 0) {
+      return false;
+    }
+
+    return true;
+  }
+
+  /**
+   * Apply waivers to baseline budget
+   *
+   * @param {Object} baseline - Baseline budget from policy
+   * @param {string[]} waiverIds - Array of waiver IDs to apply
+   * @param {string} projectRoot - Project root directory
+   * @returns {Promise<Object>} Effective budget with waivers applied
+   */
+  async applyWaivers(baseline, waiverIds, projectRoot) {
+    const effective = { ...baseline };
+    const applied = [];
+
+    for (const waiverId of waiverIds) {
+      const waiver = await this.loadWaiver(waiverId, projectRoot);
+
+      if (waiver && this.isWaiverValid(waiver)) {
+        // Apply additive delta
+        if (waiver.delta) {
+          if (waiver.delta.max_files) {
+            effective.max_files += waiver.delta.max_files;
+          }
+          if (waiver.delta.max_loc) {
+            effective.max_loc += waiver.delta.max_loc;
+          }
+        }
+        applied.push(waiverId);
+      }
+    }
+
+    return {
+      effective,
+      applied,
+    };
+  }
+
+  /**
+   * Validate policy structure
+   *
+   * @param {Object} policy - Policy to validate
+   * @throws {Error} If policy is invalid
+   */
+  validatePolicy(policy) {
+    if (!policy.version) {
+      throw new Error('Policy missing version field');
+    }
+
+    if (!policy.risk_tiers) {
+      throw new Error('Policy missing risk_tiers configuration');
+    }
+
+    // Validate all tiers have required fields
+    for (const tier of [1, 2, 3]) {
+      const budget = policy.risk_tiers[tier];
+      if (!budget) {
+        throw new Error(`Policy missing risk tier ${tier} configuration`);
+      }
+
+      if (typeof budget.max_files !== 'number' || typeof budget.max_loc !== 'number') {
+        throw new Error(`Risk tier ${tier} missing or invalid budget limits`);
+      }
+    }
+
+    // Validate edit rules if present
+    if (policy.edit_rules) {
+      if (typeof policy.edit_rules.policy_and_code_same_pr !== 'boolean') {
+        throw new Error('edit_rules.policy_and_code_same_pr must be boolean');
+      }
+      if (typeof policy.edit_rules.min_approvers_for_budget_raise !== 'number') {
+        throw new Error('edit_rules.min_approvers_for_budget_raise must be number');
+      }
+    }
+  }
+
+  /**
+   * Get default CAWS policy
+   *
+   * Returns sensible defaults when policy.yaml doesn't exist.
+   *
+   * @returns {Object} Default policy configuration
+   */
+  getDefaultPolicy() {
+    return {
+      version: 1,
+      risk_tiers: {
+        1: {
+          max_files: 25,
+          max_loc: 1000,
+          description: 'Critical changes requiring manual review',
+        },
+        2: {
+          max_files: 50,
+          max_loc: 2000,
+          description: 'Standard features with automated gates',
+        },
+        3: {
+          max_files: 100,
+          max_loc: 5000,
+          description: 'Low-risk changes with minimal oversight',
+        },
+      },
+      edit_rules: {
+        policy_and_code_same_pr: false,
+        min_approvers_for_budget_raise: 2,
+        require_signed_commits: true,
+      },
+      gates: {
+        budget_limit: {
+          enabled: true,
+          description: 'Enforce change budget limits',
+        },
+        spec_completeness: {
+          enabled: true,
+          description: 'Require complete working specifications',
+        },
+        contract_compliance: {
+          enabled: true,
+          description: 'Validate API contracts',
+        },
+        coverage_threshold: {
+          enabled: true,
+          description: 'Maintain test coverage requirements',
+        },
+        mutation_threshold: {
+          enabled: true,
+          description: 'Require mutation testing for T1/T2 changes',
+        },
+        security_scan: {
+          enabled: true,
+          description: 'Run security vulnerability scans',
+        },
+      },
+    };
+  }
+
+  /**
+   * Clear policy cache
+   *
+   * @param {string} [projectRoot] - Specific project to clear, or all if omitted
+   */
+  clearCache(projectRoot) {
+    if (projectRoot) {
+      this.policyCache.delete(projectRoot);
+    } else {
+      this.policyCache.clear();
+    }
+  }
+
+  /**
+   * Get cache status for a project
+   *
+   * @param {string} projectRoot - Project root directory
+   * @returns {Object} Cache status information
+   */
+  getCacheStatus(projectRoot) {
+    const cached = this.policyCache.get(projectRoot);
+
+    if (!cached) {
+      return {
+        cached: false,
+        ttl: this.cacheTTL,
+      };
+    }
+
+    return {
+      cached: true,
+      age: Date.now() - cached.cachedAt,
+      ttl: cached.ttl,
+      remainingTTL: Math.max(0, cached.ttl - (Date.now() - cached.cachedAt)),
+    };
+  }
+
+  /**
+   * Reload policy from disk (bypassing cache)
+   *
+   * @param {string} projectRoot - Project root directory
+   * @returns {Promise<Object>} Fresh policy
+   */
+  async reloadPolicy(projectRoot) {
+    this.clearCache(projectRoot);
+    return this.loadPolicy(projectRoot, { useCache: false });
+  }
+
+  /**
+   * Get all cached projects
+   *
+   * @returns {string[]} Array of project roots with cached policies
+   */
+  getCachedProjects() {
+    return Array.from(this.policyCache.keys());
+  }
+
+  /**
+   * Get cache statistics
+   *
+   * @returns {Object} Cache statistics
+   */
+  getCacheStats() {
+    const projects = this.getCachedProjects();
+    const now = Date.now();
+
+    const stats = {
+      totalCached: projects.length,
+      validCaches: 0,
+      expiredCaches: 0,
+      totalAge: 0,
+    };
+
+    for (const project of projects) {
+      const cached = this.policyCache.get(project);
+      const age = now - cached.cachedAt;
+
+      stats.totalAge += age;
+
+      if (age < cached.ttl) {
+        stats.validCaches++;
+      } else {
+        stats.expiredCaches++;
+      }
+    }
+
+    stats.averageAge = projects.length > 0 ? stats.totalAge / projects.length : 0;
+
+    return stats;
+  }
+}
+
+// Export singleton instance with default configuration
+const defaultPolicyManager = new PolicyManager();
+
+module.exports = {
+  PolicyManager,
+  defaultPolicyManager,
+
+  // Convenience exports for backward compatibility
+  loadPolicy: (projectRoot, options) => defaultPolicyManager.loadPolicy(projectRoot, options),
+  clearCache: (projectRoot) => defaultPolicyManager.clearCache(projectRoot),
+  getCacheStatus: (projectRoot) => defaultPolicyManager.getCacheStatus(projectRoot),
+};

package/dist/scaffold/cursor-hooks.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cursor-hooks.d.ts","sourceRoot":"","sources":["../../src/scaffold/cursor-hooks.js"],"names":[],"mappings":"AAaA;;;;GAIG;AACH,gDAHW,MAAM,WACN,MAAM,EAAE,iBAsIlB"}
+{"version":3,"file":"cursor-hooks.d.ts","sourceRoot":"","sources":["../../src/scaffold/cursor-hooks.js"],"names":[],"mappings":"AAaA;;;;GAIG;AACH,gDAHW,MAAM,WACN,MAAM,EAAE,iBAqJlB"}

package/dist/scaffold/cursor-hooks.js

@@ -138,6 +138,21 @@ async function scaffoldCursorHooks(projectDir, levels = ['safety', 'quality', 's
       await fs.copy(readmePath, path.join(cursorDir, 'README.md'));
     }
 
+    // Copy rules directory if it exists
+    const rulesTemplateDir = path.join(cursorTemplateDir, 'rules');
+    const rulesDestDir = path.join(cursorDir, 'rules');
+    if (fs.existsSync(rulesTemplateDir)) {
+      try {
+        await fs.ensureDir(rulesDestDir);
+        await fs.copy(rulesTemplateDir, rulesDestDir);
+        const ruleFiles = fs.readdirSync(rulesTemplateDir).filter((file) => file.endsWith('.mdc'));
+        console.log(chalk.green('✅ Cursor rules configured'));
+        console.log(chalk.gray(`   Rules: ${ruleFiles.length} rule files installed`));
+      } catch (error) {
+        console.warn(chalk.yellow('⚠️  Failed to copy Cursor rules:'), error.message);
+      }
+    }
+
     console.log(chalk.green('✅ Cursor hooks configured'));
     console.log(chalk.gray(`   Enabled: ${levels.join(', ')}`));
     console.log(

package/dist/scaffold/git-hooks.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"git-hooks.d.ts","sourceRoot":"","sources":["../../src/scaffold/git-hooks.js"],"names":[],"mappings":"AASA;;;;GAIG;AACH,6CAHW,MAAM;;;GAwGhB;AAoOD;;;GAGG;AACH,2CAFW,MAAM,iBAkChB;AAED;;;GAGG;AACH,gDAFW,MAAM,iBAgDhB"}
+{"version":3,"file":"git-hooks.d.ts","sourceRoot":"","sources":["../../src/scaffold/git-hooks.js"],"names":[],"mappings":"AASA;;;;GAIG;AACH,6CAHW,MAAM;;;GAwGhB;AAwND;;;GAGG;AACH,2CAFW,MAAM,iBAkChB;AAED;;;GAGG;AACH,gDAFW,MAAM,iBAgDhB"}

package/dist/scaffold/git-hooks.js

@@ -116,10 +116,10 @@ async function scaffoldGitHooks(projectDir, options = {}) {
 }
 
 /**
- * Generate pre-commit hook content
+ * Generate pre-commit hook content with staged file quality gates
  */
 function generatePreCommitHook(options) {
-  const { qualityGates = true } = options;
+  const { qualityGates = true, stagedOnly = true } = options;
 
   return `#!/bin/bash
 # CAWS Pre-commit Hook
@@ -127,8 +127,8 @@ function generatePreCommitHook(options) {
 
 set -e
 
-echo "🔍 CAWS Pre-commit Validation"
-echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+echo "🚦 Running CAWS Quality Gates${qualityGates ? ' (Crisis Response Mode)' : ''}..."
+echo "📁 Analyzing ${stagedOnly ? 'staged files only' : 'all files'}..."
 
 # Check if CAWS is initialized
 if [ ! -d ".caws" ]; then
@@ -136,55 +136,43 @@ if [ ! -d ".caws" ]; then
   exit 0
 fi
 
-# Run CAWS validation if available
-if command -v caws >/dev/null 2>&1; then
-  echo "📋 Running CAWS validation..."
-  if caws validate --quiet; then
-    echo "✅ CAWS validation passed"
+# Run quality gates
+if command -v node >/dev/null 2>&1; then
+  if node scripts/quality-gates/run-quality-gates.js; then
+    echo "✅ Quality gates passed"
   else
-    echo "❌ CAWS validation failed"
-    echo "💡 Fix issues or skip with: git commit --no-verify (allowed)"
+    echo "❌ Quality gates failed - commit blocked"
+    echo "💡 Fix the violations above before committing"
+    echo "📖 See docs/refactoring.md for crisis response plan"
     exit 1
   fi
 else
-  echo "⚠️  CAWS CLI not found - install with: npm install -g @paths.design/caws-cli"
+  echo "⚠️  Node.js not found - skipping quality gates"
+  echo "💡 Install Node.js to enable automatic quality checking"
+  exit 0
 fi
 
-# Run quality gates if enabled
-${
-  qualityGates
-    ? `
-echo "🎯 Running quality gates..."
-if [ -f "package.json" ]; then
-  # Run linting if available
-  if [ -f "node_modules/.bin/eslint" ] || command -v eslint >/dev/null 2>&1; then
-    echo "🔍 Running ESLint..."
-    if npx eslint . --quiet; then
-      echo "✅ ESLint passed"
-    else
-      echo "❌ ESLint failed"
-      echo "💡 Fix issues or skip with: git commit --no-verify (allowed)"
-      exit 1
-    fi
-  fi
-
-  # Run tests if available
-  if [ -f "package.json" ] && grep -q '"test"' package.json; then
-    echo "🧪 Running tests..."
-    if npm test; then
-      echo "✅ Tests passed"
-    else
-      echo "❌ Tests failed"
-      echo "💡 Fix issues or skip with: git commit --no-verify (allowed)"
-      exit 1
-    fi
+# Run hidden TODO analysis on staged files only
+echo "🔍 Checking for hidden TODOs in staged files..."
+if command -v python3 >/dev/null 2>&1; then
+  if python3 scripts/v3/analysis/todo_analyzer.py --staged-only --ci-mode --min-confidence 0.8 >/dev/null 2>&1; then
+    echo "✅ No critical hidden TODOs found in staged files"
+  else
+    echo "❌ Critical hidden TODOs detected in staged files - commit blocked"
+    echo "💡 Fix stub implementations and placeholder code before committing"
+    echo "📖 See docs/PLACEHOLDER-DETECTION-GUIDE.md for classification"
+    echo ""
+    echo "🔍 Running detailed analysis on staged files..."
+    python3 scripts/v3/analysis/todo_analyzer.py --staged-only --min-confidence 0.8
+    exit 1
   fi
+else
+  echo "⚠️  Python3 not found - skipping hidden TODO analysis"
+  echo "💡 Install Python3 to enable automatic TODO checking"
 fi
-`
-    : ''
-}
 
-echo "🎉 Pre-commit checks passed!"
+echo "✅ All quality checks passed - proceeding with commit"
+exit 0
 `;
 }
 

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/scaffold/index.js"],"names":[],"mappings":"AAkKA;;;GAGG;AACH,6DA0UC;AA7dD;;;;GAIG;AACH,mDAHW,MAAM;;;GA8HhB;AAMD;;;GAGG;AACH,yDAGC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/scaffold/index.js"],"names":[],"mappings":"AAkKA;;;GAGG;AACH,6DA6VC;AAhfD;;;;GAIG;AACH,mDAHW,MAAM;;;GA8HhB;AAMD;;;GAGG;AACH,yDAGC"}

package/dist/scaffold/index.js

@@ -311,6 +311,25 @@ async function scaffoldProject(options) {
       },
     });
 
+    // Add quality gates scripts for staged file analysis
+    enhancements.push({
+      name: 'scripts/quality-gates/run-quality-gates.js',
+      description: 'Quality gates runner for staged files',
+      required: false,
+    });
+
+    enhancements.push({
+      name: 'scripts/quality-gates/check-god-objects.js',
+      description: 'God object detector for staged files',
+      required: false,
+    });
+
+    enhancements.push({
+      name: 'scripts/v3/analysis/todo_analyzer.py',
+      description: 'Advanced hidden TODO analyzer with dependency resolution',
+      required: false,
+    });
+
     // Add commit conventions for setups that don't have them
     if (!setup.hasTemplates || !fs.existsSync(path.join(currentDir, 'COMMIT_CONVENTIONS.md'))) {
       enhancements.push({