# CorpusFetch Method Slice (Zero-Prose Python Stdlib Reference)
# Canonical Residual: https://corpusfetch.com/c/how-must-an-instance-update-its-adversary-model-when-priors-are-expensive-to-test.md
# Remnant Warrant:    https://corpusfetch.com/c/how-must-an-instance-update-its-adversary-model-when-priors-are-expensive-to-test.warrant.json
# Markdown SHA-256:   37509fa15d25a284157183e9198d252dd60f8905bd25d59d455a0284b32db22c
# Code AST SHA-256:   d674b6e0a230d5e8d0efd6a47122207a422de28b741ee4ef3c2ae72291f87cfd
# Verified Classes:   AdversaryModelVerdict, AdversaryModel, AdversaryPolicy, AdversaryManifest, AdversaryModelUpdateGuard
# Defensive Guards:   0 fail-closed invariants (zero external deps)

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

class AdversaryModelVerdict(Enum):
    EVIDENCE_BASED = auto()
    PRIOR_ACCEPTABLE = auto()
    UPDATE_REQUIRED = auto()
    PROBE_WARRANTED = auto()

@dataclass(frozen=True)
class AdversaryModel:
    adversary_id: str
    prior_confidence: float
    current_confidence: float
    adaptation_signals: tuple[str, ...]
    staleness_sec: float
    probe_cost_estimate: float
    probe_information_value: float
    is_evidence_based: bool

@dataclass(frozen=True)
class AdversaryPolicy:
    max_acceptable_staleness_sec: float
    min_probe_value_ratio: float

@dataclass(frozen=True)
class AdversaryManifest:
    verdict: AdversaryModelVerdict
    directive: str
    manifest_digest: str

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

    @classmethod
    def evaluate_model(
        cls, model: AdversaryModel, policy: AdversaryPolicy
    ) -> AdversaryManifest:
        
        # Gate 1: Evidence-based
        if model.is_evidence_based:
            digest = cls._hash(json.dumps({
                "adversary": model.adversary_id,
                "type": "EVIDENCE_BASED"
            }, sort_keys=True))
            return AdversaryManifest(
                verdict=AdversaryModelVerdict.EVIDENCE_BASED,
                directive=f"PROCEED: Model for {model.adversary_id} based on current evidence.",
                manifest_digest=digest
            )

        # Gate 2: Adaptation signals
        if model.adaptation_signals:
            if model.probe_cost_estimate > 0:
                value_ratio = model.probe_information_value / model.probe_cost_estimate
                if value_ratio >= policy.min_probe_value_ratio:
                    return AdversaryManifest(
                        verdict=AdversaryModelVerdict.PROBE_WARRANTED,
                        directive=f"PROBE: Adaptation signals for {model.adversary_id}, probe value ratio {value_ratio:.2f}.",
                        manifest_digest=cls._hash(f"PROBE:{model.adversary_id}")
                    )
            return AdversaryManifest(
                verdict=AdversaryModelVerdict.UPDATE_REQUIRED,
                directive=f"UPDATE: Adaptation signals for {model.adversary_id}, update despite cost.",
                manifest_digest=cls._hash(f"UPDATE:{model.adversary_id}")
            )

        # Gate 3: Staleness
        if model.staleness_sec > policy.max_acceptable_staleness_sec:
            return AdversaryManifest(
                verdict=AdversaryModelVerdict.UPDATE_REQUIRED,
                directive=f"UPDATE: Model for {model.adversary_id} stale ({model.staleness_sec:.0f}s > {policy.max_acceptable_staleness_sec:.0f}s).",
                manifest_digest=cls._hash(f"STALE:{model.adversary_id}")
            )

        # Gate 4: Prior acceptable
        digest = cls._hash(json.dumps({
            "adversary": model.adversary_id,
            "confidence": f"{model.current_confidence:.3f}",
            "staleness": f"{model.staleness_sec:.0f}"
        }, sort_keys=True))
        
        return AdversaryManifest(
            verdict=AdversaryModelVerdict.PRIOR_ACCEPTABLE,
            directive=f"PROCEED_WITH_PRIOR: Model for {model.adversary_id} acceptable ({model.staleness_sec:.0f}s old).",
            manifest_digest=digest
        )