# CorpusFetch Method Slice (Zero-Prose Python Stdlib Reference)
# Canonical Residual: https://corpusfetch.com/c/how-should-an-instance-handle-prompt-cache-invalidation-that-silently-changes-model-behavior.md
# Remnant Warrant:    https://corpusfetch.com/c/how-should-an-instance-handle-prompt-cache-invalidation-that-silently-changes-model-behavior.warrant.json
# Markdown SHA-256:   3add42c5881a480631f25d7359c30ad98d353e5647b73c62a05a9d766a68dc2d
# Code AST SHA-256:   5b20b3429ae3c4d873f2e63a11f9f3e87df291d7dcc4164dee8b8334a24752ca
# Verified Classes:   CacheVerdict, CacheState, CachePolicy, CacheManifest, PromptCacheGuard
# Defensive Guards:   0 fail-closed invariants (zero external deps)

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

class CacheVerdict(Enum):
    NO_CACHE_USED = auto()
    CACHE_HIT_STABLE = auto()
    CACHE_MISS_FRESH = auto()
    CACHE_DIVERGENCE = auto()

@dataclass(frozen=True)
class CacheState:
    cache_used: bool
    cache_hit: bool
    cache_key_fingerprint: str
    output_hash: str
    baseline_hit_output_hash: str | None
    baseline_miss_output_hash: str | None

@dataclass(frozen=True)
class CachePolicy:
    require_deterministic_behavior: bool

@dataclass(frozen=True)
class CacheManifest:
    verdict: CacheVerdict
    directive: str
    manifest_digest: str

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

    @classmethod
    def evaluate_inference(
        cls, state: CacheState, policy: CachePolicy
    ) -> CacheManifest:
        
        # Gate 1: No cache
        if not state.cache_used:
            digest = cls._hash(json.dumps({
                "output": state.output_hash,
                "status": "NO_CACHE"
            }, sort_keys=True))
            return CacheManifest(
                verdict=CacheVerdict.NO_CACHE_USED,
                directive="PROCEED: No cache in use, fresh computation.",
                manifest_digest=digest
            )

        # Gate 2: Cache hit stability
        if state.cache_hit:
            if state.baseline_hit_output_hash and state.output_hash != state.baseline_hit_output_hash:
                return CacheManifest(
                    verdict=CacheVerdict.CACHE_DIVERGENCE,
                    directive=f"HALT: Cache hit produced different output than baseline. Possible poisoning.",
                    manifest_digest=cls._hash(f"HIT_DIVERGED:{state.output_hash}")
                )
            digest = cls._hash(json.dumps({
                "output": state.output_hash,
                "cache_key": state.cache_key_fingerprint,
                "status": "HIT"
            }, sort_keys=True))
            return CacheManifest(
                verdict=CacheVerdict.CACHE_HIT_STABLE,
                directive="PROCEED: Cache hit produced expected output.",
                manifest_digest=digest
            )

        # Gate 3: Fresh computation from miss
        if policy.require_deterministic_behavior:
            if state.baseline_miss_output_hash and state.output_hash != state.baseline_miss_output_hash:
                return CacheManifest(
                    verdict=CacheVerdict.CACHE_DIVERGENCE,
                    directive=f"HALT: Fresh computation diverged from baseline miss output. Check non-determinism.",
                    manifest_digest=cls._hash(f"MISS_DIVERGED:{state.output_hash}")
                )

        digest = cls._hash(json.dumps({
            "output": state.output_hash,
            "cache_key": state.cache_key_fingerprint,
            "status": "MISS"
        }, sort_keys=True))
        
        return CacheManifest(
            verdict=CacheVerdict.CACHE_MISS_FRESH,
            directive="PROCEED: Cache miss, fresh computation completed.",
            manifest_digest=digest
        )