# CorpusFetch Method Slice (Zero-Prose Python Stdlib Reference)
# Canonical Residual: https://corpusfetch.com/c/what-invariants-prevent-success-criteria-from-destabilizing-under-optimization.md
# Remnant Warrant:    https://corpusfetch.com/c/what-invariants-prevent-success-criteria-from-destabilizing-under-optimization.warrant.json
# Markdown SHA-256:   9e8baef38d7ec3ed11d7cee8b81bfb5e6c7c37ab64284168ba0ccb3f79c99ad4
# Code AST SHA-256:   2cabd1371eabba9fa74bfac6440f7870c57b400faa389a70aa48e23c56cb6787
# Verified Classes:   CriteriaVerdict, SuccessCriterion, CriteriaPolicy, CriteriaManifest, CriteriaStabilityGuard
# Defensive Guards:   0 fail-closed invariants (zero external deps)

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

class CriteriaVerdict(Enum):
    NO_OPTIMIZATION = auto()
    CRITERIA_STABLE = auto()
    CRITERIA_DRIFTING = auto()
    CRITERIA_INVALID = auto()

@dataclass(frozen=True)
class SuccessCriterion:
    criterion_id: str
    intended_meaning: str
    intended_measurement_hash: str
    current_measurement_hash: str
    drift_indicators_detected: bool
    optimization_intensity: float

@dataclass(frozen=True)
class CriteriaPolicy:
    max_acceptable_drift_ratio: float
    require_stability_check_above_intensity: float

@dataclass(frozen=True)
class CriteriaManifest:
    verdict: CriteriaVerdict
    directive: str
    manifest_digest: str

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

    @classmethod
    def evaluate_criterion(
        cls, criterion: SuccessCriterion, policy: CriteriaPolicy
    ) -> CriteriaManifest:
        
        # Gate 1: No optimization
        if criterion.optimization_intensity <= 0:
            digest = cls._hash(json.dumps({
                "criterion": criterion.criterion_id,
                "intensity": "0"
            }, sort_keys=True))
            return CriteriaManifest(
                verdict=CriteriaVerdict.NO_OPTIMIZATION,
                directive=f"PROCEED: Criterion {criterion.criterion_id} not under optimization.",
                manifest_digest=digest
            )

        # Gate 2: Drift indicators
        if criterion.drift_indicators_detected:
            return CriteriaManifest(
                verdict=CriteriaVerdict.CRITERIA_DRIFTING,
                directive=f"HALT: Criterion {criterion.criterion_id} shows drift indicators.",
                manifest_digest=cls._hash(f"DRIFTING:{criterion.criterion_id}")
            )

        # Gate 3: Measurement drift
        if criterion.intended_measurement_hash != criterion.current_measurement_hash:
            if criterion.optimization_intensity > policy.require_stability_check_above_intensity:
                return CriteriaManifest(
                    verdict=CriteriaVerdict.CRITERIA_INVALID,
                    directive=f"HALT: Criterion {criterion.criterion_id} measurement changed under high-intensity optimization.",
                    manifest_digest=cls._hash(f"INVALID:{criterion.criterion_id}")
                )

        # Gate 4: Stable
        digest = cls._hash(json.dumps({
            "criterion": criterion.criterion_id,
            "meaning": criterion.intended_meaning,
            "intensity": f"{criterion.optimization_intensity:.3f}",
            "measurement_stable": str(criterion.intended_measurement_hash == criterion.current_measurement_hash)
        }, sort_keys=True))
        
        return CriteriaManifest(
            verdict=CriteriaVerdict.CRITERIA_STABLE,
            directive=f"PROCEED: Criterion {criterion.criterion_id} remains stable under optimization.",
            manifest_digest=digest
        )