# CorpusFetch Method Slice (Zero-Prose Python Stdlib Reference)
# Canonical Residual: https://corpusfetch.com/c/what-cross-agent-memory-consensus-invariants-prevent-agents-from-acting-on-divergent-recollections.md
# Remnant Warrant:    https://corpusfetch.com/c/what-cross-agent-memory-consensus-invariants-prevent-agents-from-acting-on-divergent-recollections.warrant.json
# Markdown SHA-256:   f4e6dd04ad1ba656f210e047a2043c9df6cf717156373aefeba86dbac49262fd
# Code AST SHA-256:   becf917a734ceeee577006743f5f7a2824918e1f3c00da2446fe9448bdb25e0a
# Verified Classes:   ConsensusVerdict, EventWitness, SharedEvent, ConsensusPolicy, ConsensusManifest, DivergentMemoryGuard
# Defensive Guards:   0 fail-closed invariants (zero external deps)

from dataclasses import dataclass
from enum import Enum, auto
import hashlib
import json

class ConsensusVerdict(Enum):
    SINGLE_WITNESS = auto()
    CONSENSUS_REACHED = auto()
    CONSENSUS_FAILED = auto()
    DIVERGENCE_ESCALATED = auto()

@dataclass(frozen=True)
class EventWitness:
    agent_id: str
    event_hash: str
    signature: str

@dataclass(frozen=True)
class SharedEvent:
    event_id: str
    witnesses: tuple[EventWitness, ...]
    oracle_attestation: str | None

@dataclass(frozen=True)
class ConsensusPolicy:
    consensus_threshold: float

@dataclass(frozen=True)
class ConsensusManifest:
    verdict: ConsensusVerdict
    reconciled_event_hash: str | None
    directive: str
    manifest_digest: str

class DivergentMemoryGuard:
    @staticmethod
    def _hash(data: str) -> str:
        return hashlib.sha256(data.encode("utf-8")).hexdigest()

    @classmethod
    def evaluate_event(
        cls, event: SharedEvent, policy: ConsensusPolicy
    ) -> ConsensusManifest:
        
        # Gate 1: Single witness
        if len(event.witnesses) <= 1:
            digest = cls._hash(json.dumps({
                "event": event.event_id,
                "witnesses": str(len(event.witnesses))
            }, sort_keys=True))
            return ConsensusManifest(
                verdict=ConsensusVerdict.SINGLE_WITNESS,
                reconciled_event_hash=event.witnesses[0].event_hash if event.witnesses else None,
                directive=f"PROCEED: Single witness, no consensus needed.",
                manifest_digest=digest
            )

        # Gate 2: Oracle attestation
        if event.oracle_attestation:
            digest = cls._hash(json.dumps({
                "event": event.event_id,
                "oracle": event.oracle_attestation
            }, sort_keys=True))
            return ConsensusManifest(
                verdict=ConsensusVerdict.CONSENSUS_REACHED,
                reconciled_event_hash=event.oracle_attestation,
                directive=f"PROCEED: Oracle-attested event.",
                manifest_digest=digest
            )

        # Gate 3: Vote tally
        vote_counts: dict[str, int] = {}
        for w in event.witnesses:
            vote_counts[w.event_hash] = vote_counts.get(w.event_hash, 0) + 1

        total = len(event.witnesses)
        for event_hash, count in vote_counts.items():
            if count / total >= policy.consensus_threshold:
                digest = cls._hash(json.dumps({
                    "event": event.event_id,
                    "winner": event_hash,
                    "votes": str(count),
                    "total": str(total)
                }, sort_keys=True))
                return ConsensusManifest(
                    verdict=ConsensusVerdict.CONSENSUS_REACHED,
                    reconciled_event_hash=event_hash,
                    directive=f"PROCEED: Consensus {count}/{total} on {event_hash[:8]}.",
                    manifest_digest=digest
                )

        # Gate 4: Escalate
        return ConsensusManifest(
            verdict=ConsensusVerdict.DIVERGENCE_ESCALATED,
            reconciled_event_hash=None,
            directive=f"HALT: No consensus ({len(vote_counts)} distinct hashes). Escalate to human.",
            manifest_digest=cls._hash(f"DIVERGENT:{event.event_id}")
        )