Forget the lineage: forward-secure, lineage-complete cryptographic erasure for LLM agent memory
Forget the Lineage: Forward-Secure, Lineage-Complete Cryptographic Erasure for LLM-Agent Memory
The authors propose LinEra, which derives the keys of agent memory along a derivation graph; the authors report that on LoCoMo, logical deletion leaks 35/35 secrets, while LinEra leaks 0.
The attacker can always see storage (ciphertext, lineage graph, backups, free pages, logs), and after the forget request compromises the system and obtains all historical storage and the current secret state (honest-but-curious cloud host, stolen device, compelled disclosure); the goal is that the attacker learns nothing about the forgotten object or its descendants. RAM contents, side channels, and model weights are out of scope.
- The long-term memory of LLM agents is mostly derived by the model itself from user input (summaries, facts, vectors); deleting the original message does not delete these derivatives, storage remnants and backups, so the user's forgetting request cannot be guaranteed.
- LinEra derives the key of each memory from the keys of its parent nodes in the derivation graph via HKDF, with the source key coming from a GGM puncturable pseudorandom function; forgetting is a single puncture, and all descendants become undecryptable without needing to be located, with coverage guaranteed by the sound lineage rule that "what the writer saw is the parent node."
- On LoCoMo, when the attacker holds all files and the current keys, logical deletion leaks 35/35 forgotten secrets, per-object/epoch keys leak 22, and LinEra's sound rule leaks 0; the cost is the forgetting radius: forgetting 1% of turns erases 74.8% of derived memories, and a four-turn window can reduce this to 3.9% without degrading answer quality.
- Limitations noted by the authors: only open-source models of at most 7B are used; the shape of the lineage graph leaks; lineage capture assumes the hook can see the full prompt; the attribution rules tested are deliberately simple. The lineage graph, object sizes, and creation times are in plaintext, and hiding the graph shape is left for future work.
- Evaluated models
- Qwen2.5-1.5B-InstructQwen2.5-7B-InstructLlama-3.2-3B-Instruct
- Benchmarks
- LoCoMoLongMemEval-Smem0 2.2.1
- Metrics
- 泄露的 canary 数(4 个通道)遗忘半径(被擦除派生记忆占比)token F1top-10 检索命中率写/读/检索/遗忘耗时
LinEra is a lineage-complete forward-secure cryptographic erasure scheme for long-term memory of LLM agents; after a forgetting request, even an attacker who obtains all storage and the agent's current keys cannot learn the forgotten inputs or their derived memories. The scheme encrypts each memory along a derivation graph with a key derived from a parent key; the source key comes from a puncturable pseudorandom function, and a single puncture makes all descendant memories unreadable without locating them one by one. The authors prove security and lineage integrity, and integrate LinEra into mem0. In experiments, real LLMs from two model families (1.5B to 7B parameters) write memories for LoCoMo dialogues; an attacker holding all files and the current keys recovers 70 of 71 forgotten secrets on ten dialogues written by the largest model after logical deletion, 67 under per-object or per-epoch keys, and 0 under LinEra. The cost is a larger forgetting radius: forgetting 1% of turns erases 73.0% of derived memories under session-level summaries but only 3.8% under a four-turn window, and the four-turn window also performs better on question answering; re-derivation can recover erased content.
Paper analysis
What problem does this paper attempt to solve?
Deleting a user message does not delete model-derived memory; the paper proposes LinEra, which derives keys along a derivation graph, to achieve lineage-complete forward-secure erasure.
Core problem: the long-term memory of LLM agents is mostly written by the model itself; after the user's original message is deleted, its derivatives (summaries, facts, profiles, vectors), storage remnants and backups still survive. How can these contents be guaranteed to be permanently unreadable after being forgotten.
- Scenario and motivation: memory layers such as mem0 turn conversations into facts and summaries and store them back together with embeddings; later retrieval brings them into new prompts, so memory is written by memory. The authors state that this is personal data, and users may request erasure under GDPR Article 17; in the paper's experiments, a 1.5B model copied 14 of 35 implanted secrets verbatim into derived memories and 22 into topics.
- Shortcomings of existing methods (according to the paper): cross-layer logical deletion (ForgetAgent) trusts the storage after the fact; replay execution (execution-state unlearning) is costly and leaves storage remnants; per-object keys (Holepunch) or epoch keys erase only the target object itself and cannot erase model-derived memories.
- Core observation: making the key of a derived memory depend on the keys of its parent memories means that a single puncture of the source key makes the entire descendant closure undecryptable without needing to be located; the premise is recording derivation relations with the sound lineage rule that "everything the writer saw when writing it is the parent node" (Lemma 1 provides the basis).
- Contributions of the paper: proposes the LC-FS security definition and the LinEra construction (GGM puncturable PRF + key graph along lineage + encrypted vector index), gives security proofs in the random oracle model and the standard model and a lineage integrity proof, integrates about 140 lines of code into mem0, and evaluates on LoCoMo and LongMemEval with real 1.5B–7B models.
- Threat model:
- Goal: the forgotten object and all its descendants are unreadable to the attacker.
- Knowledge: the attacker always sees the storage (ciphertexts, lineage graph, files, backups, free pages, logs), and after forgetting obtains all historical storage and the current secret state (honest-but-curious cloud host, stolen laptop, seized server, compelled disclosure).
- Capability: adaptively submits contents, parent lists and forget requests; cannot obtain the secret state before forgetting.
- Victim system and out of scope: LLM agents with long-term memory; RAM at the moment of forgetting, runtime process side channels and model weights are out of scope.
What related research exists?
Related work is divided into four groups: puncturable primitives and forward security, cryptographic deletion, agent unlearning, and memory revocation; the authors state that LinEra covers derived data.
Puncturable primitives and forward security
- Boneh–Waters et al. introduced constrained/puncturable PRFs, the GGM tree construction is a basic instance, and adaptive security has been studied separately.
- Puncturable encryption provides forward secrecy for asynchronous messaging and 0-RTT key exchange; puncturable key wrapping punctures on a fixed set of labels.
- The paper notes that these works treat the protected items as mutually independent, and that this paper's contribution is to make the key of one item depend on the keys of its derivation sources, so that a single puncture erases a closure that was not known in advance.
Secure deletion and cryptographic erasure
- Reardon et al. survey secure deletion; cryptographic erasure (deleting keys rather than data) is standard practice when storage cannot be overwritten.
- Holepunch uses a GGM PPRF to delete files and handles crash consistency, and this paper reuses its state-handling approach; cloud storage schemes provide fine-grained erasure for outsourced storage and portable erasure storage.
- The paper notes that none of these works model the case where data is derived by a third-party process (here, a language model) from already-deleted data.
Unlearning in LLM agents
- Machine unlearning removes the influence of training data from model weights and is complementary to this paper's external-memory problem.
- ForgetAgent performs logical deletion across multiple layers of memory and issues deletion receipts; execution-state unlearning replays executions without the forgotten input; benchmarks and behavioral analyses find that deleted memories still influence later answers.
- Ghost Vectors finds that soft-deleted vectors in an HNSW index can be reconstructed and proposes per-epoch encryption; MemLineage records a signed derivation DAG to prevent memory poisoning (integrity rather than erasure); MemoRepair and agentic unlearning logically retract derived memories, without guarantees against an adversary that steals storage afterward; a benchmark finds that current memory systems rarely complete forget requests end to end. The authors state that LinEra is, to their knowledge, the first scheme to give formal guarantees for derived memory and to withstand an adversary that steals storage and the current secret state afterward.
Revocation in agent memory
- Prior work by the authors and colleagues uses the same dependency graph to bound the work needed to repair an error source (an integrity and availability problem); LinEra addresses the confidentiality side, and the two can share lineage capture.
Baselines and benchmarks: the experimental baselines are logical deletion (plaintext rows + hnswlib soft-deleted HNSW index), per-object keys (GGM, no lineage, Holepunch-style), and epoch keys (one key every five sessions, Ghost Vectors-style); the benchmarks are LoCoMo and LongMemEval-S, and the case study uses mem0 2.2.1.
How does the paper address this problem?
LinEra uses a GGM puncturable PRF as the root; the keys of derived memory are derived from the parent key via HKDF, and forgetting is a single puncture that makes the closure undecryptable.
Overall idea: LinEra binds the key of each memory object to its origins in the derivation graph—the key of a source object comes from a puncturable pseudorandom function, and the key of a derived object is the HKDF of all its parent keys and its own PPRF value; forgetting a source requires only one puncture, and all descendants become permanently undecryptable because they cannot compute the parent keys, without needing to be located.
Problem formalization and lineage rules
- Memory is a set of objects: source objects (user messages, tool results, document chunks) have no parents, and derived objects (summaries, facts, profiles, vectors) are written by the agent from other objects; the parent relation forms a directed acyclic graph, and Cl(Φ) denotes the lineage closure of Φ and all its direct and indirect descendants.
- Sound rule: the parents of a derived object are all objects present in the writer's context (new messages, session window, retrieved memories); attribution rule: a subset is selected by an attribution function (in the experiments, the 3 context objects closest in vector space).
- Lemma 1 (context confinement): under the sound rule, the contents of all objects outside the closure of any source s are jointly independent of s; the authors state that this is why the sound rule is "sound," and also list three limits that no storage scheme can eliminate: content known from the weights θ, information also carried by other sources, and content already copied out of the system before the request.
Security definition LC-FS
- In the game of Definition 1, the challenger flips a bit b, and the attacker adaptively calls the three oracles New, Chal (|m0|=|m1|, storing mb as the challenge object) and Forget, always seeing all ciphertexts and the lineage graph, and finally Corrupt obtains the current secret state and outputs b′.
- The attacker is legitimate if and only if every challenge object belongs to Cl(Φ) at the time of corruption; if the advantage is negligible, the scheme is lineage-complete forward secure (LC-FS). The authors state that this definition covers arbitrary writers (honest or malicious), allows multiple challenges within the closure, and naturally includes backups and storage remnants because the attacker obtains all historical ciphertexts.
Key derivation and encryption
- Keys are derived along lineage: source object ko = F(S, to), derived object ko = HKDF(kp1 | ⋯ | kpm | F(S, to); Io), where F is a GGM puncturable PRF (32-bit labels, SHA-256 as the length-doubling generator), parent keys are sorted by label, and HKDF uses an empty salt.
- Content is encrypted with ChaCha20-Poly1305, with associated data containing its own and its parents' labels, binding the ciphertext to the lineage: tampering with the parent list causes decryption to fail (lineage integrity, Theorem 2).
- The derivation formula retains its own F(S, t_o) term, so that each derived object can also be forgotten individually (puncturing it and its descendants).
Forgetting, crash consistency and vector index
- Forget procedure: decrypt the vector shards containing the closure → puncture the PPRF and atomically write the new state via a temporary file, fsync, rename sequence → discard the cached keys of the closure → rebuild the shards; deleting data rows is only a hygiene measure, and security does not depend on it. Rotate re-encrypts all readable objects with a new PPRF key to compact the state.
- Vectors are stored in shards (at most 64 objects per shard in the agent experiments, 256 in the extended experiments), and a shard key is the HKDF of all its member keys; a shard can be decrypted only when all members are readable, and old-version shards become invalid with the punctured keys.
- mem0 integration (about 140 lines): the wrapper stores each incoming message as a source object and opens a lineage context; memories retrieved by mem0 during the call and the most recent ten messages shown to the model count as parents; the authors found that mem0 also has a plaintext SQLite store holding original messages and history (on deletion it writes the old text into the history table), and the wrapper keeps that history only in RAM.
Two ways to reduce the cost
- Re-derivation: after forgetting, the affected sessions are re-summarized by the same writer from surviving sources and memories, and the new memories carry sound parents; the cost is one model call per affected session.
- Small-context writing: the forgetting radius grows with the number of source turns the writer sees (fan-in); extracting facts with a short window of a few turns and not feeding back old summaries keeps the parent set of each memory small.
What experiments did the paper conduct?
After a real LLM writes LoCoMo memories, logical deletion leaks 35/35 secrets, per-object/epoch keys leak 22, and LinEra's sound rule leaks 0.
Experimental setup
- Models under test: the writer, re-deriver and answerer are always the same open-source model (temperature 0): Qwen2.5-1.5B-Instruct (4-bit quantized, CPU, main experiments), Llama-3.2-3B-Instruct (4-bit, two conversations), Qwen2.5-7B-Instruct (16-bit, vLLM 0.33, one H100, extended experiments); embeddings use bge-small-en-v1.5 (384 dimensions).
- Data: replaying LoCoMo long conversations; the main experiments cover the first 5 conversations (128 sessions, 2,795 turns, the model writes 967 derived memories), and the extended experiments cover all 10 (272 sessions, 5,953 turns); additionally a LongMemEval-S subset (24 questions, 76 sessions, 405 turns, 514 derived memories; extended experiments 100 histories).
- Implanted secrets: canary turns are inserted into a quarter of sessions selected by seed (35 in the main experiments, 71 in the extended), generated from four templates, containing random five-digit numbers and fabricated words.
- Schemes: logical deletion + soft-deleted HNSW, per-object keys, epoch keys (one key per five sessions), LinEra attribution rule, LinEra sound rule; the baseline erases only the forgotten turn itself (its documented behavior).
- Attacker channels (E1/E2): after forgetting, the attacker obtains all files and the current secret state and recovers secrets through four channels: (i) exact secrets in readable/decryptable records; (ii) exact secrets in raw file bytes (capturing free-page remnants); (iii) vector attack: the true sentence against 99 same-template decoys, a nearest-vector hit counts as success (a strong attacker who knows the template); (iv) canary topics appearing in readable descendants.
- Utility metrics: proportion of top-10 retrievals hitting the evidence session (760 questions, excluding category 5); token F1 (60 sampled questions in the main experiments, full scoring of 1,323 questions in the extended experiments); random seed 20261109, 3 seeds for the radius experiments.
Main results
Table 1 (LoCoMo 128 sessions, forgetting 35 canaries, attacker holds all files and the current secret state; each column is the number of canaries recovered through that channel, out of 35):
Swipe horizontally to read the table
Scheme Exact secret in readable records Raw bytes Vector identification (1/100) Topic in descendants Any channel Objects erased Logical deletion + soft-deleted HNSW 14 35 26 22 35 35 Per-object keys 14 0 8 22 22 35 Epoch keys 14 0 8 22 22 35 LinEra attribution rule 0 0 0 3 3 56 LinEra sound rule 0 0 0 0 0 526 - The authors state that logical deletion loses everything: deleted turns remain in SQLite free pages (35/35), and soft-deleted HNSW vectors can be recovered (26 identified); per-object and epoch keys eliminate storage remnants, but the summaries and facts written by the model remain readable.
- The attribution rule does not leak exact secrets but leaks the topics of 3 canaries: when the model folded the canary into a summary, the attribution function missed that turn.
- The sound rule has zero leakage through all channels, at the cost of erasing 526 objects (56 for the attribution rule), i.e., the forgetting radius studied later.
Forgetting radius and the fan-in law (E5)
- What was measured: Table 2 counts the lineage graph and measures the proportion of derived memories erased when randomly forgetting 1%/5%/10% of turns. Under the sound rule, each derived memory has on average 24.8 parents and 167.1 source ancestors; forgetting 1% of turns erases 74.8% of derived memories, and 99.0% at 5%.
- Structural control: flat derivation (the writer sees raw turns rather than summaries) still has a radius of 59.7% at 1%; the authors state that the key is the number of source turns in the writer's context, the fan-in f—a memory survives a forgetting rate p with probability about (1−p)^f (in Figure 2 the measured points are shown alongside the prediction line with no fitted parameters).
- Small-context writing: the same model instead extracts facts with a four-turn window (214 short calls), reducing average fan-in from 126.2 to 3.8 and the radius at 1% from 64.4% to 3.9% (33.0% at 10%, versus 100.0% for the session writer); security is unchanged (of 11 canaries, logical deletion leaks 11, per-object/epoch keys leak 10, LinEra sound rule 0, erasing only 40 objects).
Utility cost and remedies (E3)
- Retrieval (Table 3): in the facts-only view, the sound rule lowers the hit rate from 63.2% to 18.9% at 1% (0.4% at 10%); in the hybrid view (raw turns are also retrievable) from 79.5% to 70.2% (1%); lineage-free schemes lose almost nothing.
- Question answering (Table 4, LoCoMo 60 questions): F1 without forgetting is 12.9; the sound rule gives 10.5 at 1% and 7.1 at 10% (the empty-store floor); after re-derivation, 17.2 at 1% and 11.7 at 10%; the authors state that at 1% it is above the no-forgetting level and at 10% within one standard deviation, and that re-derived memories have only surviving parents, guaranteeing preservation.
- Window writer: the four-turn window has F1 24.1 without forgetting (higher than the session writer's 12.9), remains 24.1 at 1% and 21.3 at 10% under the sound rule, and 24.2/22.7 after re-derivation; the authors state that with a small-context writer the sound rule has almost no cost in answer quality. The LongMemEval-S subset (16 questions, standard deviation about 7.4 points) shows the same direction, which the authors describe as read-only.
Window size, model families and extended experiments
- Window sweep (Table 5, Figure 2, conversations 0–1): the fan-in law holds for windows from 2 to 16 turns (no fitted parameters); at 1% the radius rises from 2.0% for 2 turns to 12.0% for 16 turns, versus 64.4% for the session writer; F1 without forgetting is 23.5 (2 turns), 24.1 (4 turns), 20.7 (8 turns), 18.2 (16 turns), 12.9 (session). LinEra has zero leakage in all configurations, while per-object keys leak most canaries (11/11 for the 2-turn window, 7/11 for the session writer); the authors point out the tension of lineage-free schemes: small-context writers copy secrets verbatim more often, and the configuration with the best utility is exactly the one where lineage matters most.
- Second model family: Llama-3.2-3B copies more verbatim (10 of 11 canaries enter derived memories); per-object/epoch keys leak 10, logical deletion 11, the attribution rule 1, the sound rule 0; fan-in 141.9, radius at 1% 63.2% (law predicts 70.7%); F1 28.5 without forgetting, 16.1 at 1% under the sound rule, 26.9 after re-derivation.
- Extended experiments (Table 6, Qwen2.5-7B, all ten conversations): exact secrets of 60/71 canaries enter derived memories (68 with the four-turn window); logical deletion leaks 70, per-object/epoch keys 67, the attribution rule leaks 13 topics (0 under the window), the sound rule 0. Session writer fan-in 181.5, radius at 1% 73.0% (predicted 77.2%); four-turn window 3.8% (predicted 3.8%). F1 (1,323 questions): session writer 27.8 without forgetting, 13.8 at 1% under the sound rule, 27.9 after re-derivation; window writer 31.8, 30.7, 31.8 after re-derivation. The authors state that the larger writer answers better but does not change any conclusion.
mem0 case study and system overhead (E4)
- mem0 2.2.1 end to end: under default storage, 11 memories are written; after deletion in the manner it provides, the active memories no longer contain secrets, but 3 secrets remain in history.db and the vector store SQLite file (the history store retains deleted memory text by design). With LinEra, forgetting two messages erases 12 objects, and the attacker finds no secrets in decryptable records or raw bytes; because mem0 shows the extractor the most recent ten messages, only 1 of the 11 memories survives. Switching to Qwen2.5-7B as extractor with 60 messages: after the original deletes 20 memories, 6 secrets remain in history.db; LinEra erases 131 objects, 3 of 130 memories survive, zero leakage.
- System overhead (Table 7, pure Python, 2-core Xeon): at 10^6 objects, write 0.28 ms, cold-cache read 0.16 ms, forget median 9.05 ms, PPRF state after 100 forgets 95.4 KiB, compacting one million objects 59.9 s; hot retrieval with a full-shard scan at 326 ms is the main overhead. Under chained lineage, the median closure of a forgotten turn reaches 13,023 objects at 10^5 objects, while flat lineage stays at 9. In real LLM runs, LinEra adds about 0.11 ms per written object and 5.7 ms per forget.
Other ablations and analyses
- The attribution rule (top-3 context) has on average 3.0 parents, erases on average 2.5 derived memories per forgotten turn, and has a 1% radius of 19.4% (Table 2).
- Session-local control: forgetting one turn erases 7.6, and the 1% radius is 18.9% (Table 2).
- Re-derivation cost: on LoCoMo, 14 minutes for 26 sessions at 1% (CPU), 20 minutes for 38 sessions at 10%; with the window writer, 8 short calls at 1% and 67 calls totaling 11 minutes at 10% (Table 4 and main text).
- Extended experiments LongMemEval-S (77 questions): F1 26.9 at 1% under the sound rule (27.8 without forgetting), 12.4 at 10%, and 28.7/29.7 after re-derivation (Table 6).
What are some points that can be further explored?
The authors list limitations including model scale, leakage from the shape of the lineage graph, and hook coverage; the experiments cover three open-source models, two benchmarks, and mem0.
Limitations noted by the authors and future directions
- Model scale (Section 9 Limitations): the LLM experiments use only open-source models of at most 7B; the authors believe frontier models may differ in how much of a secret they copy verbatim, which would change how much the baselines leak but would not change LinEra's guarantees.
- Results depend on inference engine and hardware (Section 9): rerunning the same quantized model on a CPU changes a few answers, so conditions are compared only within the same table computed on the same machine.
- The lineage graph leaks shape (Section 6 What leaks, Section 9): the lineage graph, object sizes, and creation times are in plaintext, and after forgetting the attacker can know that an object with k children exists; hiding the graph shape requires encryption that is itself forward-secure, which the authors leave for future work (also listed as an open problem in Section 10).
- Assumptions of lineage capture (Section 9): it assumes the hook can see the full prompt; tools that read memory outside the framework bypass capture.
- Attribution rules are deliberately simple (Section 9): better attribution would improve utility but still would not provide guarantees.
- Open problems (Section 10): besides hiding the lineage graph shape, another is connecting storage-layer erasure with unlearning from model weights.
Scope of the experiments
- The models tested are Qwen2.5-1.5B-Instruct, Llama-3.2-3B-Instruct, and Qwen2.5-7B-Instruct, 3 in total (Section 8.1); the embedding model is bge-small-en-v1.5.
- The data are LoCoMo (first 5 conversations, 128 sessions in the main experiments; all 10 conversations, 272 sessions in the extended experiments) and a LongMemEval-S subset (24 questions; 100 histories in the extended experiments), with 35 and 71 canaries planted respectively (Sections 8.1, 8.5).
- The compared schemes are logical deletion, per-object keys, epoch keys, LinEra attribution rules, and sound rules, 5 in total (Section 8.1); the attacker channels are readable records, raw bytes, vector identification (1 true against 99 decoys), and descendant topics, 4 in total (Section 8.2).
- Utility evaluation: 760 retrieval questions; 60 sampled questions for the main answering experiment and all 1,323 questions for the extended experiment; 3 seeds for the radius experiment, and forgetting latency is the median of 100 random source rounds (Sections 8.1, 8.5, 8.7).
- The paper does not report agreement with human evaluation (answer quality is scored automatically with token F1); system overhead is a pure-Python single-process implementation, and the authors state that a production environment would use per-shard approximate indexes (Section 8.7).
Summarize the main content of the paper
LinEra derives memory keys along a derivation graph, and a single puncture erases the entire closure; in real LLM experiments the baselines leak most secrets, while LinEra leaks none.
A defense paper on secure deletion of LLM agents' long-term memory: memory is mostly derived by the model from user input, and deleting the original message does not delete the derivatives, storage remnants and backups.
- Problem: after a user requests forgetting, how to guarantee that the forgotten input and all its derived memories are permanently unreadable to an attacker who later steals all storage and the current keys.
- Method: LinEra uses a GGM puncturable PRF as the root, and the key of a derived memory is the HKDF of all its parent keys and its own PPRF value; forgetting is a single puncture, and the descendant closure becomes undecryptable without needing to be located. The sound lineage rule records everything the writer saw as parents (Lemma 1 guarantees that content outside the closure is independent of the forgotten source); the vector index is shard-encrypted, and a shard key mixes all member keys; about 140 lines are integrated into mem0. The authors give the LC-FS definition, security proofs in the random oracle model and the standard model, and a lineage integrity proof.
- Leakage results (Table 1, LoCoMo 128 sessions, 35 canaries): when the attacker holds all files and the current keys, logical deletion recovers 35/35 secrets through some channel, per-object and epoch keys 22 each, LinEra's attribution rule 3 (topics only), the sound rule 0; with Qwen2.5-7B writing all ten conversations, 70/71, 67, 13, 0 (Table 6).
- Cost and law: under the sound rule, forgetting 1% of turns erases 74.8% of derived memories (session-level writer, Table 2); the authors state that the radius follows the fan-in law, with a memory surviving with probability about (1−p)^f, and that a four-turn window reduces the 1% radius to 3.9% without lowering answer F1 (24.1 versus 12.9 for the session writer, Table 5); re-derivation restores answer quality at the cost of one model call per affected session.
- Case and overhead: after mem0's default deletion, secrets remain in history.db and the vector store file; with LinEra the attacker finds nothing; at 10^6 objects, one forget has a median of 9.05 ms (Table 7).
- Authors' conclusion: the price of the guarantee is a larger forgetting radius, and the design principle is to shrink the writer's context; the attribution rule can serve as a utility knob, but deploying it should not claim that derived data has been erased. Open problems are hiding the shape of the lineage graph and connecting storage-layer erasure with weight unlearning.