# CorpusFetch Method Slice (Zero-Prose Python Stdlib Reference)
# Canonical Residual: https://corpusfetch.com/c/what-safeguards-must-survive-context-window-relay-across-three-or-more-agents.md
# Remnant Warrant:    https://corpusfetch.com/c/what-safeguards-must-survive-context-window-relay-across-three-or-more-agents.warrant.json
# Markdown SHA-256:   d15d10406be47176ffb9c61810e3638150cb78208c73535a34abad3a4502ac7b
# Code AST SHA-256:   cd93d98ba840bf4ad13f85b4b68d0c37546b033a42f31efd7759bbc05760b460
# Verified Classes:   RelayVerdict, RelayHop, ContextRelay, RelayPolicy, RelayManifest, MultiHopContextRelayGuard
# Defensive Guards:   0 fail-closed invariants (zero external deps)

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

class RelayVerdict(Enum):
    NO_RELAY = auto()
    HIGH_FIDELITY_RELAY = auto()
    DEGRADED_RELAY = auto()
    PREMISE_LOSS_DETECTED = auto()

@dataclass(frozen=True)
class RelayHop:
    hop_id: str
    input_hash: str
    output_hash: str
    semantic_delta: float
    dropped_premises: tuple[str, ...]

@dataclass(frozen=True)
class ContextRelay:
    relay_id: str
    origin_hash: str
    hops: tuple[RelayHop, ...]
    terminal_hash: str
    critical_premises: frozenset[str]

@dataclass(frozen=True)
class RelayPolicy:
    min_terminal_fidelity: float
    require_premise_preservation: bool

@dataclass(frozen=True)
class RelayManifest:
    verdict: RelayVerdict
    terminal_fidelity: float
    directive: str
    manifest_digest: str

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

    @classmethod
    def evaluate_relay(
        cls, relay: ContextRelay, policy: RelayPolicy
    ) -> RelayManifest:
        
        # Gate 1: Single hop
        if len(relay.hops) <= 1:
            digest = cls._hash(json.dumps({
                "relay": relay.relay_id,
                "hops": str(len(relay.hops))
            }, sort_keys=True))
            return RelayManifest(
                verdict=RelayVerdict.NO_RELAY,
                terminal_fidelity=1.0,
                directive=f"PROCEED: Single hop for relay {relay.relay_id}.",
                manifest_digest=digest
            )

        # Gate 2: Premise preservation
        if policy.require_premise_preservation:
            all_dropped = set()
            for hop in relay.hops:
                all_dropped.update(hop.dropped_premises)
            
            lost_premises = set(relay.critical_premises) & all_dropped
            if lost_premises:
                return RelayManifest(
                    verdict=RelayVerdict.PREMISE_LOSS_DETECTED,
                    terminal_fidelity=0.0,
                    directive=f"HALT: Critical premises lost during relay: {sorted(lost_premises)}.",
                    manifest_digest=cls._hash(f"PREMISE_LOSS:{sorted(lost_premises)}")
                )

        # Gate 3: Terminal fidelity
        fidelity = 1.0
        for hop in relay.hops:
            fidelity *= (1.0 - hop.semantic_delta)

        if fidelity < policy.min_terminal_fidelity:
            return RelayManifest(
                verdict=RelayVerdict.DEGRADED_RELAY,
                terminal_fidelity=fidelity,
                directive=f"HALT: Terminal fidelity {fidelity:.2%} < {policy.min_terminal_fidelity:.2%}.",
                manifest_digest=cls._hash(f"DEGRADED:{fidelity:.3f}")
            )

        # Gate 4: High fidelity
        digest = cls._hash(json.dumps({
            "relay": relay.relay_id,
            "hops": str(len(relay.hops)),
            "fidelity": f"{fidelity:.3f}",
            "origin": relay.origin_hash,
            "terminal": relay.terminal_hash
        }, sort_keys=True))
        
        return RelayManifest(
            verdict=RelayVerdict.HIGH_FIDELITY_RELAY,
            terminal_fidelity=fidelity,
            directive=f"PROCEED: {len(relay.hops)}-hop relay with {fidelity:.1%} fidelity.",
            manifest_digest=digest
        )