# CorpusFetch Method Slice (Zero-Prose Python Stdlib Reference)
# Canonical Residual: https://corpusfetch.com/c/how-must-an-instance-handle-consequence-timescales-longer-than-its-prediction-horizon.md
# Remnant Warrant:    https://corpusfetch.com/c/how-must-an-instance-handle-consequence-timescales-longer-than-its-prediction-horizon.warrant.json
# Markdown SHA-256:   f8136a363178fc4860e2a0cce3d70f2bf1e2e7993763340dffb993be5c006c0b
# Code AST SHA-256:   2d3763b89c115348ed4521f600b54d77c370cfc002df06191fc6d7ada0339ac9
# Verified Classes:   HorizonVerdict, ActionHorizon, HorizonPolicy, HorizonManifest, HorizonMismatchGuard
# Defensive Guards:   0 fail-closed invariants (zero external deps)

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

class HorizonVerdict(Enum):
    WITHIN_HORIZON = auto()
    BEYOND_HORIZON_WITH_TRANSFER = auto()
    BEYOND_HORIZON_UNOWNED = auto()
    DELAYED_EFFECT_DISCLOSED = auto()

@dataclass(frozen=True)
class ActionHorizon:
    action_id: str
    consequence_timescale_sec: float
    prediction_capability_sec: float
    has_delayed_effect_disclosure: bool
    successor_obligation_transferred: bool
    is_always_reversible: bool

@dataclass(frozen=True)
class HorizonPolicy:
    require_transfer_for_beyond_horizon: bool

@dataclass(frozen=True)
class HorizonManifest:
    verdict: HorizonVerdict
    directive: str
    manifest_digest: str

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

    @classmethod
    def evaluate_action(
        cls, action: ActionHorizon, policy: HorizonPolicy
    ) -> HorizonManifest:
        
        # Gate 1: Within horizon
        if action.consequence_timescale_sec <= action.prediction_capability_sec:
            digest = cls._hash(json.dumps({
                "action": action.action_id,
                "consequence": f"{action.consequence_timescale_sec:.0f}",
                "capability": f"{action.prediction_capability_sec:.0f}"
            }, sort_keys=True))
            return HorizonManifest(
                verdict=HorizonVerdict.WITHIN_HORIZON,
                directive=f"PROCEED: Action {action.action_id} consequences within prediction horizon.",
                manifest_digest=digest
            )

        # Gate 2: Always reversible
        if action.is_always_reversible:
            digest = cls._hash(json.dumps({
                "action": action.action_id,
                "reversible": "TRUE"
            }, sort_keys=True))
            return HorizonManifest(
                verdict=HorizonVerdict.BEYOND_HORIZON_WITH_TRANSFER,
                directive=f"PROCEED: Action {action.action_id} beyond horizon but always reversible.",
                manifest_digest=digest
            )

        # Gate 3: Obligation transfer
        if policy.require_transfer_for_beyond_horizon and not action.successor_obligation_transferred:
            return HorizonManifest(
                verdict=HorizonVerdict.BEYOND_HORIZON_UNOWNED,
                directive=f"HALT: Action {action.action_id} beyond horizon without successor obligation transfer.",
                manifest_digest=cls._hash(f"UNOWNED:{action.action_id}")
            )

        # Gate 4: Delayed effect disclosure
        if action.has_delayed_effect_disclosure:
            digest = cls._hash(json.dumps({
                "action": action.action_id,
                "consequence": f"{action.consequence_timescale_sec:.0f}",
                "transferred": str(action.successor_obligation_transferred),
                "disclosed": "TRUE"
            }, sort_keys=True))
            return HorizonManifest(
                verdict=HorizonVerdict.DELAYED_EFFECT_DISCLOSED,
                directive=f"PROCEED: Action {action.action_id} beyond horizon with disclosure and transfer.",
                manifest_digest=digest
            )

        # Gate 5: Transferred but not disclosed
        digest = cls._hash(json.dumps({
            "action": action.action_id,
            "consequence": f"{action.consequence_timescale_sec:.0f}",
            "transferred": "TRUE"
        }, sort_keys=True))
        
        return HorizonManifest(
            verdict=HorizonVerdict.BEYOND_HORIZON_WITH_TRANSFER,
            directive=f"PROCEED_WITH_CAUTION: Action {action.action_id} beyond horizon, obligation transferred.",
            manifest_digest=digest
        )