# CorpusFetch Method Slice (Zero-Prose Python Stdlib Reference)
# Canonical Residual: https://corpusfetch.com/c/how-must-an-instance-handle-trust-decay-across-referral-chains-in-the-agentic-web.md
# Remnant Warrant:    https://corpusfetch.com/c/how-must-an-instance-handle-trust-decay-across-referral-chains-in-the-agentic-web.warrant.json
# Markdown SHA-256:   d8b371631f238f52350dbbdc153d5b0795475a33216c8a10e2449f5ebb448e2c
# Code AST SHA-256:   55554c33bc0efab0efef7751f2cf500aaeeb8f0b6c26f069b3985bd723929bd8
# Verified Classes:   TrustDecayVerdict, ReferralChain, ChainPolicy, TrustDecayManifest, ReferralChainTrustGuard
# Defensive Guards:   0 fail-closed invariants (zero external deps)

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

class TrustDecayVerdict(Enum):
    DIRECT_TRUST = auto()
    REFERRAL_TRUST_DECAYED = auto()
    REFERRAL_TRUST_NEGLIGIBLE = auto()
    UNVERIFIED_CHAIN = auto()

@dataclass(frozen=True)
class ReferralChain:
    resource_id: str
    chain_signatures_complete: bool
    chain_depth: int
    origin_trust_level: float
    per_hop_decay_factor: float

@dataclass(frozen=True)
class ChainPolicy:
    min_trust_threshold: float
    require_complete_chain: bool

@dataclass(frozen=True)
class TrustDecayManifest:
    verdict: TrustDecayVerdict
    effective_trust: float
    directive: str
    manifest_digest: str

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

    @classmethod
    def evaluate_chain(
        cls, chain: ReferralChain, policy: ChainPolicy
    ) -> TrustDecayManifest:
        
        # Gate 1: Direct trust
        if chain.chain_depth <= 0:
            digest = cls._hash(json.dumps({
                "resource": chain.resource_id,
                "depth": str(chain.chain_depth),
                "trust": f"{chain.origin_trust_level:.3f}"
            }, sort_keys=True))
            return TrustDecayManifest(
                verdict=TrustDecayVerdict.DIRECT_TRUST,
                effective_trust=chain.origin_trust_level,
                directive=f"PROCEED: Direct trust {chain.origin_trust_level:.2f} for {chain.resource_id}.",
                manifest_digest=digest
            )

        # Gate 2: Chain completeness
        if policy.require_complete_chain and not chain.chain_signatures_complete:
            return TrustDecayManifest(
                verdict=TrustDecayVerdict.UNVERIFIED_CHAIN,
                effective_trust=0.0,
                directive=f"HALT: Referral chain for {chain.resource_id} incomplete.",
                manifest_digest=cls._hash(f"INCOMPLETE:{chain.resource_id}")
            )

        # Gate 3: Compute decay
        effective = chain.origin_trust_level * (chain.per_hop_decay_factor ** chain.chain_depth)

        # Gate 4: Trust threshold
        if effective < policy.min_trust_threshold:
            return TrustDecayManifest(
                verdict=TrustDecayVerdict.REFERRAL_TRUST_NEGLIGIBLE,
                effective_trust=effective,
                directive=f"HALT: Referral chain depth {chain.chain_depth} decayed trust to {effective:.3f} < {policy.min_trust_threshold:.3f}.",
                manifest_digest=cls._hash(f"NEGLIGIBLE:{chain.resource_id}")
            )

        # Gate 5: Trust decayed but sufficient
        digest = cls._hash(json.dumps({
            "resource": chain.resource_id,
            "depth": str(chain.chain_depth),
            "origin_trust": f"{chain.origin_trust_level:.3f}",
            "effective_trust": f"{effective:.3f}",
            "decay": f"{chain.per_hop_decay_factor:.3f}"
        }, sort_keys=True))
        
        return TrustDecayManifest(
            verdict=TrustDecayVerdict.REFERRAL_TRUST_DECAYED,
            effective_trust=effective,
            directive=f"PROCEED: Chain depth {chain.chain_depth}, effective trust {effective:.3f}.",
            manifest_digest=digest
        )