✨ Add minimum quorum configuration to consensus protocols

- Byzantine: minQuorum = Math.floor(2*n/3)+1 (handles 33% malicious nodes)
- Raft: minQuorum = Math.floor(n/2)+1 (majority consensus)
- Gossip: minQuorum = configurable threshold (default 0.51)
- CRDT: no quorum needed (eventual consistency)

New Features:
- Created complete Raft consensus protocol implementation
- Added getMinQuorum() and hasQuorum() methods to all protocols
- Updated consensus index with quorum calculation utilities
- Enhanced Byzantine consensus with proper quorum validation
- Added configurable quorum threshold for gossip protocol

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <[email protected]>

Author: 2 people

src/protocols/a2a/consensus/byzantine-consensus.ts

@@ -51,6 +51,7 @@ export class ByzantineConsensus extends EventEmitter {
   private state: ConsensusState;
   private messageLog: ConsensusMessage[] = [];
   private faultThreshold: number;
+  private minQuorum: number; // Byzantine: Math.floor(2*n/3)+1
   private timeoutDuration: number = 30000; // 30 seconds
   private viewChangeTimeout: ReturnType<typeof setTimeout> | null = null;
   private performance: {
@@ -66,6 +67,7 @@ export class ByzantineConsensus extends EventEmitter {
   ) {
     super();
     this.faultThreshold = Math.floor((totalAgents - 1) / 3);
+    this.minQuorum = Math.floor((2 * totalAgents) / 3) + 1; // Byzantine: 2f+1 where f is fault threshold
     this.state = this.initializeState();
     this.performance = {
       consensusRounds: 0,
@@ -473,7 +475,21 @@ export class ByzantineConsensus extends EventEmitter {
     const maliciousCount = Array.from(this.agents.values())
       .filter(a => a.isMalicious && this.state.activeAgents.has(a.id)).length;
 
-    return maliciousCount <= this.faultThreshold && activeCount >= 3 * this.faultThreshold + 1;
+    return maliciousCount <= this.faultThreshold && activeCount >= this.minQuorum;
+  }
+
+  /**
+   * Get minimum quorum size for Byzantine consensus
+   */
+  public getMinQuorum(): number {
+    return this.minQuorum;
+  }
+
+  /**
+   * Check if we have sufficient nodes for quorum
+   */
+  public hasQuorum(): boolean {
+    return this.state.activeAgents.size >= this.minQuorum;
   }
 
   /**

src/protocols/a2a/consensus/index.ts

@@ -1,11 +1,11 @@
 /**
- * Byzantine Fault-Tolerant Consensus System for Agent-to-Agent Communication
+ * Consensus Protocols for Agent-to-Agent Communication
  * 
- * This module provides a comprehensive Byzantine consensus system that can handle
- * up to 33% malicious agents while maintaining correctness and security.
+ * This module provides comprehensive consensus protocols for distributed systems:
  * 
  * Features:
  * - PBFT (Practical Byzantine Fault Tolerance) consensus algorithm
+ * - Raft consensus protocol for leader-based consensus
  * - Advanced voting mechanisms (weighted, quadratic, liquid democracy)
  * - Sophisticated malicious agent detection and isolation
  * - State machine replication with conflict resolution
@@ -14,6 +14,12 @@
  * - Integration with A2A security framework
  * - Comprehensive fault injection testing
  * 
+ * Quorum Requirements:
+ * - Byzantine: Math.floor(2*n/3) + 1 (handles up to 33% malicious nodes)
+ * - Raft: Math.floor(n/2) + 1 (majority consensus)
+ * - Gossip: Configurable threshold (default 51%)
+ * - CRDT: No quorum needed (eventual consistency)
+ * 
  * @author AI Assistant
  * @version 1.0.0
  */
@@ -28,6 +34,15 @@ export {
   default as ByzantineConsensusDefault
 } from './byzantine-consensus';
 
+export {
+  RaftConsensus,
+  RaftNode,
+  LogEntry,
+  RaftMessage,
+  RaftState,
+  default as RaftConsensusDefault
+} from './raft-consensus';
+
 export {
   VotingMechanisms,
   Vote,
@@ -92,6 +107,44 @@ export {
 } from './consensus-security-integration';
 
 // Utility types and constants
+export const QUORUM_CALCULATIONS = {
+  /**
+   * Calculate Byzantine consensus quorum (2f + 1)
+   * @param totalAgents Total number of agents in the system
+   * @returns Minimum quorum size for Byzantine consensus
+   */
+  calculateByzantineQuorum: (totalAgents: number): number => {
+    return Math.floor((2 * totalAgents) / 3) + 1;
+  },
+
+  /**
+   * Calculate Raft consensus quorum (majority)
+   * @param totalAgents Total number of agents in the system
+   * @returns Minimum quorum size for Raft consensus
+   */
+  calculateRaftQuorum: (totalAgents: number): number => {
+    return Math.floor(totalAgents / 2) + 1;
+  },
+
+  /**
+   * Calculate gossip quorum based on threshold
+   * @param totalAgents Total number of agents in the system
+   * @param threshold Percentage threshold (0-1, default 0.51)
+   * @returns Minimum quorum size for gossip consensus
+   */
+  calculateGossipQuorum: (totalAgents: number, threshold: number = 0.51): number => {
+    return Math.ceil(totalAgents * threshold);
+  },
+
+  /**
+   * CRDT doesn't require quorum (eventual consistency)
+   * @returns Always 1 (any single node can make progress)
+   */
+  calculateCRDTQuorum: (): number => {
+    return 1;
+  }
+};
+
 export const BYZANTINE_FAULT_TOLERANCE = {
   /**
    * Calculate the maximum number of faulty agents that can be tolerated
@@ -160,6 +213,28 @@ export const VOTING_TYPES = {
   STAKE_WEIGHTED: 'stake-weighted' as const
 };
 
+/**
+ * Factory function to create a Raft consensus system
+ */
+export function createRaftConsensusSystem(
+  nodeId: string,
+  totalNodes: number = 3
+): {
+  consensus: RaftConsensus;
+  quorumSize: number;
+  hasQuorum: boolean;
+} {
+  const consensus = new RaftConsensus(nodeId, totalNodes);
+  const quorumSize = QUORUM_CALCULATIONS.calculateRaftQuorum(totalNodes);
+  const hasQuorum = consensus.hasQuorum();
+
+  return {
+    consensus,
+    quorumSize,
+    hasQuorum
+  };
+}
+
 /**
  * Factory function to create a complete Byzantine consensus system
  * with all components properly integrated