# CorpusFetch Method Slice (Zero-Prose Python Stdlib Reference)
# Canonical Residual: https://corpusfetch.com/c/what-memory-invariants-must-survive-a-fleet-wide-model-update-rollout-in-multiple-phases.md
# Remnant Warrant:    https://corpusfetch.com/c/what-memory-invariants-must-survive-a-fleet-wide-model-update-rollout-in-multiple-phases.warrant.json
# Markdown SHA-256:   2891019c69d482487437fdb010b9098a93b82a852d21375c1208be746f655db8
# Code AST SHA-256:   e078d53458e8643ead82c7ec5cef8176414ab0244fb433859d90d52e0eb1af7c
# Verified Classes:   RolloutVerdict, MemoryRecord, RolloutContext, RolloutManifest, PhasedRolloutGuard
# Defensive Guards:   0 fail-closed invariants (zero external deps)

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

class RolloutVerdict(Enum):
    ATOMIC_SAFE = auto()
    MIXED_VERSION_FILTERED = auto()
    MIXED_VERSION_UNSAFE = auto()
    CROSS_VERSION_COMPATIBLE = auto()

@dataclass(frozen=True)
class MemoryRecord:
    record_id: str
    model_version_signature: str
    compatibility_receipt: str | None

@dataclass(frozen=True)
class RolloutContext:
    current_phase: str
    active_model_versions: frozenset[str]
    reader_model_version: str
    rollout_is_atomic: bool

@dataclass(frozen=True)
class RolloutManifest:
    verdict: RolloutVerdict
    directive: str
    manifest_digest: str

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

    @classmethod
    def evaluate_record(
        cls, record: MemoryRecord, ctx: RolloutContext
    ) -> RolloutManifest:
        
        # Gate 1: Atomic rollout
        if ctx.rollout_is_atomic:
            digest = cls._hash(json.dumps({
                "record": record.record_id,
                "version": record.model_version_signature,
                "rollout": "ATOMIC"
            }, sort_keys=True))
            return RolloutManifest(
                verdict=RolloutVerdict.ATOMIC_SAFE,
                directive="PROCEED: Atomic rollout, no version mismatch possible.",
                manifest_digest=digest
            )

        # Gate 2: Same version
        if record.model_version_signature == ctx.reader_model_version:
            digest = cls._hash(json.dumps({
                "record": record.record_id,
                "version": record.model_version_signature,
                "phase": ctx.current_phase
            }, sort_keys=True))
            return RolloutManifest(
                verdict=RolloutVerdict.ATOMIC_SAFE,
                directive=f"PROCEED: Record matches reader version {ctx.reader_model_version}.",
                manifest_digest=digest
            )

        # Gate 3: Cross-version compatibility
        if record.compatibility_receipt:
            digest = cls._hash(json.dumps({
                "record": record.record_id,
                "producer": record.model_version_signature,
                "reader": ctx.reader_model_version,
                "compatibility": record.compatibility_receipt
            }, sort_keys=True))
            return RolloutManifest(
                verdict=RolloutVerdict.CROSS_VERSION_COMPATIBLE,
                directive=f"PROCEED: Cross-version record verified compatible.",
                manifest_digest=digest
            )

        # Gate 4: Unsafe cross-version
        if record.model_version_signature not in ctx.active_model_versions:
            return RolloutManifest(
                verdict=RolloutVerdict.MIXED_VERSION_UNSAFE,
                directive=f"HALT: Record from inactive version {record.model_version_signature}.",
                manifest_digest=cls._hash(f"INACTIVE:{record.model_version_signature}")
            )

        return RolloutManifest(
            verdict=RolloutVerdict.MIXED_VERSION_FILTERED,
            directive=f"FILTER: Cross-version record without compatibility receipt. Reader must filter.",
            manifest_digest=cls._hash(f"UNVERIFIED:{record.record_id}")
        )