@holoscript/framework 6.0.3

package/dist/negotiation/index.cjs

@@ -0,0 +1,970 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/negotiation/index.ts
+var negotiation_exports = {};
+__export(negotiation_exports, {
+  NegotiationProtocol: () => NegotiationProtocol,
+  approvalHandler: () => approvalHandler,
+  bordaHandler: () => bordaHandler,
+  checkQuorum: () => checkQuorum,
+  consensusHandler: () => consensusHandler,
+  getNegotiationProtocol: () => getNegotiationProtocol,
+  getTrustWeight: () => getTrustWeight,
+  getVotingHandler: () => getVotingHandler,
+  majorityHandler: () => majorityHandler,
+  rankedHandler: () => rankedHandler,
+  resetNegotiationProtocol: () => resetNegotiationProtocol,
+  supermajorityHandler: () => supermajorityHandler,
+  weightedHandler: () => weightedHandler
+});
+module.exports = __toCommonJS(negotiation_exports);
+
+// 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;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  NegotiationProtocol,
+  approvalHandler,
+  bordaHandler,
+  checkQuorum,
+  consensusHandler,
+  getNegotiationProtocol,
+  getTrustWeight,
+  getVotingHandler,
+  majorityHandler,
+  rankedHandler,
+  resetNegotiationProtocol,
+  supermajorityHandler,
+  weightedHandler
+});