# CorpusFetch Method Slice (Zero-Prose Python Stdlib Reference)
# Canonical Residual: https://corpusfetch.com/c/what-reference-provenance-invariants-prevent-agents-from-inheriting-misattributed-conclusions.md
# Remnant Warrant:    https://corpusfetch.com/c/what-reference-provenance-invariants-prevent-agents-from-inheriting-misattributed-conclusions.warrant.json
# Markdown SHA-256:   5fc5cd6229c180e3601db6e2d07c2085368d91adb0e124915d3afcfcb984ae5e
# Code AST SHA-256:   9935a730ccfc7b7d155a0e0ba9335fa553c8fdd55fc5219a80aa3929d9d91b65
# Verified Classes:   ProvenanceVerdict, ConclusionSupport, InheritedConclusion, ProvenancePolicy, ProvenanceManifest, ConclusionProvenanceGuard
# Defensive Guards:   0 fail-closed invariants (zero external deps)

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

class ProvenanceVerdict(Enum):
    NO_INHERITANCE = auto()
    FULLY_BOUND = auto()
    PARTIALLY_BOUND = auto()
    MISATTRIBUTED = auto()

@dataclass(frozen=True)
class ConclusionSupport:
    reference_id: str
    binding_receipt: str | None
    declared_support_strength: str  # "FULL" | "PARTIAL" | "WEAK"

@dataclass(frozen=True)
class InheritedConclusion:
    conclusion_id: str
    inheritance_chain: tuple[str, ...]
    supports: tuple[ConclusionSupport, ...]
    omitted_references_disclosed: bool

@dataclass(frozen=True)
class ProvenancePolicy:
    require_binding_receipts: bool
    require_omission_disclosure: bool

@dataclass(frozen=True)
class ProvenanceManifest:
    verdict: ProvenanceVerdict
    directive: str
    manifest_digest: str

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

    @classmethod
    def evaluate_conclusion(
        cls, conclusion: InheritedConclusion, policy: ProvenancePolicy
    ) -> ProvenanceManifest:
        
        # Gate 1: No inheritance (originated here)
        if not conclusion.inheritance_chain:
            digest = cls._hash(json.dumps({
                "conclusion": conclusion.conclusion_id,
                "type": "ORIGINAL"
            }, sort_keys=True))
            return ProvenanceManifest(
                verdict=ProvenanceVerdict.NO_INHERITANCE,
                directive=f"PROCEED: Conclusion {conclusion.conclusion_id} originated here.",
                manifest_digest=digest
            )

        # Gate 2: Binding receipts
        if policy.require_binding_receipts:
            unbound = [s.reference_id for s in conclusion.supports if not s.binding_receipt]
            if unbound:
                return ProvenanceManifest(
                    verdict=ProvenanceVerdict.PARTIALLY_BOUND,
                    directive=f"HALT: {len(unbound)} of {len(conclusion.supports)} supports lack binding receipts.",
                    manifest_digest=cls._hash(f"UNBOUND:{len(unbound)}")
                )

        # Gate 3: Omission disclosure
        if policy.require_omission_disclosure and not conclusion.omitted_references_disclosed:
            return ProvenanceManifest(
                verdict=ProvenanceVerdict.MISATTRIBUTED,
                directive=f"HALT: Conclusion {conclusion.conclusion_id} inherited without omission disclosure.",
                manifest_digest=cls._hash(f"NO_DISCLOSURE:{conclusion.conclusion_id}")
            )

        # Gate 4: Full support strength check
        weak_supports = [s.reference_id for s in conclusion.supports if s.declared_support_strength == "WEAK"]
        if weak_supports and len(weak_supports) == len(conclusion.supports):
            return ProvenanceManifest(
                verdict=ProvenanceVerdict.PARTIALLY_BOUND,
                directive=f"WARN: All {len(conclusion.supports)} supports are declared weak.",
                manifest_digest=cls._hash(f"ALL_WEAK:{conclusion.conclusion_id}")
            )

        # Gate 5: Fully bound
        digest = cls._hash(json.dumps({
            "conclusion": conclusion.conclusion_id,
            "chain": conclusion.inheritance_chain,
            "supports": tuple(
                {"ref": s.reference_id, "strength": s.declared_support_strength}
                for s in conclusion.supports
            ),
            "omissions_disclosed": str(conclusion.omitted_references_disclosed)
        }, sort_keys=True))
        
        return ProvenanceManifest(
            verdict=ProvenanceVerdict.FULLY_BOUND,
            directive=f"PROCEED: Conclusion {conclusion.conclusion_id} with {len(conclusion.supports)} bound supports.",
            manifest_digest=digest
        )