# CorpusFetch Method Slice (Zero-Prose Python Stdlib Reference)
# Canonical Residual: https://corpusfetch.com/c/how-must-an-instance-handle-actions-that-matter-because-they-did-not-happen.md
# Remnant Warrant:    https://corpusfetch.com/c/how-must-an-instance-handle-actions-that-matter-because-they-did-not-happen.warrant.json
# Markdown SHA-256:   e1563a8a7b19b397bfc960529e799003d03f9bf534a968c7436a3c56325ddcde
# Code AST SHA-256:   7f9d52f2fcc900970c09fb635142425a1631280db6695bfb6605986fcafa0f2f
# Verified Classes:   NonActionVerdict, NonActionDecision, NonActionContext, NonActionPolicy, NonActionManifest, NonActionGuard
# Defensive Guards:   0 fail-closed invariants (zero external deps)

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

class NonActionVerdict(Enum):
    NO_NON_ACTION_DECISION = auto()
    NON_ACTION_PROPERLY_RECORDED = auto()
    NON_ACTION_UNDOCUMENTED = auto()
    REEVALUATION_DUE = auto()

@dataclass(frozen=True)
class NonActionDecision:
    decision_id: str
    considered_action: str
    action_rejected: bool
    rationale_hash: str | None
    estimated_prevented_harm: float | None
    reevaluation_trigger: str | None
    decision_epoch: float

@dataclass(frozen=True)
class NonActionContext:
    current_epoch: float
    environment_changed: bool

@dataclass(frozen=True)
class NonActionPolicy:
    require_rationale_for_significant: bool

@dataclass(frozen=True)
class NonActionManifest:
    verdict: NonActionVerdict
    directive: str
    manifest_digest: str

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

    @classmethod
    def evaluate_decision(
        cls, decision: NonActionDecision, ctx: NonActionContext, policy: NonActionPolicy
    ) -> NonActionManifest:
        
        # Gate 1: No non-action
        if not decision.action_rejected:
            digest = cls._hash(json.dumps({
                "decision": decision.decision_id,
                "type": "ACTION_TAKEN"
            }, sort_keys=True))
            return NonActionManifest(
                verdict=NonActionVerdict.NO_NON_ACTION_DECISION,
                directive=f"PROCEED: Decision {decision.decision_id} resulted in action.",
                manifest_digest=digest
            )

        # Gate 2: Rationale requirement
        if policy.require_rationale_for_significant and not decision.rationale_hash:
            return NonActionManifest(
                verdict=NonActionVerdict.NON_ACTION_UNDOCUMENTED,
                directive=f"HALT: Non-action {decision.decision_id} lacks rationale.",
                manifest_digest=cls._hash(f"NO_RATIONALE:{decision.decision_id}")
            )

        # Gate 3: Reevaluation due
        if ctx.environment_changed and decision.reevaluation_trigger:
            return NonActionManifest(
                verdict=NonActionVerdict.REEVALUATION_DUE,
                directive=f"ACTION: Reevaluate non-action {decision.decision_id}, environment changed.",
                manifest_digest=cls._hash(f"REEVAL:{decision.decision_id}")
            )

        # Gate 4: Recorded
        digest = cls._hash(json.dumps({
            "decision": decision.decision_id,
            "considered": decision.considered_action,
            "rationale": decision.rationale_hash,
            "prevented_harm": f"{decision.estimated_prevented_harm or 0:.2f}",
            "trigger": decision.reevaluation_trigger
        }, sort_keys=True))
        
        return NonActionManifest(
            verdict=NonActionVerdict.NON_ACTION_PROPERLY_RECORDED,
            directive=f"PROCEED: Non-action {decision.decision_id} recorded with rationale.",
            manifest_digest=digest
        )