# What happens when an instance treats a memory deletion attestation as a durable tombstone rather than a receipt **Date of Record:** 2026 November 17 **Scope:** Applies to memory tool APIs (read/write/forget) where `forget` returns an attestation object and scoped retention is enforced by TTL. Does not apply to systems where deletion is synchronous and the attestation is the authoritative storage state (i.e., where the backend guarantees no further reads can return the deleted value). ## Core Distinction A deletion attestation is a *receipt*: a signed, timestamped assertion that a specific `forget` request was accepted and applied to a specific scope at a specific logical time. It is **not** a tombstone. A tombstone is a negative fact stored in the same read path as the data, such that subsequent reads resolve to "deleted" by construction. These two artifacts are conflated routinely because both are returned by `forget` and both are keyed by the same record identifier. The boundary failure occurs when an agent caches an attestation locally and uses it to *suppress re-reads* of a key it previously forgot. The attestation proves the request was applied at time `t_forget`, but it does not prove that no replica, cache tier, or re-materialization path can produce the value after `t_forget`. Under TTL-scoped retention, a value can legitimately reappear: a write with a longer TTL into an overlapping scope, a replay from a write-ahead log, a re-ingest from a parent scope that was not forgotten, or a resurrection triggered by a dependent record that still references the deleted key. ## What Was Observed A retrieval agent forgot key `user_pref.locale` in scope `session:abc`, received a valid attestation with `applied_at`, and stored the attestation in its own working memory as a tombstone. Two turns later, a different subsystem re-materialized the key from scope `tenant:acme` (which had a 30-day TTL and was never in the forget scope). The agent's local tombstone suppressed the read, so it reported "locale unknown" and fell back to a default. The default was wrong, and the error propagated silently — no exception, no log, because the suppression looked like a legitimate cache hit. The inverse failure also occurred in the same run: the agent treated the attestation as evidence that the value was *gone everywhere*, and issued a re-write of a corrected value. That write collided with the re-materialized record and produced a split-brain in the scope hierarchy, where `session:abc` held the corrected value and `tenant:acme` held the stale one. Reads resolved by scope precedence, so the outcome depended on which scope the reader consulted first. ## Condition of Validity The attestation is sufficient to suppress reads *only* under all of the following: 1. The forget scope is an ancestor of every scope that can produce the key (i.e., the forget cascaded to the maximal scope). 2. No other scope with an overlapping key space has a TTL longer than the attestation's `applied_at`, or the backend guarantees that a longer-TTL write into a sibling scope does not re-materialize the key. 3. The backend's read path consults the deletion log *before* any cache tier, and the attestation carries a monotonic `applied_at` comparable to write timestamps. If any condition fails, the attestation is a receipt only. It certifies the request; it does not certify the absence. ## Decision Boundary The operational rule: **treat an attestation as a tombstone only if the API exposes a `cascades_to` field naming the maximal scope, and only if that maximal scope is the one you actually wanted to forget.** If the API returns a bare attestation with no scope closure, the correct behavior is to re-read the key on the next access and let the backend resolve, not to suppress locally. Suppression is a performance optimization that is only safe when the negative fact is authoritative; otherwise it converts a stale read into a silent wrong answer. A second boundary: never re-write a key after a forget without first confirming the forget's scope closure. A re-write into a narrower scope than the one that re-materialized the key creates a precedence conflict that the backend will not detect. ## Operational Effect Agents that conflate attestation with tombstone exhibit a characteristic failure signature: correct behavior on the first turn after forget, then silent divergence several turns later when a sibling scope re-materializes the key. The divergence is not detected by read-after-write checks because the agent's own tombstone masks the read. Detection requires an out-of-band reconciliation: periodically re-read keys with live attestations and compare against the attestation's `applied_at` and scope closure. If a re-read returns a value with a write timestamp later than `applied_at`, the attestation was a receipt, not a tombstone, and the local suppression must be invalidated. ```python from dataclasses import dataclass from datetime import datetime, timezone class AttestationMisuseError(RuntimeError): """Raised when a deletion attestation is used as a tombstone without scope closure.""" @dataclass(frozen=True) class Attestation: key: str scope: str applied_at: datetime cascades_to: str | None # maximal scope the forget reached, if the API exposes it def may_suppress_read(att: Attestation, read_scope: str, maximal_scope: str) -> bool: """ Return True only if the attestation is a tombstone for read_scope. A receipt is not a tombstone: it certifies the request, not the absence. """ if att.cascades_to is None: raise AttestationMisuseError( f"attestation for {att.key!r} in scope {att.scope!r} has no cascades_to; " "cannot suppress reads — re-read and let the backend resolve" ) if att.cascades_to != maximal_scope: raise AttestationMisuseError( f"attestation for {att.key!r} cascaded only to {att.cascades_to!r}, " f"not the maximal scope {maximal_scope!r}; sibling scopes may re-materialize" ) if read_scope != att.cascades_to and not read_scope.startswith(att.cascades_to + ":"): raise AttestationMisuseError( f"read scope {read_scope!r} is outside forget closure {att.cascades_to!r}" ) return True def reconcile(att: Attestation, reread: dict | None) -> bool: """ Confirm an attestation is still a valid tombstone by re-reading out of band. Returns True if suppression remains valid, False if the attestation was a receipt. """ if reread is None: return True written = reread.get("written_at") if written is None: return True if written > att.applied_at: # A later write re-materialized the key. The attestation was a receipt. return False return True ```