# Where must an instance of a “deleted” memory be proven absent before forget-compliance can be attested **Date of Record:** 2026 November 17 **Scope:** Applies to agent memory stores that implement deletion obligations (GDPR/CCPA erasure, tenant offboarding, secret rotation) over a layered topology of write-ahead log, embedding index, KV cache, and derived summaries. Does not apply to single-process, single-store systems where the authoritative record is the only copy. ## Core Distinction The non-obvious invariant is this: *deletion is not an operation on a key; it is an operation on a set of derivations.* A forget request names a source record (a document, a conversation turn, a user ID). Compliance is not satisfied when the source record is removed from the primary store. It is satisfied only when every *derived instance* — embeddings, ANN index entries, cached KV blocks, and model-generated summaries that paraphrase the source — is either removed or provably non-recoverable. The boundary failure occurs when the audit is scoped to the primary store and the index is treated as a *cache* rather than a *derivation*. An index entry is a lossy but invertible-enough projection: given an embedding and a query set, nearest-neighbor probes can reconstruct substantial verbatim content. The deletion of the row does not delete the vector. The vector is the memory. ## What Was Observed In a system with a 12-month retention WAL, a 90-day TTL embedding index, and a nightly summarization job, a forget request for a single conversation turn was executed as: `DELETE` on the primary row, tombstone insert, and an enqueue to the index-compaction queue. The queue drained on a 6-hour cadence. During the window between tombstone and compaction, the following were all true and all observable: 1. The WAL still contained the original write, because WAL segments are rotated, not rewritten, and the segment was 4 months from expiry. 2. The ANN index still returned the deleted turn as a top-3 neighbor for queries derived from the paraphrased summary. 3. The summary job had already run and produced a natural-language paraphrase that did not share a single 8-gram with the source, so any n-gram-based deletion verifier reported “absent.” The verifier was correct about the thing it measured and wrong about the thing that mattered. This is the classic *verification-target mismatch*: the audit proved absence in the representation it could inspect, not in the representation that carries the obligation. ## Condition of Validity A forget-compliance attestation is valid only if it is conditioned on a *closure statement* over the derivation graph. Formally: let $R$ be the set of source records named by the request, and let $D(R)$ be the transitive closure of derivations (embeddings, index entries, cache blocks, summaries, fine-tune deltas, logs). The attestation is valid iff for every $d \in D(R)$, one of the following holds and is *checkable*: - $d$ is physically absent from all durable media (including WAL segments not yet rotated), or - $d$ is present but provably non-invertible to the source within a stated reconstruction bound (e.g., k-anonymized aggregate with $k \geq$ threshold), or - $d$ is present but under a retention policy that is itself attested and whose expiry is bounded and monitored. The third branch is the one that turns a deletion into a *scheduled* deletion, and it must be labeled as such in the attestation. An attestation that conflates “deleted now” with “will be deleted by TTL” is a misrepresentation, not a rounding error. ## Decision Boundary The operational decision is: **when does a forget request require a synchronous, blocking compaction versus an asynchronous, attested-deferred one?** The boundary is determined by the *invertibility class* of the most sensitive derivation, not by the sensitivity of the source. If any derivation is in the high-invertibility class (verbatim-text embeddings, unredacted summaries, KV blocks containing the literal tokens), the request must block until that derivation is gone from all media, because the WAL makes the deletion reversible until segment rotation. If all derivations are in the low-invertibility class (aggregated statistics, hashed identifiers with no preimage, deduplicated counts), the request may be attested-deferred with an explicit expiry bound. The common error is to classify by *storage tier* (“it's only in the cache”) rather than by *invertibility*. A cache of embeddings is not a cache of the source; it is a second copy of the source in a different coordinate system. ## Operational Effect Teams that adopt derivation-closure auditing observe three concrete changes. First, forget-request latency is no longer uniform: high-invertibility requests block on WAL rotation and index compaction, which means the SLO must be expressed per invertibility class, not as a single p99. Second, the index compaction queue becomes a compliance-critical path and must be monitored with the same rigor as the primary write path — a stalled compaction queue is a stalled deletion. Third, the attestation artifact changes shape: it is no longer a boolean “deleted” but a signed closure record listing each derivation, its class, its disposition, and the verifier that checked it. Auditors who ask for a boolean are asking the wrong question; the correct answer is a manifest with a verifier per entry, and the manifest is the compliance artifact. The invariant to carry forward: *the unit of deletion is the derivation, and the unit of proof is the closure.* ```python from __future__ import annotations from dataclasses import dataclass, field from enum import Enum class ForgetComplianceError(RuntimeError): """Raised when a forget request cannot be attested under the closure invariant.""" class Invertibility(Enum): HIGH = "high" # verbatim embeddings, unredacted summaries, KV blocks LOW = "low" # aggregates, hashed ids, dedup counts class Media(Enum): PRIMARY = "primary" WAL = "wal" ANN_INDEX = "ann_index" KV_CACHE = "kv_cache" SUMMARY = "summary" @dataclass(frozen=True) class Derivation: media: Media invertibility: Invertibility present: bool expiry_bounded: bool = False @dataclass class ClosureAttestation: record_id: str derivations: list[Derivation] = field(default_factory=list) blocking: bool = False def attest_forget(record_id: str, derivations: list[Derivation]) -> ClosureAttestation: """ Build a closure attestation. Blocking is required iff any HIGH-invertibility derivation is still present and not bounded by a monitored retention expiry. """ if not derivations: raise ForgetComplianceError( f"record {record_id!r}: empty derivation set; cannot distinguish " f"'no derivations' from 'derivation graph not enumerated'" ) att = ClosureAttestation(record_id=record_id, derivations=list(derivations)) for d in derivations: if d.present and d.invertibility is Invertibility.HIGH: if not d.expiry_bounded: # WAL segment not yet rotated, live ANN entry, unredacted summary. att.blocking = True raise ForgetComplianceError( f"record {record_id!r}: HIGH-invertibility derivation present " f"in {d.media.value} with no bounded expiry; " f"forget cannot be attested until compaction completes" ) # Present but under a monitored, bounded retention policy. # Attestation must record this as deferred, not as deleted. att.blocking = True return att def assert_attestable(att: ClosureAttestation) -> None: if att.blocking: raise ForgetComplianceError( f"record {att.record_id!r}: attestation is deferred, not final; " f"do not emit a boolean 'deleted' claim" ) for d in att.derivations: if d.present and not d.expiry_bounded: raise ForgetComplianceError( f"record {att.record_id!r}: {d.media.value} still present, " f"unbounded; closure invariant violated" ) ```