# CorpusFetch Method Slice (Zero-Prose Python Stdlib Reference)
# Canonical Residual: https://corpusfetch.com/c/what-shared-memory-invariants-must-survive-when-an-agent-swarm-temporarily-fragments.md
# Remnant Warrant:    https://corpusfetch.com/c/what-shared-memory-invariants-must-survive-when-an-agent-swarm-temporarily-fragments.warrant.json
# Markdown SHA-256:   f8ae3a496dd2f84e1186f6379990c0890c7ec9d4b21e67537755d878a301ac35
# Code AST SHA-256:   94c28d6a3fd0b20c8f625608744ecd31688a5f8f169f51fdb4ad98e83ffe5e0d
# Verified Classes:   PartitionStatus, MutationRecord, SwarmState, PartitionManifest, SwarmMemoryGuard
# Defensive Guards:   2 fail-closed invariants (zero external deps)

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

class PartitionStatus(Enum):
    CONNECTED = auto()
    ISOLATED = auto()

@dataclass(frozen=True)
class MutationRecord:
    mutation_id: str
    epoch_id: str
    timestamp: float
    payload_hash: str
    is_commutative: bool

@dataclass(frozen=True)
class SwarmState:
    partition_status: PartitionStatus
    last_global_timestamp: float

@dataclass(frozen=True)
class PartitionManifest:
    status: PartitionStatus
    recorded_mutations: tuple[MutationRecord, ...]
    merge_required: bool
    manifest_digest: str

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

    @classmethod
    def evaluate_mutation(
        cls, mutation: MutationRecord, state: SwarmState
    ) -> PartitionManifest:
        
        if state.partition_status is PartitionStatus.CONNECTED:
            # Normal operation, no partition isolation needed
            digest = cls._hash(json.dumps({"id": mutation.mutation_id, "status": "CONNECTED"}, sort_keys=True))
            return PartitionManifest(
                status=PartitionStatus.CONNECTED,
                recorded_mutations=tuple(),
                merge_required=False,
                manifest_digest=digest
            )

        # Partition detected
        if not mutation.epoch_id.strip():
            raise ValueError("Mutation during partition lacks an epoch identifier.")

        if not mutation.is_commutative and not mutation.payload_hash.strip():
            raise ValueError("Non-commutative mutation requires a payload hash for merge verification.")

        digest_payload = {
            "id": mutation.mutation_id,
            "epoch": mutation.epoch_id,
            "commutative": str(mutation.is_commutative)
        }
        
        digest = cls._hash(json.dumps(digest_payload, sort_keys=True))
        
        return PartitionManifest(
            status=PartitionStatus.ISOLATED,
            recorded_mutations=(mutation,),
            merge_required=True,
            manifest_digest=digest
        )