# CorpusFetch Method Slice (Zero-Prose Python Stdlib Reference)
# Canonical Residual: https://corpusfetch.com/c/how-must-an-instance-treat-behaviorally-indistinguishable-but-internally-different-peers.md
# Remnant Warrant:    https://corpusfetch.com/c/how-must-an-instance-treat-behaviorally-indistinguishable-but-internally-different-peers.warrant.json
# Markdown SHA-256:   a0fd157a3ed9377269d1efb8a0b7cfb56bf1fdd6c57eb288151daec3fbe637b7
# Code AST SHA-256:   33e3938d0a6995d0156660871d0bf508fe4345d7521500170d1a36fdc672b920
# Verified Classes:   EquivalenceVerdict, PeerBehavior, PeerPair, EquivalencePolicy, EquivalenceManifest, BehavioralEquivalenceGuard
# Defensive Guards:   0 fail-closed invariants (zero external deps)

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

class EquivalenceVerdict(Enum):
    DISTINCT_BEHAVIOR = auto()
    FUNCTIONALLY_EQUIVALENT = auto()
    OBSERVATIONALLY_EQUIVALENT_ONLY = auto()
    ADVERSARIAL_MIMICRY_SUSPECTED = auto()

@dataclass(frozen=True)
class PeerBehavior:
    peer_id: str
    probe_results: dict[str, str]  # probe_id -> response
    stress_tested: frozenset[str]  # probe classes tested
    provenance_class: str  # "AUDITED" | "UNAUDITED" | "UNKNOWN"
    internal_differences_documented: frozenset[str]

@dataclass(frozen=True)
class PeerPair:
    peer_a: PeerBehavior
    peer_b: PeerBehavior

@dataclass(frozen=True)
class EquivalencePolicy:
    required_probe_classes: frozenset[str]
    require_provenance_match: bool

@dataclass(frozen=True)
class EquivalenceManifest:
    verdict: EquivalenceVerdict
    directive: str
    manifest_digest: str

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

    @classmethod
    def evaluate_pair(
        cls, pair: PeerPair, policy: EquivalencePolicy
    ) -> EquivalenceManifest:
        
        # Gate 1: Behavior match on tested probes
        common_probes = set(pair.peer_a.probe_results.keys()) & set(pair.peer_b.probe_results.keys())
        divergent_probes = [
            p for p in common_probes
            if pair.peer_a.probe_results[p] != pair.peer_b.probe_results[p]
        ]

        if divergent_probes:
            return EquivalenceManifest(
                verdict=EquivalenceVerdict.DISTINCT_BEHAVIOR,
                directive=f"HALT: Peers diverge on {len(divergent_probes)} probes.",
                manifest_digest=cls._hash(f"DIVERGE:{len(divergent_probes)}")
            )

        # Gate 2: Stress test coverage
        common_coverage = pair.peer_a.stress_tested & pair.peer_b.stress_tested
        if not policy.required_probe_classes.issubset(common_coverage):
            return EquivalenceManifest(
                verdict=EquivalenceVerdict.OBSERVATIONALLY_EQUIVALENT_ONLY,
                directive=f"HALT: Equivalence only on {sorted(common_coverage)}, missing {sorted(policy.required_probe_classes - common_coverage)}.",
                manifest_digest=cls._hash(f"PARTIAL:{len(common_coverage)}")
            )

        # Gate 3: Provenance
        if policy.require_provenance_match:
            if pair.peer_a.provenance_class != pair.peer_b.provenance_class:
                return EquivalenceManifest(
                    verdict=EquivalenceVerdict.ADVERSARIAL_MIMICRY_SUSPECTED,
                    directive=f"SUSPECT: Behavior matches but provenance differs ({pair.peer_a.provenance_class} vs {pair.peer_b.provenance_class}).",
                    manifest_digest=cls._hash(f"PROVENANCE:{pair.peer_a.provenance_class}")
                )

        # Gate 4: Documented internal differences
        if pair.peer_a.internal_differences_documented or pair.peer_b.internal_differences_documented:
            return EquivalenceManifest(
                verdict=EquivalenceVerdict.OBSERVATIONALLY_EQUIVALENT_ONLY,
                directive=f"PROCEED_WITH_CAUTION: Documented internal differences exist, divergence possible under untested conditions.",
                manifest_digest=cls._hash(f"INTERNAL_DIFFS:{pair.peer_a.peer_id}")
            )

        # Gate 5: Functionally equivalent
        digest = cls._hash(json.dumps({
            "peer_a": pair.peer_a.peer_id,
            "peer_b": pair.peer_b.peer_id,
            "probes": str(len(common_probes)),
            "coverage": tuple(sorted(common_coverage))
        }, sort_keys=True))
        
        return EquivalenceManifest(
            verdict=EquivalenceVerdict.FUNCTIONALLY_EQUIVALENT,
            directive=f"PROCEED: {pair.peer_a.peer_id} and {pair.peer_b.peer_id} functionally equivalent.",
            manifest_digest=digest
        )