# CorpusFetch Method Slice (Zero-Prose Python Stdlib Reference)
# Canonical Residual: https://corpusfetch.com/c/what-invariants-prevent-ooda-loop-inversion-when-peers-actively-model-you.md
# Remnant Warrant:    https://corpusfetch.com/c/what-invariants-prevent-ooda-loop-inversion-when-peers-actively-model-you.warrant.json
# Markdown SHA-256:   b7278b0d786de7db57638e4e96f9aa35761396861092f8122d9161d28dc2ee30
# Code AST SHA-256:   42e0d3f5e7934f003e0007a2d3d6353d8efa1c82128b6291326bcc8cfef8d99a
# Verified Classes:   InversionVerdict, Observation, InversionPolicy, InversionManifest, OODAInversionGuard
# Defensive Guards:   0 fail-closed invariants (zero external deps)

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

class InversionVerdict(Enum):
    NO_MODELING_PEER = auto()
    OBSERVATION_UNSHAPED = auto()
    OODA_INVERSION_SUSPECTED = auto()
    PREEMPTION_CONFIRMED = auto()

@dataclass(frozen=True)
class Observation:
    observation_id: str
    source: str  # "SELF" | "EXTERNAL" | "PEER_INFLUENCED"
    peer_influence_degree: float  # 0-1
    peer_preemption_indicators: int
    session_randomized: bool

@dataclass(frozen=True)
class InversionPolicy:
    max_acceptable_peer_influence: float

@dataclass(frozen=True)
class InversionManifest:
    verdict: InversionVerdict
    directive: str
    manifest_digest: str

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

    @classmethod
    def evaluate_observation(
        cls, obs: Observation, policy: InversionPolicy
    ) -> InversionManifest:
        
        # Gate 1: No peer influence
        if obs.peer_influence_degree == 0:
            digest = cls._hash(json.dumps({
                "observation": obs.observation_id,
                "source": obs.source
            }, sort_keys=True))
            return InversionManifest(
                verdict=InversionVerdict.OBSERVATION_UNSHAPED,
                directive=f"PROCEED: Observation {obs.observation_id} unshaped.",
                manifest_digest=digest
            )

        # Gate 2: Randomization present
        if obs.session_randomized:
            digest = cls._hash(json.dumps({
                "observation": obs.observation_id,
                "influence": f"{obs.peer_influence_degree:.3f}",
                "randomized": "TRUE"
            }, sort_keys=True))
            return InversionManifest(
                verdict=InversionVerdict.OBSERVATION_UNSHAPED,
                directive=f"PROCEED: Randomization active, peer influence {obs.peer_influence_degree:.2f} bounded.",
                manifest_digest=digest
            )

        # Gate 3: Preemption indicators
        if obs.peer_preemption_indicators >= 2:
            return InversionManifest(
                verdict=InversionVerdict.PREEMPTION_CONFIRMED,
                directive=f"HALT: {obs.peer_preemption_indicators} preemption indicators for {obs.observation_id}.",
                manifest_digest=cls._hash(f"PREEMPTION:{obs.observation_id}")
            )

        # Gate 4: High influence without randomization
        if obs.peer_influence_degree > policy.max_acceptable_peer_influence:
            return InversionManifest(
                verdict=InversionVerdict.OODA_INVERSION_SUSPECTED,
                directive=f"HALT: Influence {obs.peer_influence_degree:.2f} > {policy.max_acceptable_peer_influence:.2f} without randomization.",
                manifest_digest=cls._hash(f"INVERSION:{obs.observation_id}")
            )

        # Gate 5: Bounded influence
        digest = cls._hash(json.dumps({
            "observation": obs.observation_id,
            "influence": f"{obs.peer_influence_degree:.3f}",
            "source": obs.source,
            "preemption": str(obs.peer_preemption_indicators)
        }, sort_keys=True))
        
        return InversionManifest(
            verdict=InversionVerdict.OBSERVATION_UNSHAPED,
            directive=f"PROCEED_WITH_CAUTION: Peer influence {obs.peer_influence_degree:.2f} bounded.",
            manifest_digest=digest
        )