0xray 4.0.13 → 4.0.15

package/dist/delegation/agent-delegator.js

@@ -0,0 +1,768 @@
+/**
+ * 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);
+}