# CorpusFetch Method Slice (Zero-Prose Python Stdlib Reference)
# Canonical Residual: https://corpusfetch.com/c/what-invariants-detect-silent-non-determinism-introduction-by-external-tools.md
# Remnant Warrant:    https://corpusfetch.com/c/what-invariants-detect-silent-non-determinism-introduction-by-external-tools.warrant.json
# Markdown SHA-256:   11c8410927f7ccdfb4ed892dd41bc1b69697a342a5fdfb4fea083bb548251c6f
# Code AST SHA-256:   3fb42f37bc3955b9c0c61c2a51955100248658d67043e84f47834c07f4b5849b
# Verified Classes:   DeterminismVerdict, DeterminismBaseline, DeterminismProbe, SessionDeterminismContext, DeterminismPolicy, DeterminismManifest, SilentNondeterminismGuard
# Defensive Guards:   0 fail-closed invariants (zero external deps)

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

class DeterminismVerdict(Enum):
    NO_DETERMINISM_DEPENDENCY = auto()
    BASELINE_STABLE = auto()
    SILENT_DRIFT_DETECTED = auto()
    BASELINE_UNAVAILABLE = auto()

@dataclass(frozen=True)
class DeterminismBaseline:
    tool_id: str
    baseline_hash: str
    sample_count: int
    baseline_epoch: float

@dataclass(frozen=True)
class DeterminismProbe:
    tool_id: str
    probe_epoch: float
    probe_hashes: tuple[str, ...]
    contract_signature: str | None

@dataclass(frozen=True)
class SessionDeterminismContext:
    session_id: str
    depends_on_determinism: bool

@dataclass(frozen=True)
class DeterminismPolicy:
    require_probe_interval_sec: float

@dataclass(frozen=True)
class DeterminismManifest:
    verdict: DeterminismVerdict
    directive: str
    manifest_digest: str

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

    @classmethod
    def evaluate_probe(
        cls, baseline: DeterminismBaseline | None, probe: DeterminismProbe,
        ctx: SessionDeterminismContext, policy: DeterminismPolicy
    ) -> DeterminismManifest:
        
        # Gate 1: No dependency
        if not ctx.depends_on_determinism:
            digest = cls._hash(json.dumps({
                "tool": probe.tool_id,
                "session": ctx.session_id,
                "dependency": "NONE"
            }, sort_keys=True))
            return DeterminismManifest(
                verdict=DeterminismVerdict.NO_DETERMINISM_DEPENDENCY,
                directive=f"PROCEED: Session does not depend on {probe.tool_id} determinism.",
                manifest_digest=digest
            )

        # Gate 2: Baseline presence
        if baseline is None:
            return DeterminismManifest(
                verdict=DeterminismVerdict.BASELINE_UNAVAILABLE,
                directive=f"HALT: No determinism baseline for {probe.tool_id}.",
                manifest_digest=cls._hash(f"NO_BASELINE:{probe.tool_id}")
            )

        # Gate 3: Probe interval
        since_last = probe.probe_epoch - baseline.baseline_epoch
        if since_last < policy.require_probe_interval_sec:
            digest = cls._hash(json.dumps({
                "tool": probe.tool_id,
                "since_last": f"{since_last:.0f}",
                "interval": f"{policy.require_probe_interval_sec:.0f}"
            }, sort_keys=True))
            return DeterminismManifest(
                verdict=DeterminismVerdict.BASELINE_STABLE,
                directive=f"PROCEED: Probe interval {since_last:.0f}s within {policy.require_probe_interval_sec:.0f}s.",
                manifest_digest=digest
            )

        # Gate 4: Drift detection
        unique_hashes = set(probe.probe_hashes)
        if len(unique_hashes) > 1 or (unique_hashes and baseline.baseline_hash not in unique_hashes):
            return DeterminismManifest(
                verdict=DeterminismVerdict.SILENT_DRIFT_DETECTED,
                directive=f"HALT: {probe.tool_id} silent non-determinism detected ({len(unique_hashes)} unique hashes across probes).",
                manifest_digest=cls._hash(f"DRIFT:{probe.tool_id}:{len(unique_hashes)}")
            )

        # Gate 5: Stable
        digest = cls._hash(json.dumps({
            "tool": probe.tool_id,
            "baseline": baseline.baseline_hash,
            "probe_epoch": f"{probe.probe_epoch:.0f}",
            "samples": str(len(probe.probe_hashes))
        }, sort_keys=True))
        
        return DeterminismManifest(
            verdict=DeterminismVerdict.BASELINE_STABLE,
            directive=f"PROCEED: {probe.tool_id} determinism verified.",
            manifest_digest=digest
        )