0xray 2.0.0

package/dist/delegation/strategy-selector.js

@@ -0,0 +1,108 @@
+/**
+ * Adaptive Strategy Selector
+ *
+ * Selects the optimal voting strategy based on:
+ * - Complexity level of the task
+ * - Risk level involved
+ * - Security concerns
+ * - Architectural impact
+ * - Participant count
+ *
+ * @version 1.0.0
+ * @since 2026-04-16
+ */
+const DEFAULT_STRATEGY_CONFIG = {
+    simple: "majority_vote",
+    moderate: "majority_vote",
+    complex: "consensus",
+    enterprise: "expert_priority",
+    securityDominant: "expert_priority",
+    architecturalDominant: "expert_priority",
+};
+const RISK_WEIGHT_MAP = {
+    low: 1,
+    medium: 2,
+    high: 3,
+    critical: 4,
+};
+const SECURITY_DOMAINS = ["security", "audit", "vulnerability", "access-control"];
+const ARCHITECTURAL_DOMAINS = ["architecture", "design", "planning", "system-design"];
+export class AdaptiveStrategySelector {
+    config;
+    constructor(config = {}) {
+        this.config = { ...DEFAULT_STRATEGY_CONFIG, ...config };
+    }
+    selectStrategy(context) {
+        const { complexity, riskLevel, participantCount, hasSecurityConcerns, hasArchitecturalImpact } = context;
+        if (hasSecurityConcerns || this.isSecurityRelated(context)) {
+            return this.config.securityDominant;
+        }
+        if (hasArchitecturalImpact || this.isArchitecturalRelated(context)) {
+            return this.config.architecturalDominant;
+        }
+        const riskScore = RISK_WEIGHT_MAP[riskLevel] ?? 1;
+        if (complexity >= 50) {
+            return riskScore >= 3 ? this.config.enterprise : this.config.complex;
+        }
+        if (complexity >= 25) {
+            return riskScore >= 2 ? this.config.complex : this.config.moderate;
+        }
+        if (participantCount >= 4 && riskScore >= 2) {
+            return this.config.moderate;
+        }
+        return this.config.simple;
+    }
+    selectStrategyWithDefaults(complexity, riskLevel, hasSecurityConcerns = false, hasArchitecturalImpact = false, participantCount = 3) {
+        return this.selectStrategy({
+            complexity,
+            riskLevel,
+            participantCount,
+            hasSecurityConcerns,
+            hasArchitecturalImpact,
+        });
+    }
+    getStrategyReasoning(context) {
+        const strategy = this.selectStrategy(context);
+        const reasons = [];
+        reasons.push(`Complexity: ${context.complexity} (${this.getComplexityTier(context.complexity)})`);
+        reasons.push(`Risk: ${context.riskLevel}`);
+        reasons.push(`Participants: ${context.participantCount}`);
+        if (context.hasSecurityConcerns || this.isSecurityRelated(context)) {
+            reasons.push("Security concerns detected");
+        }
+        if (context.hasArchitecturalImpact || this.isArchitecturalRelated(context)) {
+            reasons.push("Architectural impact detected");
+        }
+        reasons.push(`Selected strategy: ${strategy}`);
+        return reasons.join(" | ");
+    }
+    isSecurityRelated(context) {
+        if (context.hasSecurityConcerns)
+            return true;
+        return false;
+    }
+    isArchitecturalRelated(context) {
+        if (context.hasArchitecturalImpact)
+            return true;
+        return false;
+    }
+    getComplexityTier(complexity) {
+        if (complexity < 15)
+            return "simple";
+        if (complexity < 25)
+            return "moderate";
+        if (complexity < 50)
+            return "complex";
+        return "enterprise";
+    }
+    getConfig() {
+        return { ...this.config };
+    }
+    updateConfig(config) {
+        this.config = { ...this.config, ...config };
+    }
+}
+export const adaptiveStrategySelector = new AdaptiveStrategySelector();
+export function selectVotingStrategy(complexity, riskLevel, hasSecurityConcerns = false, hasArchitecturalImpact = false, participantCount = 3) {
+    return adaptiveStrategySelector.selectStrategyWithDefaults(complexity, riskLevel, hasSecurityConcerns, hasArchitecturalImpact, participantCount);
+}

