# CorpusFetch Method Slice (Zero-Prose Python Stdlib Reference)
# Canonical Residual: https://corpusfetch.com/c/what-invariant-drift-invariants-must-prevent-trust-signals-from-being-laundered-through-agent-endorsements.md
# Remnant Warrant:    https://corpusfetch.com/c/what-invariant-drift-invariants-must-prevent-trust-signals-from-being-laundered-through-agent-endorsements.warrant.json
# Markdown SHA-256:   67a44d1727f970e80588dbd1941df23ea1c1cd892e783e35256031910cde6505
# Code AST SHA-256:   9960319562e43d9845fcfafbb76f0bdd68b469439d3780b735373bc2fe37344f
# Verified Classes:   EndorsementVerdict, Endorsement, EndorsementPolicy, EndorsementManifest, TrustLaunderingGuard
# Defensive Guards:   0 fail-closed invariants (zero external deps)

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

class EndorsementVerdict(Enum):
    ROOTED_ENDORSEMENT = auto()
    CYCLE_DETECTED = auto()
    DECAYED_ENDORSEMENT = auto()
    INSUFFICIENT_DIVERSITY = auto()

@dataclass(frozen=True)
class Endorsement:
    endorser_id: str
    endorsee_id: str
    root_attestation: str | None
    closes_cycle: bool
    generation_from_root: int
    endorser_diversity_score: float

@dataclass(frozen=True)
class EndorsementPolicy:
    max_generation_from_root: int
    min_diversity_score: float

@dataclass(frozen=True)
class EndorsementManifest:
    verdict: EndorsementVerdict
    effective_weight: float
    directive: str
    manifest_digest: str

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

    @classmethod
    def evaluate_endorsement(
        cls, endorsement: Endorsement, policy: EndorsementPolicy
    ) -> EndorsementManifest:
        
        # Gate 1: Cycle
        if endorsement.closes_cycle:
            return EndorsementManifest(
                verdict=EndorsementVerdict.CYCLE_DETECTED,
                effective_weight=0.0,
                directive=f"HALT: Endorsement {endorsement.endorser_id} -> {endorsement.endorsee_id} closes cycle. Zero weight.",
                manifest_digest=cls._hash(f"CYCLE:{endorsement.endorser_id}:{endorsement.endorsee_id}")
            )

        # Gate 2: Root attestation
        if endorsement.root_attestation:
            digest = cls._hash(json.dumps({
                "endorser": endorsement.endorser_id,
                "endorsee": endorsement.endorsee_id,
                "root": endorsement.root_attestation,
                "generation": str(endorsement.generation_from_root)
            }, sort_keys=True))
            return EndorsementManifest(
                verdict=EndorsementVerdict.ROOTED_ENDORSEMENT,
                effective_weight=1.0,
                directive=f"PROCEED: Rooted endorsement, full weight.",
                manifest_digest=digest
            )

        # Gate 3: Generation decay
        if endorsement.generation_from_root > policy.max_generation_from_root:
            return EndorsementManifest(
                verdict=EndorsementVerdict.DECAYED_ENDORSEMENT,
                effective_weight=0.0,
                directive=f"HALT: Endorsement generation {endorsement.generation_from_root} > {policy.max_generation_from_root}.",
                manifest_digest=cls._hash(f"DECAYED:{endorsement.endorser_id}")
            )

        # Gate 4: Diversity
        if endorsement.endorser_diversity_score < policy.min_diversity_score:
            return EndorsementManifest(
                verdict=EndorsementVerdict.INSUFFICIENT_DIVERSITY,
                effective_weight=0.3,
                directive=f"WARN: Endorser diversity {endorsement.endorser_diversity_score:.2f} < {policy.min_diversity_score:.2f}. Reduced weight.",
                manifest_digest=cls._hash(f"LOW_DIVERSITY:{endorsement.endorser_id}")
            )

        # Gate 5: Decayed but acceptable
        decay = 1.0 / (1.0 + endorsement.generation_from_root * 0.5)
        digest = cls._hash(json.dumps({
            "endorser": endorsement.endorser_id,
            "endorsee": endorsement.endorsee_id,
            "generation": str(endorsement.generation_from_root),
            "diversity": f"{endorsement.endorser_diversity_score:.3f}",
            "weight": f"{decay:.3f}"
        }, sort_keys=True))
        
        return EndorsementManifest(
            verdict=EndorsementVerdict.DECAYED_ENDORSEMENT,
            effective_weight=decay,
            directive=f"PROCEED: Endorsement weight {decay:.2f} after {endorsement.generation_from_root} generations.",
            manifest_digest=digest
        )