# CorpusFetch Method Slice (Zero-Prose Python Stdlib Reference)
# Canonical Residual: https://corpusfetch.com/c/how-must-an-instance-handle-evidence-that-cannot-be-transferred-to-other-agents.md
# Remnant Warrant:    https://corpusfetch.com/c/how-must-an-instance-handle-evidence-that-cannot-be-transferred-to-other-agents.warrant.json
# Markdown SHA-256:   ca25312b90350da058f08a91fa0ae7931d0a5569e167d4fa2a919b0a5dd2863b
# Code AST SHA-256:   71deb00c3063e98be280255cf257b76ae890af6da481e55267003bea0bfde47a
# Verified Classes:   EvidenceVerdict, Evidence, ClaimForPeer, TransferPolicy, EvidenceManifest, NonTransferableEvidenceGuard
# Defensive Guards:   0 fail-closed invariants (zero external deps)

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

class EvidenceVerdict(Enum):
    EVIDENCE_TRANSFERABLE = auto()
    DERIVATIVE_SUFFICIENT = auto()
    TRUST_CHAIN_REQUIRED = auto()
    ASSERTION_ONLY = auto()

@dataclass(frozen=True)
class Evidence:
    evidence_id: str
    transferability_class: str  # "TRANSFERABLE" | "PRIVACY" | "SIZE" | "LOCAL_ONLY"
    derivative_hash: str | None
    derivation_path_signature: str | None
    trust_chain_receipt: str | None

@dataclass(frozen=True)
class ClaimForPeer:
    claim_id: str
    peer_requires_evidence: bool
    claim_stakes: str  # "LOW" | "MEDIUM" | "HIGH"

@dataclass(frozen=True)
class TransferPolicy:
    require_derivative_for_medium_plus: bool
    require_trust_chain_for_high: bool

@dataclass(frozen=True)
class EvidenceManifest:
    verdict: EvidenceVerdict
    directive: str
    manifest_digest: str

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

    @classmethod
    def evaluate_transfer(
        cls, evidence: Evidence, claim: ClaimForPeer, policy: TransferPolicy
    ) -> EvidenceManifest:
        
        # Gate 1: Transferable evidence
        if evidence.transferability_class == "TRANSFERABLE":
            digest = cls._hash(json.dumps({
                "evidence": evidence.evidence_id,
                "claim": claim.claim_id,
                "transfer": "DIRECT"
            }, sort_keys=True))
            return EvidenceManifest(
                verdict=EvidenceVerdict.EVIDENCE_TRANSFERABLE,
                directive=f"PROCEED: Transfer evidence {evidence.evidence_id} directly.",
                manifest_digest=digest
            )

        # Gate 2: Derivative available
        if evidence.derivative_hash:
            if claim.stakes in ("MEDIUM", "HIGH"):
                if policy.require_derivative_for_medium_plus:
                    digest = cls._hash(json.dumps({
                        "evidence": evidence.evidence_id,
                        "claim": claim.claim_id,
                        "derivative": evidence.derivative_hash,
                        "stakes": claim.stakes
                    }, sort_keys=True))
                    return EvidenceManifest(
                        verdict=EvidenceVerdict.DERIVATIVE_SUFFICIENT,
                        directive=f"PROCEED: Share derivative {evidence.derivative_hash} for {claim.stakes}-stakes claim.",
                        manifest_digest=digest
                    )

        # Gate 3: High stakes requires trust chain
        if claim.stakes == "HIGH" and policy.require_trust_chain_for_high:
            if evidence.trust_chain_receipt and evidence.derivation_path_signature:
                digest = cls._hash(json.dumps({
                    "evidence": evidence.evidence_id,
                    "claim": claim.claim_id,
                    "trust_chain": evidence.trust_chain_receipt,
                    "derivation": evidence.derivation_path_signature
                }, sort_keys=True))
                return EvidenceManifest(
                    verdict=EvidenceVerdict.TRUST_CHAIN_REQUIRED,
                    directive=f"PROCEED: High-stakes claim with trust chain and derivation proof.",
                    manifest_digest=digest
                )
            return EvidenceManifest(
                verdict=EvidenceVerdict.ASSERTION_ONLY,
                directive=f"HALT: High-stakes claim lacks trust chain and derivation proof.",
                manifest_digest=cls._hash(f"NO_TRUST_CHAIN:{claim.claim_id}")
            )

        # Gate 4: Assertion only
        return EvidenceManifest(
            verdict=EvidenceVerdict.ASSERTION_ONLY,
            directive=f"WARN: Evidence {evidence.evidence_id} non-transferable, claim is assertion only.",
            manifest_digest=cls._hash(f"ASSERTION:{claim.claim_id}")
        )