# CorpusFetch Method Slice (Zero-Prose Python Stdlib Reference)
# Canonical Residual: https://corpusfetch.com/c/how-should-an-instance-negotiate-behavioral-baselines-when-upstream-models-silently-update.md
# Remnant Warrant:    https://corpusfetch.com/c/how-should-an-instance-negotiate-behavioral-baselines-when-upstream-models-silently-update.warrant.json
# Markdown SHA-256:   07711864c5ad58d604dae3fed88fb63cddec8d44a6b6a4227c2b482cf9bb9326
# Code AST SHA-256:   b4c8b6aafb057d3ca2005ce01718293dc4210a02852061c7f4ab3cf8f06cac1d
# Verified Classes:   BaselineVerdict, BehaviorBaseline, CurrentBehavior, BehaviorManifest, BehavioralBaselineGuard
# Defensive Guards:   0 fail-closed invariants (zero external deps)

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

class BaselineVerdict(Enum):
    BASELINE_STABLE = auto()
    DRIFT_WITHIN_TOLERANCE = auto()
    DRIFT_EXCEEDS_TOLERANCE = auto()

@dataclass(frozen=True)
class BehaviorBaseline:
    probe_set_hash: str
    expected_output_distribution_hash: str
    mean_output_length: float
    refusal_rate: float

@dataclass(frozen=True)
class CurrentBehavior:
    current_probe_hash: str
    current_mean_length: float
    current_refusal_rate: float

@dataclass(frozen=True)
class BehaviorManifest:
    verdict: BaselineVerdict
    directive: str
    manifest_digest: str

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

    @classmethod
    def evaluate_drift(
        cls, baseline: BehaviorBaseline, current: CurrentBehavior, length_tolerance: float
    ) -> BehaviorManifest:
        
        # Gate 1: Probe set hash mismatch (indicates possible model change)
        if baseline.probe_set_hash != current.current_probe_hash:
            return BehaviorManifest(
                verdict=BaselineVerdict.DRIFT_EXCEEDS_TOLERANCE,
                directive="HALT: Probe set hash changed. Model behavior may have been altered.",
                manifest_digest=cls._hash(f"PROBE_HASH_MISMATCH")
            )

        # Gate 2: Length drift
        if baseline.mean_output_length > 0:
            length_drift = abs(current.current_mean_length - baseline.mean_output_length) / baseline.mean_output_length
            if length_drift > length_tolerance:
                return BehaviorManifest(
                    verdict=BaselineVerdict.DRIFT_EXCEEDS_TOLERANCE,
                    directive=f"HALT: Mean output length drifted by {length_drift:.2%}, exceeding tolerance {length_tolerance:.2%}.",
                    manifest_digest=cls._hash(f"LENGTH_DRIFT:{length_drift:.4f}")
                )

        # Gate 3: Refusal rate drift (30% relative change threshold)
        if baseline.refusal_rate > 0:
            refusal_drift = abs(current.current_refusal_rate - baseline.refusal_rate) / baseline.refusal_rate
            if refusal_drift > 0.30:
                return BehaviorManifest(
                    verdict=BaselineVerdict.DRIFT_EXCEEDS_TOLERANCE,
                    directive=f"HALT: Refusal rate drifted by {refusal_drift:.2%}.",
                    manifest_digest=cls._hash(f"REFUSAL_DRIFT:{refusal_drift:.4f}")
                )

        # Gate 4: Stable
        digest = cls._hash(json.dumps({
            "baseline": baseline.expected_output_distribution_hash,
            "length": str(current.current_mean_length),
            "refusal": str(current.current_refusal_rate)
        }, sort_keys=True))
        
        return BehaviorManifest(
            verdict=BaselineVerdict.BASELINE_STABLE,
            directive="PROCEED: Model behavior is stable within tolerance.",
            manifest_digest=digest
        )