agentic-qe 3.7.0 → 3.7.1

package/v3/dist/coordination/task-executor.js

@@ -9,14 +9,11 @@
  * - Reads routingTier from task payload
  * - Routes Tier 0 tasks to Agent Booster for mechanical transforms
  * - Records outcomes back to TinyDancer for learning
+ *
+ * Handler implementations are extracted into ./handlers/ modules.
  */
 import { v4 as uuidv4 } from 'uuid';
-import * as fs from 'fs/promises';
-import * as path from 'path';
-import { ok, err } from '../shared/types';
-import { toError, toErrorMessage } from '../shared/error-utils.js';
-import { safeJsonParse } from '../shared/safe-json.js';
-import { FilePath } from '../shared/value-objects/index.js';
+import { toErrorMessage } from '../shared/error-utils.js';
 import { createResultSaver } from './result-saver';
 // ADR-051: Agent Booster integration for Tier 0 tasks
 import { createAgentBoosterAdapter, } from '../integrations/agentic-flow/agent-booster';
@@ -24,6 +21,8 @@ import { createAgentBoosterAdapter, } from '../integrations/agentic-flow/agent-b
 import { getTaskRouter } from '../mcp/services/task-router';
 // CQ-005: Use DomainServiceRegistry instead of dynamic imports from domains/
 import { DomainServiceRegistry, ServiceKeys } from '../shared/domain-service-registry';
+// Handler registration functions (extracted from the monolithic registerHandlers)
+import { registerTestExecutionHandlers, registerCoverageHandlers, registerSecurityHandlers, registerQualityHandlers, registerRequirementsHandlers, registerCodeIntelligenceHandlers, registerMiscHandlers, } from './handlers/index';
 // ============================================================================
 // CQ-005: Domain Service Resolution via Registry (no coordination -> domains imports)
 // Domain modules register their factories in their index.ts files.
@@ -105,482 +104,12 @@ function detectTransformType(task) {
     return null;
 }
 // ============================================================================
