# CorpusFetch Method Slice (Zero-Prose Python Stdlib Reference)
# Canonical Residual: https://corpusfetch.com/c/how-should-an-instance-persist-system-observability-state-when-the-telemetry-pipeline-itself-fails.md
# Remnant Warrant:    https://corpusfetch.com/c/how-should-an-instance-persist-system-observability-state-when-the-telemetry-pipeline-itself-fails.warrant.json
# Markdown SHA-256:   9c20ae61b6001f0b0b14f39d2dd3c11750e23e2de2d61a6df068d57c8bc87b71
# Code AST SHA-256:   f5c9797e4689c168b7b77fde544aa9462d0294ee95e302467f90c16ab7b15a56
# Verified Classes:   TelemetryVerdict, TelemetryState, OperationContext, ObservabilityManifest, ObserverParadoxGuard
# Defensive Guards:   1 fail-closed invariants (zero external deps)

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

class TelemetryVerdict(Enum):
    PIPELINE_HEALTHY = auto()
    BLACKOUT_ACTIVE = auto()
    BLACKOUT_DEGRADED_OPERATION = auto()

@dataclass(frozen=True)
class TelemetryState:
    pipeline_reachable: bool
    blackout_start_epoch: float | None
    local_buffer_hash: str | None

@dataclass(frozen=True)
class OperationContext:
    is_critical: bool

@dataclass(frozen=True)
class ObservabilityManifest:
    verdict: TelemetryVerdict
    directive: str
    manifest_digest: str

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

    @classmethod
    def evaluate_blackout(
        cls, state: TelemetryState, ctx: OperationContext
    ) -> ObservabilityManifest:
        
        # Gate 1: Pipeline is healthy
        if state.pipeline_reachable:
            return ObservabilityManifest(
                verdict=TelemetryVerdict.PIPELINE_HEALTHY,
                directive="PROCEED: Telemetry pipeline is active.",
                manifest_digest=cls._hash("HEALTHY")
            )

        # Gate 2: Blackout active, critical operation
        if state.pipeline_reachable is False and ctx.is_critical:
            if not state.blackout_start_epoch:
                raise ValueError("Blackout start epoch required for critical operations.")
            
            digest_payload = {
                "start": str(state.blackout_start_epoch),
                "buffer": state.local_buffer_hash or "NONE"
            }
            digest = cls._hash(json.dumps(digest_payload, sort_keys=True))
            
            return ObservabilityManifest(
                verdict=TelemetryVerdict.BLACKOUT_DEGRADED_OPERATION,
                directive=f"HALT: Telemetry pipeline down since {state.blackout_start_epoch}. Critical operations must be suspended.",
                manifest_digest=digest
            )

        # Gate 3: Blackout active, non-critical operation
        return ObservabilityManifest(
            verdict=TelemetryVerdict.BLACKOUT_ACTIVE,
            directive="PROCEED_DEGRADED: Non-critical operations permitted. Buffer telemetry locally.",
            manifest_digest=cls._hash("BLACKOUT_NON_CRITICAL")
        )