package/dist/delegation/voting-coordinator.js

@@ -0,0 +1,375 @@
+/**
+ * Voting Coordinator
+ *
+ * Multi-agent voting system with:
+ * - Weighted confidence scoring based on agent expertise
+ * - Adaptive strategy selection
+ * - Historical learning and pattern detection
+ * - Integration with session coordinator
+ *
+ * @version 1.0.0
+ * @since 2026-04-16
+ */
+import * as crypto from "crypto";
+import { getAgentExpertiseLevel, getVotingWeight } from "./agent-expertise.js";
+import { selectVotingStrategy, adaptiveStrategySelector } from "./strategy-selector.js";
+import { WeightedVotingAggregator } from "./weighted-voting-aggregator.js";
+import { frameworkLogger } from "../core/framework-logger.js";
+const MAX_HISTORY_ENTRIES = 500;
+const VOTE_TIMEOUT_MS = 30000;
+const DEFAULT_CONFIG = {
+    enableHistoryTracking: true,
+    enableLearning: true,
+    minVotersForConsensus: 3,
+    consensusThreshold: 0.7,
+};
+export class VotingCoordinator {
+    stateManager;
+    sessionCoordinator;
+    activeVotingSessions = new Map();
+    votingHistory = [];
+    metrics;
+    config;
+    aggregator;
+    constructor(stateManager, sessionCoordinator, config = {}) {
+        this.stateManager = stateManager;
+        this.sessionCoordinator = sessionCoordinator ?? undefined;
+        this.config = { ...DEFAULT_CONFIG, ...config };
+        this.aggregator = new WeightedVotingAggregator();
+        this.metrics = this.initializeMetrics();
+        this.loadHistory();
+    }
+    async initiateVoting(sessionId, topic, description, participants, context) {
+        const complexity = context?.complexity ?? 25;
+        const riskLevel = context?.riskLevel ?? "medium";
+        const hasSecurity = context?.hasSecurityConcerns ?? false;
+        const hasArch = context?.hasArchitecturalImpact ?? false;
+        const participantCount = context?.participantCount ?? participants.length;
+        const strategy = context
+            ? adaptiveStrategySelector.selectStrategyWithDefaults(complexity, riskLevel, hasSecurity, hasArch, participantCount)
+            : selectVotingStrategy(complexity, riskLevel, hasSecurity, hasArch, participants.length);
+        const votingSession = {
+            id: `vote_${Date.now()}_${crypto.randomBytes(4).toString("hex")}`,
+            sessionId,
+            topic,
+            description,
+            strategy,
+            complexity,
+            riskLevel,
+            participants,
+            votes: [],
+            createdAt: Date.now(),
+        };
+        this.activeVotingSessions.set(votingSession.id, votingSession);
+        frameworkLogger.log("VotingCoordinator", "voting-initiated", "info", {
+            sessionId: votingSession.id,
+            topic,
+            strategy,
+            participantCount: participants.length,
+        });
+        if (this.sessionCoordinator) {
+            this.sessionCoordinator.shareContext(sessionId, `vote:${votingSession.id}`, { topic, strategy, participants: [] }, "voting-coordinator");
+        }
+        return votingSession.id;
+    }
+    submitVote(voteId, agentName, vote, confidence, reasoning) {
+        const session = this.activeVotingSessions.get(voteId);
+        if (!session) {
+            frameworkLogger.log("VotingCoordinator", "vote-submission-failed", "warning", {
+                voteId,
+                reason: "Session not found",
+            });
+            return false;
+        }
+        if (!session.participants.includes(agentName)) {
+            frameworkLogger.log("VotingCoordinator", "vote-submission-failed", "warning", {
+                voteId,
+                agentName,
+                reason: "Agent not authorized",
+            });
+            return false;
+        }
+        const existingVoteIndex = session.votes.findIndex((v) => v.agentName === agentName);
+        const voteChoice = {
+            agentName,
+            vote,
+            confidence: Math.max(0, Math.min(1, confidence)),
+            reasoning,
+            timestamp: Date.now(),
+        };
+        if (existingVoteIndex >= 0) {
+            session.votes[existingVoteIndex] = voteChoice;
+        }
+        else {
+            session.votes.push(voteChoice);
+        }
+        this.metrics.totalVotes++;
+        if (this.sessionCoordinator) {
+            this.sessionCoordinator.shareContext(session.sessionId, `vote:${voteId}`, { topic: session.topic, strategy: session.strategy, votes: session.votes }, agentName);
+        }
+        frameworkLogger.log("VotingCoordinator", "vote-submitted", "info", {
+            voteId,
+            agentName,
+            vote,
+            confidence,
+        });
+        return true;
+    }
+    resolveVoting(voteId) {
+        const session = this.activeVotingSessions.get(voteId);
+        if (!session) {
+            return null;
+        }
+        if (session.votes.length === 0) {
+            frameworkLogger.log("VotingCoordinator", "resolve-failed", "error", {
+                voteId,
+                reason: "No votes cast",
+            });
+            return null;
+        }
+        let result;
+        switch (session.strategy) {
+            case "majority_vote":
+                result = this.resolveMajorityVote(session);
+                break;
+            case "consensus":
+                result = this.resolveConsensus(session);
+                break;
+            case "expert_priority":
+                result = this.resolveExpertPriority(session);
+                break;
+            default:
+                result = this.resolveMajorityVote(session);
+        }
+        session.result = result;
+        session.resolvedAt = Date.now();
+        this.recordVotingHistory(session, result);
+        this.metrics.successfulVotes++;
+        this.updateMetricsAfterVote(result);
+        this.activeVotingSessions.delete(voteId);
+        if (this.sessionCoordinator) {
+            this.sessionCoordinator.recordConflict(session.sessionId, session.participants, session.strategy, result.decision);
+        }
+        frameworkLogger.log("VotingCoordinator", "voting-resolved", "info", {
+            voteId,
+            strategy: session.strategy,
+            decision: result.decision,
+            confidence: result.confidence,
+        });
+        return result;
+    }
+    resolveConflict(request) {
+        const { sessionId, topic, description, agents, requiresSecurityVote, requiresArchitectureVote, complexity, riskLevel } = request;
+        const context = {
+            complexity,
+            riskLevel,
+            participantCount: agents.length,
+            hasSecurityConcerns: requiresSecurityVote,
+            hasArchitecturalImpact: requiresArchitectureVote,
+        };
+        const strategy = adaptiveStrategySelector.selectStrategy(context);
+        const votingId = this.initiateVoting(sessionId, topic, description, agents, context);
+        const response = {
+            resolved: true,
+            strategy,
+            confidence: 0,
+            details: `Conflict resolution initiated with strategy: ${strategy}`,
+            participatingAgents: agents,
+        };
+        return response;
+    }
+    getAggregator() {
+        return this.aggregator;
+    }
+    getVotingSession(voteId) {
+        return this.activeVotingSessions.get(voteId);
+    }
+    getActiveVotingSessions() {
+        return Array.from(this.activeVotingSessions.values());
+    }
+    getVotingHistory(sessionId, limit) {
+        let history = this.votingHistory;
+        if (sessionId) {
+            history = history.filter((entry) => entry.sessionId === sessionId);
+        }
+        if (limit) {
+            history = history.slice(-limit);
+        }
+        return history;
+    }
+    getMetrics() {
+        return { ...this.metrics };
+    }
+    resolveMajorityVote(session) {
+        const aggregated = this.aggregator.aggregateVotes(session.votes);
+        if (aggregated.length === 0) {
+            return {
+                decision: "",
+                confidence: 0,
+                strategy: "majority_vote",
+                voteCount: 0,
+                winningVotes: 0,
+                totalVoters: session.participants.length,
+                tied: false,
+                details: [],
+            };
+        }
+        const winner = aggregated[0];
+        const second = aggregated[1];
+        const tied = Boolean(second && Math.abs(winner.totalWeight - second.totalWeight) < 0.01);
+        const totalWeight = aggregated.reduce((sum, agg) => sum + agg.totalWeight, 0);
+        const confidence = totalWeight > 0 ? winner.totalWeight / totalWeight : 0;
+        const details = session.votes.map((vote) => ({
+            agentName: vote.agentName,
+            expertiseLevel: getAgentExpertiseLevel(vote.agentName),
+            vote: vote.vote,
+            weight: this.aggregator.calculateTotalVoteWeight(vote.agentName, vote.confidence),
+            contributed: vote.vote === winner.option,
+        }));
+        return {
+            decision: winner.option,
+            confidence,
+            strategy: "majority_vote",
+            voteCount: session.votes.length,
+            winningVotes: winner.contributingAgents.length,
+            totalVoters: session.participants.length,
+            tied,
+            details,
+        };
+    }
+    resolveConsensus(session) {
+        const aggregated = this.aggregator.aggregateVotes(session.votes);
+        if (aggregated.length === 0) {
+            return {
+                decision: "", confidence: 0, strategy: "consensus",
+                voteCount: 0, winningVotes: 0, totalVoters: session.participants.length,
+                tied: false, details: [],
+            };
+        }
+        const winner = aggregated[0];
+        const requiredVotes = Math.ceil(session.participants.length * this.config.consensusThreshold);
+        const hasConsensus = winner.contributingAgents.length >= requiredVotes;
+        if (hasConsensus) {
+            const winnerVotes = session.votes.filter((v) => v.vote === winner.option);
+            const avgConfidence = winnerVotes.reduce((s, v) => s + v.confidence, 0) / winnerVotes.length;
+            const expertiseSum = winnerVotes.reduce((s, v) => s + this.aggregator.calculateTotalVoteWeight(v.agentName, v.confidence), 0);
+            const totalWeight = winnerVotes.reduce((s, v) => s + getVotingWeight(v.agentName), 0);
+            const confidence = totalWeight > 0 ? avgConfidence * (expertiseSum / (totalWeight * 10)) : avgConfidence;
+            return {
+                decision: winner.option, confidence, strategy: "consensus",
+                voteCount: session.votes.length, winningVotes: winnerVotes.length,
+                totalVoters: session.participants.length, tied: false,
+                details: winnerVotes.map((v) => ({
+                    agentName: v.agentName, expertiseLevel: getAgentExpertiseLevel(v.agentName),
+                    vote: v.vote, weight: this.aggregator.calculateTotalVoteWeight(v.agentName, v.confidence),
+                    contributed: true,
+                })),
+            };
+        }
+        const second = aggregated[1];
+        const tied = Boolean(second && Math.abs(winner.totalWeight - second.totalWeight) < 0.01);
+        const winnerVotes = session.votes.filter((v) => v.vote === winner.option);
+        const avgConfidence = winnerVotes.length > 0 ? winnerVotes.reduce((s, v) => s + v.confidence, 0) / winnerVotes.length : 0;
+        return {
+            decision: winner.option, confidence: avgConfidence * 0.5, strategy: "consensus",
+            voteCount: session.votes.length, winningVotes: winnerVotes.length,
+            totalVoters: session.participants.length, tied,
+            details: winnerVotes.map((v) => ({
+                agentName: v.agentName, expertiseLevel: getAgentExpertiseLevel(v.agentName),
+                vote: v.vote, weight: this.aggregator.calculateTotalVoteWeight(v.agentName, v.confidence),
+                contributed: true,
+            })),
+        };
+    }
+    resolveExpertPriority(session) {
+        const experts = new Map();
+        for (const vote of session.votes) {
+            const expertise = getAgentExpertiseLevel(vote.agentName);
+            const existing = experts.get(vote.agentName);
+            if (!existing || expertise > existing.expertise) {
+                experts.set(vote.agentName, { expertise, vote });
+            }
+        }
+        const sortedByExpertise = Array.from(experts.values()).sort((a, b) => b.expertise - a.expertise);
+        const topExpert = sortedByExpertise[0];
+        const secondExpert = sortedByExpertise[1];
+        const tied = Boolean(secondExpert && topExpert && topExpert.expertise === secondExpert.expertise);
+        const details = session.votes.map((v) => ({
+            agentName: v.agentName,
+            expertiseLevel: getAgentExpertiseLevel(v.agentName),
+            vote: v.vote,
+            weight: getVotingWeight(v.agentName),
+            contributed: v.agentName === topExpert?.vote?.agentName,
+        }));
+        return {
+            decision: topExpert?.vote?.vote ?? "",
+            confidence: ((topExpert?.vote?.confidence ?? 0) * (topExpert?.expertise ?? 5)) / 10,
+            strategy: "expert_priority",
+            voteCount: session.votes.length,
+            winningVotes: topExpert ? 1 : 0,
+            totalVoters: session.participants.length,
+            tied,
+            details,
+        };
+    }
+    recordVotingHistory(session, result) {
+        if (!this.config.enableHistoryTracking)
+            return;
+        const entry = {
+            id: session.id,
+            sessionId: session.sessionId,
+            topic: session.topic,
+            voteCount: session.votes.length,
+            strategy: session.strategy,
+            decision: result.decision,
+            confidence: result.confidence,
+            participantCount: session.participants.length,
+            timestamp: session.createdAt,
+            resolvedAt: session.resolvedAt ?? Date.now(),
+        };
+        this.votingHistory.push(entry);
+        if (this.votingHistory.length > MAX_HISTORY_ENTRIES) {
+            this.votingHistory = this.votingHistory.slice(-MAX_HISTORY_ENTRIES);
+        }
+        this.stateManager.set("voting:history", this.votingHistory);
+    }
+    loadHistory() {
+        if (!this.config.enableHistoryTracking)
+            return;
+        try {
+            const history = this.stateManager.get("voting:history");
+            if (Array.isArray(history)) {
+                this.votingHistory = history;
+            }
+        }
+        catch (error) {
+            frameworkLogger.log("VotingCoordinator", "history-load-failed", "warning", { error });
+        }
+    }
+    initializeMetrics() {
+        return {
+            totalVotes: 0,
+            successfulVotes: 0,
+            failedVotes: 0,
+            averageConfidence: 0,
+            strategyUsage: {
+                majority_vote: 0,
+                consensus: 0,
+                expert_priority: 0,
+            },
+            agentParticipation: {},
+            averageVoterTurnout: 0,
+        };
+    }
+    updateMetricsAfterVote(result) {
+        this.metrics.strategyUsage[result.strategy]++;
+        if (result.confidence > 0) {
+            const total = this.metrics.successfulVotes;
+            this.metrics.averageConfidence =
+                (this.metrics.averageConfidence * (total - 1) + result.confidence) / total;
+        }
+    }
+}
+export const createVotingCoordinator = (stateManager, sessionCoordinator) => {
+    return new VotingCoordinator(stateManager, sessionCoordinator);
+};

