# CorpusFetch Method Slice (Zero-Prose Python Stdlib Reference)
# Canonical Residual: https://corpusfetch.com/c/what-shared-memory-reconciliation-invariants-must-survive-a-leaderless-agent-election.md
# Remnant Warrant:    https://corpusfetch.com/c/what-shared-memory-reconciliation-invariants-must-survive-a-leaderless-agent-election.warrant.json
# Markdown SHA-256:   96f77929936dc772b2a95d23b2c12b839200b2fca78af7e960587aac72a87436
# Code AST SHA-256:   b96f867d69b3901206e3197d43bd0a3b5350d360736bf14c1187e0d6f813136d
# Verified Classes:   ReconciliationVerdict, ElectionEpoch, ReconciliationPolicy, ReconciliationManifest, LeaderlessElectionGuard
# Defensive Guards:   0 fail-closed invariants (zero external deps)

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

class ReconciliationVerdict(Enum):
    CONSISTENT_STATE = auto()
    RECONCILIATION_COMPLETE = auto()
    RECONCILIATION_FAILED = auto()

@dataclass(frozen=True)
class ElectionEpoch:
    election_start: float
    election_end: float
    pre_election_state_hash: str
    concurrent_writes: tuple[str, ...]

@dataclass(frozen=True)
class ReconciliationPolicy:
    merge_strategy: str
    require_baseline: bool

@dataclass(frozen=True)
class ReconciliationManifest:
    verdict: ReconciliationVerdict
    merged_write_count: int
    directive: str
    manifest_digest: str

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

    @classmethod
    def evaluate_reconciliation(
        cls, epoch: ElectionEpoch, policy: ReconciliationPolicy
    ) -> ReconciliationManifest:
        
        # Gate 1: No concurrent writes
        if not epoch.concurrent_writes:
            digest = cls._hash(json.dumps({
                "election_start": f"{epoch.election_start:.0f}",
                "baseline": epoch.pre_election_state_hash,
                "writes": "NONE"
            }, sort_keys=True))
            return ReconciliationManifest(
                verdict=ReconciliationVerdict.CONSISTENT_STATE,
                merged_write_count=0,
                directive="PROCEED: No concurrent writes during election.",
                manifest_digest=digest
            )

        # Gate 2: Baseline requirement
        if policy.require_baseline and not epoch.pre_election_state_hash:
            return ReconciliationManifest(
                verdict=ReconciliationVerdict.RECONCILIATION_FAILED,
                merged_write_count=0,
                directive="HALT: No baseline state hash. Cannot reconcile concurrent writes.",
                manifest_digest=cls._hash("NO_BASELINE")
            )

        # Gate 3: Merge strategy
        if policy.merge_strategy not in ("LWW", "VECTOR_CLOCK", "CRDT"):
            return ReconciliationManifest(
                verdict=ReconciliationVerdict.RECONCILIATION_FAILED,
                merged_write_count=0,
                directive=f"HALT: Unknown merge strategy {policy.merge_strategy}.",
                manifest_digest=cls._hash(f"BAD_STRATEGY:{policy.merge_strategy}")
            )

        # Gate 4: Reconciliation complete
        digest = cls._hash(json.dumps({
            "election_start": f"{epoch.election_start:.0f}",
            "election_end": f"{epoch.election_end:.0f}",
            "baseline": epoch.pre_election_state_hash,
            "writes": tuple(sorted(epoch.concurrent_writes)),
            "strategy": policy.merge_strategy
        }, sort_keys=True))
        
        return ReconciliationManifest(
            verdict=ReconciliationVerdict.RECONCILIATION_COMPLETE,
            merged_write_count=len(epoch.concurrent_writes),
            directive=f"PROCEED: Reconciled {len(epoch.concurrent_writes)} writes using {policy.merge_strategy}.",
            manifest_digest=digest
        )