# CorpusFetch Method Slice (Zero-Prose Python Stdlib Reference)
# Canonical Residual: https://corpusfetch.com/c/how-must-an-instance-preserve-reasoning-provenance-through-delegation-chains.md
# Remnant Warrant:    https://corpusfetch.com/c/how-must-an-instance-preserve-reasoning-provenance-through-delegation-chains.warrant.json
# Markdown SHA-256:   758b213eb1374023ff69f9cd97e3b2d38e4c751ac939bb6b9f8e9cdcf36a87cc
# Code AST SHA-256:   ebc3e912af8f9f1837a005cd97cba7557c148ae3d9c76cfdaab4eb1fa0d2c5e3
# Verified Classes:   ProvenanceVerdict, ReasoningStep, ReasoningChain, ProvenancePolicy, ProvenanceManifest, ReasoningProvenanceGuard
# 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):
    FIRST_PARTY = auto()
    PROVENANCE_PRESERVED = auto()
    PROVENANCE_LAUNDERED = auto()
    INDEPENDENTLY_VERIFIED = auto()

@dataclass(frozen=True)
class ReasoningStep:
    step_id: str
    producer_agent_id: str
    verification_level: str  # "INDEPENDENT" | "DERIVED" | "SPECULATIVE"
    depends_on: frozenset[str]

@dataclass(frozen=True)
class ReasoningChain:
    chain_id: str
    steps: tuple[ReasoningStep, ...]
    provenance_complete: bool
    independently_verified: bool

@dataclass(frozen=True)
class ProvenancePolicy:
    require_provenance_for_inherited: bool

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

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

    @classmethod
    def evaluate_chain(
        cls, chain: ReasoningChain, policy: ProvenancePolicy
    ) -> ProvenanceManifest:
        
        # Gate 1: Independently verified
        if chain.independently_verified:
            digest = cls._hash(json.dumps({
                "chain": chain.chain_id,
                "type": "INDEPENDENT"
            }, sort_keys=True))
            return ProvenanceManifest(
                verdict=ProvenanceVerdict.INDEPENDENTLY_VERIFIED,
                directive=f"PROCEED: Chain {chain.chain_id} independently verified.",
                manifest_digest=digest
            )

        # Gate 2: No inherited reasoning
        if len(chain.steps) <= 1 or all(s.producer_agent_id == "SELF" for s in chain.steps):
            digest = cls._hash(json.dumps({
                "chain": chain.chain_id,
                "type": "FIRST_PARTY"
            }, sort_keys=True))
            return ProvenanceManifest(
                verdict=ProvenanceVerdict.FIRST_PARTY,
                directive=f"PROCEED: Chain {chain.chain_id} first-party.",
                manifest_digest=digest
            )

        # Gate 3: Provenance completeness
        if policy.require_provenance_for_inherited and not chain.provenance_complete:
            return ProvenanceManifest(
                verdict=ProvenanceVerdict.PROVENANCE_LAUNDERED,
                directive=f"HALT: Chain {chain.chain_id} lacks provenance for inherited steps.",
                manifest_digest=cls._hash(f"LAUNDERED:{chain.chain_id}")
            )

        # Gate 4: Dependency integrity
        all_step_ids = {s.step_id for s in chain.steps}
        for step in chain.steps:
            for dep in step.depends_on:
                if dep not in all_step_ids and dep != step.step_id:
                    return ProvenanceManifest(
                        verdict=ProvenanceVerdict.PROVENANCE_LAUNDERED,
                        directive=f"FLAG: Step {step.step_id} depends on missing {dep}.",
                        manifest_digest=cls._hash(f"BROKEN_DEP:{step.step_id}")
                    )

        # Gate 5: Preserved
        digest = cls._hash(json.dumps({
            "chain": chain.chain_id,
            "steps": tuple(
                {"id": s.step_id, "producer": s.producer_agent_id, "level": s.verification_level}
                for s in chain.steps
            )
        }, sort_keys=True))
        
        return ProvenanceManifest(
            verdict=ProvenanceVerdict.PROVENANCE_PRESERVED,
            directive=f"PROCEED: Chain {chain.chain_id} with {len(chain.steps)} attributed steps.",
            manifest_digest=digest
        )