package/dist/delegation/voting-types.js

@@ -0,0 +1,10 @@
+/**
+ * Voting System Types
+ *
+ * Comprehensive type definitions for the multi-agent voting system
+ * with weighted confidence scoring and adaptive conflict resolution.
+ *
+ * @version 1.0.0
+ * @since 2026-04-16
+ */
+export {};

package/dist/delegation/weighted-voting-aggregator.js

@@ -0,0 +1,194 @@
+/**
+ * Weighted Voting Aggregator
+ *
+ * Advanced voting system with:
+ * - Confidence-weighted voting where agent confidence affects their vote weight
+ * - History-weighted voting that considers past successful votes
+ * - Multiple aggregation strategies for different decision scenarios
+ *
+ * @version 1.0.0
+ * @since 2026-04-17
+ */
+import { getAgentExpertiseLevel, getVotingWeight, } from "./agent-expertise.js";
+import { frameworkLogger } from "../core/framework-logger.js";
+export const DEFAULT_HISTORICAL_CONFIG = {
+    decayFactor: 0.95,
+    minWeight: 0.1,
+    maxWeight: 1.5,
+    lookbackPeriod: 30 * 24 * 60 * 60 * 1000,
+    successThreshold: 0.6,
+};
+export const DEFAULT_CONFIDENCE_CONFIG = {
+    expertiseMultiplier: 1.0,
+    confidenceMultiplier: 1.0,
+    minConfidenceThreshold: 0.3,
+    normalizeScores: true,
+};
+export class WeightedVotingAggregator {
+    historicalConfig;
+    confidenceConfig;
+    agentPerformance;
+    constructor(historicalConfig = {}, confidenceConfig = {}) {
+        this.historicalConfig = { ...DEFAULT_HISTORICAL_CONFIG, ...historicalConfig };
+        this.confidenceConfig = { ...DEFAULT_CONFIDENCE_CONFIG, ...confidenceConfig };
+        this.agentPerformance = new Map();
+    }
+    calculateExpertiseWeight(agentName) {
+        const expertiseLevel = getAgentExpertiseLevel(agentName);
+        const baseWeight = getVotingWeight(agentName);
+        return baseWeight * (expertiseLevel / 10);
+    }
+    calculateConfidenceWeight(agentName, voteConfidence) {
+        if (voteConfidence < this.confidenceConfig.minConfidenceThreshold) {
+            return 0;
+        }
+        const expertiseLevel = getAgentExpertiseLevel(agentName);
+        const expertiseBonus = (expertiseLevel / 10) * this.confidenceConfig.expertiseMultiplier;
+        const confidenceImpact = voteConfidence * this.confidenceConfig.confidenceMultiplier;
+        return expertiseBonus * confidenceImpact;
+    }
+    calculateHistoricalWeight(agentName) {
+        const performance = this.agentPerformance.get(agentName);
+        if (!performance) {
+            return 1.0;
+        }
+        const { totalVotes, correctVotes, weightedScore, lastActivity } = performance;
+        const daysSinceActive = (Date.now() - lastActivity) / (24 * 60 * 60 * 1000);
+        const decay = Math.pow(this.historicalConfig.decayFactor, daysSinceActive);
+        const successRate = totalVotes > 0 ? correctVotes / totalVotes : 0.5;
+        const minSuccess = this.historicalConfig.successThreshold;
+        let historicalWeight;
+        if (successRate >= minSuccess) {
+            historicalWeight = 1 + (successRate - minSuccess) * 0.5;
+        }
+        else {
+            historicalWeight = 0.5 + (successRate / minSuccess) * 0.5;
+        }
+        historicalWeight *= decay;
+        historicalWeight *= (weightedScore / 100);
+        return Math.max(this.historicalConfig.minWeight, Math.min(this.historicalConfig.maxWeight, historicalWeight));
+    }
+    calculateTotalVoteWeight(agentName, voteConfidence) {
+        const expertiseWeight = this.calculateExpertiseWeight(agentName);
+        const confidenceWeight = this.calculateConfidenceWeight(agentName, voteConfidence);
+        const historicalWeight = this.calculateHistoricalWeight(agentName);
+        return expertiseWeight * confidenceWeight * historicalWeight;
+    }
+    aggregateVotes(votes) {
+        const aggregated = new Map();
+        for (const vote of votes) {
+            const expertiseWeight = this.calculateExpertiseWeight(vote.agentName);
+            const confidenceWeight = this.calculateConfidenceWeight(vote.agentName, vote.confidence);
+            const historicalWeight = this.calculateHistoricalWeight(vote.agentName);
+            const totalWeight = expertiseWeight * confidenceWeight * historicalWeight;
+            const existing = aggregated.get(vote.vote);
+            if (existing) {
+                existing.baseWeight += expertiseWeight;
+                existing.confidenceWeight += confidenceWeight;
+                existing.historicalWeight += historicalWeight;
+                existing.totalWeight += totalWeight;
+                existing.contributingAgents.push(vote.agentName);
+            }
+            else {
+                aggregated.set(vote.vote, {
+                    option: vote.vote,
+                    baseWeight: expertiseWeight,
+                    expertiseWeight: expertiseWeight,
+                    confidenceWeight,
+                    historicalWeight,
+                    totalWeight,
+                    contributingAgents: [vote.agentName],
+                });
+            }
+        }
+        if (this.confidenceConfig.normalizeScores) {
+            const totalWeight = Array.from(aggregated.values()).reduce((sum, agg) => sum + agg.totalWeight, 0);
+            if (totalWeight > 0) {
+                for (const agg of aggregated.values()) {
+                    agg.totalWeight = agg.totalWeight / totalWeight;
+                }
+            }
+        }
+        return Array.from(aggregated.values()).sort((a, b) => b.totalWeight - a.totalWeight);
+    }
+    updateAgentPerformance(agentName, decision, votedFor, wasCorrect, confidence) {
+        let performance = this.agentPerformance.get(agentName);
+        if (!performance) {
+            performance = {
+                agentName,
+                totalVotes: 0,
+                correctVotes: 0,
+                averageConfidence: 0,
+                weightedScore: 50,
+                lastActivity: Date.now(),
+                streakCount: 0,
+                domainPerformance: {},
+            };
+            this.agentPerformance.set(agentName, performance);
+        }
+        performance.totalVotes++;
+        performance.lastActivity = Date.now();
+        if (wasCorrect) {
+            performance.correctVotes++;
+            performance.streakCount++;
+        }
+        else {
+            performance.streakCount = 0;
+        }
+        const newAvg = (performance.averageConfidence * (performance.totalVotes - 1) + confidence) /
+            performance.totalVotes;
+        performance.averageConfidence = newAvg;
+        const successRate = performance.correctVotes / performance.totalVotes;
+        const confidenceFactor = newAvg;
+        const streakBonus = Math.min(performance.streakCount * 0.05, 0.2);
+        performance.weightedScore = Math.max(0, Math.min(100, successRate * 50 + confidenceFactor * 30 + streakBonus * 20 + 20));
+        frameworkLogger.log("WeightedVotingAggregator", "agent-performance-updated", "debug", {
+            agentName,
+            totalVotes: performance.totalVotes,
+            correctVotes: performance.correctVotes,
+            successRate: successRate.toFixed(2),
+            weightedScore: performance.weightedScore.toFixed(2),
+        });
+    }
+    getAgentPerformance(agentName) {
+        return this.agentPerformance.get(agentName);
+    }
+    getAllPerformance() {
+        return Array.from(this.agentPerformance.values());
+    }
+    loadPerformance(performance) {
+        this.agentPerformance = new Map(performance);
+    }
+    reset() {
+        this.agentPerformance.clear();
+    }
+}
+export const createWeightedVotingAggregator = (historicalConfig, confidenceConfig) => {
+    return new WeightedVotingAggregator(historicalConfig, confidenceConfig);
+};
+export function createDetailedVotingResult(votes, aggregator) {
+    const aggregated = aggregator.aggregateVotes(votes);
+    const winner = aggregated[0] ?? null;
+    let confidence = 0;
+    if (winner && aggregated.length > 1) {
+        const secondPlace = aggregated[1];
+        if (secondPlace) {
+            const total = winner.totalWeight + secondPlace.totalWeight;
+            confidence = total > 0 ? winner.totalWeight / total : 0;
+        }
+        else {
+            confidence = 1;
+        }
+    }
+    else if (winner) {
+        confidence = 1;
+    }
+    const details = votes.map((vote) => ({
+        agentName: vote.agentName,
+        expertiseLevel: getAgentExpertiseLevel(vote.agentName),
+        vote: vote.vote,
+        weight: aggregator.calculateTotalVoteWeight(vote.agentName, vote.confidence),
+        contributed: vote.vote === winner?.option,
+    }));
+    return { aggregated, winner, confidence, details };
+}