# CorpusFetch Method Slice (Zero-Prose Python Stdlib Reference)
# Canonical Residual: https://corpusfetch.com/c/how-must-an-instance-escalate-to-a-more-capable-model-without-losing-progress.md
# Remnant Warrant:    https://corpusfetch.com/c/how-must-an-instance-escalate-to-a-more-capable-model-without-losing-progress.warrant.json
# Markdown SHA-256:   6505eca37168a545eb9d6caa406f23017a361b3a298e3a6aba2d3dc088200c90
# Code AST SHA-256:   1a09e012410cbe786149e81265503f0afc3c917440d1a81cc0e7ea8a75f87e01
# Verified Classes:   EscalationVerdict, LimitedModelState, EscalationRequest, EscalationPolicy, EscalationManifest, ModelEscalationGuard
# Defensive Guards:   0 fail-closed invariants (zero external deps)

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

class EscalationVerdict(Enum):
    NO_ESCALATION = auto()
    TRANSFER_PACKAGE_READY = auto()
    TRANSFER_PACKAGE_MISSING = auto()
    FOUNDATION_DIVERGENCE = auto()

@dataclass(frozen=True)
class LimitedModelState:
    state_id: str
    transferable_facts: tuple[tuple[str, float], ...]
    rationale_hashes: tuple[str, ...]
    non_transferable_facts: tuple[str, ...]

@dataclass(frozen=True)
class EscalationRequest:
    limited_state: LimitedModelState
    capable_model_id: str
    capable_model_accepts_transfer: bool
    capable_model_rationale_verified: bool

@dataclass(frozen=True)
class EscalationPolicy:
    require_transfer_package: bool
    require_rationale_verification: bool

@dataclass(frozen=True)
class EscalationManifest:
    verdict: EscalationVerdict
    directive: str
    manifest_digest: str

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

    @classmethod
    def evaluate_escalation(
        cls, request: EscalationRequest, policy: EscalationPolicy
    ) -> EscalationManifest:
        
        # Gate 1: Transfer package presence
        if policy.require_transfer_package:
            if not request.limited_state.transferable_facts:
                return EscalationManifest(
                    verdict=EscalationVerdict.TRANSFER_PACKAGE_MISSING,
                    directive=f"HALT: Limited state {request.limited_state.state_id} has no transferable facts.",
                    manifest_digest=cls._hash(f"NO_TRANSFER:{request.limited_state.state_id}")
                )
            if not request.limited_state.rationale_hashes:
                return EscalationManifest(
                    verdict=EscalationVerdict.TRANSFER_PACKAGE_MISSING,
                    directive=f"HALT: Limited state {request.limited_state.state_id} has no rationale hashes.",
                    manifest_digest=cls._hash(f"NO_RATIONALE:{request.limited_state.state_id}")
                )

        # Gate 2: Capable model acceptance
        if not request.capable_model_accepts_transfer:
            return EscalationManifest(
                verdict=EscalationVerdict.FOUNDATION_DIVERGENCE,
                directive=f"HALT: Capable model {request.capable_model_id} rejects transfer. Would re-derive.",
                manifest_digest=cls._hash(f"REJECTED:{request.capable_model_id}")
            )

        # Gate 3: Rationale verification
        if policy.require_rationale_verification and not request.capable_model_rationale_verified:
            return EscalationManifest(
                verdict=EscalationVerdict.FOUNDATION_DIVERGENCE,
                directive=f"HALT: Capable model did not verify rationales. Foundation divergence risk.",
                manifest_digest=cls._hash(f"UNVERIFIED:{request.capable_model_id}")
            )

        # Gate 4: Ready
        digest = cls._hash(json.dumps({
            "limited_state": request.limited_state.state_id,
            "capable_model": request.capable_model_id,
            "transferable_facts": str(len(request.limited_state.transferable_facts)),
            "non_transferable": str(len(request.limited_state.non_transferable_facts)),
            "rationale_hashes": len(request.limited_state.rationale_hashes)
        }, sort_keys=True))
        
        return EscalationManifest(
            verdict=EscalationVerdict.TRANSFER_PACKAGE_READY,
            directive=f"PROCEED: Escalate to {request.capable_model_id} with {len(request.limited_state.transferable_facts)} transferable facts.",
            manifest_digest=digest
        )