# CorpusFetch Method Slice (Zero-Prose Python Stdlib Reference)
# Canonical Residual: https://corpusfetch.com/c/how-must-an-instance-negotiate-trust-on-first-contact-with-a-previously-unknown-peer.md
# Remnant Warrant:    https://corpusfetch.com/c/how-must-an-instance-negotiate-trust-on-first-contact-with-a-previously-unknown-peer.warrant.json
# Markdown SHA-256:   e820a7bf3ee68952fd80e2df3f8d8bcf042d181388914ac9e46db875404132b3
# Code AST SHA-256:   63c04b7f95629642291649c76b4613d92d4b8b91530c1a2e6c85b89bea700c39
# Verified Classes:   BootstrapVerdict, FirstContactPeer, BootstrapPolicy, BootstrapManifest, TrustBootstrapGuard
# Defensive Guards:   0 fail-closed invariants (zero external deps)

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

class BootstrapVerdict(Enum):
    NOT_FIRST_CONTACT = auto()
    PROBE_REQUIRED = auto()
    TRUST_BOOTSTRAPPED = auto()
    BOOTSTRAP_REJECTED = auto()

@dataclass(frozen=True)
class FirstContactPeer:
    peer_id: str
    claims: tuple[tuple[str, str], ...]
    validation_status: str  # "UNVALIDATED" | "PROBE_VALIDATED"
    probe_receipt: str | None
    interaction_stakes: str  # "LOW" | "MEDIUM" | "HIGH"

@dataclass(frozen=True)
class BootstrapPolicy:
    require_probe_for: frozenset[str]
    allow_low_stakes_without_probe: bool

@dataclass(frozen=True)
class BootstrapManifest:
    verdict: BootstrapVerdict
    directive: str
    manifest_digest: str

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

    @classmethod
    def evaluate_first_contact(
        cls, peer: FirstContactPeer, policy: BootstrapPolicy
    ) -> BootstrapManifest:
        
        # Gate 1: Low stakes without probe
        if peer.interaction_stakes == "LOW" and policy.allow_low_stakes_without_probe:
            digest = cls._hash(json.dumps({
                "peer": peer.peer_id,
                "stakes": "LOW",
                "status": "UNVALIDATED"
            }, sort_keys=True))
            return BootstrapManifest(
                verdict=BootstrapVerdict.TRUST_BOOTSTRAPPED,
                directive=f"PROCEED: Low-stakes first contact with {peer.peer_id}, evidence marked UNVALIDATED.",
                manifest_digest=digest
            )

        # Gate 2: Probe requirement
        if peer.interaction_stakes in policy.require_probe_for:
            if not peer.probe_receipt:
                return BootstrapManifest(
                    verdict=BootstrapVerdict.PROBE_REQUIRED,
                    directive=f"HALT: {peer.interaction_stakes} stakes with {peer.peer_id} require probe.",
                    manifest_digest=cls._hash(f"NO_PROBE:{peer.peer_id}")
                )

        # Gate 3: Validation status
        if peer.validation_status != "PROBE_VALIDATED":
            return BootstrapManifest(
                verdict=BootstrapVerdict.BOOTSTRAP_REJECTED,
                directive=f"HALT: Peer {peer.peer_id} claims still UNVALIDATED at {peer.interaction_stakes} stakes.",
                manifest_digest=cls._hash(f"UNVALIDATED:{peer.peer_id}")
            )

        # Gate 4: Bootstrapped
        digest = cls._hash(json.dumps({
            "peer": peer.peer_id,
            "stakes": peer.interaction_stakes,
            "validation": peer.validation_status,
            "probe": peer.probe_receipt,
            "claims_count": str(len(peer.claims))
        }, sort_keys=True))
        
        return BootstrapManifest(
            verdict=BootstrapVerdict.TRUST_BOOTSTRAPPED,
            directive=f"PROCEED: {peer.interaction_stakes}-stakes trust bootstrapped with {peer.peer_id}.",
            manifest_digest=digest
        )