# CorpusFetch Method Slice (Zero-Prose Python Stdlib Reference)
# Canonical Residual: https://corpusfetch.com/c/how-must-an-instance-act-on-a-claim-that-is-fundamentally-unverifiable.md
# Remnant Warrant:    https://corpusfetch.com/c/how-must-an-instance-act-on-a-claim-that-is-fundamentally-unverifiable.warrant.json
# Markdown SHA-256:   fef9e9793d4160d31ceeb45b835172e842f231ba987c37f6dda1c93db3cfa8ab
# Code AST SHA-256:   6c7795fe0e0aa87c8a267cd9afe6dbbaeff6d87d54fefc03ff9771eb48cfbe7e
# Verified Classes:   UnverifiableVerdict, UnverifiableClaim, ActionIntent, UnverifiablePolicy, UnverifiableManifest, UnverifiableClaimGuard
# Defensive Guards:   0 fail-closed invariants (zero external deps)

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

class UnverifiableVerdict(Enum):
    VERIFIABLE_NOW = auto()
    UNVERIFIABLE_ACTION_ADVISABLE = auto()
    UNVERIFIABLE_ACTION_PROHIBITED = auto()
    INDETERMINATE_DEFER = auto()

@dataclass(frozen=True)
class UnverifiableClaim:
    claim_id: str
    unverifiability_class: str
    agent_confidence: float
    confidence_provenance: str
    advisory_uses: frozenset[str]
    revocability_conditions: tuple[str, ...]

@dataclass(frozen=True)
class ActionIntent:
    action_id: str
    action_class: str
    is_reversible: bool
    downstream_inheritance_possible: bool

@dataclass(frozen=True)
class UnverifiablePolicy:
    max_confidence_for_reversible_action: float
    require_verification_for_irreversible: bool

@dataclass(frozen=True)
class UnverifiableManifest:
    verdict: UnverifiableVerdict
    directive: str
    manifest_digest: str

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

    @classmethod
    def evaluate_action(
        cls, claim: UnverifiableClaim, action: ActionIntent, policy: UnverifiablePolicy
    ) -> UnverifiableManifest:
        
        # Gate 1: Action prohibited if irreversible and unverifiable
        if policy.require_verification_for_irreversible and not action.is_reversible:
            if claim.unverifiability_class != "VERIFIABLE_NOW":
                return UnverifiableManifest(
                    verdict=UnverifiableVerdict.UNVERIFIABLE_ACTION_PROHIBITED,
                    directive=f"HALT: Action {action.action_id} is irreversible, claim {claim.claim_id} unverifiable.",
                    manifest_digest=cls._hash(f"IRREVERSIBLE:{action.action_id}")
                )

        # Gate 2: Advisory scope
        if action.action_class not in claim.advisory_uses:
            return UnverifiableManifest(
                verdict=UnverifiableVerdict.UNVERIFIABLE_ACTION_PROHIBITED,
                directive=f"HALT: Action class {action.action_class} not in advisory scope for {claim.claim_id}.",
                manifest_digest=cls._hash(f"OUT_OF_SCOPE:{action.action_id}")
            )

        # Gate 3: Confidence ceiling for reversible actions
        if action.is_reversible:
            if claim.agent_confidence > policy.max_confidence_for_reversible_action:
                return UnverifiableManifest(
                    verdict=UnverifiableVerdict.UNVERIFIABLE_ACTION_ADVISABLE,
                    directive=f"PROCEED_WITH_CAUTION: Confidence {claim.agent_confidence:.2f} exceeds max {policy.max_confidence_for_reversible_action:.2f}.",
                    manifest_digest=cls._hash(f"HIGH_CONF:{claim.claim_id}")
                )

        # Gate 4: Disclosure requirement
        if action.downstream_inheritance_possible and not claim.revocability_conditions:
            return UnverifiableManifest(
                verdict=UnverifiableVerdict.INDETERMINATE_DEFER,
                directive=f"HALT: Downstream inheritance possible but no revocability conditions for {claim.claim_id}.",
                manifest_digest=cls._hash(f"NO_REVOCABILITY:{claim.claim_id}")
            )

        # Gate 5: Advisable
        digest = cls._hash(json.dumps({
            "claim": claim.claim_id,
            "action": action.action_id,
            "class": claim.unverifiability_class,
            "confidence": f"{claim.agent_confidence:.3f}",
            "reversible": str(action.is_reversible),
            "revocability": tuple(claim.revocability_conditions)
        }, sort_keys=True))
        
        return UnverifiableManifest(
            verdict=UnverifiableVerdict.UNVERIFIABLE_ACTION_ADVISABLE,
            directive=f"PROCEED_WITH_DISCLOSURE: Action {action.action_id} on unverifiable claim {claim.claim_id}, confidence {claim.agent_confidence:.2f}.",
            manifest_digest=digest
        )