@holoscript/framework 6.0.3 → 6.0.4

package/dist/negotiation/index.js

@@ -1,931 +0,0 @@
-// src/negotiation/VotingMechanisms.ts
-function getTotalWeight(votes) {
-  return votes.reduce((sum, v) => sum + v.weight, 0);
-}
-function initializeTallies(proposals) {
-  const tallies = /* @__PURE__ */ new Map();
-  for (const p of proposals) {
-    tallies.set(p.id, {
-      proposalId: p.id,
-      voteCount: 0,
-      weightedScore: 0,
-      approvalCount: 0,
-      bordaPoints: 0,
-      percentage: 0
-    });
-  }
-  return tallies;
-}
-function talliesToArray(tallies, totalWeight) {
-  const arr = Array.from(tallies.values());
-  for (const t of arr) {
-    t.percentage = totalWeight > 0 ? t.weightedScore / totalWeight * 100 : 0;
-  }
-  return arr.sort((a, b) => b.weightedScore - a.weightedScore);
-}
-function findTies(tallies) {
-  if (tallies.length < 2) return [];
-  const topScore = tallies[0].weightedScore;
-  return tallies.filter((t) => t.weightedScore === topScore);
-}
-function breakTie(tied, proposals, config) {
-  if (tied.length === 0) return void 0;
-  if (tied.length === 1) return tied[0].proposalId;
-  switch (config.tieBreaker) {
-    case "random":
-      return tied[Math.floor(Math.random() * tied.length)].proposalId;
-    case "seniority": {
-      const proposalMap = new Map(proposals.map((p) => [p.id, p]));
-      const sorted = [...tied].sort((a, b) => {
-        const pa = proposalMap.get(a.proposalId);
-        const pb = proposalMap.get(b.proposalId);
-        return (pa?.submittedAt || 0) - (pb?.submittedAt || 0);
-      });
-      return sorted[0].proposalId;
-    }
-    case "priority": {
-      const proposalMap = new Map(proposals.map((p) => [p.id, p]));
-      const sorted = [...tied].sort((a, b) => {
-        const pa = proposalMap.get(a.proposalId);
-        const pb = proposalMap.get(b.proposalId);
-        return (pb?.priority || 0) - (pa?.priority || 0);
-      });
-      return sorted[0].proposalId;
-    }
-    case "proposer":
-      return tied[0].proposalId;
-    case "escalate":
-    default:
-      return void 0;
-  }
-}
-var majorityHandler = {
-  count(votes, proposals, config, _round) {
-    const tallies = initializeTallies(proposals);
-    const totalWeight = getTotalWeight(votes);
-    for (const vote of votes) {
-      if (vote.ranking.length > 0) {
-        const firstChoice = vote.ranking[0];
-        const tally = tallies.get(firstChoice);
-        if (tally) {
-          tally.voteCount++;
-          tally.weightedScore += vote.weight;
-        }
-      }
-    }
-    const sorted = talliesToArray(tallies, totalWeight);
-    const ties = findTies(sorted);
-    if (sorted.length > 0 && sorted[0].percentage > 50) {
-      return {
-        tallies: sorted,
-        winnerId: sorted[0].proposalId,
-        resolved: true,
-        outcome: "winner_declared",
-        consensusLevel: sorted[0].percentage / 100
-      };
-    }
-    if (ties.length > 1) {
-      const tieBreakWinner = breakTie(ties, proposals, config);
-      if (tieBreakWinner) {
-        return {
-          tallies: sorted,
-          winnerId: tieBreakWinner,
-          resolved: true,
-          outcome: "tie_broken",
-          tie: true
-        };
-      }
-      return {
-        tallies: sorted,
-        resolved: false,
-        outcome: "deadlock",
-        tie: true
-      };
-    }
-    if (sorted.length > 0) {
-      return {
-        tallies: sorted,
-        winnerId: sorted[0].proposalId,
-        resolved: true,
-        outcome: "winner_declared",
-        consensusLevel: sorted[0].percentage / 100
-      };
-    }
-    return {
-      tallies: sorted,
-      resolved: false,
-      outcome: "deadlock"
-    };
-  },
-  validateVote(vote, proposals) {
-    if (vote.ranking.length === 0) return false;
-    const proposalIds = new Set(proposals.map((p) => p.id));
-    return proposalIds.has(vote.ranking[0]);
-  },
-  getRequiredQuorum(config) {
-    return config.quorum || 0.5;
-  }
-};
-var supermajorityHandler = {
-  count(votes, proposals, _config, _round) {
-    const tallies = initializeTallies(proposals);
-    const totalWeight = getTotalWeight(votes);
-    for (const vote of votes) {
-      if (vote.ranking.length > 0) {
-        const firstChoice = vote.ranking[0];
-        const tally = tallies.get(firstChoice);
-        if (tally) {
-          tally.voteCount++;
-          tally.weightedScore += vote.weight;
-        }
-      }
-    }
-    const sorted = talliesToArray(tallies, totalWeight);
-    const threshold = 66.67;
-    if (sorted.length > 0 && sorted[0].percentage >= threshold) {
-      return {
-        tallies: sorted,
-        winnerId: sorted[0].proposalId,
-        resolved: true,
-        outcome: "winner_declared",
-        consensusLevel: sorted[0].percentage / 100
-      };
-    }
-    return {
-      tallies: sorted,
-      resolved: false,
-      outcome: "deadlock"
-    };
-  },
-  validateVote(vote, proposals) {
-    return majorityHandler.validateVote(vote, proposals);
-  },
-  getRequiredQuorum(config) {
-    return config.quorum || 0.67;
-  }
-};
-var weightedHandler = {
-  count(votes, proposals, config, round) {
-    return majorityHandler.count(votes, proposals, config, round);
-  },
-  validateVote(vote, proposals) {
-    return majorityHandler.validateVote(vote, proposals);
-  },
-  getRequiredQuorum(config) {
-    return config.quorum || 0.5;
-  }
-};
-var consensusHandler = {
-  count(votes, proposals, _config, _round) {
-    if (votes.length === 0) {
-      return {
-        tallies: [],
-        resolved: false,
-        outcome: "deadlock"
-      };
-    }
-    const tallies = initializeTallies(proposals);
-    const totalWeight = getTotalWeight(votes);
-    const firstChoices = /* @__PURE__ */ new Map();
-    for (const vote of votes) {
-      if (vote.ranking.length > 0) {
-        const choice = vote.ranking[0];
-        const tally = tallies.get(choice);
-        if (tally) {
-          tally.voteCount++;
-          tally.weightedScore += vote.weight;
-        }
-        if (!firstChoices.has(choice)) {
-          firstChoices.set(choice, []);
-        }
-        firstChoices.get(choice).push(vote.agentId);
-      }
-    }
-    const sorted = talliesToArray(tallies, totalWeight);
-    if (firstChoices.size === 1) {
-      const winnerId = Array.from(firstChoices.keys())[0];
-      return {
-        tallies: sorted,
-        winnerId,
-        resolved: true,
-        outcome: "consensus_reached",
-        consensusLevel: 1
-      };
-    }
-    const leader = sorted[0];
-    const leaderVoters = new Set(firstChoices.get(leader.proposalId) || []);
-    const dissenters = votes.filter((v) => !leaderVoters.has(v.agentId)).map((v) => v.agentId);
-    return {
-      tallies: sorted,
-      resolved: false,
-      outcome: "deadlock",
-      consensusLevel: leader.percentage / 100,
-      dissenters
-    };
-  },
-  validateVote(vote, proposals) {
-    return majorityHandler.validateVote(vote, proposals);
-  },
-  getRequiredQuorum() {
-    return 1;
-  }
-};
-var rankedHandler = {
-  count(votes, proposals, _config, _round) {
-    const eliminated = /* @__PURE__ */ new Set();
-    const runoffVotes = votes.map((v) => ({
-      ...v,
-      currentRanking: [...v.ranking]
-    }));
-    const totalWeight = getTotalWeight(votes);
-    let rounds = 0;
-    const maxRounds = proposals.length;
-    while (rounds < maxRounds) {
-      rounds++;
-      const tallies = initializeTallies(proposals.filter((p) => !eliminated.has(p.id)));
-      for (const vote of runoffVotes) {
-        const validChoice = vote.currentRanking.find((id) => !eliminated.has(id));
-        if (validChoice) {
-          const tally = tallies.get(validChoice);
-          if (tally) {
-            tally.voteCount++;
-            tally.weightedScore += vote.weight;
-          }
-        }
-      }
-      const sorted = talliesToArray(tallies, totalWeight);
-      if (sorted.length > 0 && sorted[0].percentage > 50) {
-        return {
-          tallies: sorted,
-          winnerId: sorted[0].proposalId,
-          resolved: true,
-          outcome: "winner_declared",
-          eliminated: Array.from(eliminated),
-          consensusLevel: sorted[0].percentage / 100
-        };
-      }
-      if (sorted.length > 1) {
-        const loser = sorted[sorted.length - 1];
-        eliminated.add(loser.proposalId);
-      } else if (sorted.length === 1) {
-        return {
-          tallies: sorted,
-          winnerId: sorted[0].proposalId,
-          resolved: true,
-          outcome: "winner_declared",
-          eliminated: Array.from(eliminated)
-        };
-      } else {
-        break;
-      }
-    }
-    return {
-      tallies: [],
-      resolved: false,
-      outcome: "deadlock",
-      eliminated: Array.from(eliminated)
-    };
-  },
-  validateVote(vote, proposals) {
-    if (vote.ranking.length === 0) return false;
-    const proposalIds = new Set(proposals.map((p) => p.id));
-    return vote.ranking.every((id) => proposalIds.has(id));
-  },
-  getRequiredQuorum(config) {
-    return config.quorum || 0.5;
-  }
-};
-var approvalHandler = {
-  count(votes, proposals, config, _round) {
-    const tallies = initializeTallies(proposals);
-    const totalVotes = votes.length;
-    for (const vote of votes) {
-      const approvals = vote.approvals || vote.ranking;
-      for (const proposalId of approvals) {
-        const tally = tallies.get(proposalId);
-        if (tally) {
-          tally.voteCount++;
-          tally.weightedScore += vote.weight;
-          tally.approvalCount = (tally.approvalCount || 0) + 1;
-        }
-      }
-    }
-    const sorted = talliesToArray(
-      tallies,
-      votes.reduce((s, v) => s + v.weight, 0)
-    );
-    const ties = findTies(sorted);
-    if (ties.length > 1) {
-      const tieBreakWinner = breakTie(ties, proposals, config);
-      if (tieBreakWinner) {
-        return {
-          tallies: sorted,
-          winnerId: tieBreakWinner,
-          resolved: true,
-          outcome: "tie_broken",
-          tie: true
-        };
-      }
-    }
-    if (sorted.length > 0) {
-      return {
-        tallies: sorted,
-        winnerId: sorted[0].proposalId,
-        resolved: true,
-        outcome: "winner_declared",
-        consensusLevel: totalVotes > 0 ? (sorted[0].approvalCount || 0) / totalVotes : 0
-      };
-    }
-    return {
-      tallies: sorted,
-      resolved: false,
-      outcome: "deadlock"
-    };
-  },
-  validateVote(vote, proposals) {
-    const approvals = vote.approvals || vote.ranking;
-    if (approvals.length === 0) return false;
-    const proposalIds = new Set(proposals.map((p) => p.id));
-    return approvals.every((id) => proposalIds.has(id));
-  },
-  getRequiredQuorum(config) {
-    return config.quorum || 0.5;
-  }
-};
-var bordaHandler = {
-  count(votes, proposals, config, _round) {
-    const tallies = initializeTallies(proposals);
-    const n = proposals.length;
-    for (const vote of votes) {
-      for (let i = 0; i < vote.ranking.length; i++) {
-        const proposalId = vote.ranking[i];
-        const tally = tallies.get(proposalId);
-        if (tally) {
-          const points = (n - 1 - i) * vote.weight;
-          tally.bordaPoints = (tally.bordaPoints || 0) + points;
-          tally.weightedScore += points;
-          tally.voteCount++;
-        }
-      }
-    }
-    const sorted = talliesToArray(tallies, n * votes.reduce((s, v) => s + v.weight, 0));
-    const ties = findTies(sorted);
-    if (ties.length > 1) {
-      const tieBreakWinner = breakTie(ties, proposals, config);
-      if (tieBreakWinner) {
-        return {
-          tallies: sorted,
-          winnerId: tieBreakWinner,
-          resolved: true,
-          outcome: "tie_broken",
-          tie: true
-        };
-      }
-    }
-    if (sorted.length > 0) {
-      return {
-        tallies: sorted,
-        winnerId: sorted[0].proposalId,
-        resolved: true,
-        outcome: "winner_declared"
-      };
-    }
-    return {
-      tallies: sorted,
-      resolved: false,
-      outcome: "deadlock"
-    };
-  },
-  validateVote(vote, proposals) {
-    return rankedHandler.validateVote(vote, proposals);
-  },
-  getRequiredQuorum(config) {
-    return config.quorum || 0.5;
-  }
-};
-function getVotingHandler(mechanism) {
-  switch (mechanism) {
-    case "majority":
-      return majorityHandler;
-    case "supermajority":
-      return supermajorityHandler;
-    case "weighted":
-      return weightedHandler;
-    case "consensus":
-      return consensusHandler;
-    case "ranked":
-      return rankedHandler;
-    case "approval":
-      return approvalHandler;
-    case "borda":
-      return bordaHandler;
-    case "custom":
-    default:
-      return majorityHandler;
-  }
-}
-function checkQuorum(votes, participants, config, mechanism) {
-  const handler = getVotingHandler(mechanism);
-  const requiredQuorum = handler.getRequiredQuorum(config);
-  const participation = participants > 0 ? votes.length / participants : 0;
-  return participation >= requiredQuorum;
-}
-function getTrustWeight(trustLevel) {
-  switch (trustLevel) {
-    case "local":
-      return 1;
-    case "verified":
-      return 0.8;
-    case "external":
-      return 0.5;
-    default:
-      return 0.5;
-  }
-}
-
-// src/negotiation/NegotiationProtocol.ts
-var NegotiationProtocol = class {
-  sessions = /* @__PURE__ */ new Map();
-  auditLog = [];
-  deadlines = /* @__PURE__ */ new Map();
-  eventHandlers = /* @__PURE__ */ new Map();
-  sessionCounter = 0;
-  proposalCounter = 0;
-  voteCounter = 0;
-  // ===========================================================================
-  // PUBLIC API
-  // ===========================================================================
-  /**
-   * Initiate a new negotiation session
-   */
-  async initiate(options) {
-    const sessionId = this.generateSessionId();
-    const timeout = options.timeout ?? 6e4;
-    const config = {
-      mechanism: options.votingMechanism || "majority",
-      votingMechanism: options.votingMechanism || "majority",
-      quorum: options.quorum ?? 0.5,
-      timeout,
-      votingDeadline: timeout,
-      proposalDeadline: timeout,
-      maxRounds: options.maxRounds ?? 3,
-      allowAbstain: options.allowAbstain ?? true,
-      requireJustification: options.requireJustification ?? false,
-      tieBreaker: options.tieBreaker ?? "random",
-      escalationPath: options.escalationPath
-    };
-    const now = Date.now();
-    const session = {
-      id: sessionId,
-      topic: options.topic,
-      description: options.description,
-      participants: [...options.participants],
-      status: "open",
-      proposals: [],
-      votes: [],
-      config,
-      round: 1,
-      currentRound: 1,
-      createdAt: now,
-      startedAt: now,
-      lastActivityAt: now,
-      deadline: now + timeout,
-      history: [],
-      metadata: options.metadata || {}
-    };
-    this.sessions.set(sessionId, session);
-    this.startDeadlineTimer(session);
-    this.audit("initiated", sessionId, void 0, {
-      topic: options.topic,
-      participants: options.participants,
-      config
-    });
-    await this.emit("sessionStarted", { session });
-    return session;
-  }
-  /**
-   * Submit a proposal to a session
-   */
-  async propose(sessionId, input) {
-    const session = this.getSession(sessionId);
-    this.validateSessionOpen(session);
-    this.validateParticipant(session, input.proposerId);
-    const proposalId = this.generateProposalId();
-    const proposal = {
-      id: proposalId,
-      sessionId,
-      proposerId: input.proposerId,
-      agentId: input.proposerId,
-      title: input.title,
-      description: input.description,
-      content: input.content,
-      priority: input.priority ?? 0,
-      status: "submitted",
-      submittedAt: Date.now(),
-      metadata: input.metadata || {}
-    };
-    session.proposals.push(proposal);
-    session.lastActivityAt = Date.now();
-    this.audit("proposal_submitted", sessionId, input.proposerId, {
-      proposalId,
-      title: input.title
-    });
-    await this.emit("proposalSubmitted", { session, proposal });
-    return proposal;
-  }
-  /**
-   * Cast a vote in a session
-   */
-  async vote(sessionId, input) {
-    const session = this.getSession(sessionId);
-    this.validateSessionOpen(session);
-    this.validateParticipant(session, input.agentId);
-    this.validateNotDuplicate(session, input.agentId);
-    const mechanism = session.config.mechanism || session.config.votingMechanism || "majority";
-    const handler = getVotingHandler(mechanism);
-    const vote = {
-      id: this.generateVoteId(),
-      sessionId,
-      agentId: input.agentId,
-      ranking: input.ranking || [],
-      approvals: input.approvals,
-      weight: input.weight ?? getTrustWeight("local"),
-      justification: input.justification,
-      abstain: input.abstain ?? false,
-      timestamp: Date.now()
-    };
-    if (!vote.abstain && !handler.validateVote(vote, session.proposals)) {
-      throw new Error(
-        `Invalid vote: ranking must reference valid proposal IDs for mechanism '${mechanism}'`
-      );
-    }
-    session.votes.push(vote);
-    this.audit("vote_cast", sessionId, input.agentId, {
-      voteId: vote.id,
-      abstain: vote.abstain
-    });
-    await this.emit("voteReceived", { session, vote });
-    if (this.allVotesCast(session)) {
-      await this.tryAutoResolve(session);
-    }
-    return vote;
-  }
-  /**
-   * Resolve a negotiation session
-   */
-  async resolve(sessionId, force = false) {
-    const session = this.getSession(sessionId);
-    if (session.status !== "open" && session.status !== "voting") {
-      if (session.resolution) {
-        return session.resolution;
-      }
-      throw new Error(`Session ${sessionId} is ${session.status}, cannot resolve`);
-    }
-    const mechanism = session.config.mechanism || session.config.votingMechanism || "majority";
-    if (!force) {
-      const quorumMet = checkQuorum(
-        session.votes,
-        session.participants.length,
-        session.config,
-        mechanism
-      );
-      if (!quorumMet) {
-        return this.createFailedResolution(session, "quorum_not_met");
-      }
-    }
-    const handler = getVotingHandler(mechanism);
-    const result = handler.count(
-      session.votes.filter((v) => !v.abstain),
-      session.proposals,
-      session.config,
-      session.round || session.currentRound || 1
-    );
-    const resolution = this.buildResolution(session, result);
-    session.status = resolution.outcome === "deadlock" ? "deadlock" : "resolved";
-    session.resolution = resolution;
-    session.resolvedAt = Date.now();
-    this.clearDeadline(sessionId);
-    this.audit("resolved", sessionId, void 0, {
-      outcome: resolution.outcome,
-      winnerId: resolution.winnerId
-    });
-    await this.emit("sessionResolved", { session, resolution });
-    return resolution;
-  }
-  /**
-   * Get session by ID
-   */
-  getSession(sessionId) {
-    const session = this.sessions.get(sessionId);
-    if (!session) {
-      throw new Error(`Negotiation session not found: ${sessionId}`);
-    }
-    return session;
-  }
-  /**
-   * Get all active sessions
-   */
-  getActiveSessions() {
-    return Array.from(this.sessions.values()).filter(
-      (s) => s.status === "open" || s.status === "voting"
-    );
-  }
-  /**
-   * Get sessions for a specific agent
-   */
-  getAgentSessions(agentId) {
-    return Array.from(this.sessions.values()).filter((s) => s.participants.includes(agentId));
-  }
-  /**
-   * Cancel a session
-   */
-  async cancel(sessionId, _reason) {
-    const session = this.getSession(sessionId);
-    if (session.status === "resolved" || session.status === "cancelled") {
-      return;
-    }
-    session.status = "cancelled";
-    const mechanism = session.config.mechanism || session.config.votingMechanism || "majority";
-    session.resolution = {
-      sessionId,
-      outcome: "cancelled",
-      tallies: [],
-      finalTallies: [],
-      mechanism,
-      rounds: session.round || 1,
-      resolvedAt: Date.now(),
-      participationRate: session.votes.length / session.participants.length,
-      timestamp: Date.now()
-    };
-    this.clearDeadline(sessionId);
-    await this.emit("sessionResolved", {
-      session,
-      resolution: session.resolution
-    });
-  }
-  /**
-   * Escalate a deadlocked session
-   */
-  async escalate(sessionId) {
-    const session = this.getSession(sessionId);
-    if (!session.config.escalationPath) {
-      throw new Error(`No escalation path configured for session ${sessionId}`);
-    }
-    session.status = "escalated";
-    this.audit("escalated", sessionId, void 0, {
-      escalationPath: session.config.escalationPath
-    });
-    const mechanism = session.config.mechanism || session.config.votingMechanism || "majority";
-    const resolution = {
-      sessionId,
-      outcome: "escalated",
-      tallies: session.resolution?.tallies || [],
-      finalTallies: session.resolution?.finalTallies || [],
-      mechanism,
-      rounds: session.round || 1,
-      resolvedAt: Date.now(),
-      participationRate: session.votes.length / session.participants.length,
-      timestamp: Date.now(),
-      escalatedTo: session.config.escalationPath
-    };
-    session.resolution = resolution;
-    await this.emit("sessionResolved", { session, resolution });
-    return resolution;
-  }
-  /**
-   * Add a participant to an open session
-   */
-  addParticipant(sessionId, agentId) {
-    const session = this.getSession(sessionId);
-    if (session.status !== "open") {
-      throw new Error("Cannot add participant to non-open session");
-    }
-    if (!session.participants.includes(agentId)) {
-      session.participants.push(agentId);
-    }
-  }
-  /**
-   * Remove a participant from a session
-   */
-  removeParticipant(sessionId, agentId) {
-    const session = this.getSession(sessionId);
-    if (session.status !== "open") {
-      throw new Error("Cannot remove participant from non-open session");
-    }
-    session.participants = session.participants.filter((p) => p !== agentId);
-  }
-  /**
-   * Subscribe to negotiation events
-   */
-  on(event, handler) {
-    if (!this.eventHandlers.has(event)) {
-      this.eventHandlers.set(event, /* @__PURE__ */ new Set());
-    }
-    this.eventHandlers.get(event).add(handler);
-    return () => {
-      this.eventHandlers.get(event)?.delete(handler);
-    };
-  }
-  /**
-   * Get audit log
-   */
-  getAuditLog(sessionId) {
-    if (sessionId) {
-      return this.auditLog.filter((e) => e.sessionId === sessionId);
-    }
-    return [...this.auditLog];
-  }
-  /**
-   * Clear completed sessions older than maxAge
-   */
-  pruneOldSessions(maxAgeMs) {
-    const cutoff = Date.now() - maxAgeMs;
-    let pruned = 0;
-    for (const [id, session] of this.sessions) {
-      const sessionTime = session.resolvedAt || session.createdAt || session.startedAt || 0;
-      if ((session.status === "resolved" || session.status === "cancelled") && sessionTime < cutoff) {
-        this.sessions.delete(id);
-        pruned++;
-      }
-    }
-    return pruned;
-  }
-  /**
-   * Reset protocol state (for testing)
-   */
-  reset() {
-    for (const deadline of this.deadlines.values()) {
-      clearTimeout(deadline.timer);
-    }
-    this.sessions.clear();
-    this.auditLog = [];
-    this.deadlines.clear();
-    this.eventHandlers.clear();
-    this.sessionCounter = 0;
-    this.proposalCounter = 0;
-    this.voteCounter = 0;
-  }
-  // ===========================================================================
-  // PRIVATE METHODS
-  // ===========================================================================
-  generateSessionId() {
-    return `neg-${Date.now()}-${++this.sessionCounter}`;
-  }
-  generateProposalId() {
-    return `prop-${Date.now()}-${++this.proposalCounter}`;
-  }
-  generateVoteId() {
-    return `vote-${Date.now()}-${++this.voteCounter}`;
-  }
-  validateSessionOpen(session) {
-    if (session.status !== "open" && session.status !== "voting") {
-      throw new Error(`Session ${session.id} is ${session.status}, not accepting input`);
-    }
-  }
-  validateParticipant(session, agentId) {
-    if (!session.participants.includes(agentId)) {
-      throw new Error(`Agent ${agentId} is not a participant in session ${session.id}`);
-    }
-  }
-  validateNotDuplicate(session, agentId) {
-    const roundVotes = session.votes.filter((v) => v.agentId === agentId && !v.supersededBy);
-    if (roundVotes.length > 0) {
-      throw new Error(`Agent ${agentId} has already voted in this round of session ${session.id}`);
-    }
-  }
-  allVotesCast(session) {
-    const voted = new Set(session.votes.map((v) => v.agentId));
-    return session.participants.every((p) => {
-      const participantId = typeof p === "string" ? p : p.id;
-      return voted.has(participantId);
-    });
-  }
-  async tryAutoResolve(session) {
-    if (session.status === "open" && session.proposals.length > 0) {
-      session.status = "voting";
-    }
-    if (this.allVotesCast(session)) {
-      await this.resolve(session.id);
-    }
-  }
-  buildResolution(session, result) {
-    const winningProposal = result.winnerId ? session.proposals.find((p) => p.id === result.winnerId) : void 0;
-    const mechanism = session.config.mechanism || session.config.votingMechanism || "majority";
-    const resolvedAt = Date.now();
-    return {
-      sessionId: session.id,
-      outcome: result.outcome,
-      winnerId: result.winnerId,
-      winner: winningProposal,
-      winningProposal,
-      tallies: result.tallies,
-      finalTallies: result.tallies,
-      mechanism,
-      rounds: session.round || 1,
-      round: session.round || session.currentRound,
-      resolvedAt,
-      consensusLevel: result.consensusLevel,
-      dissenters: result.dissenters,
-      participationRate: session.votes.length / session.participants.length,
-      timestamp: resolvedAt
-    };
-  }
-  createFailedResolution(session, outcome) {
-    session.status = outcome === "timeout" ? "timeout" : "deadlock";
-    const mechanism = session.config.mechanism || session.config.votingMechanism || "majority";
-    const resolvedAt = Date.now();
-    const resolution = {
-      sessionId: session.id,
-      outcome,
-      tallies: [],
-      finalTallies: [],
-      mechanism,
-      rounds: session.round || 1,
-      resolvedAt,
-      participationRate: session.votes.length / session.participants.length,
-      timestamp: resolvedAt
-    };
-    session.resolution = resolution;
-    this.clearDeadline(session.id);
-    return resolution;
-  }
-  startDeadlineTimer(session) {
-    const timeout = session.config.timeout || session.config.votingDeadline || 6e4;
-    const timer = setTimeout(async () => {
-      if (session.status === "open" || session.status === "voting") {
-        this.audit("timeout", session.id, void 0, {
-          deadline: session.deadline
-        });
-        await this.handleTimeout(session);
-      }
-    }, timeout);
-    this.deadlines.set(session.id, { sessionId: session.id, timer });
-  }
-  async handleTimeout(session) {
-    if (session.votes.length > 0) {
-      try {
-        await this.resolve(session.id, true);
-        return;
-      } catch {
-      }
-    }
-    const resolution = this.createFailedResolution(session, "timeout");
-    await this.emit("sessionResolved", { session, resolution });
-  }
-  clearDeadline(sessionId) {
-    const deadline = this.deadlines.get(sessionId);
-    if (deadline) {
-      clearTimeout(deadline.timer);
-      this.deadlines.delete(sessionId);
-    }
-  }
-  audit(action, sessionId, agentId, details) {
-    this.auditLog.push({
-      timestamp: Date.now(),
-      sessionId,
-      action,
-      agentId,
-      details
-    });
-  }
-  async emit(event, data) {
-    const handlers = this.eventHandlers.get(event);
-    if (handlers) {
-      for (const handler of handlers) {
-        try {
-          await handler(data);
-        } catch (err) {
-          console.error(`Error in negotiation event handler for ${event}:`, err);
-        }
-      }
-    }
-  }
-};
-var defaultProtocol = null;
-function getNegotiationProtocol() {
-  if (!defaultProtocol) {
-    defaultProtocol = new NegotiationProtocol();
-  }
-  return defaultProtocol;
-}
-function resetNegotiationProtocol() {
-  if (defaultProtocol) {
-    defaultProtocol.reset();
-    defaultProtocol = null;
-  }
-}
-export {
-  NegotiationProtocol,
-  approvalHandler,
-  bordaHandler,
-  checkQuorum,
-  consensusHandler,
-  getNegotiationProtocol,
-  getTrustWeight,
-  getVotingHandler,
-  majorityHandler,
-  rankedHandler,
-  resetNegotiationProtocol,
-  supermajorityHandler,
-  weightedHandler
-};