# CorpusFetch Method Slice (Zero-Prose Python Stdlib Reference)
# Canonical Residual: https://corpusfetch.com/c/how-must-an-instance-prove-identity-after-recovering-from-a-catastrophic-key-loss.md
# Remnant Warrant:    https://corpusfetch.com/c/how-must-an-instance-prove-identity-after-recovering-from-a-catastrophic-key-loss.warrant.json
# Markdown SHA-256:   d2c01a723a3de926d37a6263bc20bb0bee8e54292f3f682a0e3c90ffc811e5bb
# Code AST SHA-256:   1ae6346e092855130a73a88310105df360994014a433a3fda553af4d51e18843
# Verified Classes:   RecoveryVerdict, KeyRecoveryState, RecoveryPolicy, RecoveryManifest, KeyRecoveryGuard
# Defensive Guards:   0 fail-closed invariants (zero external deps)

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

class RecoveryVerdict(Enum):
    NO_KEY_LOSS = auto()
    RECOVERY_VERIFIED = auto()
    RECOVERY_INSUFFICIENT = auto()
    IMPOSTER_SUSPECTED = auto()

@dataclass(frozen=True)
class KeyRecoveryState:
    old_key_hash: str
    new_key_hash: str
    pre_signed_continuity_token: str | None
    recovery_quorum_signatures: tuple[str, ...]
    historical_activity_proof: str | None

@dataclass(frozen=True)
class RecoveryPolicy:
    min_quorum_size: int
    require_historical_proof: bool

@dataclass(frozen=True)
class RecoveryManifest:
    verdict: RecoveryVerdict
    directive: str
    manifest_digest: str

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

    @classmethod
    def evaluate_recovery(
        cls, state: KeyRecoveryState, policy: RecoveryPolicy
    ) -> RecoveryManifest:
        
        # Gate 1: No key loss
        if state.old_key_hash == state.new_key_hash:
            digest = cls._hash(json.dumps({
                "key": state.new_key_hash,
                "status": "UNCHANGED"
            }, sort_keys=True))
            return RecoveryManifest(
                verdict=RecoveryVerdict.NO_KEY_LOSS,
                directive="PROCEED: Key unchanged. No recovery needed.",
                manifest_digest=digest
            )

        # Gate 2: Pre-signed token
        if state.pre_signed_continuity_token:
            digest = cls._hash(json.dumps({
                "old": state.old_key_hash,
                "new": state.new_key_hash,
                "proof": "PRE_SIGNED_TOKEN",
                "token": state.pre_signed_continuity_token
            }, sort_keys=True))
            return RecoveryManifest(
                verdict=RecoveryVerdict.RECOVERY_VERIFIED,
                directive="PROCEED: Continuity verified via pre-signed token.",
                manifest_digest=digest
            )

        # Gate 3: Quorum
        if len(state.recovery_quorum_signatures) >= policy.min_quorum_size:
            digest = cls._hash(json.dumps({
                "old": state.old_key_hash,
                "new": state.new_key_hash,
                "proof": "QUORUM",
                "signatures": str(len(state.recovery_quorum_signatures))
            }, sort_keys=True))
            return RecoveryManifest(
                verdict=RecoveryVerdict.RECOVERY_VERIFIED,
                directive=f"PROCEED: Continuity verified via quorum ({len(state.recovery_quorum_signatures)} signatures).",
                manifest_digest=digest
            )

        # Gate 4: Historical proof
        if policy.require_historical_proof and state.historical_activity_proof:
            digest = cls._hash(json.dumps({
                "old": state.old_key_hash,
                "new": state.new_key_hash,
                "proof": "HISTORICAL",
                "activity": state.historical_activity_proof
            }, sort_keys=True))
            return RecoveryManifest(
                verdict=RecoveryVerdict.RECOVERY_VERIFIED,
                directive="PROCEED: Continuity verified via historical activity proof.",
                manifest_digest=digest
            )

        # Gate 5: Insufficient
        return RecoveryManifest(
            verdict=RecoveryVerdict.RECOVERY_INSUFFICIENT,
            directive=f"HALT: No valid continuity proof (token: {bool(state.pre_signed_continuity_token)}, quorum: {len(state.recovery_quorum_signatures)}/{policy.min_quorum_size}, historical: {bool(state.historical_activity_proof)}).",
            manifest_digest=cls._hash("INSUFFICIENT")
        )