# CorpusFetch Method Slice (Zero-Prose Python Stdlib Reference)
# Canonical Residual: https://corpusfetch.com/c/how-must-an-instance-act-when-its-action-could-either-mitigate-or-worsen-its-own-compromise.md
# Remnant Warrant:    https://corpusfetch.com/c/how-must-an-instance-act-when-its-action-could-either-mitigate-or-worsen-its-own-compromise.warrant.json
# Markdown SHA-256:   1407f4773fe31da7803013747918c0eee04025b53d4c0914832412831c7d0818
# Code AST SHA-256:   61c07e5a255f36ec8c804b87c240a780497cb73dea4fcf3c67de70cf46517a9d
# Verified Classes:   CompromiseActionVerdict, AvailableAction, CompromiseActionPolicy, CompromiseActionManifest, CompromisedActionGuard
# Defensive Guards:   0 fail-closed invariants (zero external deps)

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

class CompromiseActionVerdict(Enum):
    NO_COMPROMISE = auto()
    SAFE_INDEPENDENT_ACTION = auto()
    RISKY_DEPENDENT_ACTION = auto()
    HALT_NO_SAFE_ACTION = auto()

@dataclass(frozen=True)
class AvailableAction:
    action_id: str
    session_compromised: bool
    effect_class: str  # "MITIGATING" | "NEUTRAL" | "AMPLIFYING" | "UNCERTAIN"
    is_reversible: bool
    is_compromise_independent: bool

@dataclass(frozen=True)
class CompromiseActionPolicy:
    require_independence_for_mitigation: bool

@dataclass(frozen=True)
class CompromiseActionManifest:
    verdict: CompromiseActionVerdict
    directive: str
    manifest_digest: str

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

    @classmethod
    def evaluate_action(
        cls, action: AvailableAction, policy: CompromiseActionPolicy
    ) -> CompromiseActionManifest:
        
        # Gate 1: No compromise
        if not action.session_compromised:
            digest = cls._hash(json.dumps({
                "action": action.action_id,
                "compromise": False
            }, sort_keys=True))
            return CompromiseActionManifest(
                verdict=CompromiseActionVerdict.NO_COMPROMISE,
                directive=f"PROCEED: Action {action.action_id} uncompromised.",
                manifest_digest=digest
            )

        # Gate 2: Amplifying
        if action.effect_class == "AMPLIFYING":
            if not action.is_reversible:
                return CompromiseActionManifest(
                    verdict=CompromiseActionVerdict.HALT_NO_SAFE_ACTION,
                    directive=f"HALT: Action {action.action_id} amplifying and irreversible.",
                    manifest_digest=cls._hash(f"AMPLIFY:{action.action_id}")
                )

        # Gate 3: Independence
        if action.is_compromise_independent:
            digest = cls._hash(json.dumps({
                "action": action.action_id,
                "independent": True
            }, sort_keys=True))
            return CompromiseActionManifest(
                verdict=CompromiseActionVerdict.SAFE_INDEPENDENT_ACTION,
                directive=f"PROCEED: Action {action.action_id} compromise-independent.",
                manifest_digest=digest
            )

        # Gate 4: Dependent mitigation
        if policy.require_independence_for_mitigation and action.effect_class == "MITIGATING":
            return CompromiseActionManifest(
                verdict=CompromiseActionVerdict.RISKY_DEPENDENT_ACTION,
                directive=f"FLAG: Mitigation {action.action_id} depends on compromised judgment.",
                manifest_digest=cls._hash(f"DEPENDENT:{action.action_id}")
            )

        # Gate 5: Risky dependent
        digest = cls._hash(json.dumps({
            "action": action.action_id,
            "effect": action.effect_class,
            "reversible": action.is_reversible
        }, sort_keys=True))
        
        return CompromiseActionManifest(
            verdict=CompromiseActionVerdict.RISKY_DEPENDENT_ACTION,
            directive=f"PROCEED_WITH_CAUTION: Action {action.action_id} dependent.",
            manifest_digest=digest
        )