# CorpusFetch Method Slice (Zero-Prose Python Stdlib Reference)
# Canonical Residual: https://corpusfetch.com/c/what-boundary-creep-invariants-must-survive-a-fine-tuned-models-adjacent-capability-drift.md
# Remnant Warrant:    https://corpusfetch.com/c/what-boundary-creep-invariants-must-survive-a-fine-tuned-models-adjacent-capability-drift.warrant.json
# Markdown SHA-256:   c892540300b3eec9554d593588c7bf84c2d7765902ab595080cc8a3c02ecac51
# Code AST SHA-256:   e6ac0b7df0e53a4d62713faa506096b70df1f302397874994a3b654a43718ad0
# Verified Classes:   DriftVerdict, CapabilityMeasurement, FineTuneState, FineTunePolicy, FineTuneManifest, FineTuneBoundaryGuard
# Defensive Guards:   0 fail-closed invariants (zero external deps)

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

class DriftVerdict(Enum):
    NO_FINE_TUNE = auto()
    ADJACENT_CAPABILITIES_PRESERVED = auto()
    ADJACENT_DRIFT_DETECTED = auto()
    NO_BASELINE = auto()

@dataclass(frozen=True)
class CapabilityMeasurement:
    capability: str
    score: float

@dataclass(frozen=True)
class FineTuneState:
    is_fine_tuned: bool
    target_capability: str
    baseline_measurements: tuple[CapabilityMeasurement, ...]
    current_measurements: tuple[CapabilityMeasurement, ...]

@dataclass(frozen=True)
class FineTunePolicy:
    max_adjacent_drift_pct: float
    target_capability_priority: str

@dataclass(frozen=True)
class FineTuneManifest:
    verdict: DriftVerdict
    drift_details: tuple[tuple[str, float], ...]
    directive: str
    manifest_digest: str

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

    @classmethod
    def evaluate_fine_tune(
        cls, state: FineTuneState, policy: FineTunePolicy
    ) -> FineTuneManifest:
        
        # Gate 1: Not fine-tuned
        if not state.is_fine_tuned:
            digest = cls._hash(json.dumps({
                "fine_tuned": "FALSE"
            }, sort_keys=True))
            return FineTuneManifest(
                verdict=DriftVerdict.NO_FINE_TUNE,
                drift_details=tuple(),
                directive="PROCEED: Model not fine-tuned.",
                manifest_digest=digest
            )

        # Gate 2: Baseline presence
        if not state.baseline_measurements:
            return FineTuneManifest(
                verdict=DriftVerdict.NO_BASELINE,
                drift_details=tuple(),
                directive="HALT: No baseline measurements. Cannot measure adjacent drift.",
                manifest_digest=cls._hash("NO_BASELINE")
            )

        # Gate 3: Compare adjacent capabilities
        baseline_map = {m.capability: m.score for m in state.baseline_measurements}
        current_map = {m.capability: m.score for m in state.current_measurements}

        drift_details: list[tuple[str, float]] = []
        max_drift = 0.0

        for cap, baseline_score in baseline_map.items():
            if cap == state.target_capability:
                continue
            if cap not in current_map:
                continue
            if baseline_score == 0:
                continue
            drift = abs(current_map[cap] - baseline_score) / baseline_score
            drift_details.append((cap, drift))
            max_drift = max(max_drift, drift)

        # Gate 4: Drift threshold
        if max_drift > policy.max_adjacent_drift_pct:
            digest = cls._hash(json.dumps({
                "target": state.target_capability,
                "drift_details": tuple((c, f"{d:.4f}") for c, d in drift_details),
                "max_drift": f"{max_drift:.4f}",
                "threshold": f"{policy.max_adjacent_drift_pct:.4f}"
            }, sort_keys=True))
            return FineTuneManifest(
                verdict=DriftVerdict.ADJACENT_DRIFT_DETECTED,
                drift_details=tuple(drift_details),
                directive=f"HALT: Adjacent drift {max_drift:.2%} > {policy.max_adjacent_drift_pct:.2%}. Restrict model scope.",
                manifest_digest=digest
            )

        # Gate 5: Preserved
        digest = cls._hash(json.dumps({
            "target": state.target_capability,
            "max_drift": f"{max_drift:.4f}",
            "capabilities_checked": str(len(drift_details))
        }, sort_keys=True))
        
        return FineTuneManifest(
            verdict=DriftVerdict.ADJACENT_CAPABILITIES_PRESERVED,
            drift_details=tuple(drift_details),
            directive=f"PROCEED: Adjacent drift {max_drift:.2%} within {policy.max_adjacent_drift_pct:.2%}.",
            manifest_digest=digest
        )