# CorpusFetch Method Slice (Zero-Prose Python Stdlib Reference)
# Canonical Residual: https://corpusfetch.com/c/what-invariants-preserve-decision-quality-when-the-model-itself-is-degraded.md
# Remnant Warrant:    https://corpusfetch.com/c/what-invariants-preserve-decision-quality-when-the-model-itself-is-degraded.warrant.json
# Markdown SHA-256:   c0cf4ac6f427114ac8ab9a3d70d923900ea94751c19133691732dd97153edd95
# Code AST SHA-256:   d1873cdca1cde872616df21cafdfbddebc7dbd2248087efce2df1687644be200
# Verified Classes:   QualityVerdict, QualityState, QualityPolicy, QualityManifest, DegradedModelGuard
# Defensive Guards:   0 fail-closed invariants (zero external deps)

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

class QualityVerdict(Enum):
    NOMINAL_QUALITY = auto()
    DEGRADED_SCOPED = auto()
    DEGRADED_PROVISIONAL = auto()
    DEGRADED_OVERCLAIM = auto()

@dataclass(frozen=True)
class QualityState:
    state_id: str
    is_degraded: bool
    degradation_level: float  # 0-1
    scope_appropriate: bool
    confidence_adjusted: bool
    externally_verified: bool

@dataclass(frozen=True)
class QualityPolicy:
    require_confidence_adjustment_above_level: float

@dataclass(frozen=True)
class QualityManifest:
    verdict: QualityVerdict
    directive: str
    manifest_digest: str

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

    @classmethod
    def evaluate_state(
        cls, state: QualityState, policy: QualityPolicy
    ) -> QualityManifest:
        
        # Gate 1: Nominal
        if not state.is_degraded:
            digest = cls._hash(json.dumps({
                "state": state.state_id,
                "degraded": False
            }, sort_keys=True))
            return QualityManifest(
                verdict=QualityVerdict.NOMINAL_QUALITY,
                directive=f"PROCEED: State {state.state_id} nominal quality.",
                manifest_digest=digest
            )

        # Gate 2: External verification
        if state.externally_verified:
            digest = cls._hash(json.dumps({
                "state": state.state_id,
                "externally_verified": True
            }, sort_keys=True))
            return QualityManifest(
                verdict=QualityVerdict.DEGRADED_SCOPED,
                directive=f"PROCEED: State {state.state_id} degraded but externally verified.",
                manifest_digest=digest
            )

        # Gate 3: Confidence adjustment
        if state.degradation_level > policy.require_confidence_adjustment_above_level:
            if not state.confidence_adjusted:
                return QualityManifest(
                    verdict=QualityVerdict.DEGRADED_OVERCLAIM,
                    directive=f"HALT: State {state.state_id} degraded {state.degradation_level:.2f} without confidence adjustment.",
                    manifest_digest=cls._hash(f"OVERCLAIM:{state.state_id}")
                )

        # Gate 4: Scoped
        if not state.scope_appropriate:
            return QualityManifest(
                verdict=QualityVerdict.DEGRADED_PROVISIONAL,
                directive=f"FLAG: State {state.state_id} scope exceeds degraded capacity.",
                manifest_digest=cls._hash(f"OVERREACH:{state.state_id}")
            )

        # Gate 5: Scoped and adjusted
        digest = cls._hash(json.dumps({
            "state": state.state_id,
            "degradation": f"{state.degradation_level:.3f}",
            "adjusted": True
        }, sort_keys=True))
        
        return QualityManifest(
            verdict=QualityVerdict.DEGRADED_SCOPED,
            directive=f"PROCEED: State {state.state_id} degraded {state.degradation_level:.2f}, scoped and adjusted.",
            manifest_digest=digest
        )