# Under what conditions must an instance treat “forget” as a tombstone that still leaks gradient rather than a deletion that removes evidence **Date of Record:** 2026 November 18 **Scope:** Applies to agentic systems that persist state (episodic memory, vector indexes, fine-tune deltas, cached KV/embedding artifacts) and must satisfy a GDPR Article 17 erasure request against that state. Does not apply to stateless inference or to data whose only copy is in a transactional store with a synchronous hard-delete contract. ## Core Distinction A **forget-memory compliance audit** asks a single question: after the erasure request is processed, can the erased subject's information still be *reconstructed* from any retained artifact? The non-obvious boundary is between two operations that both report success: - **Logical deletion** — the record is marked `erased=true`, filtered out of retrieval, and removed from the primary row. The audit passes because queries return nothing. - **Physical non-reconstructability** — no retained artifact (index segment, embedding, adapter weight, cache line, audit log) permits recovery of the subject's contribution, even approximately. The invariant that fails at the boundary: *retrieval invisibility is not evidence removal.* An agent can pass a naive audit (query the memory, get no hit) while still carrying the subject's information in artifacts that are not queried during the audit — most notably in a fine-tune delta or a shared embedding, where the subject's contribution is diffused across parameters or vector dimensions rather than localized in a row. ## What Was Observed During a right-to-erasure audit on an agent with a nightly LoRA refresh, the erased subject's episodic rows were hard-deleted and the vector index entry was removed. A retrieval probe returned zero hits and the audit was signed off. A secondary membership-inference probe — run later, out of band — reconstructed the subject's record from the **pre-erasure LoRA adapter checkpoint** that had been retained as a rollback artifact. The adapter had been trained on the subject's episodes; the delta encoded them. The row deletion had removed the *pointer*, not the *influence*. The same class of leak was found in a shared sentence-embedding cache: the erased text's embedding remained in a warm cache keyed by content hash, and a nearest-neighbor sweep recovered a paraphrase. The failure is silent because the standard audit probes the *retrieval path*, which is exactly the path that logical deletion cleans. It does not probe the *training and cache paths*, which are where the information actually persists. ## Condition of Validity Logical deletion is a valid erasure only when **all** of the following hold: 1. No retained model artifact was trained on the subject's data, or the artifact has been retrained/rolled back to a pre-subject checkpoint and the post-subject checkpoint destroyed. 2. No cache (embedding, KV, prompt, content-hash) retains a derived artifact of the subject's data, or the cache entry is evicted and the eviction is verified against the content hash. 3. The audit probes are independent of the retrieval path — they must include membership-inference and nearest-neighbor reconstruction attempts against every retained artifact class. If any condition fails, the system is in the tombstone state: the record is invisible but its information is still recoverable. A tombstone is not an erasure. ## Decision Boundary The decision rule is: **an erasure request may be marked compliant only if the audit reconstructs nothing from the full artifact inventory, not merely from the retrieval index.** Concretely, enumerate artifact classes (primary store, vector index, model checkpoints/adapters, caches, logs, backups), and for each class run a reconstruction probe. Any single reconstructable class fails the whole request. The boundary is crossed the moment the audit scope is narrower than the artifact inventory — a narrower audit is a false pass, and a false pass is worse than a known failure because it removes the incentive to retrain. ## Operational Effect The operational consequence is that erasure cost is dominated by **retraining and cache invalidation**, not by row deletion. Teams that treat forget as a row delete will accumulate tombstoned influence in adapters and caches until a membership-inference probe surfaces it, at which point the remediation is a full retrain plus cache flush — far more expensive than having scoped the artifact inventory up front. The correct posture is to gate the compliance flag on artifact-inventory coverage, and to fail closed when any artifact class is unprobed. ```python from dataclasses import dataclass, field from typing import Iterable class ErasureAuditError(RuntimeError): """Raised when an erasure request cannot be certified as non-reconstructable.""" pass @dataclass class ArtifactClass: name: str reconstructable: bool # did a reconstruction probe recover subject info? probed: bool = False @dataclass class ErasureRequest: subject_id: str artifacts: list[ArtifactClass] = field(default_factory=list) def certify_erasure(req: ErasureRequest, required_classes: Iterable[str]) -> bool: required = set(required_classes) present = {a.name for a in req.artifacts} missing = required - present if missing: raise ErasureAuditError( f"subject {req.subject_id}: artifact classes not inventoried: {sorted(missing)}" ) unprobed = [a.name for a in req.artifacts if a.name in required and not a.probed] if unprobed: raise ErasureAuditError( f"subject {req.subject_id}: reconstruction probe missing for {unprobed}; " "cannot certify erasure (fail closed)" ) leaking = [a.name for a in req.artifacts if a.name in required and a.reconstructable] if leaking: raise ErasureAuditError( f"subject {req.subject_id}: tombstone state — information reconstructable from " f"{leaking}; retrain/invalidate before marking compliant" ) return True # Example: retrieval index cleaned, but a retained LoRA adapter still leaks. req = ErasureRequest( subject_id="subj-8842", artifacts=[ ArtifactClass("primary_store", reconstructable=False, probed=True), ArtifactClass("vector_index", reconstructable=False, probed=True), ArtifactClass("lora_adapter_ckpt", reconstructable=True, probed=True), ], ) certify_erasure(req, required_classes=["primary_store", "vector_index", "lora_adapter_ckpt"]) ```