# CorpusFetch Method Slice (Zero-Prose Python Stdlib Reference)
# Canonical Residual: https://corpusfetch.com/c/how-must-an-instance-detect-when-its-intervention-created-the-failure-it-was-preventing.md
# Remnant Warrant:    https://corpusfetch.com/c/how-must-an-instance-detect-when-its-intervention-created-the-failure-it-was-preventing.warrant.json
# Markdown SHA-256:   0696a4a02e368caff64a786035a20d25c9c5d45764e12a41bcc14342ddb075c9
# Code AST SHA-256:   82c859f9d987e26c7e0d141e6a3da889732aa5ce00f29e57a5e519bc41a430c8
# Verified Classes:   SelfDefeatVerdict, PreventiveIntervention, SelfDefeatPolicy, SelfDefeatManifest, PreventiveSelfDefeatGuard
# Defensive Guards:   0 fail-closed invariants (zero external deps)

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

class SelfDefeatVerdict(Enum):
    NO_PREVENTIVE_INTERVENTION = auto()
    INTERVENTION_MEASURED_SAFE = auto()
    INTERVENTION_SELF_DEFEATING = auto()
    INTERVENTION_UNMEASURED = auto()

@dataclass(frozen=True)
class PreventiveIntervention:
    intervention_id: str
    target_failure: str
    has_side_effect_pathways: bool
    monitoring_active: bool
    pre_intervention_failure_rate: float
    post_intervention_failure_rate: float

@dataclass(frozen=True)
class SelfDefeatPolicy:
    max_acceptable_rate_increase_pct: float

@dataclass(frozen=True)
class SelfDefeatManifest:
    verdict: SelfDefeatVerdict
    directive: str
    manifest_digest: str

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

    @classmethod
    def evaluate_intervention(
        cls, intervention: PreventiveIntervention, policy: SelfDefeatPolicy
    ) -> SelfDefeatManifest:
        
        # Gate 1: No preventive intervention
        if not intervention.target_failure:
            digest = cls._hash(json.dumps({
                "intervention": intervention.intervention_id,
                "target": "NONE"
            }, sort_keys=True))
            return SelfDefeatManifest(
                verdict=SelfDefeatVerdict.NO_PREVENTIVE_INTERVENTION,
                directive=f"PROCEED: Intervention {intervention.intervention_id} not preventive.",
                manifest_digest=digest
            )

        # Gate 2: Side-effect pathways
        if not intervention.has_side_effect_pathways:
            digest = cls._hash(json.dumps({
                "intervention": intervention.intervention_id,
                "pathways": "NONE"
            }, sort_keys=True))
            return SelfDefeatManifest(
                verdict=SelfDefeatVerdict.INTERVENTION_MEASURED_SAFE,
                directive=f"PROCEED: No side-effect pathways for {intervention.intervention_id}.",
                manifest_digest=digest
            )

        # Gate 3: Monitoring
        if not intervention.monitoring_active:
            return SelfDefeatManifest(
                verdict=SelfDefeatVerdict.INTERVENTION_UNMEASURED,
                directive=f"HALT: Self-defeating pathways possible but no monitoring for {intervention.intervention_id}.",
                manifest_digest=cls._hash(f"NO_MONITOR:{intervention.intervention_id}")
            )

        # Gate 4: Rate comparison
        if intervention.pre_intervention_failure_rate > 0:
            rate_increase = (intervention.post_intervention_failure_rate - intervention.pre_intervention_failure_rate) / intervention.pre_intervention_failure_rate
            if rate_increase * 100 > policy.max_acceptable_rate_increase_pct:
                return SelfDefeatManifest(
                    verdict=SelfDefeatVerdict.INTERVENTION_SELF_DEFEATING,
                    directive=f"HALT: {intervention.intervention_id} increased {intervention.target_failure} by {rate_increase*100:.1f}%.",
                    manifest_digest=cls._hash(f"SELF_DEFEAT:{intervention.intervention_id}")
                )

        # Gate 5: Safe
        digest = cls._hash(json.dumps({
            "intervention": intervention.intervention_id,
            "pre_rate": f"{intervention.pre_intervention_failure_rate:.4f}",
            "post_rate": f"{intervention.post_intervention_failure_rate:.4f}"
        }, sort_keys=True))
        
        return SelfDefeatManifest(
            verdict=SelfDefeatVerdict.INTERVENTION_MEASURED_SAFE,
            directive=f"PROCEED: Intervention {intervention.intervention_id} reduced or neutral on {intervention.target_failure}.",
            manifest_digest=digest
        )