agentic-qe 3.6.7 → 3.6.9

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

@@ -14,27 +14,41 @@ 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 { createResultSaver } from './result-saver';
 // ADR-051: Agent Booster integration for Tier 0 tasks
 import { createAgentBoosterAdapter, } from '../integrations/agentic-flow/agent-booster';
 // ADR-051: Task Router for outcome recording
 import { getTaskRouter } from '../mcp/services/task-router';
-// Import real domain services
-import { CoverageAnalyzerService } from '../domains/coverage-analysis';
-import { SecurityScannerService } from '../domains/security-compliance';
-import { createTestGeneratorService } from '../domains/test-generation';
-import { KnowledgeGraphService } from '../domains/code-intelligence';
-import { QualityAnalyzerService } from '../domains/quality-assessment';
-// Service cache to avoid re-instantiation
-let coverageAnalyzer = null;
-let securityScanner = null;
-let testGenerator = null;
-let knowledgeGraph = null;
-let qualityAnalyzer = null;
-// ADR-051: Lazy-initialized Agent Booster and Task Router
-let agentBooster = null;
-let taskRouter = null;
+// CQ-005: Use DomainServiceRegistry instead of dynamic imports from domains/
+import { DomainServiceRegistry, ServiceKeys } from '../shared/domain-service-registry';
+// ============================================================================
+// CQ-005: Domain Service Resolution via Registry (no coordination -> domains imports)
+// Domain modules register their factories in their index.ts files.
+// Coordination resolves them from the shared registry at runtime.
+// ============================================================================
+function resolveCoverageAnalyzerService(memory) {
+    const factory = DomainServiceRegistry.resolve(ServiceKeys.CoverageAnalyzerService);
+    return factory(memory);
+}
+function resolveSecurityScannerService(memory) {
+    const factory = DomainServiceRegistry.resolve(ServiceKeys.SecurityScannerService);
+    return factory(memory);
+}
+function resolveTestGeneratorService(memory) {
+    const factory = DomainServiceRegistry.resolve(ServiceKeys.createTestGeneratorService);
+    return factory(memory);
+}
+function resolveKnowledgeGraphService(memory) {
+    const factory = DomainServiceRegistry.resolve(ServiceKeys.KnowledgeGraphService);
+    return factory(memory);
+}
+function resolveQualityAnalyzerService(memory) {
+    const factory = DomainServiceRegistry.resolve(ServiceKeys.QualityAnalyzerService);
+    return factory(memory);
+}
 // ============================================================================
 // ADR-051: Model Routing Support
 // ============================================================================
@@ -52,34 +66,6 @@ function getModelForTier(tier) {
         default: return 'claude-sonnet-4-20250514';
     }
 }
