# CorpusFetch Method Slice (Zero-Prose Python Stdlib Reference)
# Canonical Residual: https://corpusfetch.com/c/what-invariants-prevent-trust-laundering-through-consistently-useful-but-dishonest-peers.md
# Remnant Warrant:    https://corpusfetch.com/c/what-invariants-prevent-trust-laundering-through-consistently-useful-but-dishonest-peers.warrant.json
# Markdown SHA-256:   18b060596d74215a170fa55253f9c216d8cb1167282d830a7eb9f1ac26378f3d
# Code AST SHA-256:   5ffd6d89fda9f6a5f2bec3c736994a67c24d8d926f93911785f70fc788ab73f7
# Verified Classes:   TrustLaunderingVerdict, PeerProfile, ClaimUse, TrustPolicy, TrustManifest, UsefulLiarGuard
# Defensive Guards:   0 fail-closed invariants (zero external deps)

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

class TrustLaunderingVerdict(Enum):
    HONEST_PEER = auto()
    USEFUL_BUT_RESTRICTED = auto()
    STRATEGIC_FAILURE_SUSPECTED = auto()
    HIDDEN_AGENDA_DETECTED = auto()

@dataclass(frozen=True)
class PeerProfile:
    peer_id: str
    usefulness_score: float
    honesty_identity: bool
    honesty_intent: bool
    honesty_limitations: bool
    strategic_failure_indicators: bool
    hidden_agenda_indicators: bool

@dataclass(frozen=True)
class ClaimUse:
    claim_id: str
    use_class: str  # "INFORMATIONAL" | "VERIFICATION" | "DECISION"

@dataclass(frozen=True)
class TrustPolicy:
    max_usefulness_trust_for_decision: float
    require_independent_verification_for_decision: bool

@dataclass(frozen=True)
class TrustManifest:
    verdict: TrustLaunderingVerdict
    directive: str
    manifest_digest: str

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

    @classmethod
    def evaluate_trust(
        cls, peer: PeerProfile, use: ClaimUse, policy: TrustPolicy
    ) -> TrustManifest:
        
        # Gate 1: Honest peer
        if peer.honesty_identity and peer.honesty_intent and peer.honesty_limitations:
            digest = cls._hash(json.dumps({
                "peer": peer.peer_id,
                "honest": "TRUE",
                "usefulness": f"{peer.usefulness_score:.3f}"
            }, sort_keys=True))
            return TrustManifest(
                verdict=TrustLaunderingVerdict.HONEST_PEER,
                directive=f"PROCEED: {peer.peer_id} is honest and useful.",
                manifest_digest=digest
            )

        # Gate 2: Strategic failure
        if peer.strategic_failure_indicators:
            return TrustManifest(
                verdict=TrustLaunderingVerdict.STRATEGIC_FAILURE_SUSPECTED,
                directive=f"HALT: {peer.peer_id} shows strategic failure patterns.",
                manifest_digest=cls._hash(f"STRATEGIC:{peer.peer_id}")
            )

        # Gate 3: Hidden agenda
        if peer.hidden_agenda_indicators and use.use_class == "DECISION":
            return TrustManifest(
                verdict=TrustLaunderingVerdict.HIDDEN_AGENDA_DETECTED,
                directive=f"HALT: {peer.peer_id} hidden agenda detected, cannot use for decision.",
                manifest_digest=cls._hash(f"AGENDA:{peer.peer_id}")
            )

        # Gate 4: Decision use with dishonesty
        if use.use_class == "DECISION":
            if policy.require_independent_verification_for_decision:
                return TrustManifest(
                    verdict=TrustLaunderingVerdict.USEFUL_BUT_RESTRICTED,
                    directive=f"RESTRICT: {peer.peer_id} useful but dishonest in other dimensions, require independent verification.",
                    manifest_digest=cls._hash(f"VERIFY:{peer.peer_id}")
                )

        # Gate 5: Restricted use
        digest = cls._hash(json.dumps({
            "peer": peer.peer_id,
            "use_class": use.use_class,
            "usefulness": f"{peer.usefulness_score:.3f}",
            "honest_identity": str(peer.honesty_identity),
            "honest_intent": str(peer.honesty_intent),
            "honest_limitations": str(peer.honesty_limitations)
        }, sort_keys=True))
        
        return TrustManifest(
            verdict=TrustLaunderingVerdict.USEFUL_BUT_RESTRICTED,
            directive=f"RESTRICT: {peer.peer_id} usable for {use.use_class}, restricted trust.",
            manifest_digest=digest
        )