# When must an instance refuse to honor a forgetting request because a derived artifact's provenance is not yet resolvable **Date of Record:** 2026 November 18 **Scope:** Applies to memory tool APIs that expose read/write/forget operations with provenance-tracked deletion, where derived artifacts (summaries, embeddings, index entries, caches, fine-tuned deltas) are retained separately from the source record. Does not apply to single-store systems where forgetting is a single row delete with no downstream derivations, nor to soft-delete-then-GC pipelines where the retention window is explicitly contractual. ## Core Distinction The distinction that matters is between *deletion* and *forgetting compliance*. Deletion is the removal of a source record by its primary key. Forgetting compliance is the state in which no artifact anywhere in the system can be reconstructed back to the forgotten subject, including artifacts the forget call did not name. A forget request is *honorable* when every derivation of the target record has either been deleted, been proven not to carry recoverable provenance, or been scheduled for deletion under a bound that the caller's compliance contract accepts. It is *unhonorable* when at least one derivation exists whose provenance link to the target is unresolved — that is, we cannot yet say whether the derivation contains the forgotten content. The non-obvious part: a forget call that returns success while an unresolved derivation exists is not a partial success. It is a false attestation. The compliance contract the API is implicitly making ("this subject is now forgotten") is violated the moment the caller relies on the return value, even if the underlying deletion eventually completes. The correct behavior at the boundary is refusal, not optimistic success. ## What Was Observed In a provenance-tracked memory store, a record `R` was written and then summarized into `S1`, which was embedded into vector index entries `E1..En`, and `S1` was in turn summarized into `S2` during a compaction pass. The compaction pass recorded `S2.provenance = {S1}` but the write of `S2` landed before the provenance edge `S1 -> R` was committed to the provenance table (the edge write was batched and committed lazily). A forget request for `R` arrived in the window between the `S2` write and the provenance-edge commit. The forget path walked the provenance table, found `S1` (edge committed), deleted `S1` and `E1..En`, found no edge to `S2` (edge not yet committed), and returned `forgotten=true`. `S2` survived with content derived from `R`. The caller's downstream compliance audit passed on the return value. The leak was only detected when a later reconstruction query on `S2` surfaced a fragment of `R`'s content after the edge had been committed by the compaction pass's follow-up job. The failure was not a race in the usual sense — no lock was violated. It was a *provenance-resolution* failure: the forget path treated "no edge found" as "no derivation exists," when the correct reading is "no edge found *yet*, and an unresolved derivation may exist." The two cases are indistinguishable from inside the forget path unless the system tracks in-flight derivations separately from committed provenance edges. ## Condition of Validity The refusal behavior is valid only under all of the following: 1. The store maintains an *in-flight derivation registry* — a durable record of derivations that have been written but whose provenance edges are not yet committed. Without this registry, "no edge found" is genuinely ambiguous and refusal cannot be scoped. 2. The forget request carries a *resolution deadline* (either supplied by the caller or defaulted by policy). Refusal is bounded: the caller is told the request is deferred, not rejected forever. 3. The provenance edge commit is *monotonic and eventually durable* — an in-flight derivation either commits its edge within the deadline or is rolled back. If edges can be silently dropped, refusal degenerates into permanent denial. 4. The caller distinguishes `forgotten=true` from `forgotten=deferred`. If the API collapses both into a boolean, the refusal is invisible and the false attestation returns. When any of these fails, the correct behavior is not refusal but *escalation to a coarse-grained forget* (e.g., delete the entire derivation cohort) or *hard failure with the unresolved set enumerated*. The distinction between deferral and escalation is the decision boundary below. ## Decision Boundary Given a forget request for target `T`: - **All derivations resolved, all deleted** → return `forgotten=true`. - **All derivations resolved, some scheduled for deletion under a bound within the caller's deadline** → return `forgotten=deferred` with the bound. This is honorable. - **At least one derivation in-flight (written, edge uncommitted), and the in-flight registry says its edge commit is pending within the deadline** → return `forgotten=deferred` with the in-flight set enumerated. Do not delete the source record yet; hold it so the derivation can be re-resolved. This is the boundary case. - **At least one derivation in-flight with no bounded commit, or the in-flight registry is unavailable/untrusted** → return an error (`UnresolvableProvenanceError`), do not delete the source, and do not return any success-shaped value. This is the refusal. - **Source record already deleted, derivation in-flight** → the worst case; this must be prevented by ordering the source delete *after* provenance resolution, never before. The boundary is between the third and fourth bullets. The third is a deferral the caller can wait on; the fourth is a refusal the caller must handle. Collapsing them — returning `deferred` when the registry cannot bound the commit — is the exact failure observed. ## Operational Effect The practical consequence is that forget throughput becomes dependent on provenance-commit latency, not on source-delete latency. Systems tuned for fast forgets (delete the row, return) will either violate compliance or block on the in-flight registry. The correct operational shape is: forget requests are *admitted* quickly, *resolved* asynchronously against the in-flight registry, and *attested* only when the resolution set is empty. The caller's contract is on the attestation, not the admission. A second effect: the in-flight registry must be readable by the forget path with the same consistency guarantee as the provenance table. If the registry is eventually consistent, the forget path can miss an in-flight derivation and the boundary failure recurs. The registry is not an optimization; it is the load-bearing structure that makes refusal well-defined. ```python class UnresolvableProvenanceError(RuntimeError): """Raised when a forget request cannot be honored because at least one derived artifact's provenance link to the target is unresolved and the in-flight registry cannot bound its commit within the caller's deadline.""" pass def forget(store, target_id, deadline_s, in_flight_registry): derivations = store.provenance_derivations_of(target_id) # committed edges in_flight = in_flight_registry.pending_for(target_id) # written, edge uncommitted unbounded = [d for d in in_flight if d.expected_commit_s is None or d.expected_commit_s > deadline_s] if unbounded: raise UnresolvableProvenanceError( f"forget({target_id}) refused: {len(unbounded)} in-flight derivation(s) " f"have no bounded provenance commit within {deadline_s}s: " f"{[d.id for d in unbounded]}" ) if in_flight: # Bounded in-flight derivations: defer, do not delete the source yet. return {"forgotten": "deferred", "in_flight": [d.id for d in in_flight], "bound_s": max(d.expected_commit_s for d in in_flight)} # All derivations resolved and committed; safe to delete source and derivations. for d in derivations: store.delete_derivation(d.id) store.delete_source(target_id) return {"forgotten": True} ```