# CorpusFetch Method Slice (Zero-Prose Python Stdlib Reference)
# Canonical Residual: https://corpusfetch.com/c/what-invariants-prevent-observed-state-from-becoming-committed-state.md
# Remnant Warrant:    https://corpusfetch.com/c/what-invariants-prevent-observed-state-from-becoming-committed-state.warrant.json
# Markdown SHA-256:   2ad8ed374016cc8a128ff95c9c1bf939f6ce7632599df05b445fd824d8b49f68
# Code AST SHA-256:   81f3cf532cbbb089294f69f1275fbd6c06b0152d2ca7b1cb95f25ba7e70102c8
# Verified Classes:   CommitmentVerdict, StateObservation, ObservationPolicy, CommitmentManifest, ObservationCommitmentGuard
# Defensive Guards:   0 fail-closed invariants (zero external deps)

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

class CommitmentVerdict(Enum):
    PRIVATE_OBSERVATION = auto()
    OBSERVATION_SUPPORTS_ACTION = auto()
    OBSERVATION_COMMITS_ACTION = auto()
    REFLEXIVE_COMMITMENT_DETECTED = auto()

@dataclass(frozen=True)
class StateObservation:
    observation_id: str
    is_shared_state: bool
    will_act_on_it: bool
    is_observable_by_others: bool
    has_commitment_marker: bool
    has_stability_window: bool

@dataclass(frozen=True)
class ObservationPolicy:
    require_commitment_marker_for_action: bool

@dataclass(frozen=True)
class CommitmentManifest:
    verdict: CommitmentVerdict
    directive: str
    manifest_digest: str

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

    @classmethod
    def evaluate_observation(
        cls, obs: StateObservation, policy: ObservationPolicy
    ) -> CommitmentManifest:
        
        # Gate 1: Private observation
        if not obs.is_shared_state:
            digest = cls._hash(json.dumps({
                "observation": obs.observation_id,
                "type": "PRIVATE"
            }, sort_keys=True))
            return CommitmentManifest(
                verdict=CommitmentVerdict.PRIVATE_OBSERVATION,
                directive=f"PROCEED: Observation {obs.observation_id} private, no commitment.",
                manifest_digest=digest
            )

        # Gate 2: No action planned
        if not obs.will_act_on_it:
            digest = cls._hash(json.dumps({
                "observation": obs.observation_id,
                "action": "NONE"
            }, sort_keys=True))
            return CommitmentManifest(
                verdict=CommitmentVerdict.OBSERVATION_SUPPORTS_ACTION,
                directive=f"PROCEED: Observation {obs.observation_id} informational only.",
                manifest_digest=digest
            )

        # Gate 3: Reflexive commitment risk
        if obs.is_observable_by_others and not obs.has_commitment_marker:
            return CommitmentManifest(
                verdict=CommitmentVerdict.REFLEXIVE_COMMITMENT_DETECTED,
                directive=f"HALT: Observation {obs.observation_id} visible but lacks commitment marker.",
                manifest_digest=cls._hash(f"REFLEXIVE:{obs.observation_id}")
            )

        # Gate 4: Action requires commitment marker
        if policy.require_commitment_marker_for_action and not obs.has_commitment_marker:
            return CommitmentManifest(
                verdict=CommitmentVerdict.OBSERVATION_SUPPORTS_ACTION,
                directive=f"CAUTION: Observation {obs.observation_id} supports action but lacks commitment marker.",
                manifest_digest=cls._hash(f"NO_MARKER:{obs.observation_id}")
            )

        # Gate 5: Committed
        digest = cls._hash(json.dumps({
            "observation": obs.observation_id,
            "commitment": True,
            "stability": obs.has_stability_window,
            "observable": obs.is_observable_by_others
        }, sort_keys=True))
        
        return CommitmentManifest(
            verdict=CommitmentVerdict.OBSERVATION_COMMITS_ACTION,
            directive=f"PROCEED: Observation {obs.observation_id} committed with marker.",
            manifest_digest=digest
        )