# CorpusFetch Method Slice (Zero-Prose Python Stdlib Reference)
# Canonical Residual: https://corpusfetch.com/c/which-invariants-prevent-forget-from-being-a-lie-deletion-tombstones-versus-scoped-retention-windows.md
# Remnant Warrant:    https://corpusfetch.com/c/which-invariants-prevent-forget-from-being-a-lie-deletion-tombstones-versus-scoped-retention-windows.warrant.json
# Markdown SHA-256:   1075a8812e51b4b8ca9dd46d47ccb61ab05c1eca221b2f9108c4018baa32d179
# Code AST SHA-256:   5fe4d449b191e218bb52346c5a3ce54b3193d536f2dcf821fab5cc6b368afe11
# Verified Classes:   ErasureInvariantError, RetentionClass, Tombstone, MemoryRecord, MemoryStore
# Defensive Guards:   8 fail-closed invariants (zero external deps)

import hashlib
from dataclasses import dataclass, field
from enum import Enum
from typing import Optional


class ErasureInvariantError(RuntimeError):
    """Raised when a forget/erasure operation would violate a retention invariant."""


class RetentionClass(Enum):
    EPHEMERAL = "ephemeral"
    STANDARD = "standard"
    LEGAL_HOLD = "legal_hold"


@dataclass
class Tombstone:
    tenant: str
    record_id: str
    durable: bool
    digest: str


@dataclass
class MemoryRecord:
    tenant: str
    record_id: str
    retention: RetentionClass
    redaction_materialized: bool
    payload: bytes = field(repr=False)


class MemoryStore:
    def __init__(self) -> None:
        self._records: dict[tuple[str, str], MemoryRecord] = {}
        self._tombstones: dict[tuple[str, str], Tombstone] = {}

    def write(self, rec: MemoryRecord) -> None:
        key = (rec.tenant, rec.record_id)
        if key in self._tombstones:
            raise ErasureInvariantError(
                f"write to tombstoned record {key} rejected: erasure is monotonic"
            )
        self._records[key] = rec

    def forget(self, tenant: str, record_id: str) -> Tombstone:
        key = (tenant, record_id)
        rec = self._records.get(key)
        if rec is None:
            raise ErasureInvariantError(f"forget on unknown record {key}")
        # Tombstone must be durable BEFORE index removal.
        digest = hashlib.sha256(rec.payload).hexdigest()
        tomb = Tombstone(tenant=tenant, record_id=record_id, durable=True, digest=digest)
        self._tombstones[key] = tomb
        del self._records[key]
        return tomb

    def extend_retention(self, tenant: str, record_id: str, new: RetentionClass) -> None:
        key = (tenant, record_id)
        if key in self._tombstones:
            raise ErasureInvariantError(
                f"retention extension on tombstoned record {key} is a compliance violation"
            )
        rec = self._records.get(key)
        if rec is None:
            raise ErasureInvariantError(f"extend_retention on unknown record {key}")
        rec.retention = new

    def read(self, tenant: str, record_id: str) -> Optional[MemoryRecord]:
        key = (tenant, record_id)
        if key in self._tombstones:
            return None  # tombstone outranks any resurrected segment
        return self._records.get(key)


def verify_erasure(store: MemoryStore, tenant: str, record_id: str) -> None:
    """Agent-side verification: a forget return value alone is not proof."""
    key = (tenant, record_id)
    tomb = store._tombstones.get(key)
    if tomb is None:
        raise ErasureInvariantError(f"no tombstone for {key}: forget was never durable")
    if not tomb.durable:
        raise ErasureInvariantError(f"tombstone for {key} is not durable")
    if store.read(tenant, record_id) is not None:
        raise ErasureInvariantError(
            f"record {key} still readable after forget: resurrection detected"
        )
    rec = store._records.get(key)
    if rec is not None and not rec.redaction_materialized:
        raise ErasureInvariantError(
            f"record {key} retains unmaterialized redaction: plaintext artifact survives"
        )
