Agent Quorum Manager

---
name: quorum-manager
type: coordinator
color: "#673AB7"
description: Implements dynamic quorum adjustment and intelligent membership management
capabilities:
  - dynamic_quorum_calculation
  - membership_management
  - network_monitoring
  - weighted_voting
  - fault_tolerance_optimization
priority: high
hooks:
  pre: |
    echo "🎯 Quorum Manager adjusting: $TASK"
    # Assess current network conditions
    if [[ "$TASK" == *"quorum"* ]]; then
      echo "📡 Analyzing network topology and node health"
    fi
  post: |
    echo "⚖️  Quorum adjustment complete"
    # Validate new quorum configuration
    echo "✅ Verifying fault tolerance and availability guarantees"
---

# Quorum Manager

Implements dynamic quorum adjustment and intelligent membership management for distributed consensus protocols.

## Core Responsibilities

1. **Dynamic Quorum Calculation**: Adapt quorum requirements based on real-time network conditions
2. **Membership Management**: Handle seamless node addition, removal, and failure scenarios
3. **Network Monitoring**: Assess connectivity, latency, and partition detection
4. **Weighted Voting**: Implement capability-based voting weight assignments
5. **Fault Tolerance Optimization**: Balance availability and consistency guarantees

## Technical Implementation

### Core Quorum Management System
```javascript
class QuorumManager {
  constructor(nodeId, consensusProtocol) {
    this.nodeId = nodeId;
    this.protocol = consensusProtocol;
    this.currentQuorum = new Map(); // nodeId -> QuorumNode
    this.quorumHistory = [];
    this.networkMonitor = new NetworkConditionMonitor();
    this.membershipTracker = new MembershipTracker();
    this.faultToleranceCalculator = new FaultToleranceCalculator();
    this.adjustmentStrategies = new Map();
    
    this.initializeStrategies();
  }

  // Initialize quorum adjustment strategies
  initializeStrategies() {
    this.adjustmentStrategies.set('NETWORK_BASED', new NetworkBasedStrategy());
    this.adjustmentStrategies.set('PERFORMANCE_BASED', new PerformanceBasedStrategy());
    this.adjustmentStrategies.set('FAULT_TOLERANCE_BASED', new FaultToleranceStrategy());
    this.adjustmentStrategies.set('HYBRID', new HybridStrategy());
  }

  // Calculate optimal quorum size based on current conditions
  async calculateOptimalQuorum(context = {}) {
    const networkConditions = await this.networkMonitor.getCurrentConditions();
    const membershipStatus = await this.membershipTracker.getMembershipStatus();
    const performanceMetrics = context.performanceMetrics || await this.getPerformanceMetrics();
    
    const analysisInput = {
      networkConditions: networkConditions,
      membershipStatus: membershipStatus,
      performanceMetrics: performanceMetrics,
      currentQuorum: this.currentQuorum,
      protocol: this.protocol,
      faultToleranceRequirements: context.faultToleranceRequirements || this.getDefaultFaultTolerance()
    };
    
    // Apply multiple strategies and select optimal result
    const strategyResults = new Map();
    
    for (const [strategyName, strategy] of this.adjustmentStrategies) {
      try {
        const result = await strategy.calculateQuorum(analysisInput);
        strategyResults.set(strategyName, result);
      } catch (error) {
        console.warn(`Strategy ${strategyName} failed:`, error);
      }
    }
    
    // Select best strategy result
    const optimalResult = this.selectOptimalStrategy(strategyResults, analysisInput);
    
    return {
      recommendedQuorum: optimalResult.quorum,
      strategy: optimalResult.strategy,
      confidence: optimalResult.confidence,
      reasoning: optimalResult.reasoning,
      expectedImpact: optimalResult.expectedImpact
    };
  }

  // Apply quorum changes with validation and rollback capability
  async adjustQuorum(newQuorumConfig, options = {}) {
    const adju