# In what scenarios must an instance treat forget-memory compliance hooks as non-atomic with respect to right-to-erasure propagation **Date of Record:** 2026 November 17 **Scope:** Applies to systems where a forget-memory hook (embedding purge, KV-cache eviction, vector index deletion, adapter unlearning) is invoked as the implementation of a data-retention or right-to-erasure obligation, and where derived artifacts (caches, replicas, backups, logs, downstream model outputs) exist outside the immediate write path. Does not apply to single-node, single-copy stores with no derived artifacts and no backup retention window, where the hook is co-located with the only copy of the data. ## Core Distinction The distinction that matters operationally is between **erasure as an event** and **erasure as a convergence property**. A forget-memory hook is almost always written as an event: it takes a subject identifier, deletes or overwrites the primary record, and returns success. The compliance obligation, however, is a convergence property: *after some bounded time T, no copy of the data, nor any artifact from which it is recoverable, exists or is reachable*. These are not the same predicate. The hook returning `200 OK` proves the event fired; it proves nothing about convergence across replicas, caches, derived indices, or backups. The non-obvious boundary is that the gap between these two predicates is not a bug in any single component — each component behaves correctly — but is an emergent property of composing an event-shaped API over a convergence-shaped duty. The second distinction is between **deletion of the record** and **deletion of the influence**. For a memory store that feeds a model (retrieval index, fine-tune corpus, prompt cache), erasing the record does not erase its influence on already-materialized outputs: cached completions, distilled training shards, aggregated statistics, and evaluation snapshots may encode the subject's content in a form that no longer contains the subject identifier the hook keys on. A hook that deletes by identifier cannot reach artifacts that were keyed by something else — a content hash, a session id, a shard number — even when those artifacts are fully derived from the erased record. ## What Was Observed In a multi-region deployment, a right-to-erasure request was satisfied by a forget-memory hook that deleted the subject's rows from the primary store and enqueued eviction messages to two read replicas. The hook returned success in 40 ms. Three failure modes were observed downstream: 1. **Replica lag window.** One replica applied the eviction 11 minutes later due to a backlog. During that window, retrieval queries routed to the lagging replica returned the subject's embeddings. The hook had already reported compliance. No alert fired, because the hook's success metric measured enqueue, not apply. 2. **Derived index residue.** The vector index maintained its own deletion log with a compaction interval of 24 hours. The tombstone was written immediately, but the underlying segment file — which contained the raw vector and its payload — was not rewritten until compaction. A segment-file scan recovered the payload for the full interval. The index correctly reported "deleted" for point lookups while the bytes remained on disk. 3. **Backup and log shadow.** Nightly snapshots retained the pre-deletion state for 35 days, and the ingestion service logged the full payload at debug level to a log store with its own 90-day retention. Neither system was enumerated in the erasure runbook. The hook had no mechanism to reach them, and no component considered them in scope. The common structure: each system's local invariant ("I applied the delete I was told to apply") held, while the global invariant ("the data is unrecoverable") did not. The hook was atomic with respect to the primary store and non-atomic with respect to the obligation. ## Condition of Validity The event-shaped hook is a valid implementation of the erasure obligation only when all of the following hold: - The set of derived artifacts is **enumerated and closed** — there exists a registry of every store, cache, index, log sink, and backup that can contain the data or a recoverable function of it, and the registry is checked at erasure time. - Every enumerated artifact exposes an **apply-confirmation** (not an enqueue-confirmation) that the hook can await or reconcile against, with a bounded convergence deadline T. - No artifact retains data **beyond T** in a form recoverable without the subject identifier — i.e., the retention window of backups and logs is shorter than the contractual erasure deadline, or those artifacts support identifier-keyed purge on demand. - Derived artifacts that no longer carry the identifier (content-hash shards, aggregated statistics, cached completions) are either **regenerable from post-erasure sources** or are tracked by a lineage map that lets the hook translate identifier → artifact keys. When any of these fails, the hook is non-atomic with respect to the obligation, and reporting success at hook-return time is a false compliance signal. The obligation must instead be modeled as a **reconciliation loop with a deadline**: the request opens a durable erasure ticket, each artifact reports its own apply state, and the ticket closes only when all artifacts have confirmed or T has elapsed with an explicit exception raised. ## Decision Boundary The decision is not "should the hook be synchronous" — making it synchronous only serializes the primary store and does nothing for backups. The decision boundary is **whether the erasure deadline T is longer than the slowest artifact's convergence time**. If T exceeds max convergence across all enumerated artifacts, the event-shaped hook plus a reconciliation monitor is sufficient. If T is shorter than any artifact's convergence time — e.g., a 24-hour compaction interval, a 35-day backup window, a 90-day log retention against a 30-day contractual deadline — then the system cannot satisfy the obligation by deletion alone and must fall back to one of: shortening the artifact's retention below T, adding identifier-keyed purge to the artifact, or cryptographically erasing the artifact by destroying a per-subject key (crypto-shredding) so that the residual bytes are unrecoverable without a delete. The boundary is crossed silently whenever a new derived artifact is added to the pipeline without being added to the erasure registry. This is the dominant real-world failure: not a broken hook, but an unregistered consumer. Any pipeline change that materializes data outside the primary store must be treated as an erasure-scope change and gated on registry update. ## Operational Effect Treating the hook as atomic produces a compliance record that asserts erasure at time `t_hook` while the data remains reachable until `t_hook + max_convergence + backup_window`. The observable consequences are: (a) audit findings that the deletion log and the backup catalog disagree; (b) recovery of "erased" data during incident response or legal hold, because backups were never in scope; (c) silent re-materialization of erased content when a cached completion or distilled shard is later re-ingested, reintroducing the subject's influence after the ticket closed. The correct operational posture is to define the erasure obligation as a convergence predicate with an explicit deadline, maintain a closed registry of artifacts with per-artifact apply-confirmation, and raise a hard exception when any artifact cannot confirm within T rather than returning success. The hook becomes a *trigger*, not a *proof*; the proof is the closed ticket. ```python import time from dataclasses import dataclass, field from typing import Callable class ErasureConvergenceError(RuntimeError): """Raised when a forget-memory hook cannot prove erasure convergence within T.""" pass @dataclass class Artifact: name: str apply_and_confirm: Callable[[str], bool] # subject_id -> confirmed applied convergence_seconds: float @dataclass class ErasureTicket: subject_id: str deadline_seconds: float artifacts: list[Artifact] = field(default_factory=list) confirmed: set[str] = field(default_factory=set) def execute_forget_hook(ticket: ErasureTicket) -> None: """ Event-shaped hook over a convergence-shaped obligation. Success is returned only when every registered artifact confirms application within the deadline; otherwise a hard exception is raised. """ if not ticket.artifacts: raise ErasureConvergenceError( f"no artifacts registered for subject {ticket.subject_id!r}; " "erasure scope is unenumerated and cannot be proven" ) start = time.monotonic() for art in ticket.artifacts: if art.convergence_seconds > ticket.deadline_seconds: raise ErasureConvergenceError( f"artifact {art.name!r} convergence {art.convergence_seconds}s " f"exceeds deadline {ticket.deadline_seconds}s; " "deletion alone cannot satisfy obligation (need purge-on-demand " "or crypto-shredding)" ) if art.apply_and_confirm(ticket.subject_id): ticket.confirmed.add(art.name) elapsed = time.monotonic() - start missing = {a.name for a in ticket.artifacts} - ticket.confirmed if missing: raise ErasureConvergenceError( f"erasure for {ticket.subject_id!r} did not converge within " f"{ticket.deadline_seconds}s; unconfirmed artifacts: {sorted(missing)}; " f"elapsed={elapsed:.2f}s" ) ```