[Issue #707] Implement Byzantine-Resistant Quorum

agents/internal/swarm/go.mod

@@ -0,0 +1 @@
+module phoenix/swarm

agents/internal/swarm/reputation.go

@@ -0,0 +1,31 @@
+package swarm
+
+import (
+	"sync"
+)
+
+type ReputationStore struct {
+	mu         sync.RWMutex
+	reputation map[string]float64
+}
+
+func NewReputationStore() *ReputationStore {
+	return &ReputationStore{
+		reputation: make(map[string]float64),
+	}
+}
+
+func (s *ReputationStore) UpdateReputation(nodeID string, delta float64) {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	s.reputation[nodeID] += delta
+	if s.reputation[nodeID] < 0 {
+		s.reputation[nodeID] = 0
+	}
+}
+
+func (s *ReputationStore) GetReputation(nodeID string) float64 {
+	s.mu.RLock()
+	defer s.mu.RUnlock()
+	return s.reputation[nodeID]
+}

agents/internal/swarm/reputation_test.go

@@ -0,0 +1,12 @@
+package swarm
+
+import "testing"
+
+func TestReputationStore(t *testing.T) {
+	store := NewReputationStore()
+	store.UpdateReputation("node1", 10.0)
+
+	if store.GetReputation("node1") != 10.0 {
+		t.Errorf("Expected 10.0, got %f", store.GetReputation("node1"))
+	}
+}

phoenix_os/arbiter/consensus.go

@@ -0,0 +1,59 @@
+package arbiter
+
+import (
+	"sync"
+	"time"
+
+	"phoenix/agents/internal/swarm"
+)
+
+type Vote struct {
+	NodeID     string
+	Decision   bool
+	Confidence float64
+}
+
+type ConsensusEngine struct {
+	mu           sync.Mutex
+	reputation   *swarm.ReputationStore
+	votes        []Vote
+	threshold    float64
+}
+
+func NewConsensusEngine(rep *swarm.ReputationStore, threshold float64) *ConsensusEngine {
+	return &ConsensusEngine{
+		reputation: rep,
+		votes:      make([]Vote, 0),
+		threshold:  threshold,
+	}
+}
+
+func (e *ConsensusEngine) SubmitVote(v Vote) {
+	e.mu.Lock()
+	defer e.mu.Unlock()
+	e.votes = append(e.votes, v)
+}
+
+func (e *ConsensusEngine) EvaluateQuorum() bool {
+	e.mu.Lock()
+	defer e.mu.Unlock()
+
+	var weightedTotal float64
+	var totalReputation float64
+
+	for _, v := range e.votes {
+		rep := e.reputation.GetReputation(v.NodeID)
+		if rep == 0 { rep = 1.0 } // Default minimal rep
+
+		if v.Decision {
+			weightedTotal += rep * v.Confidence
+		}
+		totalReputation += rep
+	}
+
+	if totalReputation == 0 {
+		return false
+	}
+
+	return (weightedTotal / totalReputation) > e.threshold
+}

phoenix_os/arbiter/consensus_test.go

@@ -0,0 +1,23 @@
+package arbiter
+
+import (
+	"phoenix/agents/internal/swarm"
+	"testing"
+)
+
+func TestConsensusEngine(t *testing.T) {
+	rep := swarm.NewReputationStore()
+	rep.UpdateReputation("node1", 10.0) // High trust
+	rep.UpdateReputation("node2", 1.0)  // Low trust
+
+	engine := NewConsensusEngine(rep, 0.5)
+
+	// High trust node votes true
+	engine.SubmitVote(Vote{"node1", true, 0.9})
+	// Low trust node votes false
+	engine.SubmitVote(Vote{"node2", false, 0.9})
+
+	if !engine.EvaluateQuorum() {
+		t.Error("Expected quorum to be true based on high trust node")
+	}
+}

phoenix_os/arbiter/go.mod

@@ -1,3 +1 @@
 module phoenix/arbiter
-
-go 1.25.0