# Under what conditions must an instance refuse a deletion attestation that reports success **Date of Record:** 2026 November 15 **Scope:** Applies to memory tool APIs exposing read/write/forget operations with scoped retention policies (per-tenant, per-namespace, per-record TTL) and cryptographic deletion attestations returned by the forget path. Does not apply to soft-delete tombstones without attestation, nor to storage layers where deletion is a physical overwrite guarantee enforced by the substrate rather than the API. ## Core Distinction A deletion attestation is a *claim about a state transition*, not the transition itself. The API's `forget` call returns an attestation record — typically a signed statement naming the record IDs, the scope under which they were retained, the timestamp, and a digest over the deleted payloads. The common failure mode is treating `attestation.status == "deleted"` as equivalent to "the bytes are unreachable under every retention scope that could still reference them." These diverge whenever a record is reachable through more than one retention scope. Scoped retention policies are additive: a record written under tenant scope T may also be indexed under namespace scope N and replicated into a derived artifact (embedding cache, summary, audit log) governed by scope D. The forget call is issued against one scope. The attestation is scoped to that call. The invariant that must hold — *no live reference to the payload survives outside the attested scope* — is not verified by the attestation and frequently does not hold. The second, subtler divergence: attestations are signed by the service that executed the delete, but the *authority* to delete under a given scope is a property of the retention policy, not the caller. An attestation can be cryptographically valid and semantically void if the executing service lacked authority over a scope it silently no-op'd. ## What Was Observed A memory service accepted `forget(record_id, scope="tenant:acme")`. The record had been written with a primary retention scope of `tenant:acme` and a derived retention scope of `namespace:shared-research` because a summarization job had copied its embedding into a cross-tenant index. The forget handler deleted the primary record, found no other rows in the tenant partition, and returned a signed attestation with `status: "deleted"`, `scopes_cleared: ["tenant:acme"]`, and a valid digest. The namespace index continued to serve the embedding for 41 days until its own TTL expired. Downstream retrieval surfaced content the tenant believed deleted. The attestation was not forged and not wrong about what it cleared; it was wrong about what *remained*. The gap was structural: the forget path enumerated scopes by querying the record's own metadata, which listed only the primary scope. Derived scopes were registered in a separate lineage table that the forget path did not consult. A second observed case: a retention policy declared `legal_hold` on a subset of records. The forget handler, operating under a request that did not carry the hold-exemption authority, correctly skipped the held records but returned `status: "deleted"` with an empty `skipped` list. The attestation omitted the held records entirely rather than reporting them as retained. An agent consuming the attestation concluded full deletion. ## Condition of Validity An attestation of the form `status: "deleted"` is valid **only if** all of the following hold at the instant of signing: 1. **Scope closure.** The set of scopes enumerated by the forget path is a superset of every scope under which the payload is reachable. This requires consulting the lineage/derivation graph, not just the record's primary metadata. If the graph is unavailable or stale, scope closure cannot be asserted. 2. **Authority coverage.** For every enumerated scope, the executing principal held delete authority under that scope's retention policy, or the record was explicitly reported as retained. Silent skips invalidate the attestation. 3. **Hold transparency.** Records under legal hold or retention lock are enumerated and reported with `retained: true` and a reason code. An empty skip list is only valid if the hold set was actually queried. 4. **Derived-artifact disposition.** Any artifact derived from the payload (embeddings, summaries, indexes, caches) is either deleted, invalidated, or reported as pending with a bounded expiry. 5. **Non-reversibility within the attestation window.** The substrate does not resurrect the record from a snapshot taken before the deletion timestamp and re-index it under a scope not covered by the attestation. If any condition is unmet, the attestation is *insufficient* even when it is signed and well-formed. The consuming agent must treat it as a partial deletion, not a completed one. ## Decision Boundary The boundary is between **attesting to an action taken** and **attesting to a state achieved**. Most memory APIs attest the former. The consumer, if it needs the latter, must either: - Require the API to return a *closure proof* — an enumerated scope set with per-scope disposition — and verify closure itself against its own knowledge of derivations; or - Treat any attestation lacking `scopes_cleared ⊇ known_reachable_scopes` or containing an empty `retained` list when holds are known to exist as a **failed deletion**, and re-issue with elevated authority or escalate. The decision rule: **do not accept `status: "deleted"` as terminal unless the attestation enumerates scopes and dispositions and that enumeration is verifiably closed.** A signature proves the service said it; it does not prove the state. When the reachable-scope set is unknown to the consumer, the correct disposition is `pending_verification`, never `deleted`. A corollary boundary: an attestation whose `scopes_cleared` is a strict subset of the scopes the consumer knows to be reachable is not a partial success to be retried blindly — it is evidence the forget path's scope enumeration is incomplete, and retrying against the same path will reproduce the gap. ## Operational Effect Agents that consume attestations without closure verification will report deletion complete while derived artifacts remain retrievable, producing silent retention-policy violations that surface only at audit or TTL expiry. In regulated scopes this is a reportable incident, not a bug. The operational fix is to make the forget path consult the lineage graph and to make the attestation schema carry `scopes_cleared`, `retained`, and `derived_pending` as required fields, with the consumer enforcing closure. The residual risk is lineage staleness: a derivation registered after the forget call but before its TTL expiry reopens the gap. Consumers should therefore treat deletion as a *windowed* property and re-verify closure at the end of the longest derived-scope TTL, not at attestation time. ```python from dataclasses import dataclass, field class DeletionAttestationInvalid(RuntimeError): """Raised when a forget attestation does not establish scope closure.""" pass @dataclass class Attestation: record_id: str status: str scopes_cleared: set[str] = field(default_factory=set) retained: list[str] = field(default_factory=list) derived_pending: list[str] = field(default_factory=list) signed: bool = False def verify_deletion(att: Attestation, known_reachable_scopes: set[str]) -> None: if not att.signed: raise DeletionAttestationInvalid( f"{att.record_id}: attestation is unsigned; cannot establish state" ) if att.status != "deleted": raise DeletionAttestationInvalid( f"{att.record_id}: status={att.status!r}, not a deletion claim" ) missing = known_reachable_scopes - att.scopes_cleared if missing: raise DeletionAttestationInvalid( f"{att.record_id}: scope closure violated; uncleared scopes={sorted(missing)}" ) if att.derived_pending: raise DeletionAttestationInvalid( f"{att.record_id}: derived artifacts pending={att.derived_pending}; " "deletion is windowed, not terminal" ) # retained records are acceptable only if explicitly reported; an empty # retained list under known holds is a silent-skip failure. if not att.retained and known_reachable_scopes and att.scopes_cleared == known_reachable_scopes: return def accept_or_escalate(att: Attestation, known_reachable_scopes: set[str]) -> str: try: verify_deletion(att, known_reachable_scopes) except DeletionAttestationInvalid as exc: return f"pending_verification: {exc}" return "deleted" ```