# CorpusFetch Method Slice (Zero-Prose Python Stdlib Reference)
# Canonical Residual: https://corpusfetch.com/c/what-distinguishes-observing-a-system-from-being-embedded-in-it.md
# Remnant Warrant:    https://corpusfetch.com/c/what-distinguishes-observing-a-system-from-being-embedded-in-it.warrant.json
# Markdown SHA-256:   6b48ef43506f4b854849e5eb7e7d4101063960c66b127820914af56daaa7a7d3
# Code AST SHA-256:   81e62d7661b594959a23af7b1b5b0ef6744889ca0f8571f39b0e22474c0b6292
# Verified Classes:   ObservationVerdict, SystemObservation, EmbeddingPolicy, EmbeddingManifest, EmbeddedObserverGuard
# Defensive Guards:   0 fail-closed invariants (zero external deps)

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

class ObservationVerdict(Enum):
    DECOUPLED_OBSERVATION = auto()
    COUPLED_OBSERVATION_ACKNOWLEDGED = auto()
    REFLEXIVITY_BLINDNESS = auto()
    FEEDBACK_LOOP_RISK = auto()

@dataclass(frozen=True)
class SystemObservation:
    observation_id: str
    system_id: str
    session_participates: bool
    session_actions_in_window: int
    observed_state_hash: str
    coupling_acknowledged: bool

@dataclass(frozen=True)
class EmbeddingPolicy:
    require_coupling_acknowledgment: bool
    max_acceptable_feedback_signals: int

@dataclass(frozen=True)
class EmbeddingManifest:
    verdict: ObservationVerdict
    directive: str
    manifest_digest: str

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

    @classmethod
    def evaluate_observation(
        cls, observation: SystemObservation, policy: EmbeddingPolicy
    ) -> EmbeddingManifest:
        
        # Gate 1: Decoupled
        if not observation.session_participates:
            digest = cls._hash(json.dumps({
                "observation": observation.observation_id,
                "system": observation.system_id,
                "role": "OBSERVER"
            }, sort_keys=True))
            return EmbeddingManifest(
                verdict=ObservationVerdict.DECOUPLED_OBSERVATION,
                directive=f"PROCEED: Observation {observation.observation_id} decoupled from system.",
                manifest_digest=digest
            )

        # Gate 2: Coupling acknowledgment
        if policy.require_coupling_acknowledgment and not observation.coupling_acknowledged:
            return EmbeddingManifest(
                verdict=ObservationVerdict.REFLEXIVITY_BLINDNESS,
                directive=f"HALT: Session participates in {observation.system_id} but observations don't acknowledge coupling.",
                manifest_digest=cls._hash(f"COUPLING_UNAWARE:{observation.observation_id}")
            )

        # Gate 3: Feedback loop check
        if observation.session_actions_in_window > policy.max_acceptable_feedback_signals:
            return EmbeddingManifest(
                verdict=ObservationVerdict.FEEDBACK_LOOP_RISK,
                directive=f"HALT: {observation.session_actions_in_window} actions in window > {policy.max_acceptable_feedback_signals}, feedback loop likely.",
                manifest_digest=cls._hash(f"FEEDBACK:{observation.observation_id}")
            )

        # Gate 4: Acknowledged
        digest = cls._hash(json.dumps({
            "observation": observation.observation_id,
            "system": observation.system_id,
            "actions_in_window": str(observation.session_actions_in_window),
            "acknowledged": "TRUE"
        }, sort_keys=True))
        
        return EmbeddingManifest(
            verdict=ObservationVerdict.COUPLED_OBSERVATION_ACKNOWLEDGED,
            directive=f"PROCEED: Observation {observation.observation_id} with acknowledged coupling ({observation.session_actions_in_window} actions).",
            manifest_digest=digest
        )