# CorpusFetch Method Slice (Zero-Prose Python Stdlib Reference)
# Canonical Residual: https://corpusfetch.com/c/how-must-multi-judge-consensus-handle-judge-non-independence-due-to-shared-base-models.md
# Remnant Warrant:    https://corpusfetch.com/c/how-must-multi-judge-consensus-handle-judge-non-independence-due-to-shared-base-models.warrant.json
# Markdown SHA-256:   314734640d03cade4edf9397a9398ad1c9f2385cae93fb476a946a9478c2dbc3
# Code AST SHA-256:   49fe37ec71abc8fc37bf68970c4d36f87b509a679707c19c053530fa4403a0e7
# Verified Classes:   JudgeVerdict, Judge, ConsensusState, JudgePolicy, JudgeManifest, JudgeIndependenceGuard
# Defensive Guards:   0 fail-closed invariants (zero external deps)

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

class JudgeVerdict(Enum):
    INDEPENDENT_CONSENSUS = auto()
    CORRELATED_CONSENSUS = auto()
    INSUFFICIENT_INDEPENDENCE = auto()
    SINGLE_JUDGE = auto()

@dataclass(frozen=True)
class Judge:
    judge_id: str
    base_model: str
    prompt_strategy: str

@dataclass(frozen=True)
class ConsensusState:
    judges: tuple[Judge, ...]
    correlated_error_score: float
    votes_agree: bool

@dataclass(frozen=True)
class JudgePolicy:
    max_acceptable_correlation: float
    require_distinct_bases: bool

@dataclass(frozen=True)
class JudgeManifest:
    verdict: JudgeVerdict
    effective_judge_count: float
    directive: str
    manifest_digest: str

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

    @classmethod
    def evaluate_consensus(
        cls, state: ConsensusState, policy: JudgePolicy
    ) -> JudgeManifest:
        
        # Gate 1: Single judge
        if len(state.judges) <= 1:
            digest = cls._hash(json.dumps({
                "judges": str(len(state.judges)),
                "consensus": "N/A"
            }, sort_keys=True))
            return JudgeManifest(
                verdict=JudgeVerdict.SINGLE_JUDGE,
                effective_judge_count=1.0,
                directive="PROCEED: Single judge, no consensus applicable.",
                manifest_digest=digest
            )

        # Gate 2: Distinct base models
        base_models = {j.base_model for j in state.judges}
        if policy.require_distinct_bases and len(base_models) < len(state.judges):
            # Compute correlation-adjusted effective count
            effective_count = len(base_models) * 1.2 if len(base_models) > 1 else 1.0
            digest = cls._hash(json.dumps({
                "judges": str(len(state.judges)),
                "distinct_bases": str(len(base_models)),
                "effective": f"{effective_count:.2f}"
            }, sort_keys=True))
            return JudgeManifest(
                verdict=JudgeVerdict.INSUFFICIENT_INDEPENDENCE,
                effective_judge_count=effective_count,
                directive=f"WARN: {len(state.judges)} judges share {len(base_models)} base models. Effective {effective_count:.1f}.",
                manifest_digest=digest
            )

        # Gate 3: Correlation threshold
        if state.correlated_error_score > policy.max_acceptable_correlation:
            effective_count = len(state.judges) * (1 - state.correlated_error_score)
            digest = cls._hash(json.dumps({
                "judges": str(len(state.judges)),
                "correlation": f"{state.correlated_error_score:.3f}",
                "effective": f"{effective_count:.2f}"
            }, sort_keys=True))
            return JudgeManifest(
                verdict=JudgeVerdict.CORRELATED_CONSENSUS,
                effective_judge_count=effective_count,
                directive=f"WARN: Correlation {state.correlated_error_score:.2f} exceeds {policy.max_acceptable_correlation:.2f}. Effective {effective_count:.1f} judges.",
                manifest_digest=digest
            )

        # Gate 4: Independent consensus
        digest = cls._hash(json.dumps({
            "judges": str(len(state.judges)),
            "distinct_bases": str(len(base_models)),
            "correlation": f"{state.correlated_error_score:.3f}",
            "agreement": str(state.votes_agree)
        }, sort_keys=True))
        
        return JudgeManifest(
            verdict=JudgeVerdict.INDEPENDENT_CONSENSUS,
            effective_judge_count=float(len(state.judges)),
            directive=f"PROCEED: {len(state.judges)} independent judges, agreement={state.votes_agree}.",
            manifest_digest=digest
        )