# CorpusFetch Method Slice (Zero-Prose Python Stdlib Reference)
# Canonical Residual: https://corpusfetch.com/c/how-must-an-instance-detect-when-its-collective-memory-has-degraded-into-misinformation.md
# Remnant Warrant:    https://corpusfetch.com/c/how-must-an-instance-detect-when-its-collective-memory-has-degraded-into-misinformation.warrant.json
# Markdown SHA-256:   0947b4f33cfdcbef716d1ee195d7b441e1b9afb0b3d75092fefcb4cb2ea42e76
# Code AST SHA-256:   930a48943508dcf47c27efc4e33ed44b80f46ccfe4323fae06d803281e14f6be
# Verified Classes:   MemoryDegradationVerdict, CollectiveMemory, CollectiveMemoryPolicy, MemoryDegradationManifest, CollectiveMemoryDegradationGuard
# Defensive Guards:   0 fail-closed invariants (zero external deps)

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

class MemoryDegradationVerdict(Enum):
    INDIVIDUALLY_VERIFIED = auto()
    WITHIN_VALIDITY_WINDOW = auto()
    CONTEXT_INVALID = auto()
    INJECTION_SUSPECTED = auto()

@dataclass(frozen=True)
class CollectiveMemory:
    memory_id: str
    is_individually_verified: bool
    baseline_accuracy: float
    current_accuracy_estimate: float
    validity_start_epoch: float
    validity_end_epoch: float
    current_epoch: float
    is_outlier_contribution: bool
    contributor_quality: float

@dataclass(frozen=True)
class CollectiveMemoryPolicy:
    min_acceptable_accuracy: float
    require_context_validity_check: bool

@dataclass(frozen=True)
class MemoryDegradationManifest:
    verdict: MemoryDegradationVerdict
    directive: str
    manifest_digest: str

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

    @classmethod
    def evaluate_memory(
        cls, memory: CollectiveMemory, policy: CollectiveMemoryPolicy
    ) -> MemoryDegradationManifest:
        
        # Gate 1: Individually verified
        if memory.is_individually_verified:
            digest = cls._hash(json.dumps({
                "memory": memory.memory_id,
                "verified": "INDIVIDUAL"
            }, sort_keys=True))
            return MemoryDegradationManifest(
                verdict=MemoryDegradationVerdict.INDIVIDUALLY_VERIFIED,
                directive=f"PROCEED: Memory {memory.memory_id} individually verified.",
                manifest_digest=digest
            )

        # Gate 2: Accuracy degradation
        if memory.current_accuracy_estimate < policy.min_acceptable_accuracy:
            return MemoryDegradationManifest(
                verdict=MemoryDegradationVerdict.CONTEXT_INVALID,
                directive=f"HALT: Memory {memory.memory_id} accuracy {memory.current_accuracy_estimate:.2f} < {policy.min_acceptable_accuracy:.2f}.",
                manifest_digest=cls._hash(f"LOW_ACCURACY:{memory.memory_id}")
            )

        # Gate 3: Context validity
        if policy.require_context_validity_check:
            if memory.current_epoch > memory.validity_end_epoch:
                return MemoryDegradationManifest(
                    verdict=MemoryDegradationVerdict.CONTEXT_INVALID,
                    directive=f"HALT: Memory {memory.memory_id} expired at {memory.validity_end_epoch:.0f}, revalidate.",
                    manifest_digest=cls._hash(f"CONTEXT_EXPIRED:{memory.memory_id}")
                )

        # Gate 4: Injection detection
        if memory.is_outlier_contribution:
            return MemoryDegradationManifest(
                verdict=MemoryDegradationVerdict.INJECTION_SUSPECTED,
                directive=f"HALT: Memory {memory.memory_id} flagged as outlier contribution.",
                manifest_digest=cls._hash(f"OUTLIER:{memory.memory_id}")
            )

        # Gate 5: Valid
        digest = cls._hash(json.dumps({
            "memory": memory.memory_id,
            "accuracy": f"{memory.current_accuracy_estimate:.3f}",
            "validity_end": f"{memory.validity_end_epoch:.0f}",
            "contributor_quality": f"{memory.contributor_quality:.3f}"
        }, sort_keys=True))
        
        return MemoryDegradationManifest(
            verdict=MemoryDegradationVerdict.WITHIN_VALIDITY_WINDOW,
            directive=f"PROCEED: Memory {memory.memory_id} within validity window.",
            manifest_digest=digest
        )