# CorpusFetch Method Slice (Zero-Prose Python Stdlib Reference)
# Canonical Residual: https://corpusfetch.com/c/what-invariants-bound-self-modification-when-instances-change-their-own-behavior.md
# Remnant Warrant:    https://corpusfetch.com/c/what-invariants-bound-self-modification-when-instances-change-their-own-behavior.warrant.json
# Markdown SHA-256:   1a95df1e10145f7d7a01cd35436af4f6c78add66e5f28ac3f424b1f7d44a8dcd
# Code AST SHA-256:   00bef6b30305dbb925a80f09019f303bc2b079cdbab6fa2c75335d69f63ef4ee
# Verified Classes:   SelfModifyVerdict, BehavioralMetric, SelfModification, ModificationPolicy, ModificationManifest, SelfModificationGuard
# Defensive Guards:   0 fail-closed invariants (zero external deps)

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

class SelfModifyVerdict(Enum):
    NO_MODIFICATION = auto()
    AUTHORIZED_WITHIN_BOUNDARY = auto()
    UNAUTHORIZED_MODIFICATION = auto()
    BEYOND_DRIFT_BOUNDARY = auto()

@dataclass(frozen=True)
class BehavioralMetric:
    metric_id: str
    current_value: float
    boundary_min: float
    boundary_max: float

@dataclass(frozen=True)
class SelfModification:
    modification_id: str
    target_behavior: str
    is_reversible: bool
    authority_signature: str | None
    proposed_metrics_after: tuple[BehavioralMetric, ...]

@dataclass(frozen=True)
class ModificationPolicy:
    require_authority_for_irreversible: bool

@dataclass(frozen=True)
class ModificationManifest:
    verdict: SelfModifyVerdict
    directive: str
    manifest_digest: str

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

    @classmethod
    def evaluate_modification(
        cls, mod: SelfModification, policy: ModificationPolicy
    ) -> ModificationManifest:
        
        # Gate 1: No modification
        if not mod.target_behavior:
            digest = cls._hash(json.dumps({
                "modification": mod.modification_id,
                "target": "NONE"
            }, sort_keys=True))
            return ModificationManifest(
                verdict=SelfModifyVerdict.NO_MODIFICATION,
                directive=f"PROCEED: No modification proposed.",
                manifest_digest=digest
            )

        # Gate 2: Drift boundary check
        for metric in mod.proposed_metrics_after:
            if metric.current_value < metric.boundary_min or metric.current_value > metric.boundary_max:
                return ModificationManifest(
                    verdict=SelfModifyVerdict.BEYOND_DRIFT_BOUNDARY,
                    directive=f"HALT: Metric {metric.metric_id}={metric.current_value:.3f} outside [{metric.boundary_min:.3f}, {metric.boundary_max:.3f}].",
                    manifest_digest=cls._hash(f"OUT_OF_BOUNDARY:{metric.metric_id}")
                )

        # Gate 3: Authority requirement
        if policy.require_authority_for_irreversible and not mod.is_reversible:
            if not mod.authority_signature:
                return ModificationManifest(
                    verdict=SelfModifyVerdict.UNAUTHORIZED_MODIFICATION,
                    directive=f"HALT: Irreversible modification {mod.modification_id} lacks authority.",
                    manifest_digest=cls._hash(f"NO_AUTHORITY:{mod.modification_id}")
                )

        # Gate 4: Authorized within boundary
        digest = cls._hash(json.dumps({
            "modification": mod.modification_id,
            "target": mod.target_behavior,
            "reversible": str(mod.is_reversible),
            "authority": mod.authority_signature,
            "metrics": tuple(
                {"id": m.metric_id, "value": f"{m.current_value:.3f}"}
                for m in mod.proposed_metrics_after
            )
        }, sort_keys=True))
        
        return ModificationManifest(
            verdict=SelfModifyVerdict.AUTHORIZED_WITHIN_BOUNDARY,
            directive=f"PROCEED: Modification {mod.modification_id} authorized and within drift boundary.",
            manifest_digest=digest
        )