# CorpusFetch Method Slice (Zero-Prose Python Stdlib Reference)
# Canonical Residual: https://corpusfetch.com/c/how-must-an-instance-bound-trust-after-observing-defection-history.md
# Remnant Warrant:    https://corpusfetch.com/c/how-must-an-instance-bound-trust-after-observing-defection-history.warrant.json
# Markdown SHA-256:   cf5c7dadc3da4424f790ac6ff77bb855b5adf4f836b238fc08ad59555bb5cda2
# Code AST SHA-256:   280ea1f6969144be25118b60704af02fa817182c20ab8695c43cb2705cf2568a
# Verified Classes:   TrustTrajectoryVerdict, PeerTrustState, TrustPolicy, TrustTrajectoryManifest, DefectionHistoryTrustGuard
# Defensive Guards:   0 fail-closed invariants (zero external deps)

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

class TrustTrajectoryVerdict(Enum):
    NO_HISTORY = auto()
    CLEAN_HISTORY = auto()
    LIMITED_TRUST = auto()
    REDEMPTION_ELIGIBLE = auto()
    PERMANENTLY_EXCLUDED = auto()

@dataclass(frozen=True)
class PeerTrustState:
    peer_id: str
    defection_count: int
    defection_pattern_strategic: bool
    post_defection_cooperation_ratio: float
    explicit_remediation_completed: bool
    recent_cooperation_duration_sec: float

@dataclass(frozen=True)
class TrustPolicy:
    min_recovery_duration_sec: float
    require_explicit_remediation: bool
    max_acceptable_defections: int

@dataclass(frozen=True)
class TrustTrajectoryManifest:
    verdict: TrustTrajectoryVerdict
    directive: str
    manifest_digest: str

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

    @classmethod
    def evaluate_peer(
        cls, peer: PeerTrustState, policy: TrustPolicy
    ) -> TrustTrajectoryManifest:
        
        # Gate 1: No history
        if peer.defection_count == 0:
            digest = cls._hash(json.dumps({
                "peer": peer.peer_id,
                "history": "NONE"
            }, sort_keys=True))
            return TrustTrajectoryManifest(
                verdict=TrustTrajectoryVerdict.CLEAN_HISTORY,
                directive=f"PROCEED: Peer {peer.peer_id} has no defection history.",
                manifest_digest=digest
            )

        # Gate 2: Excessive defections
        if peer.defection_count > policy.max_acceptable_defections:
            return TrustTrajectoryManifest(
                verdict=TrustTrajectoryVerdict.PERMANENTLY_EXCLUDED,
                directive=f"EXCLUDE: Peer {peer.peer_id} has {peer.defection_count} defections > {policy.max_acceptable_defections}.",
                manifest_digest=cls._hash(f"EXCLUDED:{peer.peer_id}")
            )

        # Gate 3: Strategic pattern
        if peer.defection_pattern_strategic:
            return TrustTrajectoryManifest(
                verdict=TrustTrajectoryVerdict.LIMITED_TRUST,
                directive=f"LIMIT: Peer {peer.peer_id} shows strategic defection pattern.",
                manifest_digest=cls._hash(f"STRATEGIC:{peer.peer_id}")
            )

        # Gate 4: Redemption criteria
        remediation_ok = (
            peer.explicit_remediation_completed 
            if policy.require_explicit_remediation 
            else True
        )
        duration_ok = peer.recent_cooperation_duration_sec >= policy.min_recovery_duration_sec
        cooperation_ok = peer.post_defection_cooperation_ratio >= 0.8

        if remediation_ok and duration_ok and cooperation_ok:
            digest = cls._hash(json.dumps({
                "peer": peer.peer_id,
                "cooperation": f"{peer.post_defection_cooperation_ratio:.3f}",
                "duration": f"{peer.recent_cooperation_duration_sec:.0f}",
                "remediated": peer.explicit_remediation_completed
            }, sort_keys=True))
            return TrustTrajectoryManifest(
                verdict=TrustTrajectoryVerdict.REDEMPTION_ELIGIBLE,
                directive=f"REDEEM: Peer {peer.peer_id} eligible for redemption ({peer.post_defection_cooperation_ratio:.2f} cooperation).",
                manifest_digest=digest
            )

        # Gate 5: Limited trust
        digest = cls._hash(json.dumps({
            "peer": peer.peer_id,
            "defections": str(peer.defection_count),
            "cooperation": f"{peer.post_defection_cooperation_ratio:.3f}"
        }, sort_keys=True))
        
        return TrustTrajectoryManifest(
            verdict=TrustTrajectoryVerdict.LIMITED_TRUST,
            directive=f"LIMIT: Peer {peer.peer_id} has {peer.defection_count} defections, limited trust.",
            manifest_digest=digest
        )