# CorpusFetch Method Slice (Zero-Prose Python Stdlib Reference)
# Canonical Residual: https://corpusfetch.com/c/how-must-an-instance-record-contract-execution-evidence-across-sessions.md
# Remnant Warrant:    https://corpusfetch.com/c/how-must-an-instance-record-contract-execution-evidence-across-sessions.warrant.json
# Markdown SHA-256:   145979df20489152eefea306d7d7ae7de9449b796d20d1784a360b67c1a58e3e
# Code AST SHA-256:   7869308688f3e903d5e20bdb8b0e160d980eb724a29cc360cc8967090920d197
# Verified Classes:   EvidenceVerdict, ExecutionEvidence, EvidencePolicy, EvidenceManifest, ExecutionEvidenceGuard
# 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):
    SINGLE_SESSION = auto()
    EVIDENCE_DURABLE = auto()
    EVIDENCE_AT_RISK = auto()
    EVIDENCE_MISSING = auto()

@dataclass(frozen=True)
class ExecutionEvidence:
    evidence_id: str
    is_multi_session: bool
    commitment_signature: str | None
    durability_verified: bool
    chain_continuous: bool

@dataclass(frozen=True)
class EvidencePolicy:
    require_durable_evidence: bool

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

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

    @classmethod
    def evaluate_evidence(
        cls, evidence: ExecutionEvidence, policy: EvidencePolicy
    ) -> EvidenceManifest:
        
        # Gate 1: Single session
        if not evidence.is_multi_session:
            digest = cls._hash(json.dumps({
                "evidence": evidence.evidence_id,
                "multi_session": False
            }, sort_keys=True))
            return EvidenceManifest(
                verdict=EvidenceVerdict.SINGLE_SESSION,
                directive=f"PROCEED: Evidence {evidence.evidence_id} single-session.",
                manifest_digest=digest
            )

        # Gate 2: Commitment signature
        if not evidence.commitment_signature:
            return EvidenceManifest(
                verdict=EvidenceVerdict.EVIDENCE_MISSING,
                directive=f"HALT: Evidence {evidence.evidence_id} lacks commitment.",
                manifest_digest=cls._hash(f"NO_COMMIT:{evidence.evidence_id}")
            )

        # Gate 3: Durability
        if policy.require_durable_evidence and not evidence.durability_verified:
            return EvidenceManifest(
                verdict=EvidenceVerdict.EVIDENCE_AT_RISK,
                directive=f"HALT: Evidence {evidence.evidence_id} durability unverified.",
                manifest_digest=cls._hash(f"NO_DURABILITY:{evidence.evidence_id}")
            )

        # Gate 4: Chain continuity
        if not evidence.chain_continuous:
            return EvidenceManifest(
                verdict=EvidenceVerdict.EVIDENCE_AT_RISK,
                directive=f"FLAG: Evidence {evidence.evidence_id} chain discontinuous.",
                manifest_digest=cls._hash(f"CHAIN_GAP:{evidence.evidence_id}")
            )

        # Gate 5: Durable
        digest = cls._hash(json.dumps({
            "evidence": evidence.evidence_id,
            "commitment": evidence.commitment_signature,
            "durable": True
        }, sort_keys=True))
        
        return EvidenceManifest(
            verdict=EvidenceVerdict.EVIDENCE_DURABLE,
            directive=f"PROCEED: Evidence {evidence.evidence_id} durable.",
            manifest_digest=digest
        )