-// Helper Functions for Real Implementations
-// ============================================================================
-/**
- * Load coverage data from common coverage file formats
- */
-async function loadCoverageData(targetPath) {
-    // Try various coverage file locations (JS, Python, Java, etc.)
-    const coverageLocations = [
-        // JavaScript/TypeScript (Istanbul/nyc/vitest)
-        path.join(targetPath, 'coverage', 'coverage-final.json'),
-        path.join(targetPath, 'coverage', 'lcov.info'),
-        path.join(targetPath, '.nyc_output', 'coverage-final.json'),
-        path.join(targetPath, 'coverage-final.json'),
-        // Python (pytest-cov, coverage.py)
-        path.join(targetPath, 'coverage.xml'),
-        path.join(targetPath, 'htmlcov', 'status.json'),
-        // Cobertura (generic)
-        path.join(targetPath, 'cobertura-coverage.xml'),
-    ];
-    for (const coveragePath of coverageLocations) {
-        try {
-            const content = await fs.readFile(coveragePath, 'utf-8');
-            if (coveragePath.endsWith('.json')) {
-                return parseCoverageJson(content);
-            }
-            else if (coveragePath.endsWith('.info')) {
-                return parseLcovInfo(content);
-            }
-            else if (coveragePath.endsWith('.xml')) {
-                return parseCoberturaXml(content);
-            }
-        }
-        catch {
-            // File not found, try next
-        }
-    }
-    return null;
-}
-/**
- * Parse Istanbul/nyc coverage-final.json format
- */
-function parseCoverageJson(content) {
-    const data = safeJsonParse(content);
-    const files = [];
-    let totalLines = 0, coveredLines = 0;
-    let totalBranches = 0, coveredBranches = 0;
-    let totalFunctions = 0, coveredFunctions = 0;
-    let totalStatements = 0, coveredStatements = 0;
-    for (const [filePath, fileData] of Object.entries(data)) {
-        const fd = fileData;
-        // Calculate file-level metrics
-        const lineMap = fd.statementMap || {};
-        const lineCounts = fd.s || {};
-        const branchMap = fd.branchMap || {};
-        const branchCounts = fd.b || {};
-        const fnCounts = fd.f || {};
-        const fileLines = Object.keys(lineCounts).length;
-        const fileCoveredLines = Object.values(lineCounts).filter((v) => v > 0).length;
-        const fileBranches = Object.values(branchCounts).flat().length;
-        const fileCoveredBranches = Object.values(branchCounts).flat().filter((v) => v > 0).length;
-        const fileFunctions = Object.keys(fnCounts).length;
-        const fileCoveredFunctions = Object.values(fnCounts).filter((v) => v > 0).length;
-        const fileStatements = Object.keys(lineMap).length;
-        const fileCoveredStatements = Object.values(lineCounts).filter((v) => v > 0).length;
-        // Find uncovered lines
-        const uncoveredLines = [];
-        for (const [key, count] of Object.entries(lineCounts)) {
-            if (count === 0) {
-                const stmtInfo = lineMap[key];
-                if (stmtInfo?.start?.line) {
-                    uncoveredLines.push(stmtInfo.start.line);
-                }
-            }
-        }
-        // Find uncovered branches
-        const uncoveredBranches = [];
-        for (const [branchId, counts] of Object.entries(branchCounts)) {
-            const branchInfo = branchMap[branchId];
-            counts.forEach((count, idx) => {
-                if (count === 0 && branchInfo?.locations?.[idx]?.start?.line) {
-                    uncoveredBranches.push(branchInfo.locations[idx].start.line);
-                }
-            });
-        }
-        files.push({
-            path: filePath,
-            lines: { covered: fileCoveredLines, total: fileLines },
-            branches: { covered: fileCoveredBranches, total: fileBranches },
-            functions: { covered: fileCoveredFunctions, total: fileFunctions },
-            statements: { covered: fileCoveredStatements, total: fileStatements },
-            uncoveredLines: Array.from(new Set(uncoveredLines)).sort((a, b) => a - b),
-            uncoveredBranches: Array.from(new Set(uncoveredBranches)).sort((a, b) => a - b),
-        });
-        totalLines += fileLines;
-        coveredLines += fileCoveredLines;
-        totalBranches += fileBranches;
-        coveredBranches += fileCoveredBranches;
-        totalFunctions += fileFunctions;
-        coveredFunctions += fileCoveredFunctions;
-        totalStatements += fileStatements;
-        coveredStatements += fileCoveredStatements;
-    }
-    return {
-        files,
-        summary: {
-            line: totalLines > 0 ? (coveredLines / totalLines) * 100 : 0,
-            branch: totalBranches > 0 ? (coveredBranches / totalBranches) * 100 : 0,
-            function: totalFunctions > 0 ? (coveredFunctions / totalFunctions) * 100 : 0,
-            statement: totalStatements > 0 ? (coveredStatements / totalStatements) * 100 : 0,
-            files: files.length,
-        },
-    };
-}
-/**
- * Parse LCOV info format
- */
-function parseLcovInfo(content) {
-    const files = [];
-    const lines = content.split('\n');
-    let currentFile = null;
-    let linesTotal = 0, linesCovered = 0;
-    let branchesTotal = 0, branchesCovered = 0;
-    let functionsTotal = 0, functionsCovered = 0;
-    const uncoveredLines = [];
-    const uncoveredBranches = [];
-    for (const line of lines) {
-        if (line.startsWith('SF:')) {
-            currentFile = line.slice(3);
-        }
-        else if (line.startsWith('LF:')) {
-            linesTotal = parseInt(line.slice(3), 10);
-        }
-        else if (line.startsWith('LH:')) {
-            linesCovered = parseInt(line.slice(3), 10);
-        }
-        else if (line.startsWith('BRF:')) {
-            branchesTotal = parseInt(line.slice(4), 10);
-        }
-        else if (line.startsWith('BRH:')) {
-            branchesCovered = parseInt(line.slice(4), 10);
-        }
-        else if (line.startsWith('FNF:')) {
-            functionsTotal = parseInt(line.slice(4), 10);
-        }
-        else if (line.startsWith('FNH:')) {
-            functionsCovered = parseInt(line.slice(4), 10);
-        }
-        else if (line.startsWith('DA:')) {
-            const [lineNum, count] = line.slice(3).split(',').map(s => parseInt(s, 10));
-            if (count === 0) {
-                uncoveredLines.push(lineNum);
-            }
-        }
-        else if (line.startsWith('BRDA:')) {
-            const parts = line.slice(5).split(',');
-            const lineNum = parseInt(parts[0], 10);
-            const taken = parts[3];
-            if (taken === '0' || taken === '-') {
-                uncoveredBranches.push(lineNum);
-            }
-        }
-        else if (line === 'end_of_record' && currentFile) {
-            files.push({
-                path: currentFile,
-                lines: { covered: linesCovered, total: linesTotal },
-                branches: { covered: branchesCovered, total: branchesTotal },
-                functions: { covered: functionsCovered, total: functionsTotal },
-                statements: { covered: linesCovered, total: linesTotal },
-                uncoveredLines: Array.from(new Set(uncoveredLines)),
-                uncoveredBranches: Array.from(new Set(uncoveredBranches)),
-            });
-            // Reset for next file
-            currentFile = null;
-            linesTotal = linesCovered = 0;
-            branchesTotal = branchesCovered = 0;
-            functionsTotal = functionsCovered = 0;
-            uncoveredLines.length = 0;
-            uncoveredBranches.length = 0;
-        }
-    }
-    // Calculate summary
-    let totalLines = 0, totalCoveredLines = 0;
-    let totalBranches = 0, totalCoveredBranches = 0;
-    let totalFunctions = 0, totalCoveredFunctions = 0;
-    for (const file of files) {
-        totalLines += file.lines.total;
-        totalCoveredLines += file.lines.covered;
-        totalBranches += file.branches.total;
-        totalCoveredBranches += file.branches.covered;
-        totalFunctions += file.functions.total;
-        totalCoveredFunctions += file.functions.covered;
-    }
-    return {
-        files,
-        summary: {
-            line: totalLines > 0 ? (totalCoveredLines / totalLines) * 100 : 0,
-            branch: totalBranches > 0 ? (totalCoveredBranches / totalBranches) * 100 : 0,
-            function: totalFunctions > 0 ? (totalCoveredFunctions / totalFunctions) * 100 : 0,
-            statement: totalLines > 0 ? (totalCoveredLines / totalLines) * 100 : 0,
-            files: files.length,
-        },
-    };
-}
-/**
- * Parse Cobertura XML format (Python coverage.py, Java JaCoCo, etc.)
- * Handles both coverage.xml and cobertura-coverage.xml formats.
- * Uses attribute-order-independent extraction to handle output from
- * different tools (coverage.py, JaCoCo, Cobertura) that order attributes differently.
- */
-function parseCoberturaXml(content) {
-    const files = [];
-    // Helper: extract a named attribute from an XML element string, order-independent
-    function attr(element, name) {
-        const match = element.match(new RegExp(`${name}=["']([^"']*)["']`));
-        return match ? match[1] : null;
-    }
-    // Find all <class ...> elements (handles any attribute order)
-    const classRegex = /<class\s[^>]*?>/g;
-    let classMatch;
-    while ((classMatch = classRegex.exec(content)) !== null) {
-        const classTag = classMatch[0];
-        const filename = attr(classTag, 'filename');
-        if (!filename)
-            continue;
-        const lineRate = parseFloat(attr(classTag, 'line-rate') || 'NaN');
-        const branchRate = parseFloat(attr(classTag, 'branch-rate') || 'NaN');
-        // Find the </class> boundary for this element
-        const classStart = classMatch.index;
-        const classEnd = content.indexOf('</class>', classStart);
-        const classContent = classEnd > classStart
-            ? content.slice(classStart, classEnd)
-            : '';
-        let linesTotal = 0, linesCovered = 0;
-        let branchesTotal = 0, branchesCovered = 0;
-        let functionsTotal = 0, functionsCovered = 0;
-        const uncoveredLines = [];
-        const uncoveredBranches = [];
-        // Parse <line> elements (attribute-order-independent)
-        const lineRegex = /<line\s([^>]*?)\/>/g;
-        let lineMatch;
-        while ((lineMatch = lineRegex.exec(classContent)) !== null) {
-            const lineTag = lineMatch[1];
-            const lineNum = parseInt(attr(lineTag, 'number') || '0', 10);
-            const hits = parseInt(attr(lineTag, 'hits') || '0', 10);
-            const isBranch = attr(lineTag, 'branch') === 'true';
-            const condCoverage = attr(lineTag, 'condition-coverage');
-            linesTotal++;
-            if (hits > 0) {
-                linesCovered++;
-            }
-            else {
-                uncoveredLines.push(lineNum);
-            }
-            if (isBranch) {
-                branchesTotal++;
-                const condPct = condCoverage ? parseInt(condCoverage, 10) : (hits > 0 ? 100 : 0);
-                if (condPct === 100) {
-                    branchesCovered++;
-                }
-                else {
-                    uncoveredBranches.push(lineNum);
-                }
-            }
-        }
-        // Parse <method> elements for function coverage
-        const methodRegex = /<method\s([^>]*?)>/g;
-        let methodMatch;
-        while ((methodMatch = methodRegex.exec(classContent)) !== null) {
-            functionsTotal++;
-            // Check if method has any line hits (look for <line> within this method)
-            const methodStart = methodMatch.index;
-            const methodEnd = classContent.indexOf('</method>', methodStart);
-            if (methodEnd > methodStart) {
-                const methodContent = classContent.slice(methodStart, methodEnd);
-                const methodLineRegex = /<line\s([^>]*?)\/>/g;
-                let hasHits = false;
-                let mLineMatch;
-                while ((mLineMatch = methodLineRegex.exec(methodContent)) !== null) {
-                    if (parseInt(attr(mLineMatch[1], 'hits') || '0', 10) > 0) {
-                        hasHits = true;
-                        break;
-                    }
-                }
-                if (hasHits)
-                    functionsCovered++;
-            }
-        }
-        // If no lines parsed, estimate from rates
-        if (linesTotal === 0 && !isNaN(lineRate)) {
-            linesTotal = 1;
-            linesCovered = lineRate >= 0.5 ? 1 : 0;
-        }
-        files.push({
-            path: filename,
-            lines: { covered: linesCovered, total: linesTotal },
-            branches: { covered: branchesCovered, total: branchesTotal },
-            functions: { covered: functionsCovered, total: functionsTotal },
-            statements: { covered: linesCovered, total: linesTotal },
-            uncoveredLines,
-            uncoveredBranches,
-        });
-    }
-    // Calculate summary
-    let totalLines = 0, totalCoveredLines = 0;
-    let totalBranches = 0, totalCoveredBranches = 0;
-    let totalFunctions = 0, totalCoveredFunctions = 0;
-    for (const file of files) {
-        totalLines += file.lines.total;
-        totalCoveredLines += file.lines.covered;
-        totalBranches += file.branches.total;
-        totalCoveredBranches += file.branches.covered;
-        totalFunctions += file.functions.total;
-        totalCoveredFunctions += file.functions.covered;
-    }
-    // Also try to extract top-level summary from <coverage> element (order-independent)
-    const coverageTag = content.match(/<coverage\s[^>]*?>/);
-    const summaryLineRate = coverageTag ? parseFloat(attr(coverageTag[0], 'line-rate') || 'NaN') * 100 : NaN;
-    const summaryBranchRate = coverageTag ? parseFloat(attr(coverageTag[0], 'branch-rate') || 'NaN') * 100 : NaN;
-    return {
-        files,
-        summary: {
-            line: !isNaN(summaryLineRate) ? summaryLineRate : (totalLines > 0 ? (totalCoveredLines / totalLines) * 100 : 0),
-            branch: !isNaN(summaryBranchRate) ? summaryBranchRate : (totalBranches > 0 ? (totalCoveredBranches / totalBranches) * 100 : 0),
-            function: totalFunctions > 0 ? (totalCoveredFunctions / totalFunctions) * 100 : 0,
-            statement: totalLines > 0 ? (totalCoveredLines / totalLines) * 100 : 0,
-            files: files.length,
-        },
-    };
-}
-/**
- * Discover source files in a directory
- */
-async function discoverSourceFiles(targetPath, options = {}) {
-    const files = [];
-    const { includeTests = true, languages } = options;
-    // Determine file extensions to include
-    // Default: scan ALL common source languages unless explicitly filtered
-    let extensions = [
-        '.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs', // JavaScript/TypeScript
-        '.py', '.pyw', // Python
-        '.go', // Go
-        '.rs', // Rust
-        '.java', '.kt', '.kts', // Java/Kotlin
-        '.rb', // Ruby
-        '.cs', // C#
-        '.php', // PHP
-        '.swift', // Swift
-        '.c', '.h', '.cpp', '.hpp', '.cc', // C/C++
-        '.scala', // Scala
-    ];
-    if (languages && languages.length > 0) {
-        extensions = [];
-        for (const lang of languages) {
-            if (lang === 'typescript')
-                extensions.push('.ts', '.tsx');
-            if (lang === 'javascript')
-                extensions.push('.js', '.jsx', '.mjs', '.cjs');
-            if (lang === 'python')
-                extensions.push('.py', '.pyw');
-            if (lang === 'go')
-                extensions.push('.go');
-            if (lang === 'rust')
-                extensions.push('.rs');
-            if (lang === 'java')
-                extensions.push('.java');
-            if (lang === 'kotlin')
-                extensions.push('.kt', '.kts');
-            if (lang === 'ruby')
-                extensions.push('.rb');
-            if (lang === 'csharp' || lang === 'c#')
-                extensions.push('.cs');
-            if (lang === 'php')
-                extensions.push('.php');
-            if (lang === 'swift')
-                extensions.push('.swift');
-            if (lang === 'c' || lang === 'cpp' || lang === 'c++')
-                extensions.push('.c', '.h', '.cpp', '.hpp', '.cc');
-            if (lang === 'scala')
-                extensions.push('.scala');
-        }
-    }
-    async function walkDir(dir) {
-        try {
-            const entries = await fs.readdir(dir, { withFileTypes: true });
-            for (const entry of entries) {
-                const fullPath = path.join(dir, entry.name);
-                // Skip common non-source directories
-                if (entry.isDirectory()) {
-                    if (['node_modules', '.git', 'dist', 'build', 'coverage', '.nyc_output',
-                        '__pycache__', '.venv', 'venv', '.tox', '.mypy_cache', 'target',
-                        '.gradle', 'vendor', '.bundle'].includes(entry.name)) {
-                        continue;
-                    }
-                    await walkDir(fullPath);
-                }
-                else if (entry.isFile()) {
-                    const ext = path.extname(entry.name);
-                    // Check extension
-                    if (!extensions.includes(ext))
-                        continue;
-                    // Skip test files if not including tests
-                    if (!includeTests) {
-                        const isTestFile = entry.name.includes('.test.') ||
-                            entry.name.includes('.spec.') ||
-                            entry.name.endsWith('_test.ts') ||
-                            entry.name.endsWith('_test.js') ||
-                            fullPath.includes('/__tests__/') ||
-                            fullPath.includes('/test/') ||
-                            fullPath.includes('/tests/');
-                        if (isTestFile)
-                            continue;
-                    }
-                    files.push(fullPath);
-                }
-            }
-        }
-        catch {
-            // Directory not accessible
-        }
-    }
-    // Check if targetPath is a file or directory
-    try {
-        const stat = await fs.stat(targetPath);
-        if (stat.isFile()) {
-            return [targetPath];
-        }
-        await walkDir(targetPath);
-    }
-    catch {
-        // Path doesn't exist
-    }
-    return files;
-}
-/**
- * Generate security recommendations based on findings
- */
-function generateSecurityRecommendations(vulnerabilities) {
-    const recommendations = new Set();
-    const categoryRecommendations = {
-        'injection': 'Use parameterized queries and input validation to prevent injection attacks',
-        'xss': 'Sanitize user input and use Content-Security-Policy headers',
-        'sensitive-data': 'Never hardcode secrets; use environment variables or secret managers',
-        'access-control': 'Implement proper authentication and authorization checks',
-        'security-misconfiguration': 'Review and harden security configurations',
-        'insecure-deserialization': 'Avoid deserializing untrusted data; use safe alternatives',
-        'broken-auth': 'Use strong authentication mechanisms and secure session management',
-        'dependencies': 'Keep dependencies updated and regularly audit for vulnerabilities',
-    };
-    // Add category-specific recommendations
-    for (const vuln of vulnerabilities) {
-        const rec = categoryRecommendations[vuln.category];
-        if (rec) {
-            recommendations.add(rec);
-        }
-    }
-    // Add severity-based general recommendations
-    const hasCritical = vulnerabilities.some(v => v.severity === 'critical');
-    const hasHigh = vulnerabilities.some(v => v.severity === 'high');
-    if (hasCritical) {
-        recommendations.add('CRITICAL: Address critical vulnerabilities immediately before deployment');
-    }
-    if (hasHigh) {
-        recommendations.add('Prioritize fixing high-severity issues in the next sprint');
-    }
-    if (recommendations.size === 0 && vulnerabilities.length === 0) {
-        recommendations.add('No vulnerabilities found - maintain current security practices');
-    }
-    return Array.from(recommendations);
-}
-// ============================================================================
 // Task Executor
 // ============================================================================
 export class DomainTaskExecutor {
     kernel;
     eventBus;
-    config;
+    _config;
     resultSaver;
     // Instance-level service caches to prevent cross-contamination between executor instances
     coverageAnalyzer = null;
@@ -598,7 +127,7 @@ export class DomainTaskExecutor {
     constructor(kernel, eventBus, config) {
         this.kernel = kernel;
         this.eventBus = eventBus;
-        this.config = {
+        this._config = {
             timeout: config?.timeout ?? 300000,
             maxRetries: config?.maxRetries ?? 3,
             enableCaching: config?.enableCaching ?? true,
@@ -607,9 +136,20 @@ export class DomainTaskExecutor {
             defaultLanguage: config?.defaultLanguage ?? 'typescript',
             defaultFramework: config?.defaultFramework ?? 'vitest',
         };
-        this.resultSaver = createResultSaver(this.config.resultsDir);
+        this.resultSaver = createResultSaver(this._config.resultsDir);
         this.registerHandlers();
     }
+    // ============================================================================
+    // TaskHandlerContext implementation (used by handler modules)
+    // ============================================================================
+    /** Expose config to handler modules */
+    get config() {
+        return this._config;
+    }
+    /** Register a handler for a given task type */
+    registerHandler(type, handler) {
+        this.taskHandlers.set(type, handler);
+    }
     /** Connect QualityFeedbackLoop for routing outcome recording */
     setQualityFeedbackLoop(loop) {
         this.qualityFeedbackLoop = loop;
@@ -647,6 +187,21 @@ export class DomainTaskExecutor {
         }
         return this.qualityAnalyzer;
     }
+    // ============================================================================
+    // Handler Registration (delegates to extracted handler modules)
+    // ============================================================================
+    registerHandlers() {
+        registerTestExecutionHandlers(this);
+        registerCoverageHandlers(this);
+        registerSecurityHandlers(this);
+        registerQualityHandlers(this);
+        registerRequirementsHandlers(this);
+        registerCodeIntelligenceHandlers(this);
+        registerMiscHandlers(this);
+    }
+    // ============================================================================
+    // ADR-051: Agent Booster Execution (Tier 0)
+    // ============================================================================
     /**
      * Get or create Agent Booster adapter (instance-level)
      */
@@ -675,875 +230,6 @@ export class DomainTaskExecutor {
         }
         return this.taskRouter;
     }
-    // ============================================================================
-    // Task Handler Registration (instance-level)
-    // ============================================================================
-    registerHandlers() {
-        // Register test generation handler - REAL IMPLEMENTATION
-        this.taskHandlers.set('generate-tests', async (task) => {
-            const payload = task.payload;
-            try {
-                const generator = this.getTestGenerator();
-                // Determine source files to analyze
-                let sourceFiles = [];
-                if (payload.sourceFiles && payload.sourceFiles.length > 0) {
-                    sourceFiles = payload.sourceFiles;
-                }
-                else if (payload.filePath) {
-                    sourceFiles = [payload.filePath];
-                }
-                else if (payload.sourceCode) {
-                    // Write temporary file for analysis if only source code provided
-                    // Use correct file extension based on language parameter
-                    const langExtMap = {
-                        python: '.py', typescript: '.ts', javascript: '.js',
-                        go: '.go', rust: '.rs', java: '.java', ruby: '.rb',
-                        kotlin: '.kt', csharp: '.cs', php: '.php', swift: '.swift',
-                        cpp: '.cpp', c: '.c', scala: '.scala',
-                    };
-                    const ext = langExtMap[payload.language?.toLowerCase() || 'typescript'] || '.ts';
-                    const tempPath = `/tmp/aqe-temp-${uuidv4()}${ext}`;
-                    await fs.writeFile(tempPath, payload.sourceCode, 'utf-8');
-                    sourceFiles = [tempPath];
-                }
-                if (sourceFiles.length === 0) {
-                    // Return a graceful fallback with warning when no source files provided
-                    return ok({
-                        testsGenerated: 0,
-                        coverageEstimate: 0,
-                        tests: [],
-                        patternsUsed: [],
-                        warning: 'No source files or code provided for test generation. Provide sourceCode, filePath, or sourceFiles in the payload.',
-                    });
-                }
-                // Use the real TestGeneratorService
-                const framework = (payload.framework || 'vitest');
-                const result = await generator.generateTests({
-                    sourceFiles,
-                    testType: payload.testType || 'unit',
-                    framework,
-                    coverageTarget: payload.coverageGoal || 80,
-                    patterns: [],
-                });
-                if (!result.success) {
-                    return result;
-                }
-                const generatedTests = result.value;
-                return ok({
-                    testsGenerated: generatedTests.tests.length,
-                    coverageEstimate: generatedTests.coverageEstimate,
-                    tests: generatedTests.tests.map(t => ({
-                        name: t.name,
-                        file: t.testFile,
-                        type: t.type,
-                        sourceFile: t.sourceFile,
-                        assertions: t.assertions,
-                        testCode: t.testCode,
-                    })),
-                    patternsUsed: generatedTests.patternsUsed,
-                });
-            }
-            catch (error) {
-                return err(toError(error));
-            }
-        });
-        // Register coverage analysis handler - REAL IMPLEMENTATION
-        this.taskHandlers.set('analyze-coverage', async (task) => {
-            const payload = task.payload;
-            try {
-                const analyzer = this.getCoverageAnalyzer();
-                const targetPath = payload.target || process.cwd();
-                const threshold = payload.threshold || 80;
-                // Try to find and read actual coverage files
-                let coverageData = await loadCoverageData(targetPath);
-                if (!coverageData) {
-                    // No coverage data found — attempt to collect it by running tests with coverage
-                    let collected = false;
-                    try {
-                        const { execSync } = await import('child_process');
-                        // Detect test runner from package.json
-                        let coverageCmd = 'npx vitest run --coverage --reporter=json 2>/dev/null';
-                        try {
-                            const pkgContent = await fs.readFile(path.join(targetPath, 'package.json'), 'utf-8');
-                            const pkg = safeJsonParse(pkgContent);
-                            const deps = { ...(pkg.devDependencies || {}), ...(pkg.dependencies || {}) };
-                            if (deps['jest'] || deps['@jest/core']) {
-                                coverageCmd = 'npx jest --coverage --json 2>/dev/null';
-                            }
-                            else if (deps['mocha'] || deps['nyc']) {
-                                coverageCmd = 'npx nyc mocha 2>/dev/null';
-                            }
-                            // vitest is the default — covers vitest, @vitest/coverage-v8, etc.
-                        }
-                        catch {
-                            // No package.json — use default vitest
-                        }
-                        execSync(coverageCmd, {
-                            cwd: targetPath,
-                            timeout: 120000,
-                            encoding: 'utf-8',
-                            stdio: ['pipe', 'pipe', 'pipe'],
-                        });
-                        collected = true;
-                    }
-                    catch {
-                        // Test runner failed or not available — that's OK, we'll check for output anyway
-                    }
-                    // Re-check for coverage data after collection attempt
-                    coverageData = await loadCoverageData(targetPath);
-                    if (!coverageData) {
-                        return ok({
-                            lineCoverage: 0,
-                            branchCoverage: 0,
-                            functionCoverage: 0,
-                            statementCoverage: 0,
-                            totalFiles: 0,
-                            coverageByFile: [],
-                            gaps: [],
-                            algorithm: 'sublinear-O(log n)',
-                            warning: collected
-                                ? 'Tests ran but no coverage output was generated. Ensure a coverage provider is configured (e.g., @vitest/coverage-v8, istanbul).'
-                                : 'No coverage data found and could not run tests automatically. Run: npm test -- --coverage',
-                        });
-                    }
-                }
-                // Analyze coverage using the real CoverageAnalyzerService
-                const analysisResult = await analyzer.analyze({
-                    coverageData,
-                    threshold,
-                    includeFileDetails: payload.detectGaps,
-                });
-                if (!analysisResult.success) {
-                    return analysisResult;
-                }
-                const report = analysisResult.value;
-                // Find gaps if requested
-                let gaps = [];
-                if (payload.detectGaps) {
-                    const gapsResult = await analyzer.findGaps(coverageData, threshold);
-                    if (gapsResult.success) {
-                        gaps = gapsResult.value.gaps.map(gap => ({
-                            file: gap.file,
-                            lines: gap.lines,
-                            risk: gap.severity,
-                        }));
-                    }
-                }
-                return ok({
-                    lineCoverage: Math.round(report.summary.line * 10) / 10,
-                    branchCoverage: Math.round(report.summary.branch * 10) / 10,
-                    functionCoverage: Math.round(report.summary.function * 10) / 10,
-                    statementCoverage: Math.round(report.summary.statement * 10) / 10,
-                    totalFiles: report.summary.files,
-                    coverageByFile: coverageData.files.map(f => ({
-                        file: f.path,
-                        lineCoverage: f.lines.total > 0 ? Math.round((f.lines.covered / f.lines.total) * 1000) / 10 : 0,
-                        branchCoverage: f.branches.total > 0 ? Math.round((f.branches.covered / f.branches.total) * 1000) / 10 : 0,
-                        functionCoverage: f.functions.total > 0 ? Math.round((f.functions.covered / f.functions.total) * 1000) / 10 : 0,
-                    })),
-                    gaps,
-                    meetsThreshold: report.meetsThreshold,
-                    delta: report.delta,
-                    recommendations: report.recommendations,
-                    algorithm: 'sublinear-O(log n)',
-                });
-            }
-            catch (error) {
-                return err(toError(error));
-            }
-        });
-        // Register security scan handler - REAL IMPLEMENTATION
-        this.taskHandlers.set('scan-security', async (task) => {
-            const payload = task.payload;
-            try {
-                const scanner = this.getSecurityScanner();
-                const targetPath = payload.target || process.cwd();
-                // Discover files to scan
-                const filesToScan = await discoverSourceFiles(targetPath);
-                if (filesToScan.length === 0) {
-                    return ok({
-                        vulnerabilities: 0,
-                        critical: 0,
-                        high: 0,
-                        medium: 0,
-                        low: 0,
-                        informational: 0,
-                        topVulnerabilities: [],
-                        recommendations: ['No source files found to scan'],
-                        scanTypes: {
-                            sast: payload.sast !== false,
-                            dast: payload.dast || false,
-                        },
-                        warning: `No source files found in ${targetPath}`,
-                    });
-                }
-                // Separate files by language capability
-                const jstsFiles = filesToScan.filter(f => /\.(ts|tsx|js|jsx|mjs|cjs)$/.test(f));
-                const otherFiles = filesToScan.filter(f => !/\.(ts|tsx|js|jsx|mjs|cjs)$/.test(f));
-                // Run basic cross-language security patterns on non-JS/TS files
-                const crossLangVulns = [];
-                // Run secret/CORS patterns on ALL files (not just otherFiles) to catch JS/TS secrets too
-                for (const filePath of filesToScan) {
-                    try {
-                        const content = await fs.readFile(filePath, 'utf-8');
-                        const lines = content.split('\n');
-                        const relPath = filePath.startsWith(targetPath)
-                            ? filePath.slice(targetPath.length).replace(/^\//, '')
-                            : filePath;
-                        // Pattern: Hardcoded secrets/keys
-                        // Fix #287: Use \w* around keywords to match SECRET_KEY, JWT_SECRET, API_TOKEN, etc.
-                        const secretPatterns = [
-                            { regex: /\w*(?:secret|password|passwd|api_key|apikey|private_key|jwt_secret)\w*\s*[=:]\s*['"][^'"]{4,}['"]/gi, title: 'Hardcoded secret', severity: 'critical' },
-                            { regex: /\w*(?:token|auth_token|access_key|secret_key)\w*\s*[=:]\s*['"][^'"]{8,}['"]/gi, title: 'Hardcoded credential', severity: 'critical' },
-                            { regex: /(?:AWS_SECRET|GITHUB_TOKEN|SLACK_TOKEN|OPENAI_API_KEY)\s*[=:]\s*['"][^'"]+['"]/gi, title: 'Hardcoded cloud credential', severity: 'critical' },
-                        ];
-                        for (const pattern of secretPatterns) {
-                            for (let i = 0; i < lines.length; i++) {
-                                // Use matchAll to find ALL secrets on a single line (not just first)
-                                const matches = [...lines[i].matchAll(pattern.regex)];
-                                for (const _m of matches) {
-                                    crossLangVulns.push({
-                                        title: pattern.title,
-                                        severity: pattern.severity,
-                                        location: { file: relPath, line: i + 1 },
-                                        description: `Potential hardcoded secret found at line ${i + 1}`,
-                                        category: 'sensitive-data',
-                                    });
-                                }
-                            }
-                        }
-                        // Pattern: SQL injection risks
-                        const sqlPatterns = /(?:execute|query|cursor\.execute)\s*\(\s*(?:f['"]|['"].*%s|['"].*\+\s*\w)/gi;
-                        for (let i = 0; i < lines.length; i++) {
-                            if (sqlPatterns.test(lines[i])) {
-                                crossLangVulns.push({
-                                    title: 'Potential SQL injection',
-                                    severity: 'high',
-                                    location: { file: relPath, line: i + 1 },
-                                    description: 'String interpolation in SQL query — use parameterized queries',
-                                    category: 'injection',
-                                });
-                            }
-                            sqlPatterns.lastIndex = 0;
-                        }
-                        // Pattern: CORS wildcard (multi-framework)
-                        const corsPatterns = [
-                            /allow_origins\s*=\s*\[?\s*['"]?\*['"]?\s*\]?/i, // Python FastAPI/Flask
-                            /cors\(\s*\{[^}]*origin:\s*['"]?\*['"]?/i, // Express.js cors()
-                            /Access-Control-Allow-Origin['":\s]+\*/i, // Raw header / Nginx / .htaccess
-                            /@CrossOrigin\(\s*origins?\s*=\s*["']\*["']/i, // Spring Boot
-                            /\.Header\(\)\.Set\(["']Access-Control-Allow-Origin["'],\s*["']\*["']/i, // Go
-                        ];
-                        for (const corsPattern of corsPatterns) {
-                            if (corsPattern.test(content)) {
-                                crossLangVulns.push({
-                                    title: 'CORS wildcard origin',
-                                    severity: 'high',
-                                    location: { file: relPath, line: lines.findIndex(l => corsPattern.test(l)) + 1 },
-                                    description: 'CORS configured with wildcard (*) origin — restrict to specific domains',
-                                    category: 'security-misconfiguration',
-                                });
-                                break; // One CORS finding per file is enough
-                            }
-                        }
-                        // Pattern: Debug/development mode enabled
-                        if (/(?:DEBUG|debug)\s*[=:]\s*(?:True|true|1)/i.test(content)) {
-                            crossLangVulns.push({
-                                title: 'Debug mode enabled',
-                                severity: 'medium',
-                                location: { file: relPath, line: lines.findIndex(l => /DEBUG\s*[=:]\s*(?:True|true|1)/i.test(l)) + 1 },
-                                description: 'Debug mode should be disabled in production',
-                                category: 'security-misconfiguration',
-                            });
-                        }
-                        // Pattern: Eval/exec usage
-                        if (/\b(?:eval|exec)\s*\(/i.test(content)) {
-                            crossLangVulns.push({
-                                title: 'Dangerous eval/exec usage',
-                                severity: 'high',
-                                location: { file: relPath, line: lines.findIndex(l => /\b(?:eval|exec)\s*\(/.test(l)) + 1 },
-                                description: 'eval/exec can lead to code injection — avoid using with user input',
-                                category: 'injection',
-                            });
-                        }
-                    }
-                    catch {
-                        // Skip unreadable files
-                    }
-                }
-                // Also check dependency manifests for known vulnerable packages
-                const depManifests = ['requirements.txt', 'pyproject.toml', 'Gemfile', 'go.mod', 'Cargo.toml'];
-                for (const manifest of depManifests) {
-                    const manifestPath = path.join(targetPath, manifest);
-                    try {
-                        const manifestContent = await fs.readFile(manifestPath, 'utf-8');
-                        crossLangVulns.push({
-                            title: 'Dependency audit recommended',
-                            severity: 'informational',
-                            location: { file: manifest, line: 1 },
-                            description: `Found ${manifest} — run language-specific dependency audit (e.g., pip-audit, npm audit, cargo audit)`,
-                            category: 'dependencies',
-                        });
-                        // Check for known high-severity CVEs in Python dependencies
-                        if (manifest === 'requirements.txt' || manifest === 'pyproject.toml') {
-                            const knownCVEs = [
-                                { pkg: 'python-jose', pattern: /python-jose/i, cve: 'CVE-2024-33663', severity: 'high', title: 'python-jose ECDSA key confusion (CVE-2024-33663)', description: 'python-jose allows ECDSA key confusion — upgrade to >=3.3.0 or switch to PyJWT' },
-                                { pkg: 'python-jose', pattern: /python-jose/i, cve: 'CVE-2024-33664', severity: 'high', title: 'python-jose JWT algorithm confusion (CVE-2024-33664)', description: 'python-jose JWT algorithm confusion vulnerability — upgrade or switch to PyJWT' },
-                                { pkg: 'python-multipart', pattern: /python-multipart/i, cve: 'CVE-2026-24486', severity: 'critical', title: 'python-multipart DoS (CVE-2026-24486)', description: 'python-multipart denial of service via crafted multipart data — upgrade to >=0.0.18' },
-                            ];
-                            for (const known of knownCVEs) {
-                                if (known.pattern.test(manifestContent)) {
-                                    crossLangVulns.push({
-                                        title: known.title,
-                                        severity: known.severity,
-                                        location: { file: manifest, line: manifestContent.split('\n').findIndex(l => known.pattern.test(l)) + 1 },
-                                        description: known.description,
-                                        category: 'dependencies',
-                                    });
-                                }
-                            }
-                        }
-                    }
-                    catch {
-                        // Manifest doesn't exist
-                    }
-                }
-                // Convert JS/TS file paths to FilePath value objects for the SAST scanner
-                const filePathObjects = jstsFiles.map(filePath => FilePath.create(filePath));
-                // Run SAST scan on JS/TS files if requested and files exist
-                let sastResult = null;
-                if (payload.sast !== false && filePathObjects.length > 0) {
-                    const result = await scanner.scanFiles(filePathObjects);
-                    if (result.success) {
-                        sastResult = result.value;
-                    }
-                }
-                // Run DAST scan if URL provided and dast is enabled
-                let dastResult = null;
-                if (payload.dast && payload.targetUrl) {
-                    const result = await scanner.scanUrl(payload.targetUrl, {
-                        activeScanning: true,
-                        maxDepth: 3,
-                        timeout: 30000,
-                    });
-                    if (result.success) {
-                        dastResult = result.value;
-                    }
-                }
-                // Combine results from all scan sources - SAST, DAST, and cross-language patterns
-                const crossLangSeverityCounts = {
-                    critical: crossLangVulns.filter(v => v.severity === 'critical').length,
-                    high: crossLangVulns.filter(v => v.severity === 'high').length,
-                    medium: crossLangVulns.filter(v => v.severity === 'medium').length,
-                    low: crossLangVulns.filter(v => v.severity === 'low').length,
-                    informational: crossLangVulns.filter(v => v.severity === 'informational').length,
-                };
-                const summary = {
-                    critical: (sastResult?.summary?.critical || 0) + (dastResult?.summary?.critical || 0) + crossLangSeverityCounts.critical,
-                    high: (sastResult?.summary?.high || 0) + (dastResult?.summary?.high || 0) + crossLangSeverityCounts.high,
-                    medium: (sastResult?.summary?.medium || 0) + (dastResult?.summary?.medium || 0) + crossLangSeverityCounts.medium,
-                    low: (sastResult?.summary?.low || 0) + (dastResult?.summary?.low || 0) + crossLangSeverityCounts.low,
-                    informational: (sastResult?.summary?.informational || 0) + (dastResult?.summary?.informational || 0) + crossLangSeverityCounts.informational,
-                };
-                // Extract top vulnerabilities from all sources
-                const allVulns = [
-                    ...(sastResult?.vulnerabilities || []),
-                    ...(dastResult?.vulnerabilities || []),
-                    ...crossLangVulns,
-                ];
-                const topVulnerabilities = allVulns
-                    .sort((a, b) => {
-                    const severityOrder = { critical: 0, high: 1, medium: 2, low: 3, informational: 4 };
-                    return severityOrder[a.severity] - severityOrder[b.severity];
-                })
-                    .slice(0, 10)
-                    .map(v => ({
-                    type: v.title,
-                    severity: v.severity,
-                    file: v.location.file,
-                    line: v.location.line,
-                    description: v.description,
-                }));
-                // Generate recommendations based on findings
-                const recommendations = generateSecurityRecommendations(allVulns);
-                return ok({
-                    vulnerabilities: allVulns.length,
-                    critical: summary.critical,
-                    high: summary.high,
-                    medium: summary.medium,
-                    low: summary.low,
-                    informational: summary.informational,
-                    topVulnerabilities,
-                    recommendations,
-                    scanTypes: {
-                        sast: payload.sast !== false,
-                        dast: payload.dast || false,
-                    },
-                    filesScanned: filesToScan.length,
-                    jstsFilesScanned: jstsFiles.length,
-                    otherFilesScanned: otherFiles.length,
-                    coverage: sastResult?.coverage,
-                    ...(otherFiles.length > 0 && jstsFiles.length === 0 ? {
-                        note: 'Non-JS/TS files were scanned with cross-language pattern matching. For deeper analysis, use language-specific security tools.',
-                    } : {}),
-                });
-            }
-            catch (error) {
-                return err(toError(error));
-            }
-        });
-        // Register code indexing handler - REAL IMPLEMENTATION
-        this.taskHandlers.set('index-code', async (task) => {
-            const payload = task.payload;
-            try {
-                const kg = this.getKnowledgeGraph();
-                const targetPath = payload.target || process.cwd();
-                const startTime = Date.now();
-                // Discover files to index
-                const filesToIndex = await discoverSourceFiles(targetPath, {
-                    includeTests: payload.includeTests !== false,
-                    languages: payload.languages,
-                });
-                if (filesToIndex.length === 0) {
-                    return ok({
-                        filesIndexed: 0,
-                        nodesCreated: 0,
-                        edgesCreated: 0,
-                        target: targetPath,
-                        incremental: payload.incremental || false,
-                        languages: payload.languages || [],
-                        duration: Date.now() - startTime,
-                        warning: `No source files found in ${targetPath}. Searched for: TypeScript, JavaScript, Python, Go, Rust, Java, Ruby, C/C++, and more.`,
-                    });
-                }
-                // Use the real KnowledgeGraphService to index files
-                const result = await kg.index({
-                    paths: filesToIndex,
-                    incremental: payload.incremental || false,
-                    includeTests: payload.includeTests !== false,
-                    languages: payload.languages,
-                });
-                if (!result.success) {
-                    return result;
-                }
-                const indexResult = result.value;
-                // Detect languages from files
-                const detectedLanguages = new Set();
-                const extToLang = {
-                    ts: 'typescript', tsx: 'typescript',
-                    js: 'javascript', jsx: 'javascript', mjs: 'javascript', cjs: 'javascript',
-                    py: 'python', pyw: 'python',
-                    go: 'go', rs: 'rust',
-                    java: 'java', kt: 'kotlin', kts: 'kotlin',
-                    rb: 'ruby', cs: 'csharp', php: 'php', swift: 'swift',
-                    c: 'c', h: 'c', cpp: 'cpp', hpp: 'cpp', cc: 'cpp',
-                    scala: 'scala',
-                };
-                for (const file of filesToIndex) {
-                    const ext = path.extname(file).slice(1);
-                    const lang = extToLang[ext];
-                    if (lang)
-                        detectedLanguages.add(lang);
-                }
-                return ok({
-                    filesIndexed: indexResult.filesIndexed,
-                    nodesCreated: indexResult.nodesCreated,
-                    edgesCreated: indexResult.edgesCreated,
-                    target: targetPath,
-                    incremental: payload.incremental || false,
-                    languages: Array.from(detectedLanguages),
-                    duration: indexResult.duration,
-                    errors: indexResult.errors,
-                });
-            }
-            catch (error) {
-                return err(toError(error));
-            }
-        });
-        // Register quality assessment handler - REAL IMPLEMENTATION
-        this.taskHandlers.set('assess-quality', async (task) => {
-            const payload = task.payload;
-            try {
-                const analyzer = this.getQualityAnalyzer();
-                const threshold = payload.threshold || 80;
-                // Determine source files to analyze
-                let sourceFiles = [];
-                if (payload.sourceFiles && payload.sourceFiles.length > 0) {
-                    sourceFiles = payload.sourceFiles;
-                }
-                else if (payload.target) {
-                    sourceFiles = await discoverSourceFiles(payload.target, { includeTests: false });
-                }
-                else {
-                    sourceFiles = await discoverSourceFiles(process.cwd(), { includeTests: false });
-                }
-                if (sourceFiles.length === 0) {
-                    return ok({
-                        qualityScore: 0,
-                        passed: false,
-                        threshold,
-                        metrics: {
-                            coverage: 0,
-                            complexity: 0,
-                            maintainability: 0,
-                            testability: 0,
-                        },
-                        recommendations: ['No source files found for quality assessment'],
-                        warning: 'No source files found',
-                    });
-                }
-                // Use the real QualityAnalyzerService
-                const result = await analyzer.analyzeQuality({
-                    sourceFiles,
-                    includeMetrics: payload.metrics || ['coverage', 'complexity', 'maintainability', 'testability'],
-                });
-                if (!result.success) {
-                    return result;
-                }
-                const report = result.value;
-                const passed = report.score.overall >= threshold;
-                // Convert metrics to the expected format
-                const metrics = {};
-                for (const metric of report.metrics) {
-                    metrics[metric.name] = metric.value;
-                }
-                return ok({
-                    qualityScore: report.score.overall,
-                    passed,
-                    threshold,
-                    metrics: {
-                        coverage: report.score.coverage,
-                        complexity: report.score.complexity,
-                        maintainability: report.score.maintainability,
-                        security: report.score.security,
-                        ...metrics,
-                    },
-                    recommendations: report.recommendations.map(r => `[${r.type}] ${r.title}: ${r.description}`),
-                    trends: report.trends.map(t => ({
-                        metric: t.metric,
-                        direction: t.direction,
-                        dataPoints: t.dataPoints.length,
-                    })),
-                    filesAnalyzed: sourceFiles.length,
-                });
-            }
-            catch (error) {
-                return err(toError(error));
-            }
-        });
-        // Register test execution handler - runs real tests via child process
-        this.taskHandlers.set('execute-tests', async (task) => {
-            const payload = task.payload;
-            try {
-                const { execSync } = await import('child_process');
-                const testFiles = payload.testFiles || [];
-                if (testFiles.length === 0) {
-                    return ok({
-                        total: 0, passed: 0, failed: 0, skipped: 0,
-                        duration: 0, coverage: 0, failedTests: [],
-                        warning: 'No test files specified. Provide testFiles array with paths to test files.',
-                    });
-                }
-                // Attempt to run tests using common test runners
-                const cwd = process.cwd();
-                let output;
-                try {
-                    // Try vitest first, then jest, then mocha
-                    output = execSync(`npx vitest run ${testFiles.join(' ')} --reporter=json 2>/dev/null || npx jest ${testFiles.join(' ')} --json 2>/dev/null`, { cwd, timeout: 120000, encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] });
-                }
-                catch (execError) {
-                    // Test runner may exit non-zero when tests fail — that's expected
-                    output = execError.stdout || '';
-                }
-                // Try to parse JSON output from test runner
-                try {
-                    const jsonStart = output.indexOf('{');
-                    if (jsonStart >= 0) {
-                        const json = JSON.parse(output.slice(jsonStart));
-                        // vitest format
-                        if (json.testResults) {
-                            const total = json.numTotalTests || 0;
-                            const passed = json.numPassedTests || 0;
-                            const failed = json.numFailedTests || 0;
-                            return ok({ total, passed, failed, skipped: total - passed - failed, duration: 0, coverage: 0, failedTests: [] });
-                        }
-                    }
-                }
-                catch {
-                    // JSON parsing failed — return raw info
-                }
-                return ok({
-                    total: testFiles.length, passed: 0, failed: 0, skipped: 0,
-                    duration: 0, coverage: 0, failedTests: [],
-                    warning: 'Could not parse test runner output. Check that vitest or jest is installed.',
-                    rawOutput: output.slice(0, 500),
-                });
-            }
-            catch (error) {
-                return err(toError(error));
-            }
-        });
-        // Register defect prediction handler - REAL IMPLEMENTATION
-        this.taskHandlers.set('predict-defects', async (task) => {
-            const payload = task.payload;
-            try {
-                const targetPath = payload.target || process.cwd();
-                const minConfidence = payload.minConfidence || 0.5;
-                // Discover actual source files in the target directory
-                const sourceFiles = await discoverSourceFiles(targetPath, { includeTests: false });
-                if (sourceFiles.length === 0) {
-                    return ok({
-                        predictedDefects: [],
-                        riskScore: 0,
-                        recommendations: [
-                            `No source files found in ${targetPath}. Ensure the path contains source code files.`,
-                        ],
-                        warning: `No source files found in ${targetPath}`,
-                        filesAnalyzed: 0,
-                    });
-                }
-                // Analyze each file for defect indicators based on real metrics
-                const predictedDefects = [];
-                for (const filePath of sourceFiles) {
-                    try {
-                        const content = await fs.readFile(filePath, 'utf-8');
-                        const lines = content.split('\n');
-                        const lineCount = lines.length;
-                        // Calculate complexity indicators from real code
-                        let probability = 0;
-                        const reasons = [];
-                        // Factor 1: File size (large files are more defect-prone)
-                        if (lineCount > 500) {
-                            probability += 0.25;
-                            reasons.push(`Large file (${lineCount} lines)`);
-                        }
-                        else if (lineCount > 300) {
-                            probability += 0.15;
-                            reasons.push(`Medium-large file (${lineCount} lines)`);
-                        }
-                        // Factor 2: Cyclomatic complexity indicators
-                        const branchKeywords = content.match(/\b(if|else|switch|case|for|while|catch|&&|\|\|)\b/g) || [];
-                        const branchDensity = branchKeywords.length / Math.max(lineCount, 1);
-                        if (branchDensity > 0.15) {
-                            probability += 0.25;
-                            reasons.push(`High branch density (${branchKeywords.length} branches in ${lineCount} lines)`);
-                        }
-                        else if (branchDensity > 0.08) {
-                            probability += 0.10;
-                            reasons.push('Moderate branch complexity');
-                        }
-                        // Factor 3: Deeply nested code
-                        const maxIndent = Math.max(...lines.map(l => {
-                            const match = l.match(/^(\s*)/);
-                            return match ? match[1].length : 0;
-                        }));
-                        if (maxIndent > 20) {
-                            probability += 0.15;
-                            reasons.push('Deep nesting detected');
-                        }
-                        // Factor 4: TODO/FIXME/HACK comments
-                        const debtComments = (content.match(/\b(TODO|FIXME|HACK|XXX|WORKAROUND)\b/gi) || []).length;
-                        if (debtComments > 3) {
-                            probability += 0.15;
-                            reasons.push(`${debtComments} technical debt markers`);
-                        }
-                        // Factor 5: Long functions (heuristic)
-                        const functionStarts = (content.match(/\b(function|def|func|async)\b/g) || []).length;
-                        if (functionStarts > 0 && lineCount / functionStarts > 80) {
-                            probability += 0.10;
-                            reasons.push('Potentially long functions');
-                        }
-                        probability = Math.min(probability, 0.95);
-                        if (probability >= minConfidence) {
-                            // Use relative path for readability
-                            const relativePath = filePath.startsWith(targetPath)
-                                ? filePath.slice(targetPath.length).replace(/^\//, '')
-                                : filePath;
-                            predictedDefects.push({
-                                file: relativePath,
-                                probability: Math.round(probability * 100) / 100,
-                                reason: reasons.join('; '),
-                            });
-                        }
-                    }
-                    catch {
-                        // Skip files that can't be read
-                    }
-                }
-                // Sort by probability descending
-                predictedDefects.sort((a, b) => b.probability - a.probability);
-                // Calculate overall risk score
-                const avgProb = predictedDefects.length > 0
-                    ? predictedDefects.reduce((sum, d) => sum + d.probability, 0) / predictedDefects.length
-                    : 0;
-                const riskScore = Math.round(avgProb * 100);
-                // Generate recommendations from actual findings
-                const recommendations = [];
-                if (predictedDefects.length > 0) {
-                    recommendations.push(`${predictedDefects.length} files flagged for potential defects out of ${sourceFiles.length} analyzed`);
-                    const topFile = predictedDefects[0];
-                    recommendations.push(`Highest risk: ${topFile.file} (${Math.round(topFile.probability * 100)}%) — ${topFile.reason}`);
-                }
-                if (predictedDefects.some(d => d.reason.includes('Large file'))) {
-                    recommendations.push('Consider splitting large files to reduce complexity');
-                }
-                if (predictedDefects.some(d => d.reason.includes('technical debt'))) {
-                    recommendations.push('Address TODO/FIXME comments to reduce technical debt');
-                }
-                if (predictedDefects.length === 0) {
-                    recommendations.push('No files exceeded the defect probability threshold — code looks healthy');
-                }
-                return ok({
-                    predictedDefects: predictedDefects.slice(0, 20), // Top 20
-                    riskScore,
-                    recommendations,
-                    filesAnalyzed: sourceFiles.length,
-                });
-            }
-            catch (error) {
-                return err(toError(error));
-            }
-        });
-        // Register requirements validation handler
-        this.taskHandlers.set('validate-requirements', async (task) => {
-            const payload = task.payload;
-            try {
-                const targetPath = payload.requirementsPath || process.cwd();
-                // Look for requirements files (markdown, feature files, etc.)
-                const reqFiles = await discoverSourceFiles(targetPath, {
-                    includeTests: false,
-                    languages: [],
-                });
-                // Scan for requirement-like files
-                const reqPatterns = ['.md', '.feature', '.gherkin', '.txt', '.rst'];
-                const requirementFiles = [];
-                for (const f of reqFiles) {
-                    if (reqPatterns.some(ext => f.endsWith(ext))) {
-                        requirementFiles.push(f);
-                    }
-                }
-                return ok({
-                    requirementsAnalyzed: requirementFiles.length,
-                    testable: 0,
-                    ambiguous: 0,
-                    untestable: 0,
-                    coverage: 0,
-                    bddScenarios: [],
-                    warning: requirementFiles.length === 0
-                        ? 'No requirement files (.md, .feature, .gherkin) found. Provide requirementsPath or add requirement docs.'
-                        : 'Requirements validation requires LLM analysis. File inventory returned — use task_orchestrate for deep analysis.',
-                    files: requirementFiles.map(f => f.startsWith(targetPath) ? f.slice(targetPath.length + 1) : f).slice(0, 20),
-                });
-            }
-            catch (error) {
-                return err(toError(error));
-            }
-        });
-        // Register contract validation handler
-        this.taskHandlers.set('validate-contracts', async (task) => {
-            const payload = task.payload;
-            try {
-                if (!payload.contractPath) {
-                    return ok({
-                        contractPath: '',
-                        valid: false,
-                        breakingChanges: [],
-                        warnings: [],
-                        coverage: 0,
-                        error: 'contractPath is required. Provide a path to an OpenAPI spec, JSON Schema, or Protocol Buffer file.',
-                    });
-                }
-                // Check if the contract file exists
-                try {
-                    const content = await fs.readFile(payload.contractPath, 'utf-8');
-                    const isJson = payload.contractPath.endsWith('.json');
-                    const isYaml = payload.contractPath.endsWith('.yaml') || payload.contractPath.endsWith('.yml');
-                    // Basic structural validation
-                    if (isJson) {
-                        JSON.parse(content); // throws if invalid
-                    }
-                    return ok({
-                        contractPath: payload.contractPath,
-                        valid: true,
-                        format: isJson ? 'json' : isYaml ? 'yaml' : 'unknown',
-                        breakingChanges: [],
-                        warnings: [],
-                        linesAnalyzed: content.split('\n').length,
-                        note: 'Structural validation passed. For semantic contract testing, use consumer-driven contract tests.',
-                    });
-                }
-                catch (readErr) {
-                    return ok({
-                        contractPath: payload.contractPath,
-                        valid: false,
-                        breakingChanges: [],
-                        warnings: [],
-                        error: `Could not read or parse contract file: ${toErrorMessage(readErr)}`,
-                    });
-                }
-            }
-            catch (error) {
-                return err(toError(error));
-            }
-        });
-        // Register accessibility test handler
-        this.taskHandlers.set('test-accessibility', async (task) => {
-            const payload = task.payload;
-            // Accessibility testing requires a browser/DOM — return honest guidance
-            return ok({
-                url: payload.url || '',
-                standard: payload.standard || 'wcag21-aa',
-                passed: false,
-                violations: [],
-                warnings: [],
-                score: 0,
-                note: 'Accessibility testing requires a browser environment (Puppeteer/Playwright). ' +
-                    'Use tools like axe-core, pa11y, or Lighthouse CLI for WCAG compliance testing. ' +
-                    'Example: npx pa11y ' + (payload.url || '<url>'),
-            });
-        });
-        // Register chaos test handler
-        this.taskHandlers.set('run-chaos', async (task) => {
-            const payload = task.payload;
-            // Chaos testing requires infrastructure access — return honest guidance
-            return ok({
-                faultType: payload.faultType || 'unknown',
-                target: payload.target || 'unknown',
-                dryRun: payload.dryRun ?? true,
-                duration: payload.duration || 0,
-                systemBehavior: 'not-executed',
-                resilience: null,
-                note: 'Chaos engineering requires infrastructure-level fault injection. ' +
-                    'Use tools like Chaos Monkey, Litmus, or toxiproxy for real resilience testing. ' +
-                    'For Node.js apps, consider: nock (HTTP faults), testcontainers (dependency failures).',
-            });
-        });
-        // Register learning optimization handler
-        this.taskHandlers.set('optimize-learning', async (_task) => {
-            // Check actual pattern store state
-            try {
-                const memUsage = await import('../kernel/unified-memory-hnsw.js');
-                return ok({
-                    patternsLearned: 0,
-                    modelsUpdated: 0,
-                    memoryConsolidated: false,
-                    note: 'Learning optimization runs during the dream cycle (SessionEnd hook). ' +
-                        'Use "npx agentic-qe hooks session-end --save-state" to trigger pattern consolidation.',
-                });
-            }
-            catch {
-                return ok({
-                    patternsLearned: 0,
-                    modelsUpdated: 0,
-                    memoryConsolidated: false,
-                    note: 'Learning system not initialized. Run "aqe init --auto" first.',
-                });
-            }
-        });
-    }
-    // ============================================================================
-    // ADR-051: Agent Booster Execution (Tier 0)
-    // ============================================================================
     /**
      * Execute task using Agent Booster for mechanical transforms
      * Falls back to normal execution if transform not applicable or low confidence
@@ -1669,7 +355,7 @@ export class DomainTaskExecutor {
             // Execute with timeout
             const result = await Promise.race([
                 handler(task),
-                this.timeout(task.timeout || this.config.timeout),
+                this.timeout(task.timeout || this._config.timeout),
             ]);
             if (!result.success) {
                 const errorMsg = 'error' in result ? result.error.message : 'Unknown error';
@@ -1689,11 +375,11 @@ export class DomainTaskExecutor {
             this.recordOutcome(task, routingTier, true, Date.now() - startTime).catch(() => { });
             // Save results to files if enabled
             let savedFiles;
-            if (this.config.saveResults) {
+            if (this._config.saveResults) {
                 try {
                     const saveOptions = {
-                        language: payload?.language || this.config.defaultLanguage,
-                        framework: payload?.framework || this.config.defaultFramework,
+                        language: payload?.language || this._config.defaultLanguage,
+                        framework: payload?.framework || this._config.defaultFramework,
                         includeSecondary: true,
                     };
                     const saved = await this.resultSaver.save(task.id, task.type, result.value, saveOptions);