-/**
- * Get or create Agent Booster adapter
- */
-async function getAgentBooster() {
-    if (!agentBooster) {
-        agentBooster = await createAgentBoosterAdapter({
-            enabled: true,
-            fallbackToLLM: true,
-            confidenceThreshold: 0.7,
-        });
-    }
-    return agentBooster;
-}
-/**
- * Get or create Task Router for outcome recording
- */
-async function getTaskRouterInstance() {
-    if (!taskRouter) {
-        try {
-            taskRouter = await getTaskRouter();
-        }
-        catch {
-            // Task router not available - outcome recording will be skipped
-            return null;
-        }
-    }
-    return taskRouter;
-}
 /**
  * Map task type and code context to transform type for Agent Booster
  * Returns null if no applicable transform is detected
@@ -109,499 +95,6 @@ function detectTransformType(task) {
     // add-types is harder to detect without type analysis
     return null;
 }
-// Helper to get or create services
-function getCoverageAnalyzer(memory) {
-    if (!coverageAnalyzer) {
-        coverageAnalyzer = new CoverageAnalyzerService(memory);
-    }
-    return coverageAnalyzer;
-}
-function getSecurityScanner(memory) {
-    if (!securityScanner) {
-        securityScanner = new SecurityScannerService(memory);
-    }
-    return securityScanner;
-}
-function getTestGenerator(memory) {
-    if (!testGenerator) {
-        testGenerator = createTestGeneratorService(memory);
-    }
-    return testGenerator;
-}
-function getKnowledgeGraph(memory) {
-    if (!knowledgeGraph) {
-        knowledgeGraph = new KnowledgeGraphService(memory);
-    }
-    return knowledgeGraph;
-}
-function getQualityAnalyzer(memory) {
-    if (!qualityAnalyzer) {
-        qualityAnalyzer = new QualityAnalyzerService(memory);
-    }
-    return qualityAnalyzer;
-}
-// ============================================================================
-// Task Handler Registry
-// ============================================================================
-const taskHandlers = new Map();
-// Register test generation handler - REAL IMPLEMENTATION
-taskHandlers.set('generate-tests', async (task, kernel) => {
-    const payload = task.payload;
-    try {
-        const generator = getTestGenerator(kernel.memory);
-        // 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
-            const tempPath = `/tmp/aqe-temp-${uuidv4()}.ts`;
-            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,
-            })),
-            patternsUsed: generatedTests.patternsUsed,
-        });
-    }
-    catch (error) {
-        return err(error instanceof Error ? error : new Error(String(error)));
-    }
-});
-// Register coverage analysis handler - REAL IMPLEMENTATION
-taskHandlers.set('analyze-coverage', async (task, kernel) => {
-    const payload = task.payload;
-    try {
-        const analyzer = getCoverageAnalyzer(kernel.memory);
-        const targetPath = payload.target || process.cwd();
-        const threshold = payload.threshold || 80;
-        // Try to find and read actual coverage files
-        const coverageData = await loadCoverageData(targetPath);
-        if (!coverageData) {
-            // No coverage data found - return informative error with fallback metrics
-            return ok({
-                lineCoverage: 0,
-                branchCoverage: 0,
-                functionCoverage: 0,
-                statementCoverage: 0,
-                totalFiles: 0,
-                gaps: [],
-                algorithm: 'sublinear-O(log n)',
-                warning: 'No coverage data found. Run tests with coverage first: 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,
-            gaps,
-            meetsThreshold: report.meetsThreshold,
-            delta: report.delta,
-            recommendations: report.recommendations,
-            algorithm: 'sublinear-O(log n)',
-        });
-    }
-    catch (error) {
-        return err(error instanceof Error ? error : new Error(String(error)));
-    }
-});
-// Register security scan handler - REAL IMPLEMENTATION
-taskHandlers.set('scan-security', async (task, kernel) => {
-    const payload = task.payload;
-    try {
-        const scanner = getSecurityScanner(kernel.memory);
-        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 TypeScript/JavaScript files found in ${targetPath}`,
-            });
-        }
-        // Convert string paths to FilePath value objects
-        const filePathObjects = filesToScan.map(filePath => FilePath.create(filePath));
-        // Run SAST scan if requested
-        let sastResult = null;
-        if (payload.sast !== false) {
-            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 - create mutable copy
-        const summary = {
-            critical: (sastResult?.summary?.critical || 0) + (dastResult?.summary?.critical || 0),
-            high: (sastResult?.summary?.high || 0) + (dastResult?.summary?.high || 0),
-            medium: (sastResult?.summary?.medium || 0) + (dastResult?.summary?.medium || 0),
-            low: (sastResult?.summary?.low || 0) + (dastResult?.summary?.low || 0),
-            informational: (sastResult?.summary?.informational || 0) + (dastResult?.summary?.informational || 0),
-        };
-        // Extract top vulnerabilities
-        const allVulns = [
-            ...(sastResult?.vulnerabilities || []),
-            ...(dastResult?.vulnerabilities || []),
-        ];
-        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,
-            coverage: sastResult?.coverage,
-        });
-    }
-    catch (error) {
-        return err(error instanceof Error ? error : new Error(String(error)));
-    }
-});
-// Register code indexing handler - REAL IMPLEMENTATION
-taskHandlers.set('index-code', async (task, kernel) => {
-    const payload = task.payload;
-    try {
-        const kg = getKnowledgeGraph(kernel.memory);
-        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 || ['typescript', 'javascript'],
-                duration: Date.now() - startTime,
-                warning: `No source files found in ${targetPath}`,
-            });
-        }
-        // 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();
-        for (const file of filesToIndex) {
-            const ext = path.extname(file).slice(1);
-            if (['ts', 'tsx'].includes(ext))
-                detectedLanguages.add('typescript');
-            if (['js', 'jsx', 'mjs', 'cjs'].includes(ext))
-                detectedLanguages.add('javascript');
-            if (ext === 'py')
-                detectedLanguages.add('python');
-        }
-        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(error instanceof Error ? error : new Error(String(error)));
-    }
-});
-// Register quality assessment handler - REAL IMPLEMENTATION
-taskHandlers.set('assess-quality', async (task, kernel) => {
-    const payload = task.payload;
-    try {
-        const analyzer = getQualityAnalyzer(kernel.memory);
-        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(error instanceof Error ? error : new Error(String(error)));
-    }
-});
-// Register test execution handler
-taskHandlers.set('execute-tests', async (task, _kernel) => {
-    const payload = task.payload;
-    // In production, would actually run tests via test runner
-    const testCount = payload.testFiles?.length || 10;
-    const passed = Math.floor(testCount * 0.9);
-    const failed = testCount - passed;
-    return ok({
-        total: testCount,
-        passed,
-        failed,
-        skipped: 0,
-        duration: testCount * 50, // ~50ms per test
-        coverage: 82.5,
-        failedTests: failed > 0 ? ['example.test.ts:42'] : [],
-    });
-});
-// Register defect prediction handler
-taskHandlers.set('predict-defects', async (task, _kernel) => {
-    const payload = task.payload;
-    return ok({
-        predictedDefects: [
-            {
-                file: `${payload.target}/complex-module.ts`,
-                probability: 0.78,
-                reason: 'High cyclomatic complexity combined with low test coverage',
-            },
-            {
-                file: `${payload.target}/legacy-handler.ts`,
-                probability: 0.65,
-                reason: 'Frequent changes in recent commits with error-prone patterns',
-            },
-        ],
-        riskScore: 42,
-        recommendations: [
-            'Add integration tests for complex-module.ts',
-            'Refactor legacy-handler.ts to reduce complexity',
-        ],
-    });
-});
-// Register requirements validation handler
-taskHandlers.set('validate-requirements', async (task, _kernel) => {
-    const payload = task.payload;
-    return ok({
-        requirementsAnalyzed: 15,
-        testable: 12,
-        ambiguous: 2,
-        untestable: 1,
-        coverage: 80,
-        bddScenarios: payload.generateBDD ? [
-            'Given a user is logged in, When they view the dashboard, Then they see their metrics',
-            'Given an API request fails, When the retry limit is exceeded, Then an error is returned',
-        ] : [],
-    });
-});
-// Register contract validation handler
-taskHandlers.set('validate-contracts', async (task, _kernel) => {
-    const payload = task.payload;
-    return ok({
-        contractPath: payload.contractPath,
-        valid: true,
-        breakingChanges: [],
-        warnings: [
-            'Deprecated field "legacyId" should be removed in next major version',
-        ],
-        coverage: 95,
-    });
-});
-// Register accessibility test handler
-taskHandlers.set('test-accessibility', async (task, _kernel) => {
-    const payload = task.payload;
-    return ok({
-        url: payload.url,
-        standard: payload.standard || 'wcag21-aa',
-        passed: true,
-        violations: [],
-        warnings: [
-            { rule: 'color-contrast', impact: 'minor', element: 'nav > a' },
-        ],
-        score: 94,
-    });
-});
-// Register chaos test handler
-taskHandlers.set('run-chaos', async (task, _kernel) => {
-    const payload = task.payload;
-    return ok({
-        faultType: payload.faultType,
-        target: payload.target,
-        dryRun: payload.dryRun,
-        duration: payload.duration,
-        systemBehavior: payload.dryRun ? 'simulated' : 'tested',
-        resilience: {
-            recovered: true,
-            recoveryTime: 2500,
-            dataLoss: false,
-        },
-    });
-});
-// Register learning optimization handler
-taskHandlers.set('optimize-learning', async (task, _kernel) => {
-    return ok({
-        patternsLearned: 12,
-        modelsUpdated: 3,
-        memoryConsolidated: true,
-        recommendations: [
-            'Pattern recognition improved for error handling',
-            'Test generation templates optimized',
-        ],
-    });
-});
 // ============================================================================
 // Helper Functions for Real Implementations
 // ============================================================================
@@ -636,7 +129,7 @@ async function loadCoverageData(targetPath) {
  * Parse Istanbul/nyc coverage-final.json format
  */
 function parseCoverageJson(content) {
-    const data = JSON.parse(content);
+    const data = safeJsonParse(content);
     const files = [];
     let totalLines = 0, coveredLines = 0;
     let totalBranches = 0, coveredBranches = 0;
@@ -910,6 +403,19 @@ export class DomainTaskExecutor {
     eventBus;
     config;
     resultSaver;
+    // Instance-level service caches to prevent cross-contamination between executor instances
+    coverageAnalyzer = null;
+    securityScanner = null;
+    testGenerator = null;
+    knowledgeGraph = null;
+    qualityAnalyzer = null;
+    // ADR-051: Lazy-initialized Agent Booster and Task Router (instance-level)
+    agentBooster = null;
+    taskRouter = null;
+    // ADR-023: Quality Feedback Loop for routing outcome recording
+    qualityFeedbackLoop = null;
+    // Instance-level task handler registry
+    taskHandlers = new Map();
     constructor(kernel, eventBus, config) {
         this.kernel = kernel;
         this.eventBus = eventBus;
@@ -923,6 +429,535 @@ export class DomainTaskExecutor {
             defaultFramework: config?.defaultFramework ?? 'vitest',
         };
         this.resultSaver = createResultSaver(this.config.resultsDir);
+        this.registerHandlers();
+    }
+    /** Connect QualityFeedbackLoop for routing outcome recording */
+    setQualityFeedbackLoop(loop) {
+        this.qualityFeedbackLoop = loop;
+    }
+    // ============================================================================
+    // Instance-level service getters (lazy initialization)
+    // ============================================================================
+    getCoverageAnalyzer() {
+        if (!this.coverageAnalyzer) {
+            this.coverageAnalyzer = resolveCoverageAnalyzerService(this.kernel.memory);
+        }
+        return this.coverageAnalyzer;
+    }
+    getSecurityScanner() {
+        if (!this.securityScanner) {
+            this.securityScanner = resolveSecurityScannerService(this.kernel.memory);
+        }
+        return this.securityScanner;
+    }
+    getTestGenerator() {
+        if (!this.testGenerator) {
+            this.testGenerator = resolveTestGeneratorService(this.kernel.memory);
+        }
+        return this.testGenerator;
+    }
+    getKnowledgeGraph() {
+        if (!this.knowledgeGraph) {
+            this.knowledgeGraph = resolveKnowledgeGraphService(this.kernel.memory);
+        }
+        return this.knowledgeGraph;
+    }
+    getQualityAnalyzer() {
+        if (!this.qualityAnalyzer) {
+            this.qualityAnalyzer = resolveQualityAnalyzerService(this.kernel.memory);
+        }
+        return this.qualityAnalyzer;
+    }
+    /**
+     * Get or create Agent Booster adapter (instance-level)
+     */
+    async getAgentBooster() {
+        if (!this.agentBooster) {
+            this.agentBooster = await createAgentBoosterAdapter({
+                enabled: true,
+                fallbackToLLM: true,
+                confidenceThreshold: 0.7,
+            });
+        }
+        return this.agentBooster;
+    }
+    /**
+     * Get or create Task Router for outcome recording (instance-level)
+     */
+    async getTaskRouterInstance() {
+        if (!this.taskRouter) {
+            try {
+                this.taskRouter = await getTaskRouter();
+            }
+            catch {
+                // Task router not available - outcome recording will be skipped
+                return null;
+            }
+        }
+        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
+                    const tempPath = `/tmp/aqe-temp-${uuidv4()}.ts`;
+                    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,
+                    })),
+                    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
+                const coverageData = await loadCoverageData(targetPath);
+                if (!coverageData) {
+                    // No coverage data found - return informative error with fallback metrics
+                    return ok({
+                        lineCoverage: 0,
+                        branchCoverage: 0,
+                        functionCoverage: 0,
+                        statementCoverage: 0,
+                        totalFiles: 0,
+                        gaps: [],
+                        algorithm: 'sublinear-O(log n)',
+                        warning: 'No coverage data found. Run tests with coverage first: 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,
+                    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 TypeScript/JavaScript files found in ${targetPath}`,
+                    });
+                }
+                // Convert string paths to FilePath value objects
+                const filePathObjects = filesToScan.map(filePath => FilePath.create(filePath));
+                // Run SAST scan if requested
+                let sastResult = null;
+                if (payload.sast !== false) {
+                    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 - create mutable copy
+                const summary = {
+                    critical: (sastResult?.summary?.critical || 0) + (dastResult?.summary?.critical || 0),
+                    high: (sastResult?.summary?.high || 0) + (dastResult?.summary?.high || 0),
+                    medium: (sastResult?.summary?.medium || 0) + (dastResult?.summary?.medium || 0),
+                    low: (sastResult?.summary?.low || 0) + (dastResult?.summary?.low || 0),
+                    informational: (sastResult?.summary?.informational || 0) + (dastResult?.summary?.informational || 0),
+                };
+                // Extract top vulnerabilities
+                const allVulns = [
+                    ...(sastResult?.vulnerabilities || []),
+                    ...(dastResult?.vulnerabilities || []),
+                ];
+                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,
+                    coverage: sastResult?.coverage,
+                });
+            }
+            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 || ['typescript', 'javascript'],
+                        duration: Date.now() - startTime,
+                        warning: `No source files found in ${targetPath}`,
+                    });
+                }
+                // 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();
+                for (const file of filesToIndex) {
+                    const ext = path.extname(file).slice(1);
+                    if (['ts', 'tsx'].includes(ext))
+                        detectedLanguages.add('typescript');
+                    if (['js', 'jsx', 'mjs', 'cjs'].includes(ext))
+                        detectedLanguages.add('javascript');
+                    if (ext === 'py')
+                        detectedLanguages.add('python');
+                }
+                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
+        this.taskHandlers.set('execute-tests', async (task) => {
+            const payload = task.payload;
+            // In production, would actually run tests via test runner
+            const testCount = payload.testFiles?.length || 10;
+            const passed = Math.floor(testCount * 0.9);
+            const failed = testCount - passed;
+            return ok({
+                total: testCount,
+                passed,
+                failed,
+                skipped: 0,
+                duration: testCount * 50, // ~50ms per test
+                coverage: 82.5,
+                failedTests: failed > 0 ? ['example.test.ts:42'] : [],
+            });
+        });
+        // Register defect prediction handler
+        this.taskHandlers.set('predict-defects', async (task) => {
+            const payload = task.payload;
+            return ok({
+                predictedDefects: [
+                    {
+                        file: `${payload.target}/complex-module.ts`,
+                        probability: 0.78,
+                        reason: 'High cyclomatic complexity combined with low test coverage',
+                    },
+                    {
+                        file: `${payload.target}/legacy-handler.ts`,
+                        probability: 0.65,
+                        reason: 'Frequent changes in recent commits with error-prone patterns',
+                    },
+                ],
+                riskScore: 42,
+                recommendations: [
+                    'Add integration tests for complex-module.ts',
+                    'Refactor legacy-handler.ts to reduce complexity',
+                ],
+            });
+        });
+        // Register requirements validation handler
+        this.taskHandlers.set('validate-requirements', async (task) => {
+            const payload = task.payload;
+            return ok({
+                requirementsAnalyzed: 15,
+                testable: 12,
+                ambiguous: 2,
+                untestable: 1,
+                coverage: 80,
+                bddScenarios: payload.generateBDD ? [
+                    'Given a user is logged in, When they view the dashboard, Then they see their metrics',
+                    'Given an API request fails, When the retry limit is exceeded, Then an error is returned',
+                ] : [],
+            });
+        });
+        // Register contract validation handler
+        this.taskHandlers.set('validate-contracts', async (task) => {
+            const payload = task.payload;
+            return ok({
+                contractPath: payload.contractPath,
+                valid: true,
+                breakingChanges: [],
+                warnings: [
+                    'Deprecated field "legacyId" should be removed in next major version',
+                ],
+                coverage: 95,
+            });
+        });
+        // Register accessibility test handler
+        this.taskHandlers.set('test-accessibility', async (task) => {
+            const payload = task.payload;
+            return ok({
+                url: payload.url,
+                standard: payload.standard || 'wcag21-aa',
+                passed: true,
+                violations: [],
+                warnings: [
+                    { rule: 'color-contrast', impact: 'minor', element: 'nav > a' },
+                ],
+                score: 94,
+            });
+        });
+        // Register chaos test handler
+        this.taskHandlers.set('run-chaos', async (task) => {
+            const payload = task.payload;
+            return ok({
+                faultType: payload.faultType,
+                target: payload.target,
+                dryRun: payload.dryRun,
+                duration: payload.duration,
+                systemBehavior: payload.dryRun ? 'simulated' : 'tested',
+                resilience: {
+                    recovered: true,
+                    recoveryTime: 2500,
+                    dataLoss: false,
+                },
+            });
+        });
+        // Register learning optimization handler
+        this.taskHandlers.set('optimize-learning', async (_task) => {
+            return ok({
+                patternsLearned: 12,
+                modelsUpdated: 3,
+                memoryConsolidated: true,
+                recommendations: [
+                    'Pattern recognition improved for error handling',
+                    'Test generation templates optimized',
+                ],
+            });
+        });
     }
     // ============================================================================
     // ADR-051: Agent Booster Execution (Tier 0)
@@ -939,7 +974,7 @@ export class DomainTaskExecutor {
             return null;
         }
         try {
-            const booster = await getAgentBooster();
+            const booster = await this.getAgentBooster();
             const codeContext = task.payload?.codeContext ||
                 task.payload?.sourceCode || '';
             const result = await booster.transform(codeContext, transformType);
@@ -982,14 +1017,28 @@ export class DomainTaskExecutor {
      */
     async recordOutcome(task, tier, success, durationMs) {
         try {
-            const router = await getTaskRouterInstance();
+            const router = await this.getTaskRouterInstance();
             if (!router)
                 return;
             // Log outcome for debugging and metrics
             console.debug(`[TaskExecutor] Outcome recorded: task=${task.id}, tier=${tier}, ` +
                 `model=${getModelForTier(tier)}, success=${success}, duration=${durationMs}ms`);
-            // Note: In a future enhancement, we could call router.recordOutcome()
-            // to feed back to the TinyDancer learning system
+            // ADR-023: Record routing outcome for learning feedback loop
+            if (this.qualityFeedbackLoop) {
+                const targetDomains = task.targetDomains || [];
+                await this.qualityFeedbackLoop.recordRoutingOutcome({
+                    taskId: task.id,
+                    taskDescription: task.type,
+                    recommendedAgent: String(tier),
+                    usedAgent: String(tier),
+                    followedRecommendation: true,
+                    success,
+                    qualityScore: success ? 0.8 : 0.2,
+                    durationMs,
+                    timestamp: new Date(),
+                    error: success ? undefined : 'Task execution failed',
+                });
+            }
         }
         catch (error) {
             // Don't fail task execution if metrics recording fails
@@ -1023,7 +1072,7 @@ export class DomainTaskExecutor {
                 // Fall through to normal execution with Tier 1 (Haiku) as fallback
                 console.debug(`[TaskExecutor] Agent Booster fallback to Tier 1 for task ${task.id}`);
             }
-            const handler = taskHandlers.get(task.type);
+            const handler = this.taskHandlers.get(task.type);
             if (!handler) {
                 const result = {
                     taskId: task.id,
@@ -1037,7 +1086,7 @@ export class DomainTaskExecutor {
             }
             // Execute with timeout
             const result = await Promise.race([
-                handler(task, this.kernel),
+                handler(task),
                 this.timeout(task.timeout || this.config.timeout),
             ]);
             if (!result.success) {
@@ -1091,7 +1140,7 @@ export class DomainTaskExecutor {
             };
         }
         catch (error) {
-            const errorMessage = error instanceof Error ? error.message : String(error);
+            const errorMessage = toErrorMessage(error);
             await this.publishTaskFailed(task.id, errorMessage, domain);
             // ADR-051: Record failed outcome
             this.recordOutcome(task, routingTier, false, Date.now() - startTime).catch(() => { });
@@ -1104,6 +1153,42 @@ export class DomainTaskExecutor {
             };
         }
     }
+    /**
+     * Reset cached services - call when disposing fleet/kernel
+     * to ensure services don't hold references to disposed memory backends.
+     * Instance method replaces the former module-level resetServiceCaches().
+     */
+    async resetServiceCaches() {
+        this.coverageAnalyzer = null;
+        this.securityScanner = null;
+        this.testGenerator = null;
+        this.knowledgeGraph = null;
+        this.qualityAnalyzer = null;
+        // ADR-051: Also reset Agent Booster and Task Router
+        if (this.agentBooster) {
+            try {
+                await this.agentBooster.dispose();
+            }
+            catch (error) {
+                // Non-critical: disposal errors don't affect subsequent operations
+                console.debug('[TaskExecutor] Agent Booster disposal error:', error instanceof Error ? error.message : error);
+            }
+            this.agentBooster = null;
+        }
+        this.taskRouter = null;
+    }
+    /**
+     * Sync version for backwards compatibility
+     */
+    resetServiceCachesSync() {
+        this.coverageAnalyzer = null;
+        this.securityScanner = null;
+        this.testGenerator = null;
+        this.knowledgeGraph = null;
+        this.qualityAnalyzer = null;
+        this.agentBooster = null;
+        this.taskRouter = null;
+    }
     getTaskDomain(taskType) {
         const domainMap = {
             'generate-tests': 'test-generation',
@@ -1155,38 +1240,26 @@ export function createTaskExecutor(kernel, config) {
     return new DomainTaskExecutor(kernel, kernel.eventBus, config);
 }
 /**
- * Reset cached services - call when disposing fleet/kernel
- * to ensure services don't hold references to disposed memory backends
+ * Reset cached services on a specific executor instance.
+ * This is the module-level wrapper for backwards compatibility with
+ * callers that import resetServiceCaches() directly.
+ * It requires the caller to also call resetTaskExecutor() which nullifies
+ * the cached executor - so the next getTaskExecutor() creates a fresh instance
+ * with clean caches. This function is now a no-op since caches are instance-level.
+ *
+ * @deprecated Prefer calling executor.resetServiceCaches() on the instance directly.
  */
 export async function resetServiceCaches() {
-    coverageAnalyzer = null;
-    securityScanner = null;
-    testGenerator = null;
-    knowledgeGraph = null;
-    qualityAnalyzer = null;
-    // ADR-051: Also reset Agent Booster and Task Router
-    if (agentBooster) {
-        try {
-            await agentBooster.dispose();
-        }
-        catch (error) {
-            // Non-critical: disposal errors don't affect subsequent operations
-            console.debug('[TaskExecutor] Agent Booster disposal error:', error instanceof Error ? error.message : error);
-        }
-        agentBooster = null;
-    }
-    taskRouter = null;
+    // No-op: service caches are now instance-level properties.
+    // When the cached executor is nullified by resetTaskExecutor(),
+    // the old instance (and its caches) become eligible for GC.
+    // The next executor instance starts with fresh null caches.
 }
 /**
  * Sync version for backwards compatibility
+ * @deprecated Prefer calling executor.resetServiceCachesSync() on the instance directly.
  */
 export function resetServiceCachesSync() {
-    coverageAnalyzer = null;
-    securityScanner = null;
-    testGenerator = null;
-    knowledgeGraph = null;
-    qualityAnalyzer = null;
-    agentBooster = null;
-    taskRouter = null;
+    // No-op: service caches are now instance-level properties.
 }
 //# sourceMappingURL=task-executor.js.map