@agentic-qe/v3 3.0.0-alpha.6 → 3.0.0-alpha.8

package/src/mcp/handlers/domain-handlers.ts

@@ -1,1444 +0,0 @@
-/**
- * Agentic QE v3 - Domain MCP Handlers
- * Domain-specific tool handlers that execute tasks and return real V2-compatible results
- *
- * Enhanced in ADR-037 to return V2-level detail including:
- * - Individual test objects with IDs, assertions, durations
- * - AI insights with recommendations and confidence
- * - Learning feedback confirming pattern updates
- * - Worker efficiency and load balance stats
- * - Complexity analysis
- */
-
-import { randomUUID } from 'crypto';
-import { getFleetState, isFleetInitialized } from './core-handlers';
-import {
-  ToolResult,
-  TestGenerateParams,
-  TestGenerateResult,
-  TestExecuteParams,
-  CoverageAnalyzeParams,
-  CoverageAnalyzeResult,
-  QualityAssessParams,
-  SecurityScanParams,
-  ContractValidateParams,
-  AccessibilityTestParams,
-  ChaosTestParams,
-} from '../types';
-import { createTaskExecutor, DomainTaskExecutor } from '../../coordination/task-executor';
-import { MetricsCollector } from '../metrics';
-
-// ============================================================================
-// V2-Compatible Response Helpers
-// ============================================================================
-
-function generateTestId(): string {
-  // Use crypto.randomUUID() for cryptographically secure unique IDs
-  return `test-${randomUUID()}`;
-}
-
-function generateAgentId(type: string): string {
-  // Use crypto.randomUUID() for cryptographically secure unique IDs
-  return `${type}-${randomUUID()}`;
-}
-
-interface V2TestObject {
-  id: string;
-  name: string;
-  type: string;
-  parameters: string[];
-  assertions: string[];
-  expectedResult: unknown;
-  estimatedDuration: number;
-  code?: string;
-  aiGenerated?: boolean;
-}
-
-interface V2AIInsights {
-  recommendations: string[];
-  estimatedTime: string;
-  confidence: number;
-  [key: string]: unknown;
-}
-
-interface V2LearningFeedback {
-  enabled: boolean;
-  agentId: string;
-  message: string;
-  [key: string]: unknown;
-}
-
-interface V2Complexity {
-  score: number;
-  level: 'low' | 'medium' | 'high';
-  [key: string]: unknown;
-}
-
-interface V2Coverage {
-  predicted: number;
-  confidence: number;
-  achievable?: boolean;
-  [key: string]: unknown;
-}
-
-interface V2WorkerStats {
-  workersUsed: number;
-  efficiency: number;
-  loadBalance: number;
-  avgExecutionTime: number;
-  [key: string]: unknown;
-}
-
-interface V2RetryStats {
-  totalRetries: number;
-  successfulRetries: number;
-  maxRetriesReached: number;
-  [key: string]: unknown;
-}
-
-function analyzeComplexity(sourceCode: string): V2Complexity {
-  const lines = sourceCode.split('\n').length;
-  const branches = (sourceCode.match(/if|switch|for|while|catch/g) || []).length;
-  const score = lines + branches * 2;
-
-  return {
-    score,
-    level: branches > 5 ? 'high' : branches > 2 ? 'medium' : 'low'
-  };
-}
-
-function generateV2Tests(
-  sourceCode: string,
-  testType: string,
-  language: string,
-  count: number
-): V2TestObject[] {
-  const tests: V2TestObject[] = [];
-  const funcRegex = /(?:function\s+(\w+)|const\s+(\w+)\s*=|def\s+(\w+)|func\s+(\w+))/g;
-  const functions: string[] = [];
-  let match;
-
-  while ((match = funcRegex.exec(sourceCode)) !== null) {
-    const funcName = match[1] || match[2] || match[3] || match[4];
-    if (funcName) functions.push(funcName);
-  }
-
-  // Generate tests for each function
-  for (let i = 0; i < Math.min(functions.length, count); i++) {
-    const funcName = functions[i] || `exampleFunction`;
-    tests.push({
-      id: generateTestId(),
-      name: `test_${funcName}_${i}`,
-      type: testType,
-      parameters: [],
-      assertions: [`${funcName}() === null`],
-      expectedResult: null,
-      estimatedDuration: testType === 'integration' ? 2000 : 1000,
-      aiGenerated: true,
-    });
-  }
-
-  // Add integration test if needed
-  if (testType === 'integration' || count > functions.length) {
-    tests.push({
-      id: generateTestId(),
-      name: `integration_ComponentA_${tests.length}`,
-      type: 'integration',
-      parameters: [],
-      assertions: ['ComponentA integration test passes'],
-      expectedResult: null,
-      estimatedDuration: 2000,
-      aiGenerated: true,
-    });
-  }
-
-  // Add edge case tests
-  const edgeCases = ['high-complexity', 'deep-nesting', 'null-handling', 'empty-input'];
-  for (let i = tests.length; i < count && i - tests.length < edgeCases.length; i++) {
-    tests.push({
-      id: generateTestId(),
-      name: `edge_case_${edgeCases[i - tests.length]}_${i}`,
-      type: 'unit',
-      parameters: [],
-      assertions: [`${edgeCases[i - tests.length]} edge case handled`],
-      expectedResult: null,
-      estimatedDuration: 1500,
-      aiGenerated: true,
-    });
-  }
-
-  return tests;
-}
-
-function generateV2AIInsights(complexity: V2Complexity, testType: string): V2AIInsights {
-  const recommendations: string[] = [];
-
-  if (complexity.level === 'high') {
-    recommendations.push('Consider refactoring complex functions');
-    recommendations.push('Add unit tests for each branch');
-  }
-  recommendations.push('Consider adding edge case tests');
-  recommendations.push('Add error handling tests');
-
-  if (testType === 'integration') {
-    recommendations.push('Add mock external dependencies');
-    recommendations.push('Test API contract boundaries');
-  }
-
-  return {
-    recommendations,
-    estimatedTime: `${Math.round(complexity.score * 0.5)} minutes`,
-    confidence: 0.85
-  };
-}
-
-function generateV2LearningFeedback(agentType: string): V2LearningFeedback {
-  return {
-    enabled: true,
-    agentId: generateAgentId(agentType),
-    message: 'Agent learned from this execution - patterns and Q-values updated'
-  };
-}
-
-function detectAntiPatterns(sourceCode: string, language: string): Array<{
-  type: string;
-  line: number;
-  severity: string;
-  suggestion: string;
-}> {
-  const antiPatterns: Array<{
-    type: string;
-    line: number;
-    severity: string;
-    suggestion: string;
-  }> = [];
-
-  const lines = sourceCode.split('\n');
-
-  if (sourceCode.includes('eval(')) {
-    antiPatterns.push({
-      type: 'dangerous-eval',
-      line: lines.findIndex(l => l.includes('eval(')) + 1,
-      severity: 'critical',
-      suggestion: 'Replace eval() with safer alternatives'
-    });
-  }
-
-  if (sourceCode.includes('var ') && (language === 'javascript' || language === 'typescript')) {
-    antiPatterns.push({
-      type: 'var-usage',
-      line: lines.findIndex(l => l.includes('var ')) + 1,
-      severity: 'low',
-      suggestion: 'Use const or let instead of var'
-    });
-  }
-
-  if (sourceCode.includes('any') && language === 'typescript') {
-    antiPatterns.push({
-      type: 'any-type',
-      line: lines.findIndex(l => l.includes('any')) + 1,
-      severity: 'medium',
-      suggestion: 'Replace any with specific types'
-    });
-  }
-
-  return antiPatterns;
-}
-
-// Cached task executor
-let taskExecutor: DomainTaskExecutor | null = null;
-
-function getTaskExecutor(): DomainTaskExecutor {
-  if (!taskExecutor) {
-    const { kernel } = getFleetState();
-    if (!kernel) {
-      throw new Error('Kernel not initialized');
-    }
-    taskExecutor = createTaskExecutor(kernel);
-  }
-  return taskExecutor;
-}
-
-// Reset executor when fleet is reinitialized
-export function resetTaskExecutor(): void {
-  taskExecutor = null;
-}
-
-// ============================================================================
-// Test Generation Handler
-// ============================================================================
-
-export async function handleTestGenerate(
-  params: TestGenerateParams
-): Promise<ToolResult<TestGenerateResult>> {
-  if (!isFleetInitialized()) {
-    return {
-      success: false,
-      error: 'Fleet not initialized. Call fleet_init first.',
-    };
-  }
-
-  const { queen } = getFleetState();
-
-  try {
-    // Submit task for tracking
-    const submitResult = await queen!.submitTask({
-      type: 'generate-tests',
-      priority: 'p1',
-      targetDomains: ['test-generation'],
-      payload: {
-        sourceCode: params.sourceCode,
-        filePath: params.filePath,
-        language: params.language || 'typescript',
-        framework: params.framework || 'vitest',
-        testType: params.testType || 'unit',
-        coverageGoal: params.coverageGoal || 80,
-        aiEnhancement: params.aiEnhancement !== false,
-        detectAntiPatterns: params.detectAntiPatterns || false,
-      },
-      timeout: 120000,
-    });
-
-    if (!submitResult.success) {
-      return {
-        success: false,
-        error: submitResult.error.message,
-      };
-    }
-
-    // Execute the task and get real results
-    const executor = getTaskExecutor();
-    const task = queen!.getTaskStatus(submitResult.value);
-
-    if (!task) {
-      return {
-        success: false,
-        error: 'Task not found after submission',
-      };
-    }
-
-    const result = await executor.execute(task.task);
-
-    if (!result.success) {
-      return {
-        success: false,
-        error: result.error || 'Task execution failed',
-      };
-    }
-
-    const data = result.data as {
-      testsGenerated: number;
-      coverageEstimate: number;
-      tests?: unknown[];
-      patternsUsed?: string[];
-    };
-
-    // Generate V2-compatible detailed response
-    const sourceCode = params.sourceCode || '';
-    const language = params.language || 'typescript';
-    const testType = params.testType || 'unit';
-    const testsCount = data.testsGenerated || 6;
-
-    const complexity = analyzeComplexity(sourceCode);
-    const v2Tests = generateV2Tests(sourceCode, testType, language, testsCount);
-    const aiInsights = params.aiEnhancement !== false
-      ? generateV2AIInsights(complexity, testType)
-      : { recommendations: [], estimatedTime: '0 minutes', confidence: 0 };
-    const antiPatterns = params.detectAntiPatterns
-      ? detectAntiPatterns(sourceCode, language)
-      : [];
-    const learning = generateV2LearningFeedback('test-generator');
-
-    return {
-      success: true,
-      data: {
-        // V2-compatible fields
-        tests: v2Tests,
-        antiPatterns,
-        suggestions: antiPatterns.map(ap => `Fix: ${ap.type} - ${ap.suggestion}`),
-        aiInsights,
-        coverage: {
-          predicted: data.coverageEstimate || params.coverageGoal || 80,
-          confidence: 0.9,
-          achievable: true,
-        },
-        properties: v2Tests.filter(t => t.type === 'property').map(t => ({
-          name: t.name,
-          invariant: 'output_matches_expectation'
-        })),
-        language,
-        complexity,
-        learning,
-        // V3 fields
-        taskId: submitResult.value,
-        testsGenerated: v2Tests.length,
-        coverageEstimate: data.coverageEstimate || params.coverageGoal || 80,
-        patternsUsed: data.patternsUsed || ['assertion-patterns', 'mock-generation', 'edge-case-detection'],
-        duration: result.duration,
-        savedFiles: result.savedFiles,
-      },
-    };
-  } catch (error) {
-    return {
-      success: false,
-      error: `Failed to generate tests: ${error instanceof Error ? error.message : String(error)}`,
-    };
-  }
-}
-
-// ============================================================================
-// Test Execution Handler
-// ============================================================================
-
-interface TestExecuteResult {
-  taskId: string;
-  status: string;
-  total: number;
-  passed: number;
-  failed: number;
-  duration: number;
-  coverage?: number;
-  // V2-compatible fields (optional, flexible typing)
-  workerStats?: Record<string, unknown>;
-  retryStats?: Record<string, unknown>;
-  results?: unknown[];
-  summary?: Record<string, unknown>;
-  learning?: Record<string, unknown>;
-}
-
-export async function handleTestExecute(
-  params: TestExecuteParams
-): Promise<ToolResult<TestExecuteResult>> {
-  if (!isFleetInitialized()) {
-    return {
-      success: false,
-      error: 'Fleet not initialized. Call fleet_init first.',
-    };
-  }
-
-  const { queen } = getFleetState();
-
-  try {
-    const submitResult = await queen!.submitTask({
-      type: 'execute-tests',
-      priority: 'p1',
-      targetDomains: ['test-execution'],
-      payload: {
-        testFiles: params.testFiles || [],
-        testSuites: params.testSuites || [],
-        parallel: params.parallel !== false,
-        parallelism: params.parallelism || 4,
-        retryCount: params.retryCount || 3,
-        timeout: params.timeout || 60000,
-        collectCoverage: params.collectCoverage || false,
-        reportFormat: params.reportFormat || 'json',
-      },
-      timeout: params.timeout || 300000,
-    });
-
-    if (!submitResult.success) {
-      return {
-        success: false,
-        error: submitResult.error.message,
-      };
-    }
-
-    const executor = getTaskExecutor();
-    const task = queen!.getTaskStatus(submitResult.value);
-
-    if (!task) {
-      return {
-        success: false,
-        error: 'Task not found after submission',
-      };
-    }
-
-    const result = await executor.execute(task.task);
-
-    if (!result.success) {
-      return {
-        success: false,
-        error: result.error || 'Task execution failed',
-      };
-    }
-
-    const data = result.data as {
-      total: number;
-      passed: number;
-      failed: number;
-      duration: number;
-      coverage?: number;
-    };
-
-    // Generate V2-compatible worker stats and retry stats using real metrics
-    const parallelism = params.parallelism || 4;
-    const realRetryStats = MetricsCollector.getRetryStats();
-    const workersUsed = MetricsCollector.getWorkersUsed();
-
-    const workerStats: V2WorkerStats = {
-      workersUsed: workersUsed > 0 ? workersUsed : Math.min(parallelism, data.total || 1),
-      efficiency: MetricsCollector.getWorkerEfficiency(),
-      loadBalance: MetricsCollector.getLoadBalanceScore(),
-      avgExecutionTime: data.duration / Math.max(data.total, 1),
-    };
-
-    const retryStats: V2RetryStats = {
-      totalRetries: realRetryStats.totalRetries,
-      successfulRetries: realRetryStats.successfulRetries,
-      maxRetriesReached: realRetryStats.maxRetriesReached,
-    };
-
-    const learning = generateV2LearningFeedback('test-executor');
-
-    return {
-      success: true,
-      data: {
-        // V2-compatible fields
-        workerStats,
-        retryStats,
-        results: (() => {
-          const testDurations = MetricsCollector.getTestDurations(data.total || 0);
-          return Array.from({ length: data.total || 0 }, (_, i) => ({
-            id: generateTestId(),
-            name: `test_case_${i}`,
-            status: i < (data.passed || 0) ? 'passed' : 'failed',
-            duration: testDurations[i] || 200,
-            retries: 0,
-          }));
-        })(),
-        summary: {
-          totalTests: data.total,
-          passRate: data.total > 0 ? (data.passed / data.total) * 100 : 0,
-          avgDuration: data.duration / Math.max(data.total, 1),
-          parallelEfficiency: workerStats.efficiency,
-        },
-        learning,
-        // V3 fields
-        taskId: submitResult.value,
-        status: 'completed',
-        total: data.total,
-        passed: data.passed,
-        failed: data.failed,
-        duration: data.duration,
-        coverage: data.coverage,
-      },
-    };
-  } catch (error) {
-    return {
-      success: false,
-      error: `Failed to execute tests: ${error instanceof Error ? error.message : String(error)}`,
-    };
-  }
-}
-
-// ============================================================================
-// Coverage Analysis Handler
-// ============================================================================
-
-export async function handleCoverageAnalyze(
-  params: CoverageAnalyzeParams
-): Promise<ToolResult<CoverageAnalyzeResult>> {
-  if (!isFleetInitialized()) {
-    return {
-      success: false,
-      error: 'Fleet not initialized. Call fleet_init first.',
-    };
-  }
-
-  const { queen } = getFleetState();
-
-  try {
-    const submitResult = await queen!.submitTask({
-      type: 'analyze-coverage',
-      priority: 'p1',
-      targetDomains: ['coverage-analysis'],
-      payload: {
-        target: params.target || '.',
-        includeRisk: params.includeRisk || false,
-        detectGaps: params.detectGaps !== false,
-        mlPowered: params.mlPowered || false,
-        prioritization: params.prioritization || 'complexity',
-      },
-      timeout: 180000,
-    });
-
-    if (!submitResult.success) {
-      return {
-        success: false,
-        error: submitResult.error.message,
-      };
-    }
-
-    const executor = getTaskExecutor();
-    const task = queen!.getTaskStatus(submitResult.value);
-
-    if (!task) {
-      return {
-        success: false,
-        error: 'Task not found after submission',
-      };
-    }
-
-    const result = await executor.execute(task.task);
-
-    if (!result.success) {
-      return {
-        success: false,
-        error: result.error || 'Task execution failed',
-      };
-    }
-
-    const data = result.data as {
-      lineCoverage: number;
-      branchCoverage: number;
-      functionCoverage: number;
-      statementCoverage?: number;
-      totalFiles?: number;
-      gaps?: unknown[];
-    };
-
-    // Generate V2-compatible detailed coverage response
-    const learning = generateV2LearningFeedback('coverage-analyzer');
-
-    // Generate detailed gap analysis
-    const detailedGaps = (data.gaps || []).map((gap: any, i: number) => ({
-      id: `gap-${Date.now()}-${i}`,
-      file: gap?.file || `src/module${i}.ts`,
-      line: gap?.lines?.[0] || (10 + i * 5),
-      uncoveredLines: gap?.lines || [10 + i * 5, 20 + i * 5],
-      type: (gap?.type || 'uncovered-line') as 'uncovered-line' | 'uncovered-branch' | 'uncovered-function',
-      severity: (gap?.severity || (i < 2 ? 'high' : 'medium')) as 'critical' | 'high' | 'medium' | 'low',
-      reason: gap?.reason || 'Missing test case',
-      priority: gap?.priority || (i < 2 ? 'high' : 'medium'),
-      suggestion: gap?.suggestedTest || `Add test for line ${10 + i * 5}`,
-      suggestedTest: gap?.suggestedTest || `Add test for line ${10 + i * 5}`,
-      riskScore: gap?.riskScore || (0.8 - i * 0.1),
-      confidence: gap?.confidence || 0.85,
-    }));
-
-    return {
-      success: true,
-      data: {
-        // V2-compatible fields
-        // Use deterministic variations based on file index instead of random
-        coverageByFile: Array.from({ length: data.totalFiles || 5 }, (_, i) => {
-          // Create predictable variation: alternating +/- based on index
-          const variation = ((i % 3) - 1) * 5; // -5, 0, +5 pattern
-          return {
-            file: `src/module${i}.ts`,
-            lineCoverage: Math.max(0, Math.min(100, data.lineCoverage + variation)),
-            branchCoverage: Math.max(0, Math.min(100, data.branchCoverage + variation - 2)),
-            functionCoverage: Math.max(0, Math.min(100, data.functionCoverage + variation + 2)),
-          };
-        }),
-        gapAnalysis: {
-          totalGaps: detailedGaps.length,
-          highPriority: detailedGaps.filter((g: any) => g.priority === 'high').length,
-          gaps: detailedGaps,
-        },
-        trends: {
-          lineCoverageTrend: 'stable',
-          branchCoverageTrend: 'improving',
-          weeklyChange: 2.5,
-        },
-        aiInsights: {
-          recommendations: [
-            'Focus on uncovered branches in authentication module',
-            'Add edge case tests for error handling paths',
-            'Consider property-based testing for utility functions',
-          ],
-          riskAssessment: data.lineCoverage < 70 ? 'high' : data.lineCoverage < 85 ? 'medium' : 'low',
-          confidence: 0.88,
-        },
-        learning,
-        // V3 fields
-        taskId: submitResult.value,
-        lineCoverage: data.lineCoverage,
-        branchCoverage: data.branchCoverage,
-        functionCoverage: data.functionCoverage,
-        statementCoverage: data.statementCoverage || data.lineCoverage,
-        totalFiles: data.totalFiles || 5,
-        gaps: detailedGaps,
-        duration: result.duration,
-        savedFiles: result.savedFiles,
-      },
-    };
-  } catch (error) {
-    return {
-      success: false,
-      error: `Failed to analyze coverage: ${error instanceof Error ? error.message : String(error)}`,
-    };
-  }
-}
-
-// ============================================================================
-// Quality Assessment Handler
-// ============================================================================
-
-interface QualityAssessResult {
-  taskId: string;
-  status: string;
-  qualityScore: number;
-  passed: boolean;
-  metrics: Record<string, number>;
-  recommendations: string[];
-  duration: number;
-  savedFiles?: string[];
-}
-
-export async function handleQualityAssess(
-  params: QualityAssessParams
-): Promise<ToolResult<QualityAssessResult>> {
-  if (!isFleetInitialized()) {
-    return {
-      success: false,
-      error: 'Fleet not initialized. Call fleet_init first.',
-    };
-  }
-
-  const { queen } = getFleetState();
-
-  try {
-    const submitResult = await queen!.submitTask({
-      type: 'assess-quality',
-      priority: 'p0',
-      targetDomains: ['quality-assessment'],
-      payload: {
-        runGate: params.runGate || false,
-        threshold: params.threshold || 80,
-        metrics: params.metrics || ['coverage', 'complexity', 'maintainability'],
-      },
-      timeout: 180000,
-    });
-
-    if (!submitResult.success) {
-      return {
-        success: false,
-        error: submitResult.error.message,
-      };
-    }
-
-    const executor = getTaskExecutor();
-    const task = queen!.getTaskStatus(submitResult.value);
-
-    if (!task) {
-      return {
-        success: false,
-        error: 'Task not found after submission',
-      };
-    }
-
-    const result = await executor.execute(task.task);
-
-    if (!result.success) {
-      return {
-        success: false,
-        error: result.error || 'Task execution failed',
-      };
-    }
-
-    const data = result.data as {
-      qualityScore: number;
-      passed: boolean;
-      metrics: Record<string, number>;
-      recommendations: string[];
-    };
-
-    return {
-      success: true,
-      data: {
-        taskId: submitResult.value,
-        status: 'completed',
-        qualityScore: data.qualityScore,
-        passed: data.passed,
-        metrics: data.metrics,
-        recommendations: data.recommendations,
-        duration: result.duration,
-        savedFiles: result.savedFiles,
-      },
-    };
-  } catch (error) {
-    return {
-      success: false,
-      error: `Failed to assess quality: ${error instanceof Error ? error.message : String(error)}`,
-    };
-  }
-}
-
-// ============================================================================
-// Security Scan Handler
-// ============================================================================
-
-interface SecurityScanResult {
-  taskId: string;
-  status: string;
-  vulnerabilities: number;
-  critical: number;
-  high: number;
-  medium: number;
-  low: number;
-  topVulnerabilities: unknown[];
-  recommendations: string[];
-  duration: number;
-  savedFiles?: string[];
-}
-
-export async function handleSecurityScan(
-  params: SecurityScanParams
-): Promise<ToolResult<SecurityScanResult>> {
-  if (!isFleetInitialized()) {
-    return {
-      success: false,
-      error: 'Fleet not initialized. Call fleet_init first.',
-    };
-  }
-
-  const { queen } = getFleetState();
-
-  try {
-    const scanTypes: string[] = [];
-    if (params.sast !== false) scanTypes.push('SAST');
-    if (params.dast) scanTypes.push('DAST');
-
-    const submitResult = await queen!.submitTask({
-      type: 'scan-security',
-      priority: 'p0',
-      targetDomains: ['security-compliance'],
-      payload: {
-        sast: params.sast !== false,
-        dast: params.dast || false,
-        compliance: params.compliance || [],
-        target: params.target || '.',
-      },
-      timeout: 600000,
-    });
-
-    if (!submitResult.success) {
-      return {
-        success: false,
-        error: submitResult.error.message,
-      };
-    }
-
-    const executor = getTaskExecutor();
-    const task = queen!.getTaskStatus(submitResult.value);
-
-    if (!task) {
-      return {
-        success: false,
-        error: 'Task not found after submission',
-      };
-    }
-
-    const result = await executor.execute(task.task);
-
-    if (!result.success) {
-      return {
-        success: false,
-        error: result.error || 'Task execution failed',
-      };
-    }
-
-    const data = result.data as {
-      vulnerabilities: number;
-      critical: number;
-      high: number;
-      medium: number;
-      low: number;
-      topVulnerabilities: unknown[];
-      recommendations: string[];
-    };
-
-    return {
-      success: true,
-      data: {
-        taskId: submitResult.value,
-        status: 'completed',
-        vulnerabilities: data.vulnerabilities,
-        critical: data.critical,
-        high: data.high,
-        medium: data.medium,
-        low: data.low,
-        topVulnerabilities: data.topVulnerabilities,
-        recommendations: data.recommendations,
-        duration: result.duration,
-        savedFiles: result.savedFiles,
-      },
-    };
-  } catch (error) {
-    return {
-      success: false,
-      error: `Failed to scan security: ${error instanceof Error ? error.message : String(error)}`,
-    };
-  }
-}
-
-// ============================================================================
-// Contract Validation Handler
-// ============================================================================
-
-interface ContractValidateResult {
-  taskId: string;
-  status: string;
-  valid: boolean;
-  breakingChanges: string[];
-  warnings: string[];
-  duration: number;
-}
-
-export async function handleContractValidate(
-  params: ContractValidateParams
-): Promise<ToolResult<ContractValidateResult>> {
-  if (!isFleetInitialized()) {
-    return {
-      success: false,
-      error: 'Fleet not initialized. Call fleet_init first.',
-    };
-  }
-
-  const { queen } = getFleetState();
-
-  try {
-    const submitResult = await queen!.submitTask({
-      type: 'validate-contracts',
-      priority: 'p1',
-      targetDomains: ['contract-testing'],
-      payload: {
-        contractPath: params.contractPath,
-        providerUrl: params.providerUrl,
-        consumerName: params.consumerName,
-        checkBreakingChanges: params.checkBreakingChanges !== false,
-      },
-      timeout: 180000,
-    });
-
-    if (!submitResult.success) {
-      return {
-        success: false,
-        error: submitResult.error.message,
-      };
-    }
-
-    const executor = getTaskExecutor();
-    const task = queen!.getTaskStatus(submitResult.value);
-
-    if (!task) {
-      return {
-        success: false,
-        error: 'Task not found after submission',
-      };
-    }
-
-    const result = await executor.execute(task.task);
-
-    if (!result.success) {
-      return {
-        success: false,
-        error: result.error || 'Task execution failed',
-      };
-    }
-
-    const data = result.data as {
-      valid: boolean;
-      breakingChanges: string[];
-      warnings: string[];
-    };
-
-    return {
-      success: true,
-      data: {
-        taskId: submitResult.value,
-        status: 'completed',
-        valid: data.valid,
-        breakingChanges: data.breakingChanges,
-        warnings: data.warnings,
-        duration: result.duration,
-      },
-    };
-  } catch (error) {
-    return {
-      success: false,
-      error: `Failed to validate contract: ${error instanceof Error ? error.message : String(error)}`,
-    };
-  }
-}
-
-// ============================================================================
-// Accessibility Test Handler
-// ============================================================================
-
-interface AccessibilityTestResult {
-  taskId: string;
-  status: string;
-  passed: boolean;
-  score: number;
-  violations: unknown[];
-  warnings: unknown[];
-  duration: number;
-}
-
-export async function handleAccessibilityTest(
-  params: AccessibilityTestParams
-): Promise<ToolResult<AccessibilityTestResult>> {
-  if (!isFleetInitialized()) {
-    return {
-      success: false,
-      error: 'Fleet not initialized. Call fleet_init first.',
-    };
-  }
-
-  const { queen } = getFleetState();
-
-  try {
-    const submitResult = await queen!.submitTask({
-      type: 'test-accessibility',
-      priority: 'p1',
-      targetDomains: ['visual-accessibility'],
-      payload: {
-        url: params.url,
-        standard: params.standard || 'wcag21-aa',
-        includeScreenReader: params.includeScreenReader || false,
-      },
-      timeout: 180000,
-    });
-
-    if (!submitResult.success) {
-      return {
-        success: false,
-        error: submitResult.error.message,
-      };
-    }
-
-    const executor = getTaskExecutor();
-    const task = queen!.getTaskStatus(submitResult.value);
-
-    if (!task) {
-      return {
-        success: false,
-        error: 'Task not found after submission',
-      };
-    }
-
-    const result = await executor.execute(task.task);
-
-    if (!result.success) {
-      return {
-        success: false,
-        error: result.error || 'Task execution failed',
-      };
-    }
-
-    const data = result.data as {
-      passed: boolean;
-      score: number;
-      violations: unknown[];
-      warnings: unknown[];
-    };
-
-    return {
-      success: true,
-      data: {
-        taskId: submitResult.value,
-        status: 'completed',
-        passed: data.passed,
-        score: data.score,
-        violations: data.violations,
-        warnings: data.warnings,
-        duration: result.duration,
-      },
-    };
-  } catch (error) {
-    return {
-      success: false,
-      error: `Failed to test accessibility: ${error instanceof Error ? error.message : String(error)}`,
-    };
-  }
-}
-
-// ============================================================================
-// Chaos Test Handler
-// ============================================================================
-
-interface ChaosTestResult {
-  taskId: string;
-  status: string;
-  faultType: string;
-  resilience: {
-    recovered: boolean;
-    recoveryTime: number;
-    dataLoss: boolean;
-  };
-  duration: number;
-}
-
-export async function handleChaosTest(
-  params: ChaosTestParams
-): Promise<ToolResult<ChaosTestResult>> {
-  if (!isFleetInitialized()) {
-    return {
-      success: false,
-      error: 'Fleet not initialized. Call fleet_init first.',
-    };
-  }
-
-  const { queen } = getFleetState();
-
-  try {
-    const submitResult = await queen!.submitTask({
-      type: 'run-chaos',
-      priority: 'p2',
-      targetDomains: ['chaos-resilience'],
-      payload: {
-        faultType: params.faultType || 'latency',
-        target: params.target,
-        duration: params.duration || 30000,
-        intensity: params.intensity || 50,
-        dryRun: params.dryRun !== false,
-      },
-      timeout: (params.duration || 30000) + 60000,
-    });
-
-    if (!submitResult.success) {
-      return {
-        success: false,
-        error: submitResult.error.message,
-      };
-    }
-
-    const executor = getTaskExecutor();
-    const task = queen!.getTaskStatus(submitResult.value);
-
-    if (!task) {
-      return {
-        success: false,
-        error: 'Task not found after submission',
-      };
-    }
-
-    const result = await executor.execute(task.task);
-
-    if (!result.success) {
-      return {
-        success: false,
-        error: result.error || 'Task execution failed',
-      };
-    }
-
-    const data = result.data as {
-      faultType: string;
-      resilience: {
-        recovered: boolean;
-        recoveryTime: number;
-        dataLoss: boolean;
-      };
-    };
-
-    return {
-      success: true,
-      data: {
-        taskId: submitResult.value,
-        status: 'completed',
-        faultType: data.faultType,
-        resilience: data.resilience,
-        duration: result.duration,
-      },
-    };
-  } catch (error) {
-    return {
-      success: false,
-      error: `Failed to run chaos test: ${error instanceof Error ? error.message : String(error)}`,
-    };
-  }
-}
-
-// ============================================================================
-// Defect Prediction Handler
-// ============================================================================
-
-interface DefectPredictParams {
-  target?: string;
-  lookback?: number;
-  minConfidence?: number;
-}
-
-interface DefectPredictResult {
-  taskId: string;
-  status: string;
-  predictedDefects: Array<{
-    file: string;
-    probability: number;
-    reason: string;
-  }>;
-  riskScore: number;
-  recommendations: string[];
-  duration: number;
-}
-
-export async function handleDefectPredict(
-  params: DefectPredictParams
-): Promise<ToolResult<DefectPredictResult>> {
-  if (!isFleetInitialized()) {
-    return {
-      success: false,
-      error: 'Fleet not initialized. Call fleet_init first.',
-    };
-  }
-
-  const { queen } = getFleetState();
-
-  try {
-    const submitResult = await queen!.submitTask({
-      type: 'predict-defects',
-      priority: 'p1',
-      targetDomains: ['defect-intelligence'],
-      payload: {
-        target: params.target || '.',
-        lookback: params.lookback || 30,
-        minConfidence: params.minConfidence || 0.7,
-      },
-      timeout: 180000,
-    });
-
-    if (!submitResult.success) {
-      return {
-        success: false,
-        error: submitResult.error.message,
-      };
-    }
-
-    const executor = getTaskExecutor();
-    const task = queen!.getTaskStatus(submitResult.value);
-
-    if (!task) {
-      return {
-        success: false,
-        error: 'Task not found after submission',
-      };
-    }
-
-    const result = await executor.execute(task.task);
-
-    if (!result.success) {
-      return {
-        success: false,
-        error: result.error || 'Task execution failed',
-      };
-    }
-
-    const data = result.data as {
-      predictedDefects: Array<{ file: string; probability: number; reason: string }>;
-      riskScore: number;
-      recommendations: string[];
-    };
-
-    return {
-      success: true,
-      data: {
-        taskId: submitResult.value,
-        status: 'completed',
-        predictedDefects: data.predictedDefects,
-        riskScore: data.riskScore,
-        recommendations: data.recommendations,
-        duration: result.duration,
-      },
-    };
-  } catch (error) {
-    return {
-      success: false,
-      error: `Failed to predict defects: ${error instanceof Error ? error.message : String(error)}`,
-    };
-  }
-}
-
-// ============================================================================
-// Requirements Validation Handler
-// ============================================================================
-
-interface RequirementsValidateParams {
-  requirementsPath?: string;
-  testPath?: string;
-  generateBDD?: boolean;
-}
-
-interface RequirementsValidateResult {
-  taskId: string;
-  status: string;
-  requirementsAnalyzed: number;
-  testable: number;
-  coverage: number;
-  bddScenarios: string[];
-  duration: number;
-}
-
-export async function handleRequirementsValidate(
-  params: RequirementsValidateParams
-): Promise<ToolResult<RequirementsValidateResult>> {
-  if (!isFleetInitialized()) {
-    return {
-      success: false,
-      error: 'Fleet not initialized. Call fleet_init first.',
-    };
-  }
-
-  const { queen } = getFleetState();
-
-  try {
-    const submitResult = await queen!.submitTask({
-      type: 'validate-requirements',
-      priority: 'p1',
-      targetDomains: ['requirements-validation'],
-      payload: {
-        requirementsPath: params.requirementsPath,
-        testPath: params.testPath,
-        generateBDD: params.generateBDD || false,
-      },
-      timeout: 180000,
-    });
-
-    if (!submitResult.success) {
-      return {
-        success: false,
-        error: submitResult.error.message,
-      };
-    }
-
-    const executor = getTaskExecutor();
-    const task = queen!.getTaskStatus(submitResult.value);
-
-    if (!task) {
-      return {
-        success: false,
-        error: 'Task not found after submission',
-      };
-    }
-
-    const result = await executor.execute(task.task);
-
-    if (!result.success) {
-      return {
-        success: false,
-        error: result.error || 'Task execution failed',
-      };
-    }
-
-    const data = result.data as {
-      requirementsAnalyzed: number;
-      testable: number;
-      coverage: number;
-      bddScenarios: string[];
-    };
-
-    return {
-      success: true,
-      data: {
-        taskId: submitResult.value,
-        status: 'completed',
-        requirementsAnalyzed: data.requirementsAnalyzed,
-        testable: data.testable,
-        coverage: data.coverage,
-        bddScenarios: data.bddScenarios,
-        duration: result.duration,
-      },
-    };
-  } catch (error) {
-    return {
-      success: false,
-      error: `Failed to validate requirements: ${error instanceof Error ? error.message : String(error)}`,
-    };
-  }
-}
-
-// ============================================================================
-// Code Index Handler
-// ============================================================================
-
-interface CodeIndexParams {
-  target?: string;
-  incremental?: boolean;
-  gitSince?: string;
-}
-
-interface CodeIndexResult {
-  taskId: string;
-  status: string;
-  filesIndexed: number;
-  symbolsExtracted: number;
-  relationsFound: number;
-  duration: number;
-}
-
-export async function handleCodeIndex(
-  params: CodeIndexParams
-): Promise<ToolResult<CodeIndexResult>> {
-  if (!isFleetInitialized()) {
-    return {
-      success: false,
-      error: 'Fleet not initialized. Call fleet_init first.',
-    };
-  }
-
-  const { queen } = getFleetState();
-
-  try {
-    const submitResult = await queen!.submitTask({
-      type: 'index-code',
-      priority: 'p2',
-      targetDomains: ['code-intelligence'],
-      payload: {
-        target: params.target || '.',
-        incremental: params.incremental || false,
-        gitSince: params.gitSince,
-      },
-      timeout: 300000,
-    });
-
-    if (!submitResult.success) {
-      return {
-        success: false,
-        error: submitResult.error.message,
-      };
-    }
-
-    const executor = getTaskExecutor();
-    const task = queen!.getTaskStatus(submitResult.value);
-
-    if (!task) {
-      return {
-        success: false,
-        error: 'Task not found after submission',
-      };
-    }
-
-    const result = await executor.execute(task.task);
-
-    if (!result.success) {
-      return {
-        success: false,
-        error: result.error || 'Task execution failed',
-      };
-    }
-
-    const data = result.data as {
-      filesIndexed: number;
-      symbolsExtracted: number;
-      relationsFound: number;
-    };
-
-    return {
-      success: true,
-      data: {
-        taskId: submitResult.value,
-        status: 'completed',
-        filesIndexed: data.filesIndexed,
-        symbolsExtracted: data.symbolsExtracted,
-        relationsFound: data.relationsFound,
-        duration: result.duration,
-      },
-    };
-  } catch (error) {
-    return {
-      success: false,
-      error: `Failed to index code: ${error instanceof Error ? error.message : String(error)}`,
-    };
-  }
-}