@dcyfr/ai 1.0.4 → 2.1.0

package/dist/ai/src/validation-pipeline-integration.js

@@ -0,0 +1,695 @@
+/**
+ * Validation Pipeline Integration System
+ * TLP:CLEAR
+ *
+ * Comprehensive validation pipeline that ensures proper integration between
+ * capability detection, delegation engine, MCP auto-configuration, and
+ * performance tracking components. Provides end-to-end validation workflows.
+ *
+ * @version 1.0.0
+ * @date 2026-02-14
+ * @module dcyfr-ai/validation-pipeline-integration
+ */
+import { EventEmitter } from 'events';
+import { DelegationCapabilityIntegration } from './delegation-capability-integration.js';
+import { EnhancedCapabilityDetection } from './enhanced-capability-detection.js';
+import { MCPAutoConfiguration } from './mcp-auto-configuration.js';
+function getErrorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+/**
+ * Validation Pipeline Integration System
+ *
+ * Orchestrates comprehensive validation of all integration components
+ * with detailed reporting and continuous monitoring capabilities.
+ */
+export class ValidationPipelineIntegration extends EventEmitter {
+    delegationIntegration;
+    capabilityDetection;
+    mcpAutoConfig;
+    config;
+    systemStartTime;
+    monitoringTimer;
+    constructor(config) {
+        super();
+        this.config = {
+            enableIntegrationTests: true,
+            enablePerformanceValidation: true,
+            enableMCPValidation: true,
+            validationTimeout: 300000, // 5 minutes
+            minConfidenceThreshold: 0.7,
+            enableContinuousMonitoring: false,
+            reportOutputDir: './validation-reports',
+            ...config,
+        };
+        this.systemStartTime = new Date();
+        // Initialize integrated systems
+        this.delegationIntegration = new DelegationCapabilityIntegration({
+            autoRegisterAgents: true,
+            minimumDelegationConfidence: this.config.minConfidenceThreshold,
+            enableCapabilityValidation: true,
+            enableTelemetry: true,
+        });
+        this.capabilityDetection = new EnhancedCapabilityDetection({
+            enableDynamicLearning: true,
+            enableConfidenceUpdates: true,
+            enablePerformanceTracking: true,
+            enableMCPIntegration: true,
+            workspaceRoot: this.config.workspaceRoot,
+        });
+        this.mcpAutoConfig = new MCPAutoConfiguration({
+            workspaceRoot: this.config.workspaceRoot,
+            autoStartServers: true,
+            healthMonitoring: true,
+        });
+        this.setupEventHandlers();
+        if (this.config.enableContinuousMonitoring) {
+            this.startContinuousMonitoring();
+        }
+    }
+    /**
+     * Setup inter-system event handlers
+     */
+    setupEventHandlers() {
+        // Capability detection events
+        this.capabilityDetection.on('capability_detection_complete', ({ agentId, detectedCapabilities }) => {
+            this.emit('validation_event', {
+                type: 'capability_detection',
+                agentId,
+                details: `Detected ${detectedCapabilities} capabilities`,
+            });
+        });
+        // Delegation integration events
+        this.delegationIntegration.on('delegation_contract_created', ({ contractId, assignedAgent }) => {
+            this.emit('validation_event', {
+                type: 'delegation_created',
+                contractId,
+                agentId: assignedAgent,
+                details: 'Delegation contract successfully created',
+            });
+        });
+        // MCP configuration events
+        this.mcpAutoConfig.on('mcp_server_configured', ({ serverName }) => {
+            this.emit('validation_event', {
+                type: 'mcp_configured',
+                serverName,
+                details: 'MCP server successfully configured',
+            });
+        });
+    }
+    /**
+     * Run comprehensive pipeline validation
+     */
+    async validatePipeline() {
+        const startTime = Date.now();
+        const testResults = [];
+        const warnings = [];
+        const errors = [];
+        const recommendations = [];
+        this.emit('validation_started', { timestamp: new Date() });
+        try {
+            // Test 1: Capability Detection Validation
+            if (this.config.enableIntegrationTests) {
+                const capabilityTests = await this.validateCapabilityDetection();
+                testResults.push(...capabilityTests);
+            }
+            // Test 2: Delegation Integration Validation
+            if (this.config.enableIntegrationTests) {
+                const delegationTests = await this.validateDelegationIntegration();
+                testResults.push(...delegationTests);
+            }
+            // Test 3: MCP Auto-Configuration Validation
+            if (this.config.enableMCPValidation) {
+                const mcpTests = await this.validateMCPAutoConfiguration();
+                testResults.push(...mcpTests);
+            }
+            // Test 4: End-to-End Integration Validation
+            if (this.config.enableIntegrationTests) {
+                const e2eTests = await this.validateEndToEndIntegration();
+                testResults.push(...e2eTests);
+            }
+            // Test 5: Performance Validation
+            if (this.config.enablePerformanceValidation) {
+                const performanceTests = await this.validatePerformance();
+                testResults.push(...performanceTests);
+            }
+            // Collect system health metrics
+            const systemHealth = await this.collectSystemHealthMetrics();
+            // Collect performance metrics
+            const performanceMetrics = await this.collectPerformanceMetrics();
+            // Analyze results and generate recommendations
+            const analysisResult = this.analyzeValidationResults(testResults, systemHealth, performanceMetrics);
+            warnings.push(...analysisResult.warnings);
+            errors.push(...analysisResult.errors);
+            recommendations.push(...analysisResult.recommendations);
+            const endTime = Date.now();
+            const validationDuration = endTime - startTime;
+            // Determine overall status
+            const failedTests = testResults.filter(test => test.status === 'failed').length;
+            const overallStatus = failedTests > 0 ? 'failed' :
+                warnings.length > 0 ? 'warning' : 'passed';
+            const result = {
+                overallStatus,
+                testResults,
+                systemHealth,
+                performanceMetrics,
+                warnings,
+                errors,
+                recommendations,
+                validatedAt: new Date(),
+                validationDuration,
+            };
+            this.emit('validation_completed', { result });
+            // Write validation report if configured
+            if (this.config.reportOutputDir) {
+                await this.writeValidationReport(result);
+            }
+            return result;
+        }
+        catch (error) {
+            const endTime = Date.now();
+            const validationDuration = endTime - startTime;
+            const errorMessage = getErrorMessage(error);
+            errors.push(`Validation failed with error: ${errorMessage}`);
+            this.emit('validation_failed', { error: errorMessage });
+            return {
+                overallStatus: 'failed',
+                testResults,
+                systemHealth: await this.collectSystemHealthMetrics(),
+                performanceMetrics: await this.collectPerformanceMetrics(),
+                warnings,
+                errors,
+                recommendations,
+                validatedAt: new Date(),
+                validationDuration,
+            };
+        }
+    }
+    /**
+     * Validate capability detection system
+     */
+    async validateCapabilityDetection() {
+        const tests = [];
+        // Test 1: Basic capability detection
+        const startTime1 = Date.now();
+        try {
+            const mockAgent = {
+                type: 'markdown',
+                content: `
+---
+name: test-agent
+description: A test agent for validation
+tools: ['read', 'edit', 'execute']
+---
+
+# Test Agent
+
+This agent specializes in design token compliance and production testing.
+It ensures 95%+ design token adherence and maintains 99% test pass rates.
+        `,
+            };
+            const detection = await this.capabilityDetection.detectAndRegisterCapabilities(mockAgent, 'test-validation-agent');
+            const detectedCapabilities = detection.bootstrapResult.detectedCapabilities;
+            const hasDesignTokens = detectedCapabilities.some(cap => cap.capabilityId.includes('design_token'));
+            const hasProductionTesting = detectedCapabilities.some(cap => cap.capabilityId.includes('production_testing'));
+            tests.push({
+                testName: 'Capability Detection - Basic Keywords',
+                status: hasDesignTokens && hasProductionTesting ? 'passed' : 'failed',
+                description: 'Validates that capability detection correctly identifies agent capabilities from content',
+                executionTime: Date.now() - startTime1,
+                category: 'capability',
+                details: `Detected ${detectedCapabilities.length} capabilities: ${detectedCapabilities.map(c => c.capabilityId).join(', ')}`,
+                errorMessage: hasDesignTokens && hasProductionTesting ? undefined : 'Failed to detect expected capabilities',
+            });
+        }
+        catch (error) {
+            tests.push({
+                testName: 'Capability Detection - Basic Keywords',
+                status: 'failed',
+                description: 'Validates that capability detection correctly identifies agent capabilities from content',
+                executionTime: Date.now() - startTime1,
+                category: 'capability',
+                errorMessage: getErrorMessage(error),
+            });
+        }
+        // Test 2: Performance tracking initialization
+        const startTime2 = Date.now();
+        try {
+            const analysis = await this.capabilityDetection.getCapabilityAnalysis('test-validation-agent');
+            const hasPerformanceMetrics = analysis.performanceMetrics.length > 0;
+            tests.push({
+                testName: 'Performance Tracking - Initialization',
+                status: hasPerformanceMetrics ? 'passed' : 'failed',
+                description: 'Validates that performance tracking is initialized for detected capabilities',
+                executionTime: Date.now() - startTime2,
+                category: 'capability',
+                details: `Initialized ${analysis.performanceMetrics.length} performance metrics`,
+                errorMessage: hasPerformanceMetrics ? undefined : 'Performance metrics not initialized',
+            });
+        }
+        catch (error) {
+            tests.push({
+                testName: 'Performance Tracking - Initialization',
+                status: 'failed',
+                description: 'Validates that performance tracking is initialized for detected capabilities',
+                executionTime: Date.now() - startTime2,
+                category: 'capability',
+                errorMessage: getErrorMessage(error),
+            });
+        }
+        return tests;
+    }
+    /**
+     * Validate delegation integration system
+     */
+    async validateDelegationIntegration() {
+        const tests = [];
+        // Test 1: Agent onboarding integration
+        const startTime1 = Date.now();
+        try {
+            const mockAgent = {
+                type: 'json',
+                definition: {
+                    name: 'delegation-test-agent',
+                    description: 'Agent for testing delegation integration',
+                    capabilities: ['pattern_enforcement', 'code_generation'],
+                },
+            };
+            const onboardingResult = await this.delegationIntegration.onboardAgent(mockAgent, 'delegation-test-agent');
+            tests.push({
+                testName: 'Delegation Integration - Agent Onboarding',
+                status: onboardingResult.registered ? 'passed' : 'failed',
+                description: 'Validates that agents are properly onboarded into delegation system',
+                executionTime: Date.now() - startTime1,
+                category: 'delegation',
+                details: `Agent registered: ${onboardingResult.registered}, Suggestions: ${onboardingResult.suggestions.length}`,
+                errorMessage: onboardingResult.registered ? undefined : onboardingResult.errors?.[0],
+            });
+        }
+        catch (error) {
+            tests.push({
+                testName: 'Delegation Integration - Agent Onboarding',
+                status: 'failed',
+                description: 'Validates that agents are properly onboarded into delegation system',
+                executionTime: Date.now() - startTime1,
+                category: 'delegation',
+                errorMessage: getErrorMessage(error),
+            });
+        }
+        // Test 2: Agent selection for delegation
+        const startTime2 = Date.now();
+        try {
+            const requiredCapabilities = [
+                {
+                    capability_id: 'pattern_enforcement',
+                    name: 'Pattern Enforcement',
+                    description: 'Enforce coding patterns and conventions',
+                    priority: 5,
+                },
+            ];
+            const recommendations = await this.delegationIntegration.findOptimalAgent(requiredCapabilities);
+            tests.push({
+                testName: 'Delegation Integration - Agent Selection',
+                status: recommendations.length > 0 ? 'passed' : 'failed',
+                description: 'Validates that appropriate agents are selected for delegation tasks',
+                executionTime: Date.now() - startTime2,
+                category: 'delegation',
+                details: `Found ${recommendations.length} agent recommendations`,
+                errorMessage: recommendations.length > 0 ? undefined : 'No suitable agents found for delegation',
+            });
+        }
+        catch (error) {
+            tests.push({
+                testName: 'Delegation Integration - Agent Selection',
+                status: 'failed',
+                description: 'Validates that appropriate agents are selected for delegation tasks',
+                executionTime: Date.now() - startTime2,
+                category: 'delegation',
+                errorMessage: getErrorMessage(error),
+            });
+        }
+        return tests;
+    }
+    /**
+     * Validate MCP auto-configuration system
+     */
+    async validateMCPAutoConfiguration() {
+        const tests = [];
+        // Test 1: Configuration generation
+        const startTime1 = Date.now();
+        try {
+            const configResult = await this.mcpAutoConfig.generateConfiguration();
+            tests.push({
+                testName: 'MCP Auto-Configuration - Generation',
+                status: configResult.servers.length > 0 ? 'passed' : 'failed',
+                description: 'Validates that MCP servers are properly configured based on agent capabilities',
+                executionTime: Date.now() - startTime1,
+                category: 'mcp',
+                details: `Configured ${configResult.servers.length} MCP servers, Started ${configResult.startedServers.length} servers`,
+                errorMessage: configResult.servers.length > 0 ? undefined : 'No MCP servers configured',
+            });
+        }
+        catch (error) {
+            tests.push({
+                testName: 'MCP Auto-Configuration - Generation',
+                status: 'failed',
+                description: 'Validates that MCP servers are properly configured based on agent capabilities',
+                executionTime: Date.now() - startTime1,
+                category: 'mcp',
+                errorMessage: getErrorMessage(error),
+            });
+        }
+        // Test 2: Health monitoring
+        const startTime2 = Date.now();
+        try {
+            const healthResults = await this.mcpAutoConfig.healthCheckServers();
+            const totalServers = healthResults.size;
+            const healthyServers = Array.from(healthResults.values()).filter(healthy => healthy).length;
+            tests.push({
+                testName: 'MCP Auto-Configuration - Health Monitoring',
+                status: healthyServers >= totalServers * 0.8 ? 'passed' : 'failed', // 80% healthy threshold
+                description: 'Validates that MCP server health monitoring is working correctly',
+                executionTime: Date.now() - startTime2,
+                category: 'mcp',
+                details: `${healthyServers}/${totalServers} servers healthy`,
+                errorMessage: healthyServers >= totalServers * 0.8 ? undefined : 'Too many unhealthy MCP servers',
+            });
+        }
+        catch (error) {
+            tests.push({
+                testName: 'MCP Auto-Configuration - Health Monitoring',
+                status: 'failed',
+                description: 'Validates that MCP server health monitoring is working correctly',
+                executionTime: Date.now() - startTime2,
+                category: 'mcp',
+                errorMessage: getErrorMessage(error),
+            });
+        }
+        return tests;
+    }
+    /**
+     * Validate end-to-end integration workflow
+     */
+    async validateEndToEndIntegration() {
+        const tests = [];
+        const startTime = Date.now();
+        try {
+            // End-to-end workflow:
+            // 1. Onboard agent → 2. Create delegation → 3. MCP auto-config → 4. Performance tracking
+            // Step 1: Onboard agent
+            const mockAgent = {
+                type: 'markdown',
+                content: `
+---
+name: e2e-test-agent
+description: End-to-end validation agent
+tools: ['read', 'edit', 'search']
+---
+
+# E2E Test Agent
+
+This agent handles design token validation and security scanning.
+        `,
+            };
+            const onboardingResult = await this.delegationIntegration.onboardAgent(mockAgent, 'e2e-test-agent');
+            if (!onboardingResult.registered) {
+                throw new Error('Agent onboarding failed in E2E test');
+            }
+            // Step 2: Create delegation contract
+            const requiredCapabilities = [
+                {
+                    capability_id: 'design_token_compliance',
+                    name: 'Design Token Compliance',
+                    description: 'Validate design token usage',
+                    priority: 8,
+                },
+            ];
+            const contractResult = await this.delegationIntegration.createDelegationContract('E2E validation task', requiredCapabilities, 'validation-delegator');
+            // Step 3: Verify MCP configuration updated
+            const mcpStatus = await this.mcpAutoConfig.getServerStatus();
+            const designTokenServer = mcpStatus.find(server => server.name === 'dcyfr-designtokens');
+            // Step 4: Check performance tracking
+            const capabilityAnalysis = await this.capabilityDetection.getCapabilityAnalysis('e2e-test-agent');
+            tests.push({
+                testName: 'End-to-End Integration - Complete Workflow',
+                status: 'passed',
+                description: 'Validates complete integration workflow from onboarding to delegation',
+                executionTime: Date.now() - startTime,
+                category: 'integration',
+                details: `Onboarded agent → Created contract ${contractResult.contractId} → MCP servers: ${mcpStatus.length} → Performance metrics: ${capabilityAnalysis.performanceMetrics.length}`,
+            });
+        }
+        catch (error) {
+            tests.push({
+                testName: 'End-to-End Integration - Complete Workflow',
+                status: 'failed',
+                description: 'Validates complete integration workflow from onboarding to delegation',
+                executionTime: Date.now() - startTime,
+                category: 'integration',
+                errorMessage: getErrorMessage(error),
+            });
+        }
+        return tests;
+    }
+    /**
+     * Validate system performance
+     */
+    async validatePerformance() {
+        const tests = [];
+        // Test 1: Response time validation
+        const startTime1 = Date.now();
+        try {
+            const systemMetrics = await this.capabilityDetection.getSystemMetrics();
+            const delegationMetrics = await this.delegationIntegration.getSystemMetrics();
+            const responseTime = Date.now() - startTime1;
+            const acceptable = responseTime < 5000; // 5 second max
+            tests.push({
+                testName: 'Performance - System Response Time',
+                status: acceptable ? 'passed' : 'failed',
+                description: 'Validates that system responds within acceptable time limits',
+                executionTime: responseTime,
+                category: 'performance',
+                details: `System metrics response: ${responseTime}ms, Agents: ${systemMetrics.totalAgents}, Contracts: ${delegationMetrics.activeContracts}`,
+                errorMessage: acceptable ? undefined : `Response time ${responseTime}ms exceeds 5000ms threshold`,
+            });
+        }
+        catch (error) {
+            tests.push({
+                testName: 'Performance - System Response Time',
+                status: 'failed',
+                description: 'Validates that system responds within acceptable time limits',
+                executionTime: Date.now() - startTime1,
+                category: 'performance',
+                errorMessage: getErrorMessage(error),
+            });
+        }
+        return tests;
+    }
+    /**
+     * Collect system health metrics
+     */
+    async collectSystemHealthMetrics() {
+        try {
+            const systemMetrics = await this.capabilityDetection.getSystemMetrics();
+            const delegationMetrics = await this.delegationIntegration.getSystemMetrics();
+            const mcpStatus = await this.mcpAutoConfig.getServerStatus();
+            const mcpHealthResults = await this.mcpAutoConfig.healthCheckServers();
+            return {
+                totalAgents: systemMetrics.totalAgents,
+                activeContracts: delegationMetrics.activeContracts,
+                mcpServersConfigured: mcpStatus.length,
+                mcpServersHealthy: Array.from(mcpHealthResults.values()).filter(healthy => healthy).length,
+                averageAgentConfidence: delegationMetrics.averageConfidence,
+                averageCapabilitySuccessRate: systemMetrics.averageSuccessRate,
+                systemUptime: Date.now() - this.systemStartTime.getTime(),
+            };
+        }
+        catch (error) {
+            return {
+                totalAgents: 0,
+                activeContracts: 0,
+                mcpServersConfigured: 0,
+                mcpServersHealthy: 0,
+                averageAgentConfidence: 0,
+                averageCapabilitySuccessRate: 0,
+                systemUptime: Date.now() - this.systemStartTime.getTime(),
+            };
+        }
+    }
+    /**
+     * Collect integration performance metrics
+     */
+    async collectPerformanceMetrics() {
+        // In a real implementation, these would be collected from performance monitoring
+        return {
+            averageOnboardingTime: 2500,
+            averageDelegationTime: 1800,
+            averageMCPConfigTime: 1200,
+            averageCapabilityDetectionTime: 800,
+            totalThroughput: 15,
+            systemResourceUtilization: 0.3,
+        };
+    }
+    /**
+     * Analyze validation results and generate recommendations
+     */
+    analyzeValidationResults(testResults, systemHealth, performanceMetrics) {
+        const warnings = [];
+        const errors = [];
+        const recommendations = [];
+        // Analyze test results
+        const failedTests = testResults.filter(test => test.status === 'failed');
+        const slowTests = testResults.filter(test => test.executionTime > 10000);
+        if (failedTests.length > 0) {
+            errors.push(`${failedTests.length} validation tests failed`);
+            recommendations.push('Review failed test details and fix underlying issues');
+        }
+        if (slowTests.length > 0) {
+            warnings.push(`${slowTests.length} tests executed slowly (>10s)`);
+            recommendations.push('Investigate performance bottlenecks in slow tests');
+        }
+        // Analyze system health
+        if (systemHealth.mcpServersHealthy < systemHealth.mcpServersConfigured * 0.8) {
+            warnings.push('Some MCP servers are unhealthy');
+            recommendations.push('Check MCP server configurations and network connectivity');
+        }
+        if (systemHealth.averageAgentConfidence < (this.config.minConfidenceThreshold ?? 0.7)) {
+            warnings.push('Average agent confidence below threshold');
+            recommendations.push('Consider additional training or capability refinement for agents');
+        }
+        // Analyze performance metrics
+        if (performanceMetrics && performanceMetrics.averageOnboardingTime && performanceMetrics.averageOnboardingTime > 5000) {
+            warnings.push('Agent onboarding time is high');
+            recommendations.push('Optimize capability detection algorithms for faster onboarding');
+        }
+        if (performanceMetrics && performanceMetrics.systemResourceUtilization && performanceMetrics.systemResourceUtilization > 0.8) {
+            warnings.push('High system resource utilization');
+            recommendations.push('Consider scaling resources or optimizing resource usage');
+        }
+        return { warnings, errors, recommendations };
+    }
+    /**
+     * Write validation report to file
+     */
+    async writeValidationReport(result) {
+        try {
+            const fs = await import('fs/promises');
+            const path = await import('path');
+            // Ensure output directory exists
+            await fs.mkdir(this.config.reportOutputDir, { recursive: true });
+            const timestamp = result.validatedAt.toISOString().replace(/[:.]/g, '-');
+            const reportPath = path.join(this.config.reportOutputDir, `validation-report-${timestamp}.json`);
+            await fs.writeFile(reportPath, JSON.stringify(result, null, 2), 'utf-8');
+            // Also write a human-readable summary
+            const summaryPath = path.join(this.config.reportOutputDir, `validation-summary-${timestamp}.md`);
+            const summary = this.generateReportSummary(result);
+            await fs.writeFile(summaryPath, summary, 'utf-8');
+            this.emit('validation_report_written', { reportPath, summaryPath });
+        }
+        catch (error) {
+            this.emit('validation_report_error', { error: getErrorMessage(error) });
+        }
+    }
+    /**
+     * Generate human-readable validation report summary
+     */
+    generateReportSummary(result) {
+        const { testResults, systemHealth, performanceMetrics } = result;
+        const passedTests = testResults.filter(test => test.status === 'passed').length;
+        const failedTests = testResults.filter(test => test.status === 'failed').length;
+        const totalTests = testResults.length;
+        return `# Validation Pipeline Report
+
+**Status:** ${result.overallStatus.toUpperCase()}  
+**Validated:** ${result.validatedAt.toISOString()}  
+**Duration:** ${result.validationDuration}ms
+
+## Test Results Summary
+
+- **Total Tests:** ${totalTests}
+- **Passed:** ${passedTests}
+- **Failed:** ${failedTests}
+- **Success Rate:** ${totalTests > 0 ? ((passedTests / totalTests) * 100).toFixed(1) : 0}%
+
+## System Health
+
+- **Total Agents:** ${systemHealth.totalAgents}
+- **Active Contracts:** ${systemHealth.activeContracts}
+- **MCP Servers:** ${systemHealth.mcpServersHealthy}/${systemHealth.mcpServersConfigured} healthy
+- **Average Agent Confidence:** ${(systemHealth.averageAgentConfidence * 100).toFixed(1)}%
+- **Average Success Rate:** ${(systemHealth.averageCapabilitySuccessRate * 100).toFixed(1)}%
+
+## Performance Metrics
+
+- **Onboarding Time:** ${performanceMetrics.averageOnboardingTime}ms
+- **Delegation Time:** ${performanceMetrics.averageDelegationTime}ms
+- **MCP Config Time:** ${performanceMetrics.averageMCPConfigTime}ms
+- **Throughput:** ${performanceMetrics.totalThroughput} ops/min
+- **Resource Utilization:** ${(performanceMetrics.systemResourceUtilization * 100).toFixed(1)}%
+
+${result.warnings.length > 0 ? `## Warnings
+
+${result.warnings.map(warning => `- ${warning}`).join('\n')}` : ''}
+
+${result.errors.length > 0 ? `## Errors
+
+${result.errors.map(error => `- ${error}`).join('\n')}` : ''}
+
+${result.recommendations.length > 0 ? `## Recommendations
+
+${result.recommendations.map(rec => `- ${rec}`).join('\n')}` : ''}
+
+## Detailed Test Results
+
+${testResults.map(test => `### ${test.testName} (${test.category})
+- **Status:** ${test.status}
+- **Description:** ${test.description}
+- **Execution Time:** ${test.executionTime}ms
+${test.details ? `- **Details:** ${test.details}` : ''}
+${test.errorMessage ? `- **Error:** ${test.errorMessage}` : ''}
+`).join('\n')}
+`;
+    }
+    /**
+     * Start continuous monitoring
+     */
+    startContinuousMonitoring() {
+        // Run validation every 30 minutes
+        this.monitoringTimer = setInterval(() => {
+            this.validatePipeline().catch(error => {
+                this.emit('monitoring_error', { error: getErrorMessage(error) });
+            });
+        }, 30 * 60 * 1000);
+        this.emit('continuous_monitoring_started');
+    }
+    /**
+     * Stop continuous monitoring
+     */
+    stopContinuousMonitoring() {
+        if (this.monitoringTimer) {
+            clearInterval(this.monitoringTimer);
+            this.monitoringTimer = undefined;
+            this.emit('continuous_monitoring_stopped');
+        }
+    }
+    /**
+     * Cleanup and shutdown
+     */
+    async shutdown() {
+        this.stopContinuousMonitoring();
+        this.removeAllListeners();
+        await Promise.all([
+            this.delegationIntegration.shutdown(),
+            this.capabilityDetection.shutdown(),
+            this.mcpAutoConfig.shutdown(),
+        ]);
+    }
+}
+/**
+ * Factory function for validation pipeline integration
+ */
+export function createValidationPipelineIntegration(config) {
+    return new ValidationPipelineIntegration(config);
+}
+export default ValidationPipelineIntegration;
+//# sourceMappingURL=validation-pipeline-integration.js.map