0xray 4.0.12 → 4.0.13

package/dist/delegation/agent-delegator.js

@@ -1,768 +0,0 @@
-/**
- * Agent Delegator
- *
- * Intelligent agent delegation system that uses complexity analysis to determine
- * optimal task distribution strategies and conflict resolution.
- *
- * Integrates with TaskSkillRouter for keyword-based preprocessing.
- *
- * @since 2026-01-07
- */
-import * as fs from "fs";
-import * as path from "path";
-import * as nodePath from "path";
-import { ComplexityAnalyzer, } from "./complexity-analyzer.js";
-import { frameworkLogger } from "../core/framework-logger.js";
-import { getKernel } from "../core/kernel-patterns.js";
-import { DEFAULT_AGENTS } from "../config/default-agents.js";
-import { getActiveAgents, isAllowedAgent } from "../agents/registry.js";
-import { routingOutcomeTracker } from "./analytics/outcome-tracker.js";
-import { predictiveAnalytics } from "../analytics/predictive-analytics.js";
-import { aggregateDelegationMetrics, aggregateOrchestrationMetrics, summarizeByAgent, summarizeByComplexityLevel, summarizeByTimePeriod, rotateMetrics, cleanupOldMetrics, exportMetrics, } from "./metrics-aggregator.js";
-import { initializeAgentMetrics, } from "../metrics/agent-metrics.js";
-/**
- * AgentDelegator class for intelligent task delegation
- */
-export class AgentDelegator {
-    complexityAnalyzer;
-    stateManager;
-    configLoader;
-    kernel;
-    agentMetrics;
-    /** Minimum confidence for a learned mapping to override hardcoded routing. */
-    static MAPPING_CONFIDENCE_THRESHOLD = 0.7;
-    constructor(stateManager, configLoader) {
-        this.stateManager = stateManager;
-        this.configLoader = configLoader;
-        this.complexityAnalyzer = new ComplexityAnalyzer();
-        this.kernel = getKernel();
-        this.agentMetrics = initializeAgentMetrics(stateManager);
-    }
-    /**
-     * Load routing-mappings.json from disk (fresh each call — picks up tuner writes).
-     * Same path resolution as inference-tuner.ts.
-     */
-    loadRoutingMappings() {
-        const candidates = [
-            path.resolve(process.cwd(), ".xray/routing-mappings.json"),
-            path.resolve(process.cwd(), "xray/routing-mappings.json"),
-            path.resolve(process.cwd(), ".xray/routing-mappings.json"),
-            path.resolve(process.cwd(), "routing-mappings.json"),
-        ];
-        for (const p of candidates) {
-            try {
-                if (fs.existsSync(p)) {
-                    const data = fs.readFileSync(p, "utf-8");
-                    const parsed = JSON.parse(data);
-                    if (!Array.isArray(parsed))
-                        continue;
-                    const valid = [];
-                    for (const entry of parsed) {
-                        if (entry.autoGenerated === true) {
-                            frameworkLogger.log("agent-delegator", "routing-filtered", "warning", {
-                                reason: "autoGenerated flag",
-                                agent: entry.agent,
-                            });
-                            continue;
-                        }
-                        if (entry.agent && !isAllowedAgent(entry.agent)) {
-                            frameworkLogger.log("agent-delegator", "routing-filtered", "warning", {
-                                reason: "agent not in registry",
-                                agent: entry.agent,
-                            });
-                            continue;
-                        }
-                        valid.push(entry);
-                    }
-                    return valid;
-                }
-            }
-            catch {
-                // try next candidate
-            }
-        }
-        return [];
-    }
-    /**
-     * Match a task description against learned keyword mappings.
-     * Returns the best matching mapping if any keyword hits above threshold.
-     */
-    matchRoutingMappings(description) {
-        const mappings = this.loadRoutingMappings();
-        if (mappings.length === 0)
-            return null;
-        const descLower = description.toLowerCase();
-        const descWords = new Set(descLower.split(/\W+/).filter(w => w.length > 2));
-        if (descWords.size === 0)
-            return null;
-        let bestMatch = null;
-        let bestScore = 0;
-        for (const mapping of mappings) {
-            if (mapping.confidence < AgentDelegator.MAPPING_CONFIDENCE_THRESHOLD)
-                continue;
-            // Score: fraction of mapping keywords found in description
-            let hits = 0;
-            for (const keyword of mapping.keywords) {
-                if (descWords.has(keyword.toLowerCase()) || descLower.includes(keyword.toLowerCase())) {
-                    hits++;
-                }
-            }
-            if (hits === 0)
-                continue;
-            // Weight by confidence and keyword coverage
-            const coverage = hits / mapping.keywords.length;
-            const score = (coverage * 0.6) + (mapping.confidence * 0.4);
-            if (score > bestScore) {
-                bestScore = score;
-                bestMatch = mapping;
-            }
-        }
-        return bestMatch;
-    }
-    getAvailableAgents() {
-        return DEFAULT_AGENTS.map((agent) => {
-            const storedAgent = this.stateManager.get(`agent_capabilities:${agent.name}`);
-            return storedAgent || agent;
-        });
-    }
-    /**
-     * Pre-process a task description using TaskSkillRouter
-     * This extracts operation type and context from natural language descriptions
-     * before running complexity analysis
-     */
-    preprocessTaskDescription(description, options) {
-        const routingOptions = {
-            ...(options?.sessionId && { sessionId: options.sessionId }),
-            ...(options?.taskId && { taskId: options.taskId }),
-            ...(options?.complexity !== undefined && {
-                complexity: options.complexity,
-            }),
-            stateManager: this.stateManager,
-        };
-        return {
-            operation: description,
-            context: {},
-            suggestedAgent: DEFAULT_AGENTS[0]?.name || "code-reviewer",
-            suggestedSkill: "",
-            confidence: 0.5,
-        };
-    }
-    async analyzeDelegation(request) {
-        try {
-            const metrics = {
-                fileCount: request.context?.files?.length || 1,
-                changeVolume: request.context?.changeVolume || 10,
-                operationType: this.mapOperationToType(request.operation),
-                dependencies: request.context?.dependencies?.length || 0,
-                riskLevel: request.context?.riskLevel || "low",
-                estimatedDuration: 10,
-                operation: request.operation,
-            };
-            const complexityScore = this.complexityAnalyzer.calculateComplexityScore(metrics);
-            // KERNEL ANALYSIS: Apply kernel pattern detection
-            const kernelInsights = this.kernel.analyze(request.description);
-            // Log kernel insights for debugging and learning
-            frameworkLogger.log("agent-delegator", "kernel-analysis", "info", {
-                operation: request.operation,
-                kernelLevel: kernelInsights.level,
-                kernelConfidence: kernelInsights.confidence,
-                detectedPatterns: kernelInsights.cascadePatterns?.length || 0,
-                detectedAssumptions: kernelInsights.fatalAssumptions?.length || 0,
-            });
-            const agentDetails = this.determineAgents(metrics, complexityScore, kernelInsights);
-            const conflictResolution = this.determineConflictResolution(metrics, complexityScore);
-            const agents = agentDetails.map((a) => a.name);
-            // Persist orchestration metrics for tracking sub-agent invocations
-            const orchestrationMetrics = this.stateManager.get("orchestration_metrics") || [];
-            const orchestrationEntry = {
-                timestamp: Date.now(),
-                parentTask: request.description?.substring(0, 100),
-                operation: request.operation,
-                orchestratorType: "orchestrator-led",
-                subAgents: agents.map((name, idx) => ({
-                    name,
-                    role: agentDetails[idx]?.role || "delegated",
-                    confidence: agentDetails[idx]?.confidence || 0.8,
-                })),
-                complexityLevel: complexityScore.level,
-                complexityScore: complexityScore.score,
-                sessionId: request.sessionId,
-            };
-            orchestrationMetrics.push(orchestrationEntry);
-            if (orchestrationMetrics.length > 100) {
-                orchestrationMetrics.shift();
-            }
-            this.stateManager.set("orchestration_metrics", orchestrationMetrics);
-            await frameworkLogger.log("agent-delegator", "orchestration-metrics-logged", "info", {
-                parentTask: request.description?.substring(0, 50),
-                subAgentCount: agents.length,
-                subAgents: agents,
-                complexityLevel: complexityScore.level,
-            }, request.sessionId);
-            // Persist delegation analysis metrics to state for tracking
-            const existingMetrics = this.stateManager.get("delegation_metrics") || [];
-            const delegationMetric = {
-                timestamp: Date.now(),
-                operation: request.operation,
-                strategy: complexityScore.recommendedStrategy,
-                complexity: complexityScore,
-                estimatedDuration: metrics.estimatedDuration,
-                agents: agents,
-                analysisOnly: true,
-                sessionId: request.sessionId,
-            };
-            existingMetrics.push(delegationMetric);
-            if (existingMetrics.length > 100) {
-                existingMetrics.shift();
-            }
-            this.stateManager.set("delegation_metrics", existingMetrics);
-            await frameworkLogger.log("agent-delegator", "delegation-analyzed", "info", {
-                operation: request.operation,
-                strategy: complexityScore.recommendedStrategy,
-                complexity: complexityScore.score,
-                agentsCount: agents.length,
-            }, request.sessionId);
-            // Record for learning system
-            this.recordAnalysisForLearning(request, { agents, agentDetails, strategy: complexityScore.recommendedStrategy });
-            return {
-                strategy: complexityScore.recommendedStrategy,
-                agents,
-                agentDetails,
-                complexity: complexityScore,
-                conflictResolution,
-                estimatedDuration: metrics.estimatedDuration,
-            };
-        }
-        catch (error) {
-            await frameworkLogger.log("agent-delegator", "analysis-failed", "error", {
-                operation: request.operation,
-                error: String(error),
-            }, request.sessionId);
-            throw error;
-        }
-    }
-    determineAgents(metrics, complexityScore, kernelInsights) {
-        const agents = [];
-        const operation = metrics.operation;
-        // ── LEARNED ROUTING: check routing-mappings.json first ──
-        // This picks up refinements written by the inference tuner.
-        const learnedMapping = this.matchRoutingMappings(operation || "");
-        if (learnedMapping) {
-            frameworkLogger.log("agent-delegator", "routing-from-learned-mapping", "info", {
-                agent: learnedMapping.agent,
-                skill: learnedMapping.skill,
-                confidence: learnedMapping.confidence,
-                matchedKeywords: learnedMapping.keywords,
-                operation: operation.substring(0, 100),
-            });
-            agents.push({
-                name: learnedMapping.agent,
-                confidence: learnedMapping.confidence,
-                role: learnedMapping.skill || "learned",
-            });
-        }
-        if (operation === "security") {
-            // KERNEL-AWARE: Apply P6 (Security Vulnerability) and A8/A9 patterns
-            if (kernelInsights.fatalAssumptions?.some(a => a.id === 'A8' || a.id === 'A9')) {
-                // Kernel detected security foundation assumption
-                frameworkLogger.log("agent-delegator", "kernel-guided-security", "info", {
-                    detectedPattern: kernelInsights.fatalAssumptions?.find(a => a.id)?.id,
-                    guidance: 'Apply security foundation protocols first',
-                    kernelAction: kernelInsights.fatalAssumptions?.find(a => a.id)?.action,
-                });
-            }
-            agents.push({
-                name: "security-auditor",
-                confidence: 0.95,
-                role: "security",
-            });
-        }
-        if (operation === "review") {
-            agents.push({ name: "code-reviewer", confidence: 0.8, role: "review" });
-        }
-        if (operation === "design") {
-            agents.push({ name: "architect", confidence: 0.9, role: "design" });
-        }
-        if (complexityScore.recommendedStrategy === "multi-agent" ||
-            complexityScore.recommendedStrategy === "orchestrator-led") {
-            if (metrics.riskLevel === "critical") {
-                agents.push({
-                    name: "security-auditor",
-                    confidence: 0.95,
-                    role: "security",
-                });
-            }
-            if (metrics.operationType === "refactor") {
-                agents.push({
-                    name: "refactorer",
-                    confidence: 0.85,
-                    role: "refactoring",
-                });
-            }
-            if (metrics.dependencies > 3) {
-                agents.push({ name: "code-reviewer", confidence: 0.8, role: "review" });
-            }
-            if (agents.length === 1) {
-                agents.push({ name: "code-reviewer", confidence: 0.75, role: "validation" });
-            }
-        }
-        else {
-            if (metrics.operationType === "debug") {
-                agents.push({
-                    name: "bug-triage-specialist",
-                    confidence: 0.85,
-                    role: "debugging",
-                });
-            }
-            else if (metrics.operationType === "test") {
-                agents.push({
-                    name: "testing-lead",
-                    confidence: 0.8,
-                    role: "testing",
-                });
-            }
-            else if (metrics.operationType === "refactor") {
-                agents.push({
-                    name: "refactorer",
-                    confidence: 0.85,
-                    role: "refactoring",
-                });
-            }
-            else if (metrics.operationType === "create" && operation !== "design") {
-                agents.push({ name: "architect", confidence: 0.85, role: "design" });
-            }
-            else if (operation === "review" && agents.length === 0) {
-                agents.push({ name: "code-reviewer", confidence: 0.8, role: "review" });
-            }
-            else if (complexityScore.level === "moderate" ||
-                metrics.dependencies > 3) {
-                agents.push({ name: "code-reviewer", confidence: 0.8, role: "review" });
-            }
-            else if (agents.length === 0) {
-                agents.push({ name: "code-reviewer", confidence: 0.75, role: "validation" });
-            }
-        }
-        if (complexityScore.recommendedStrategy === "orchestrator-led") {
-            agents.push({
-                name: "architect",
-                confidence: 0.9,
-                role: "coordination",
-            });
-        }
-        const finalAgents = agents.length > 0
-            ? agents
-            : [{ name: "code-reviewer", confidence: 0.75, role: "validation" }];
-        // Log complete agent selection for analytics
-        frameworkLogger.log("agent-delegator", "agents-selected", "info", {
-            operation,
-            strategy: complexityScore.recommendedStrategy,
-            complexityLevel: complexityScore.level,
-            complexityScore: complexityScore.score,
-            agents: finalAgents.map(a => ({ name: a.name, role: a.role, confidence: a.confidence })),
-            agentCount: finalAgents.length,
-        });
-        // Feedback loop: if top agent confidence is low, consult historical outcomes
-        // and predictive analytics for a better routing suggestion.
-        // Threshold lowered to 0.7 so the prediction layer fires more often
-        // instead of being suppressed by hardcoded high confidence values.
-        const topAgent = finalAgents.reduce((best, a) => a.confidence > best.confidence ? a : best, finalAgents[0]);
-        if (topAgent && topAgent.confidence < 0.7) {
-            try {
-                const prediction = predictiveAnalytics.predictSync(operation || "");
-                if (prediction && prediction.confidence > topAgent.confidence) {
-                    frameworkLogger.log("agent-delegator", "routing-refined-by-prediction", "info", {
-                        originalAgent: topAgent.name,
-                        originalConfidence: topAgent.confidence,
-                        predictedAgent: prediction.agent,
-                        predictedConfidence: prediction.confidence,
-                        sampleSize: prediction.sampleSize,
-                    });
-                    // Promote predicted agent if not already in the list
-                    if (!finalAgents.some(a => a.name === prediction.agent)) {
-                        finalAgents.unshift({
-                            name: prediction.agent,
-                            confidence: prediction.confidence,
-                            role: "predicted",
-                        });
-                    }
-                }
-            }
-            catch {
-                // Prediction unavailable — continue with original agents
-            }
-        }
-        return finalAgents;
-    }
-    mapOperationToType(operation) {
-        const op = operation.toLowerCase();
-        if (op.includes("security") || op.includes("audit")) {
-            return "analyze";
-        }
-        if (op.includes("review") || op.includes("quality")) {
-            return "modify";
-        }
-        if (op.includes("refactor") || op.includes("restructure")) {
-            return "refactor";
-        }
-        if (op.includes("debug") || op.includes("fix") || op.includes("resolve")) {
-            return "debug";
-        }
-        if (op.includes("test")) {
-            return "test";
-        }
-        if (op.includes("create") || op.includes("add") || op.includes("new")) {
-            return "create";
-        }
-        if (op.includes("design") || op.includes("architect")) {
-            return "create";
-        }
-        return "modify";
-    }
-    /**
-     * Record analysis results for learning system
-     */
-    recordAnalysisForLearning(request, analysis) {
-        for (const agentName of analysis.agents) {
-            const agentDetail = analysis.agentDetails.find(a => a.name === agentName);
-            routingOutcomeTracker.recordOutcome({
-                taskId: request.sessionId || `analysis-${Date.now()}`,
-                taskDescription: request.description,
-                routedAgent: agentName,
-                routedSkill: agentDetail?.role || agentName.replace("-", "_") + "_skill",
-                confidence: agentDetail?.confidence || 0.8,
-                success: true,
-            });
-        }
-    }
-    determineConflictResolution(metrics, complexityScore) {
-        if (complexityScore.level === "enterprise" ||
-            metrics.riskLevel === "critical") {
-            return "expert_priority";
-        }
-        if (complexityScore.level === "complex" || metrics.dependencies > 5) {
-            return "consensus";
-        }
-        return "majority_vote";
-    }
-    /**
-   * Resolve the project directory for delegated agents
-   * Ensures working directory is set correctly (src/ vs dist/ vs project root)
-   */
-    resolveProjectDirectory() {
-        const root = process.cwd();
-        if (fs.existsSync(`${root}/package.json`) || fs.existsSync(`${root}/xray.config.json`)) {
-            return root;
-        }
-        let current = root;
-        const maxLevels = 5;
-        for (let i = 0; i < maxLevels; i++) {
-            const parent = nodePath.dirname(current);
-            if (fs.existsSync(`${parent}/package.json`)) {
-                return parent;
-            }
-            current = parent;
-        }
-        return root;
-    }
-    /**
-     * Allowlist of valid agent names for dynamic imports
-     * Prevents path traversal and unauthorized agent loading
-     */
-    static ALLOWED_AGENTS = new Set(getActiveAgents());
-    /**
-     * Validate agent name for security
-     * @throws Error if agent name is invalid or not allowed
-     */
-    validateAgentName(agentName) {
-        // Check for path traversal attempts
-        if (agentName.includes('..') || agentName.includes('/') || agentName.includes('\\')) {
-            throw new Error(`Invalid agent name: path traversal detected in "${agentName}"`);
-        }
-        // Check for other dangerous characters
-        if (!/^[a-zA-Z0-9_-]+$/.test(agentName)) {
-            throw new Error(`Invalid agent name: only alphanumeric, underscore, and hyphen allowed in "${agentName}"`);
-        }
-        // Check allowlist
-        if (!isAllowedAgent(agentName)) {
-            throw new Error(`Agent "${agentName}" is not in the allowed list`);
-        }
-    }
-    /**
-     * Create a properly configured agent with full tool access and working directory context
-     */
-    createProperlyConfiguredAgent(agentName, agentConfig, request) {
-        this.validateAgentName(agentName);
-        return {
-            config: agentConfig,
-            agentName: agentName,
-            execute: async (_req) => {
-                return {
-                    agent: agentName,
-                    operation: request.operation,
-                    description: request.description,
-                    capabilities: agentConfig.capabilities,
-                    mode: agentConfig.mode,
-                    status: "delegated",
-                    timestamp: new Date().toISOString(),
-                    message: `Agent ${agentName} delegated via skill/MCP layer`,
-                };
-            },
-            getCapabilities: () => agentConfig.capabilities,
-            getMaxComplexity: () => agentConfig.maxComplexity,
-            isEnabled: () => agentConfig.enabled,
-            isAgent: true,
-            getType: () => 'agent'
-        };
-    }
-    /**
-     * Clear agent-stub creation and deprecated features
-     * Remove this method if it exists in the future version
-     */
-    clearDeprecatedStubAgent() {
-        // Legacy method removal - this ensures no stub agents are created
-        frameworkLogger.log("agent-delegator", "deprecated-method-removed", "info", {
-            message: "Cleared deprecated stub agent creation to ensure proper tool access",
-            timestamp: new Date().toISOString()
-        });
-    }
-    async executeDelegation(analysis, request) {
-        const startTime = Date.now();
-        const results = [];
-        const errors = [];
-        // Set up proper working directory for delegated agents
-        const originalWorkingDir = process.cwd();
-        const projectRootDir = this.resolveProjectDirectory();
-        try {
-            // Change to project working directory for all delegated agents
-            process.chdir(projectRootDir);
-            // Properly configured agent execution
-            const { builtinAgents } = await import("../agents/index.js");
-            for (const agentName of analysis.agents) {
-                const agentStartTime = Date.now();
-                try {
-                    // First check state manager for custom/mock agents (for testing)
-                    let agentInstance = this.stateManager.get(`agent:${agentName}`);
-                    // If no custom agent in state, use builtin configuration
-                    if (!agentInstance) {
-                        const agentConfig = builtinAgents[agentName];
-                        if (!agentConfig) {
-                            throw new Error(`Agent ${agentName} not found in builtin agents`);
-                        }
-                        // Create properly configured agent with full tool access
-                        agentInstance = this.createProperlyConfiguredAgent(agentName, agentConfig, request);
-                    }
-                    // Execute the agent
-                    const output = await agentInstance.execute(request);
-                    const executionTime = Date.now() - agentStartTime;
-                    results.push({
-                        agent: agentName,
-                        output,
-                        executionTime,
-                    });
-                    const successInvocation = {
-                        agentName,
-                        agentType: agentName,
-                        operation: request.operation,
-                        description: request.description,
-                        complexityLevel: analysis.complexity.level,
-                        complexityScore: analysis.complexity.score,
-                        duration: executionTime,
-                    };
-                    if (request.sessionId) {
-                        successInvocation.sessionId = request.sessionId;
-                    }
-                    this.agentMetrics.trackSuccess(successInvocation);
-                    await frameworkLogger.log("agent-delegator", "agent-executed", "success", {
-                        agent: agentName,
-                        executionTime,
-                        success: true,
-                        workingDirectory: projectRootDir,
-                    }, request.sessionId);
-                }
-                catch (error) {
-                    const executionTime = Date.now() - agentStartTime;
-                    const errorMessage = `Agent ${agentName} failed: ${String(error)}`;
-                    errors.push(errorMessage);
-                    const failureInvocation = {
-                        agentName,
-                        agentType: agentName,
-                        operation: request.operation,
-                        description: request.description,
-                        complexityLevel: analysis.complexity.level,
-                        complexityScore: analysis.complexity.score,
-                        duration: executionTime,
-                        error: errorMessage,
-                    };
-                    if (request.sessionId) {
-                        failureInvocation.sessionId = request.sessionId;
-                    }
-                    this.agentMetrics.trackFailure(failureInvocation);
-                    await frameworkLogger.log("agent-delegator", "agent-execution-failed", "error", {
-                        agent: agentName,
-                        executionTime,
-                        error: errorMessage,
-                        workingDirectory: projectRootDir,
-                    }, request.sessionId);
-                }
-            }
-            const totalTime = Date.now() - startTime;
-            const success = errors.length === 0 && results.length > 0;
-            const existingMetrics = this.stateManager.get("delegation_metrics") || [];
-            const delegationMetric = {
-                timestamp: Date.now(),
-                operation: request.operation,
-                strategy: analysis.strategy,
-                complexity: analysis.complexity,
-                estimatedDuration: analysis.estimatedDuration,
-                agents: analysis.agents,
-                results,
-                totalTime,
-                success,
-                errors,
-                analysisOnly: false,
-                sessionId: request.sessionId,
-            };
-            existingMetrics.push(delegationMetric);
-            if (existingMetrics.length > 100) {
-                existingMetrics.shift();
-            }
-            this.stateManager.set("delegation_metrics", existingMetrics);
-            await frameworkLogger.log("agent-delegator", "delegation-completed", success ? "success" : "error", {
-                strategy: analysis.strategy,
-                agentsCount: analysis.agents.length,
-                successCount: results.length,
-                errorCount: errors.length,
-                totalTime,
-            }, request.sessionId);
-            // Restore original working directory
-            process.chdir(originalWorkingDir);
-            return {
-                success,
-                results,
-                totalTime,
-                errors: errors.length > 0 ? errors : undefined,
-            };
-        }
-        catch (error) {
-            // Ensure working directory is restored even on failure
-            process.chdir(originalWorkingDir);
-            const totalTime = Date.now() - startTime;
-            await frameworkLogger.log("agent-delegator", "delegation-failed", "error", {
-                error: String(error),
-                totalTime,
-                workingDirectoryRestored: process.cwd(),
-            }, request.sessionId);
-            throw error;
-        }
-    }
-    getPerformanceMetrics() {
-        const delegations = this.stateManager.get("delegation_metrics") || [];
-        const executionDelegations = delegations.filter((d) => !d.analysisOnly);
-        const totalDelegations = executionDelegations.length > 0
-            ? executionDelegations.length
-            : delegations.length;
-        const successfulDelegations = executionDelegations.filter((d) => d.success).length;
-        const failedDelegations = executionDelegations.filter((d) => !d.success).length;
-        const averageExecutionTime = totalDelegations > 0
-            ? delegations.reduce((sum, d) => sum + (d.totalTime || 0), 0) /
-                totalDelegations
-            : 0;
-        const agentUtilization = {};
-        const strategyUsage = {};
-        let totalComplexity = 0;
-        let totalDuration = 0;
-        delegations.forEach((delegation) => {
-            if (delegation.strategy) {
-                strategyUsage[delegation.strategy] =
-                    (strategyUsage[delegation.strategy] || 0) + 1;
-            }
-            if (delegation.complexity?.score) {
-                totalComplexity += delegation.complexity.score || 0;
-            }
-            if (delegation.estimatedDuration) {
-                totalDuration += delegation.estimatedDuration || 0;
-            }
-            (delegation.results || []).forEach((result) => {
-                agentUtilization[result.agent] =
-                    (agentUtilization[result.agent] || 0) + 1;
-            });
-        });
-        const averageResponseTime = averageExecutionTime;
-        const averageComplexity = totalDelegations > 0 ? totalComplexity / totalDelegations : 0;
-        const averageDuration = totalDelegations > 0 ? totalDuration / totalDelegations : 0;
-        return {
-            totalDelegations,
-            successfulDelegations,
-            failedDelegations,
-            averageExecutionTime,
-            averageResponseTime,
-            averageComplexity,
-            averageDuration,
-            strategyUsage,
-            agentUtilization,
-        };
-    }
-    getDelegationMetrics() {
-        const baseMetrics = this.getPerformanceMetrics();
-        const recentDelegations = (this.stateManager.get("delegation_metrics") || [])
-            .slice(-10)
-            .map((d) => ({
-            timestamp: d.timestamp || Date.now(),
-            operation: d.operation,
-            strategy: d.strategy,
-            success: d.success,
-            totalTime: d.totalTime,
-        }));
-        return {
-            ...baseMetrics,
-            recentDelegations,
-        };
-    }
-    aggregateAllMetrics() {
-        return {
-            delegation: aggregateDelegationMetrics(this.stateManager),
-            orchestration: aggregateOrchestrationMetrics(this.stateManager),
-        };
-    }
-    getMetricsByAgent(type = "delegation") {
-        return summarizeByAgent(this.stateManager, type);
-    }
-    getMetricsByComplexity(type = "delegation") {
-        return summarizeByComplexityLevel(this.stateManager, type);
-    }
-    getMetricsByTimePeriod(type = "delegation") {
-        return summarizeByTimePeriod(this.stateManager, type);
-    }
-    rotateMetricsEntries(maxEntries = 100) {
-        return rotateMetrics(this.stateManager, maxEntries);
-    }
-    cleanupMetricsOlderThan(olderThanMs) {
-        return cleanupOldMetrics(this.stateManager, olderThanMs);
-    }
-    exportMetricsData(format = "json") {
-        return exportMetrics(this.stateManager, format);
-    }
-    updateAgentCapability(agentName, capabilities) {
-        const availableAgents = this.getAvailableAgents();
-        const agentIndex = availableAgents.findIndex((a) => a.name === agentName);
-        if (agentIndex !== -1) {
-            const existingAgent = availableAgents[agentIndex];
-            const updatedAgent = {
-                ...existingAgent,
-                ...capabilities,
-                name: agentName,
-                capabilities: capabilities.capabilities || existingAgent?.capabilities || [],
-                status: capabilities.status || existingAgent?.status || "active",
-            };
-            availableAgents[agentIndex] = updatedAgent;
-            this.stateManager.set(`agent_capabilities:${agentName}`, updatedAgent);
-            frameworkLogger.log("agent-delegator", "agent-capability-updated", "info", {
-                agentName,
-                updatedCapabilities: capabilities,
-            });
-        }
-    }
-}
-export function createAgentDelegator(stateManager, configLoader) {
-    return new AgentDelegator(stateManager, configLoader);
-}