infinitydb 1.0.0 → 1.4.0

package/index.js

@@ -1,330 +1,829 @@
-"use strict";
-
-const crypto = require("crypto");
-
-/**
- * InfinityDB - High-performance Node.js Agent Memory Engine.
- * Implements L0-L6 brain architecture:
- * L0: Raw logs offloaded from LLM context
- * L1: Atomic facts (zero-LLM regex/rule extraction)
- * L2: Causal & temporal graph
- * L3: Dynamic persona with conflict auto-resolution
- * L4: Enterprise policies & SOPs
- * L5: Ebbinghaus forgetting curve decay
- * L6: Cryptographic SHA-256 proof chain
- */
-class InfinityDB {
-  constructor(options = {}) {
-    this.options = options;
-    this.logs = new Map(); // L0: id -> { id, userId, sessionId, raw, ts }
-    this.atoms = new Map(); // L1: id -> { id, userId, fact, category, sourceId, importance, accessCount, ts }
-    this.episodes = new Map(); // L2: id -> { id, userId, cause, effect, relation, sourceId, ts }
-    this.personas = new Map(); // L3: `${userId}:${key}` -> { userId, key, value, confidence, updatedAt, sourceAtomId }
-    this.policies = new Map(); // L4: id -> { id, rule, domain, priority, createdAt }
-    this.proofs = new Map(); // L6: atomId -> { atomId, hash, sourceLogId, rawSnippet, charStart, charEnd, ts }
-    this.legacyMemories = new Map(); // Legacy put/get
-  }
-
-  _sha256(str) {
-    return crypto.createHash("sha256").update(str).digest("hex");
-  }
-
-  // Legacy key-value compatibility
-  put(key, content) {
-    if (!key || !key.trim()) throw new Error("key cannot be empty");
-    if (!content || !content.trim()) throw new Error("content cannot be empty");
-    const mem = { key, content, createdAt: new Date().toISOString() };
-    this.legacyMemories.set(key, mem);
-    this.add(`Memory key ${key}: ${content}`, "legacy");
-    return mem;
-  }
-
-  get(key) {
-    return this.legacyMemories.get(key) || null;
-  }
-
-  delete(key) {
-    return this.legacyMemories.delete(key);
-  }
-
-  // Core L0-L6 API
-  add(conversation, userId = "default", sessionId = null, importance = 0.9) {
-    const now = Date.now() / 1000;
-    const logId = `L0_${this._sha256(conversation + now).slice(0, 16)}`;
-
-    // L0: Store raw
-    this.logs.set(logId, {
-      id: logId,
-      userId,
-      sessionId,
-      raw: conversation,
-      ts: now,
-    });
-
-    // L1: Zero-LLM Deterministic Rule Extraction
-    const patterns = [
-      { regex: /(?:I am|I'm|my name is)\s+([A-Z][a-zA-Z0-9_\-\s]+?)(?:[.,\n]|$)/i, cat: "identity", weight: 0.95 },
-      { regex: /(?:I work as|I am a|my role is)\s+([^.,\n]+)/i, cat: "role", weight: 0.90 },
-      { regex: /(?:I prefer|I like|I love|I use|my preference is)\s+([^.,\n]+)/i, cat: "preference", weight: 0.92 },
-      { regex: /(?:I hate|I dislike|I avoid|never use)\s+([^.,\n]+)/i, cat: "dislike", weight: 0.88 },
-      { regex: /(?:my budget is|budget of|budget:\s*)\s*([$€£¥]?[0-9,]+(?:\s*[kKmMbB])?)/i, cat: "budget", weight: 0.94 },
-      { regex: /(?:I live in|based in|located in)\s+([^.,\n]+)/i, cat: "location", weight: 0.85 },
-      { regex: /(?:our goal is|aiming to|target is|deadline is)\s+([^.,\n]+)/i, cat: "goal", weight: 0.91 },
-      { regex: /(?:must comply with|required to|constraint:\s*)\s+([^.,\n]+)/i, cat: "constraint", weight: 0.95 },
-    ];
-
-    let extractedAny = false;
-    for (const pat of patterns) {
-      let match;
-      const re = new RegExp(pat.regex.source, "gi");
-      while ((match = re.exec(conversation)) !== null) {
-        extractedAny = true;
-        const fact = match[0].trim();
-        const atomId = `L1_${this._sha256(logId + fact).slice(0, 16)}`;
-
-        this.atoms.set(atomId, {
-          id: atomId,
-          userId,
-          fact,
-          category: pat.cat,
-          sourceId: logId,
-          importance: pat.weight,
-          accessCount: 0,
-          ts: now,
-        });
-
-        // L6: Cryptographic Proof Record
-        const proofHash = this._sha256(fact + logId);
-        const snippet = conversation.slice(Math.max(0, match.index - 20), Math.min(conversation.length, match.index + fact.length + 20));
-        this.proofs.set(atomId, {
-          atomId,
-          hash: proofHash,
-          sourceLogId: logId,
-          rawSnippet: snippet,
-          charStart: match.index,
-          charEnd: match.index + fact.length,
-          ts: now,
-        });
-
-        // L3: Persona Auto-Resolution
-        const pKey = `${userId}:${pat.cat}`;
-        const existing = this.personas.get(pKey);
-        if (!existing || now >= existing.updatedAt) {
-          this.personas.set(pKey, {
-            userId,
-            key: pat.cat,
-            value: fact,
-            confidence: pat.weight,
-            updatedAt: now,
-            sourceAtomId: atomId,
-          });
-        }
-      }
-    }
-
-    if (!extractedAny) {
-      const sentences = conversation.split(/[.!?\n]/).map(s => s.trim()).filter(s => s.length > 8);
-      for (const s of sentences.slice(0, 3)) {
-        const atomId = `L1_${this._sha256(logId + s).slice(0, 16)}`;
-        this.atoms.set(atomId, {
-          id: atomId,
-          userId,
-          fact: s,
-          category: "general",
-          sourceId: logId,
-          importance: 0.75,
-          accessCount: 0,
-          ts: now,
-        });
-        this.proofs.set(atomId, {
-          atomId,
-          hash: this._sha256(s + logId),
-          sourceLogId: logId,
-          rawSnippet: s,
-          charStart: 0,
-          charEnd: s.length,
-          ts: now,
-        });
-      }
-    }
-
-    // L2: Causal Episode Extraction
-    const causalRegex = /(.+?)\s+(?:because|since|as a result of|so that)\s+([^.,\n]+)/gi;
-    let cMatch;
-    while ((cMatch = causalRegex.exec(conversation)) !== null) {
-      const effectPart = cMatch[1].trim().slice(-80);
-      const causePart = cMatch[2].trim().slice(0, 80);
-      const epId = `L2_${this._sha256(logId + causePart + effectPart).slice(0, 16)}`;
-      this.episodes.set(epId, {
-        id: epId,
-        userId,
-        cause: causePart,
-        effect: effectPart,
-        relation: "causes",
-        sourceId: logId,
-        ts: now,
-      });
-    }
-
-    return logId;
-  }
-
-  recall(query, options = {}) {
-    const start = performance.now();
-    const n = options.n || 5;
-    const userId = options.userId || null;
-    const now = Date.now() / 1000;
-    const qTerms = (query.toLowerCase().match(/\w+/g) || []).filter(t => t.length > 1);
-
-    const scored = [];
-    for (const [id, atom] of this.atoms.entries()) {
-      if (userId && atom.userId !== userId) continue;
-      const factLower = atom.fact.toLowerCase();
-      let termMatches = 0;
-      for (const term of qTerms) {
-        if (factLower.includes(term)) termMatches++;
-      }
-
-      let termScore = termMatches * 2.5;
-      if (factLower.includes(query.toLowerCase())) termScore += 4.0;
-
-      // L5 Ebbinghaus decay
-      const deltaDays = (now - atom.ts) / 86400.0;
-      const stability = 1.0 + atom.importance * 3.0 + Math.log1p(atom.accessCount);
-      const retention = Math.exp(-deltaDays / Math.max(stability, 0.1));
-      const totalScore = (termScore + atom.importance * 1.5) * retention;
-
-      if (termMatches > 0 || totalScore > 0.5) {
-        scored.push({
-          id: atom.id,
-          fact: atom.fact,
-          category: atom.category,
-          sourceId: atom.sourceId,
-          score: Math.round(totalScore * 1000) / 1000,
-          retention: Math.round(retention * 1000) / 1000,
-          ts: atom.ts,
-        });
-      }
-    }
-
-    scored.sort((a, b) => b.score - a.score);
-    const topK = scored.slice(0, n);
-
-    // Reinforce access count
-    for (const item of topK) {
-      const at = this.atoms.get(item.id);
-      if (at) at.accessCount++;
-    }
-
-    // Causal graph insights
-    const causalGraph = [];
-    for (const item of topK) {
-      for (const ep of this.episodes.values()) {
-        if (ep.sourceId === item.sourceId) {
-          causalGraph.push({ cause: ep.cause, effect: ep.effect, relation: ep.relation });
-        }
-      }
-    }
-
-    // Policies
-    const policies = Array.from(this.policies.values())
-      .sort((a, b) => b.priority - a.priority)
-      .slice(0, 3);
-
-    const elapsedMs = performance.now() - start;
-    return {
-      results: topK,
-      causalGraph,
-      policies,
-      latencyMs: Math.round(elapsedMs * 100) / 100,
-      tokensSaved: "81.4%",
-      proofAvailable: true,
-    };
-  }
-
-  getProof(atomId) {
-    const p = this.proofs.get(atomId);
-    if (!p) return null;
-    return {
-      atomId: p.atomId,
-      hash: p.hash,
-      sourceLogId: p.sourceLogId,
-      rawSnippet: p.rawSnippet,
-      charRange: [p.charStart, p.charEnd],
-      verified: true,
-      timestamp: p.ts,
-    };
-  }
-
-  getPersona(userId = "default") {
-    const out = {};
-    for (const [key, p] of this.personas.entries()) {
-      if (p.userId === userId) {
-        out[p.key] = p.value;
-      }
-    }
-    return out;
-  }
-
-  addPolicy(rule, domain = "general", priority = 1.0) {
-    const pid = `L4_${this._sha256(rule + domain).slice(0, 12)}`;
-    this.policies.set(pid, { id: pid, rule, domain, priority, createdAt: Date.now() / 1000 });
-    return pid;
-  }
-
-  exportGraph(userId = "default") {
-    const lines = ["graph TD"];
-    let idx = 0;
-    for (const ep of this.episodes.values()) {
-      if (ep.userId === userId) {
-        const c = ep.cause.replace(/["\n]/g, "").slice(0, 30);
-        const e = ep.effect.replace(/["\n]/g, "").slice(0, 30);
-        lines.push(`  C${idx}["${c}"] -->|${ep.relation}| E${idx}["${e}"]`);
-        idx++;
-      }
-    }
-    if (idx === 0) return "graph TD\n  Empty[No causal memory recorded]";
-    return lines.join("\n");
-  }
-
-  deleteUser(userId) {
-    let c0 = 0, c1 = 0, c2 = 0, c3 = 0;
-    for (const [id, log] of Array.from(this.logs.entries())) {
-      if (log.userId === userId) { this.logs.delete(id); c0++; }
-    }
-    for (const [id, atom] of Array.from(this.atoms.entries())) {
-      if (atom.userId === userId) {
-        this.atoms.delete(id);
-        this.proofs.delete(id);
-        c1++;
-      }
-    }
-    for (const [id, ep] of Array.from(this.episodes.entries())) {
-      if (ep.userId === userId) { this.episodes.delete(id); c2++; }
-    }
-    for (const [key, p] of Array.from(this.personas.entries())) {
-      if (p.userId === userId) { this.personas.delete(key); c3++; }
-    }
-    return {
-      l0LogsDeleted: c0,
-      l1AtomsDeleted: c1,
-      l2EpisodesDeleted: c2,
-      l3PersonaDeleted: c3,
-      gdprCompliant: true,
-    };
-  }
-
-  stats() {
-    return {
-      l0RawLogs: this.logs.size,
-      l1AtomFacts: this.atoms.size,
-      l2CausalEpisodes: this.episodes.size,
-      l3Personas: this.personas.size,
-      l4Policies: this.policies.size,
-      l6CryptographicProofs: this.proofs.size,
-      p95RecallTargetMs: "<5.0",
-    };
-  }
-}
-
-module.exports = { InfinityDB };
+"use strict";
+
+const crypto = require("crypto");
+
+/**
+ * InfinityDB - High-performance Node.js Agent Memory Engine.
+ * Implements L0-L6 brain architecture:
+ * L0: Raw logs offloaded from LLM context
+ * L1: Atomic facts (zero-LLM regex/rule extraction)
+ * L2: Causal & temporal graph
+ * L3: Dynamic persona with conflict auto-resolution
+ * L4: Enterprise policies & SOPs
+ * L5: Ebbinghaus forgetting curve decay
+ * L6: Cryptographic SHA-256 proof chain
+ */
+class InfinityDB {
+  constructor(options = {}) {
+    this.options = options;
+    this._seq = 0;
+    this._lastTimestamp = 0;
+    this._storage = null;
+    if (options.dbPath) {
+      const Database = require("better-sqlite3");
+      this._storage = new Database(options.dbPath);
+      this._storage.pragma("journal_mode = WAL");
+      this._storage.pragma("synchronous = FULL");
+      this._storage.pragma("busy_timeout = 5000");
+      this._initStorage();
+    }
+    this.logs = new Map();
+    this.atoms = new Map();
+    this.episodes = new Map();
+    this.personas = new Map();
+    this.policies = new Map();
+    this.proofs = new Map();
+    this.legacyMemories = new Map();
+    this.relations = [];
+    this._loadState();
+  }
+
+  _initStorage() {
+    this._storage.exec(`
+      CREATE TABLE IF NOT EXISTS infinitydb_meta (key TEXT PRIMARY KEY, value TEXT NOT NULL);
+      CREATE TABLE IF NOT EXISTS l0_logs (id TEXT PRIMARY KEY, user_id TEXT NOT NULL, payload TEXT NOT NULL);
+      CREATE INDEX IF NOT EXISTS idx_js_l0_user ON l0_logs(user_id);
+      CREATE TABLE IF NOT EXISTS l1_atoms (id TEXT PRIMARY KEY, user_id TEXT NOT NULL, source_id TEXT NOT NULL, fact TEXT NOT NULL, ts REAL NOT NULL, payload TEXT NOT NULL);
+      CREATE TABLE IF NOT EXISTS l1_atom_relations (old_atom_id TEXT NOT NULL, new_atom_id TEXT NOT NULL, user_id TEXT NOT NULL, relation TEXT NOT NULL CHECK(relation='supersedes'), created_at REAL NOT NULL, PRIMARY KEY(old_atom_id,new_atom_id), CHECK(old_atom_id <> new_atom_id));
+      CREATE INDEX IF NOT EXISTS idx_js_atom_relations_user_time ON l1_atom_relations(user_id, created_at);
+      CREATE INDEX IF NOT EXISTS idx_js_l1_user_ts ON l1_atoms(user_id, ts);
+      CREATE INDEX IF NOT EXISTS idx_js_l1_source ON l1_atoms(source_id);
+      CREATE VIRTUAL TABLE IF NOT EXISTS l1_atoms_fts
+        USING fts5(fact, content='l1_atoms', content_rowid='rowid',
+                   tokenize='unicode61 remove_diacritics 2');
+      CREATE TRIGGER IF NOT EXISTS l1_atoms_fts_insert AFTER INSERT ON l1_atoms BEGIN
+        INSERT INTO l1_atoms_fts(rowid, fact) VALUES (new.rowid, new.fact);
+      END;
+      CREATE TRIGGER IF NOT EXISTS l1_atoms_fts_delete AFTER DELETE ON l1_atoms BEGIN
+        INSERT INTO l1_atoms_fts(l1_atoms_fts, rowid, fact)
+        VALUES ('delete', old.rowid, old.fact);
+      END;
+      CREATE TRIGGER IF NOT EXISTS l1_atoms_fts_update AFTER UPDATE OF fact ON l1_atoms
+      WHEN old.fact <> new.fact BEGIN
+        INSERT INTO l1_atoms_fts(l1_atoms_fts, rowid, fact)
+        VALUES ('delete', old.rowid, old.fact);
+        INSERT INTO l1_atoms_fts(rowid, fact) VALUES (new.rowid, new.fact);
+      END;
+      CREATE TABLE IF NOT EXISTS l2_episodes (id TEXT PRIMARY KEY, user_id TEXT NOT NULL, source_id TEXT NOT NULL, payload TEXT NOT NULL);
+      CREATE INDEX IF NOT EXISTS idx_js_l2_user ON l2_episodes(user_id);
+      CREATE TABLE IF NOT EXISTS l3_personas (id TEXT PRIMARY KEY, user_id TEXT NOT NULL, payload TEXT NOT NULL);
+      CREATE INDEX IF NOT EXISTS idx_js_l3_user ON l3_personas(user_id);
+      CREATE TABLE IF NOT EXISTS l4_policies (id TEXT PRIMARY KEY, payload TEXT NOT NULL);
+      CREATE TABLE IF NOT EXISTS l6_proofs (atom_id TEXT PRIMARY KEY, source_log_id TEXT NOT NULL, payload TEXT NOT NULL);
+      CREATE INDEX IF NOT EXISTS idx_js_l6_source ON l6_proofs(source_log_id);
+      CREATE TABLE IF NOT EXISTS legacy_memories (memory_key TEXT PRIMARY KEY, payload TEXT NOT NULL);
+    `);
+    const version = this._storage.prepare("SELECT value FROM infinitydb_meta WHERE key='schema_version'").get();
+    if (!version) {
+      const legacyTable = this._storage.prepare("SELECT 1 FROM sqlite_master WHERE type='table' AND name='infinitydb_state'").get();
+      this._storage.transaction(() => {
+        if (legacyTable) {
+          const row = this._storage.prepare("SELECT schema_version, payload FROM infinitydb_state WHERE id=1").get();
+          if (row) {
+            if (row.schema_version !== 1) throw new Error(`Unsupported InfinityDB storage schema version: ${row.schema_version}`);
+            const state = JSON.parse(row.payload);
+            this._seq = state.seq || 0;
+            this._writeEntries("l0_logs", "id", state.logs || [], entry => [entry[1].id, entry[1].userId, JSON.stringify(entry[1])]);
+            this._writeEntries("l1_atoms", "id", state.atoms || [], entry => [entry[1].id, entry[1].userId, entry[1].sourceId, entry[1].fact, entry[1].ts, JSON.stringify(entry[1])]);
+            this._writeEntries("l2_episodes", "id", state.episodes || [], entry => [entry[1].id, entry[1].userId, entry[1].sourceId, JSON.stringify(entry[1])]);
+            this._writeEntries("l3_personas", "id", state.personas || [], entry => [entry[0], entry[1].userId, JSON.stringify(entry[1])]);
+            this._writeEntries("l4_policies", "id", state.policies || [], entry => [entry[1].id, JSON.stringify(entry[1])]);
+            this._writeEntries("l6_proofs", "atom_id", state.proofs || [], entry => [entry[1].atomId, entry[1].sourceLogId, JSON.stringify(entry[1])]);
+            this._writeEntries("legacy_memories", "memory_key", state.legacyMemories || [], v => [v[0], JSON.stringify(v[1])]);
+          }
+          this._storage.exec("DROP TABLE infinitydb_state");
+        }
+        this._storage.prepare("INSERT INTO infinitydb_meta(key,value) VALUES ('schema_version','2')").run();
+        this._storage.prepare("INSERT INTO infinitydb_meta(key,value) VALUES ('sequence',?)").run(String(this._seq));
+      })();
+    } else if (version.value !== "2") {
+      throw new Error(`Unsupported InfinityDB storage schema version: ${version.value}`);
+    }
+    const ftsVersion = this._storage.prepare("SELECT value FROM infinitydb_meta WHERE key='l1_atoms_fts_version'").get();
+    if (!ftsVersion) {
+      this._storage.transaction(() => {
+        this._storage.prepare("INSERT INTO l1_atoms_fts(l1_atoms_fts) VALUES ('rebuild')").run();
+        this._storage.prepare("INSERT INTO infinitydb_meta(key,value) VALUES ('l1_atoms_fts_version','1')").run();
+      })();
+    }
+  }
+
+  _writeEntries(table, keyColumn, entries, mapper) {
+    const columns = {
+      l0_logs: "id, user_id, payload", l1_atoms: "id, user_id, source_id, fact, ts, payload",
+      l2_episodes: "id, user_id, source_id, payload", l3_personas: "id, user_id, payload",
+      l4_policies: "id, payload", l6_proofs: "atom_id, source_log_id, payload",
+      legacy_memories: "memory_key, payload",
+    }[table];
+    const values = columns.split(", ").map(() => "?").join(", ");
+    const updates = columns.split(", ").slice(1).map(col => `${col}=excluded.${col}`).join(", ");
+    const stmt = this._storage.prepare(`INSERT INTO ${table} (${columns}) VALUES (${values}) ON CONFLICT(${keyColumn}) DO UPDATE SET ${updates}`);
+    for (const entry of entries) stmt.run(...mapper(entry));
+  }
+
+  _loadState() {
+    if (!this._storage) return;
+    const loadSnapshot = () => {
+    const get = (sql, key) => this._storage.prepare(sql).all().map(row => [row[key], JSON.parse(row.payload)]);
+    this._seq = Number(this._storage.prepare("SELECT value FROM infinitydb_meta WHERE key='sequence'").get()?.value || 0);
+    this.logs = new Map(get("SELECT id, payload FROM l0_logs", "id"));
+    this.atoms = new Map(get("SELECT id, payload FROM l1_atoms", "id"));
+    this.episodes = new Map(get("SELECT id, payload FROM l2_episodes", "id"));
+    this.personas = new Map(get("SELECT id, payload FROM l3_personas", "id"));
+    this.policies = new Map(get("SELECT id, payload FROM l4_policies", "id"));
+    this.proofs = new Map(get("SELECT atom_id AS id, payload FROM l6_proofs", "id"));
+    this.legacyMemories = new Map(get("SELECT memory_key AS id, payload FROM legacy_memories", "id"));
+    this.relations = this._storage.prepare("SELECT old_atom_id AS oldAtomId, new_atom_id AS newAtomId, user_id AS userId, relation, created_at AS createdAt FROM l1_atom_relations").all();
+    this._persisted = {
+      logs: this._snapshotMap(this.logs),
+      atoms: this._snapshotMap(this.atoms),
+      episodes: this._snapshotMap(this.episodes),
+      personas: this._snapshotMap(this.personas),
+      policies: this._snapshotMap(this.policies),
+      proofs: this._snapshotMap(this.proofs),
+      legacyMemories: this._snapshotMap(this.legacyMemories),
+      relations: new Set(this.relations.map(r => `${r.oldAtomId}\0${r.newAtomId}`)),
+    };
+    for (const atom of this.atoms.values()) {
+      if (atom.ts > this._lastTimestamp) this._lastTimestamp = atom.ts;
+    }
+    };
+    this._storage.transaction(loadSnapshot)();
+  }
+
+  _refreshState() {
+    if (this._storage) this._loadState();
+  }
+
+  _allocateSequence() {
+    if (!this._storage) return ++this._seq;
+    const allocate = this._storage.transaction(() => {
+      const current = Number(this._storage.prepare(
+        "SELECT value FROM infinitydb_meta WHERE key='sequence'"
+      ).get()?.value || 0);
+      const next = current + 1;
+      this._storage.prepare(
+        "UPDATE infinitydb_meta SET value=? WHERE key='sequence'"
+      ).run(String(next));
+      return next;
+    });
+    this._seq = allocate();
+    return this._seq;
+  }
+
+  _snapshotMap(map) {
+    return new Map(Array.from(map.entries(), ([key, value]) => [key, JSON.stringify(value)]));
+  }
+
+  _changedEntries(map, snapshot) {
+    return Array.from(map.entries()).filter(([key, value]) =>
+      !snapshot.has(key) || snapshot.get(key) !== JSON.stringify(value)
+    );
+  }
+
+  _persist() {
+    if (!this._storage) return;
+    const previous = this._persisted || {};
+    const snapshots = {
+      logs: this._snapshotMap(this.logs),
+      atoms: this._snapshotMap(this.atoms),
+      episodes: this._snapshotMap(this.episodes),
+      personas: this._snapshotMap(this.personas),
+      policies: this._snapshotMap(this.policies),
+      proofs: this._snapshotMap(this.proofs),
+      legacyMemories: this._snapshotMap(this.legacyMemories),
+    };
+    const removed = (current, snapshot) => Array.from(snapshot.keys()).filter(key => !current.has(key));
+    this._storage.transaction(() => {
+      this._writeEntries("l0_logs", "id", this._changedEntries(this.logs, previous.logs || new Map()), v => [v[1].id, v[1].userId, JSON.stringify(v[1])]);
+      this._writeEntries("l1_atoms", "id", this._changedEntries(this.atoms, previous.atoms || new Map()), v => [v[1].id, v[1].userId, v[1].sourceId, v[1].fact, v[1].ts, JSON.stringify(v[1])]);
+      this._writeEntries("l2_episodes", "id", this._changedEntries(this.episodes, previous.episodes || new Map()), v => [v[1].id, v[1].userId, v[1].sourceId, JSON.stringify(v[1])]);
+      this._writeEntries("l3_personas", "id", this._changedEntries(this.personas, previous.personas || new Map()), v => [v[0], v[1].userId, JSON.stringify(v[1])]);
+      this._writeEntries("l4_policies", "id", this._changedEntries(this.policies, previous.policies || new Map()), v => [v[1].id, JSON.stringify(v[1])]);
+      this._writeEntries("l6_proofs", "atom_id", this._changedEntries(this.proofs, previous.proofs || new Map()), v => [v[1].atomId, v[1].sourceLogId, JSON.stringify(v[1])]);
+      this._writeEntries("legacy_memories", "memory_key", this._changedEntries(this.legacyMemories, previous.legacyMemories || new Map()), v => [v[0], JSON.stringify(v[1])]);
+
+      const deletes = [
+        ["l0_logs", "id", removed(this.logs, previous.logs || new Map())],
+        ["l1_atoms", "id", removed(this.atoms, previous.atoms || new Map())],
+        ["l2_episodes", "id", removed(this.episodes, previous.episodes || new Map())],
+        ["l3_personas", "id", removed(this.personas, previous.personas || new Map())],
+        ["l4_policies", "id", removed(this.policies, previous.policies || new Map())],
+        ["l6_proofs", "atom_id", removed(this.proofs, previous.proofs || new Map())],
+        ["legacy_memories", "memory_key", removed(this.legacyMemories, previous.legacyMemories || new Map())],
+      ];
+      for (const [table, column, keys] of deletes) {
+        if (!keys.length) continue;
+        const stmt = this._storage.prepare(`DELETE FROM ${table} WHERE ${column}=?`);
+        for (const key of keys) stmt.run(key);
+      }
+
+      const relationInsert = this._storage.prepare("INSERT OR IGNORE INTO l1_atom_relations (old_atom_id,new_atom_id,user_id,relation,created_at) VALUES (?,?,?,?,?)");
+      const relationKeys = new Set(this.relations.map(r => `${r.oldAtomId}\0${r.newAtomId}`));
+      for (const relation of this.relations) {
+        const key = `${relation.oldAtomId}\0${relation.newAtomId}`;
+        if (!(previous.relations || new Set()).has(key)) {
+          relationInsert.run(relation.oldAtomId, relation.newAtomId, relation.userId, relation.relation, relation.createdAt);
+        }
+      }
+      for (const key of (previous.relations || new Set())) {
+        if (!relationKeys.has(key)) {
+          const [oldAtomId, newAtomId] = key.split("\0");
+          this._storage.prepare("DELETE FROM l1_atom_relations WHERE old_atom_id=? AND new_atom_id=?").run(oldAtomId, newAtomId);
+        }
+      }
+    })();
+    this._persisted = {
+      ...snapshots,
+      relations: new Set(this.relations.map(r => `${r.oldAtomId}\0${r.newAtomId}`)),
+    };
+  }
+
+  close() {
+    if (this._storage && this._storage.open) this._storage.close();
+  }
+
+  _sha256(str) {
+    return crypto.createHash("sha256").update(str).digest("hex");
+  }
+
+  // Legacy key-value compatibility
+  put(key, content) {
+    this._refreshState();
+    if (!key || !key.trim()) throw new Error("key cannot be empty");
+    if (!content || !content.trim()) throw new Error("content cannot be empty");
+    const mem = { key, content, createdAt: new Date().toISOString() };
+    const previousState = {
+      logs: new Map(this.logs),
+      atoms: new Map(this.atoms),
+      episodes: new Map(this.episodes),
+      personas: new Map(this.personas),
+      proofs: new Map(this.proofs),
+      legacyMemories: new Map(this.legacyMemories),
+      lastTimestamp: this._lastTimestamp,
+    };
+    try {
+      this._add(`Memory key ${key}: ${content}`, "legacy", null, 0.9, false);
+      this.legacyMemories.set(key, mem);
+      this._persist();
+    } catch (error) {
+      this.logs = previousState.logs;
+      this.atoms = previousState.atoms;
+      this.episodes = previousState.episodes;
+      this.personas = previousState.personas;
+      this.proofs = previousState.proofs;
+      this.legacyMemories = previousState.legacyMemories;
+      this._lastTimestamp = previousState.lastTimestamp;
+      throw error;
+    }
+    return mem;
+  }
+
+  get(key) {
+    this._refreshState();
+    return this.legacyMemories.get(key) || null;
+  }
+
+  delete(key) {
+    this._refreshState();
+    if (!this.legacyMemories.has(key)) return false;
+    const previous = this.legacyMemories.get(key);
+    this.legacyMemories.delete(key);
+    try {
+      this._persist();
+    } catch (error) {
+      this.legacyMemories.set(key, previous);
+      throw error;
+    }
+    return true;
+  }
+
+  // Core L0-L6 API
+  add(conversation, userId = "default", sessionId = null, importance = 0.9) {
+    return this._add(conversation, userId, sessionId, importance, true);
+  }
+
+  _add(conversation, userId, sessionId, importance, persist = true) {
+    this._refreshState();
+    if (typeof conversation !== "string" || !conversation.trim()) {
+      throw new TypeError("conversation must be a non-empty string");
+    }
+    if (typeof userId !== "string" || !userId.trim()) {
+      throw new TypeError("userId must be a non-empty string");
+    }
+    if (typeof importance !== "number" || !Number.isFinite(importance)) {
+      throw new TypeError("importance must be a finite number between 0 and 1");
+    }
+    if (importance < 0 || importance > 1) {
+      throw new RangeError("importance must be between 0 and 1");
+    }
+    // Keep the in-memory view aligned with SQLite if the durable write fails.
+    const previousState = {
+      logs: new Map(this.logs),
+      atoms: new Map(this.atoms),
+      episodes: new Map(this.episodes),
+      personas: new Map(this.personas),
+      proofs: new Map(this.proofs),
+      lastTimestamp: this._lastTimestamp,
+    };
+    const now = Math.max(Date.now() / 1000, this._lastTimestamp + 0.001);
+    this._lastTimestamp = now;
+    this._allocateSequence();
+    const logId = `L0_${this._sha256(conversation + now + this._seq).slice(0, 16)}`;
+
+    // L0: Store raw
+    this.logs.set(logId, {
+      id: logId,
+      userId,
+      sessionId,
+      raw: conversation,
+      ts: now,
+    });
+
+    // L1: Zero-LLM Deterministic Rule Extraction
+    const patterns = [
+      { regex: /(?:I am|I'm|my name is)\s+([A-Z][a-zA-Z0-9_\-\s]+?)(?:[.,\n]|$)/i, cat: "identity", weight: 0.95 },
+      { regex: /(?:I work as|I am a|my role is)\s+([^.,\n]+)/i, cat: "role", weight: 0.90 },
+      { regex: /(?:I prefer|I like|I love|I use|my preference is)\s+([^.,\n]+)/i, cat: "preference", weight: 0.92 },
+      { regex: /(?:I hate|I dislike|I avoid|never use)\s+([^.,\n]+)/i, cat: "dislike", weight: 0.88 },
+      { regex: /(?:my budget is|budget of|budget:\s*)\s*([$€£¥]?[0-9,]+(?:\s*[kKmMbB])?)/i, cat: "budget", weight: 0.94 },
+      { regex: /(?:I live in|based in|located in)\s+([^.,\n]+)/i, cat: "location", weight: 0.85 },
+      { regex: /(?:our goal is|aiming to|target is|deadline is)\s+([^.,\n]+)/i, cat: "goal", weight: 0.91 },
+      { regex: /(?:must comply with|required to|constraint:\s*)\s+([^.,\n]+)/i, cat: "constraint", weight: 0.95 },
+    ];
+
+    let extractedAny = false;
+    for (const pat of patterns) {
+      let match;
+      const re = new RegExp(pat.regex.source, "gi");
+      while ((match = re.exec(conversation)) !== null) {
+        extractedAny = true;
+        const fact = match[0].trim();
+        const atomId = `L1_${this._sha256(logId + fact).slice(0, 16)}`;
+
+        this.atoms.set(atomId, {
+          id: atomId,
+          userId,
+          fact,
+          category: pat.cat,
+          sourceId: logId,
+          importance: pat.weight * importance,
+          accessCount: 0,
+          ts: now,
+        });
+
+        // L6: Cryptographic Proof Record
+        const proofHash = this._sha256(fact + logId);
+        const snippet = conversation.slice(Math.max(0, match.index - 20), Math.min(conversation.length, match.index + fact.length + 20));
+        this.proofs.set(atomId, {
+          atomId,
+          hash: proofHash,
+          sourceLogId: logId,
+          rawSnippet: snippet,
+          charStart: match.index,
+          charEnd: match.index + fact.length,
+          ts: now,
+        });
+
+        // L3: Persona Auto-Resolution
+        const pKey = `${userId}:${pat.cat}`;
+        const existing = this.personas.get(pKey);
+        if (!existing || now >= existing.updatedAt) {
+          this.personas.set(pKey, {
+            userId,
+            key: pat.cat,
+            value: fact,
+            confidence: pat.weight,
+            updatedAt: now,
+            sourceAtomId: atomId,
+          });
+        }
+      }
+    }
+
+    if (!extractedAny) {
+      // Store offsets for the exact trimmed sentence so L6 verifies the
+      // original source range rather than an unrelated prefix of the log.
+      const sentencePattern = /[^.!?\n]+/g;
+      let sentenceMatch;
+      let extractedCount = 0;
+      while ((sentenceMatch = sentencePattern.exec(conversation)) !== null && extractedCount < 3) {
+        const rawSentence = sentenceMatch[0];
+        const leadingWhitespace = rawSentence.length - rawSentence.trimStart().length;
+        const fact = rawSentence.trim();
+        if (fact.length <= 8) continue;
+        const charStart = sentenceMatch.index + leadingWhitespace;
+        const charEnd = charStart + fact.length;
+        const atomId = `L1_${this._sha256(logId + fact).slice(0, 16)}`;
+        this.atoms.set(atomId, {
+          id: atomId,
+          userId,
+          fact,
+          category: "general",
+          sourceId: logId,
+          importance: 0.75 * importance,
+          accessCount: 0,
+          ts: now,
+        });
+        this.proofs.set(atomId, {
+          atomId,
+          hash: this._sha256(fact + logId),
+          sourceLogId: logId,
+          rawSnippet: conversation.slice(Math.max(0, charStart - 20), Math.min(conversation.length, charEnd + 20)),
+          charStart,
+          charEnd,
+          ts: now,
+        });
+        extractedCount++;
+      }
+    }
+
+    // L2: Causal Episode Extraction
+    const causalRegex = /(.+?)\s+(?:because|since|as a result of|so that)\s+([^.,\n]+)/gi;
+    let cMatch;
+    while ((cMatch = causalRegex.exec(conversation)) !== null) {
+      const effectPart = cMatch[1].trim().slice(-80);
+      const causePart = cMatch[2].trim().slice(0, 80);
+      const epId = `L2_${this._sha256(logId + causePart + effectPart).slice(0, 16)}`;
+      this.episodes.set(epId, {
+        id: epId,
+        userId,
+        cause: causePart,
+        effect: effectPart,
+        relation: "causes",
+        sourceId: logId,
+        ts: now,
+      });
+    }
+
+    try {
+      if (persist) this._persist();
+    } catch (error) {
+      this.logs = previousState.logs;
+      this.atoms = previousState.atoms;
+      this.episodes = previousState.episodes;
+      this.personas = previousState.personas;
+      this.proofs = previousState.proofs;
+      this._lastTimestamp = previousState.lastTimestamp;
+      throw error;
+    }
+    return logId;
+  }
+
+  supersedeFact(oldAtomId, newAtomId, userId) {
+    this._refreshState();
+    if (![oldAtomId, newAtomId, userId].every(v => typeof v === "string" && v.trim())) {
+      throw new TypeError("atom ids and userId must be non-empty strings");
+    }
+    if (oldAtomId === newAtomId) throw new Error("a fact cannot supersede itself");
+
+    const validateAndBuild = (oldAtom, newAtom, relations) => {
+      if (!oldAtom || !newAtom) throw new Error("both facts must exist");
+      if (oldAtom.userId !== userId || newAtom.userId !== userId) {
+        throw new Error("both facts must belong to the supplied userId");
+      }
+      const byOld = new Map();
+      for (const edge of relations) {
+        if (!byOld.has(edge.oldAtomId)) byOld.set(edge.oldAtomId, []);
+        byOld.get(edge.oldAtomId).push(edge.newAtomId);
+      }
+      const pending = [newAtomId], visited = new Set();
+      while (pending.length) {
+        const current = pending.pop();
+        if (current === oldAtomId) throw new Error("supersession would create a cycle");
+        if (visited.has(current)) continue;
+        visited.add(current);
+        pending.push(...(byOld.get(current) || []));
+      }
+      if (relations.some(r => r.oldAtomId === oldAtomId && r.newAtomId === newAtomId)) {
+        throw new Error("supersession relation already exists");
+      }
+      const createdAt = Math.max(Date.now() / 1000, oldAtom.ts, newAtom.ts) + 0.001;
+      return { oldAtomId, newAtomId, userId, relation: "supersedes", createdAt };
+    };
+
+    let relation;
+    if (this._storage) {
+      // Acquire the write reservation before reading the graph. This makes
+      // validation and insertion one serialized SQLite operation across
+      // connections, and a failed insert cannot mutate the in-memory view.
+      const persistRelation = this._storage.transaction(() => {
+        const oldAtom = this._storage.prepare("SELECT payload FROM l1_atoms WHERE id=?").get(oldAtomId);
+        const newAtom = this._storage.prepare("SELECT payload FROM l1_atoms WHERE id=?").get(newAtomId);
+        const relations = this._storage.prepare(
+          "SELECT old_atom_id AS oldAtomId, new_atom_id AS newAtomId, user_id AS userId, relation, created_at AS createdAt FROM l1_atom_relations"
+        ).all();
+        const built = validateAndBuild(
+          oldAtom ? JSON.parse(oldAtom.payload) : null,
+          newAtom ? JSON.parse(newAtom.payload) : null,
+          relations
+        );
+        this._storage.prepare(
+          "INSERT INTO l1_atom_relations (old_atom_id,new_atom_id,user_id,relation,created_at) VALUES (?,?,?,?,?)"
+        ).run(oldAtomId, newAtomId, userId, "supersedes", built.createdAt);
+        return built;
+      }).immediate();
+      relation = persistRelation;
+    } else {
+      relation = validateAndBuild(
+        this.atoms.get(oldAtomId),
+        this.atoms.get(newAtomId),
+        this.relations
+      );
+    }
+
+    this.relations.push(relation);
+    return this._sha256(`${userId}:${oldAtomId}:${newAtomId}:${relation.createdAt}`).slice(0, 24);
+  }
+
+  recall(query, options = {}) {
+    this._refreshState();
+    if (typeof query !== "string") throw new TypeError("query must be a string");
+    const n = options.n === undefined ? 5 : options.n;
+    if (!Number.isInteger(n) || n <= 0) {
+      throw new RangeError("n must be a positive integer");
+    }
+    if (options.userId !== undefined &&
+        (typeof options.userId !== "string" || !options.userId.trim())) {
+      throw new TypeError("userId must be a non-empty string");
+    }
+    if (options.asOf !== undefined && (typeof options.asOf !== "number" || !Number.isFinite(options.asOf))) {
+      throw new TypeError("asOf must be a finite Unix timestamp");
+    }
+    const start = performance.now();
+    const userId = options.userId || null;
+    const now = Date.now() / 1000;
+    const asOf = options.asOf;
+    const qTerms = (query.toLowerCase().match(/\w+/g) || []).filter(t => t.length > 1);
+
+    const scored = [];
+    if (qTerms.length === 0) {
+      return {
+        results: [],
+        causalGraph: [],
+        policies: [],
+        latencyMs: Math.round((performance.now() - start) * 100) / 100,
+        tokensSaved: null,
+        proofAvailable: false,
+      };
+    }
+    let candidateAtoms = this.atoms.entries();
+    if (this._storage) {
+      const matchQuery = qTerms.map(term => '"' + term.replace(/"/g, '""') + '"').join(" OR ");
+      const rows = this._storage.prepare(
+        "SELECT a.id, a.payload FROM l1_atoms_fts f JOIN l1_atoms a ON a.rowid=f.rowid WHERE l1_atoms_fts MATCH ?"
+      ).all(matchQuery);
+      candidateAtoms = rows.map(row => [row.id, JSON.parse(row.payload)]);
+    }
+    for (const [id, atom] of candidateAtoms) {
+      if (userId && atom.userId !== userId) continue;
+      if (asOf !== undefined && atom.ts > asOf) continue;
+      if (this.relations.some(r => r.oldAtomId === id && (asOf === undefined || r.createdAt <= asOf))) continue;
+      const factLower = atom.fact.toLowerCase();
+      let termMatches = 0;
+      for (const term of qTerms) {
+        if (factLower.includes(term)) termMatches++;
+      }
+
+      let termScore = termMatches * 2.5;
+      if (factLower.includes(query.toLowerCase())) termScore += 4.0;
+
+      // L5 Ebbinghaus decay
+      const deltaDays = (now - atom.ts) / 86400.0;
+      const stability = 1.0 + atom.importance * 3.0 + Math.log1p(atom.accessCount);
+      const retention = Math.exp(-deltaDays / Math.max(stability, 0.1));
+      const totalScore = (termScore + atom.importance * 1.5) * retention;
+
+      if (termMatches > 0) {
+        scored.push({
+          id: atom.id,
+          fact: atom.fact,
+          category: atom.category,
+          sourceId: atom.sourceId,
+          score: Math.round(totalScore * 1000) / 1000,
+          retention: Math.round(retention * 1000) / 1000,
+          ts: atom.ts,
+        });
+      }
+    }
+
+    scored.sort((a, b) => b.score - a.score);
+    const topK = scored.slice(0, n);
+
+    // Reinforce access count only when the updated counts are durable.
+    const previousAccessCounts = [];
+    for (const item of topK) {
+      const at = this.atoms.get(item.id);
+      if (at) {
+        previousAccessCounts.push([at, at.accessCount]);
+        at.accessCount++;
+      }
+    }
+
+    try {
+      this._persist();
+    } catch (error) {
+      for (const [atom, accessCount] of previousAccessCounts) {
+        atom.accessCount = accessCount;
+      }
+      throw error;
+    }
+
+    // Causal graph insights
+    const causalGraph = [];
+    for (const item of topK) {
+      for (const ep of this.episodes.values()) {
+        if (ep.sourceId === item.sourceId) {
+          causalGraph.push({ cause: ep.cause, effect: ep.effect, relation: ep.relation });
+        }
+      }
+    }
+
+    // Global policies apply to every tenant; scoped policies require a matching userId.
+    const policies = Array.from(this.policies.values())
+      .filter(policy => !policy.tenantId || (userId && policy.tenantId === userId))
+      .sort((a, b) => b.priority - a.priority)
+      .slice(0, 3);
+
+    const elapsedMs = performance.now() - start;
+    return {
+      results: topK,
+      causalGraph,
+      policies,
+      latencyMs: Math.round(elapsedMs * 100) / 100,
+      tokensSaved: null,
+      proofAvailable: true,
+    };
+  }
+
+  getProof(atomId) {
+    this._refreshState();
+    const p = this.proofs.get(atomId);
+    if (!p) return null;
+    const source = this.logs.get(p.sourceLogId);
+    const atom = this.atoms.get(atomId);
+    let verified = false;
+    if (source && atom &&
+        Number.isInteger(p.charStart) && Number.isInteger(p.charEnd) &&
+        p.charStart >= 0 && p.charEnd >= p.charStart &&
+        p.charEnd <= source.raw.length) {
+      const sourceFact = source.raw.slice(p.charStart, p.charEnd);
+      const expected = this._sha256(atom.fact + p.sourceLogId);
+      const actualBuffer = Buffer.from(p.hash, "hex");
+      const expectedBuffer = Buffer.from(expected, "hex");
+      verified = sourceFact === atom.fact &&
+        actualBuffer.length === expectedBuffer.length &&
+        crypto.timingSafeEqual(actualBuffer, expectedBuffer);
+    }
+    return {
+      atomId: p.atomId,
+      hash: p.hash,
+      sourceLogId: p.sourceLogId,
+      rawSnippet: p.rawSnippet,
+      charRange: [p.charStart, p.charEnd],
+      verified,
+      timestamp: p.ts,
+    };
+  }
+
+  getPersona(userId = "default") {
+    this._refreshState();
+    const out = {};
+    for (const [key, p] of this.personas.entries()) {
+      if (p.userId === userId) {
+        out[p.key] = p.value;
+      }
+    }
+    return out;
+  }
+
+  addPolicy(rule, domain = "general", priority = 1.0, tenantId = null) {
+    this._refreshState();
+    if (typeof rule !== "string" || !rule.trim()) throw new TypeError("rule must be a non-empty string");
+    if (typeof domain !== "string" || !domain.trim()) throw new TypeError("domain must be a non-empty string");
+    if (typeof priority !== "number" || !Number.isFinite(priority)) throw new TypeError("priority must be a finite number");
+    if (tenantId !== null && (typeof tenantId !== "string" || !tenantId.trim())) {
+      throw new TypeError("tenantId must be null or a non-empty string");
+    }
+    const scope = tenantId || "global";
+    const pid = `L4_${this._sha256(rule.trim() + domain.trim() + scope).slice(0, 16)}`;
+    const existing = this.policies.get(pid);
+    this.policies.set(pid, { id: pid, rule: rule.trim(), domain: domain.trim(), priority,
+      tenantId, createdAt: existing?.createdAt ?? Date.now() / 1000 });
+    try {
+      this._persist();
+    } catch (error) {
+      if (existing) this.policies.set(pid, existing);
+      else this.policies.delete(pid);
+      throw error;
+    }
+    return pid;
+  }
+
+  exportGraph(userId = "default") {
+    const lines = ["graph TD"];
+    let idx = 0;
+    for (const ep of this.episodes.values()) {
+      if (ep.userId === userId) {
+        const c = ep.cause.replace(/["\n]/g, "").slice(0, 30);
+        const e = ep.effect.replace(/["\n]/g, "").slice(0, 30);
+        lines.push(`  C${idx}["${c}"] -->|${ep.relation}| E${idx}["${e}"]`);
+        idx++;
+      }
+    }
+    if (idx === 0) return "graph TD\n  Empty[No causal memory recorded]";
+    return lines.join("\n");
+  }
+
+  deleteUser(userId) {
+    this._refreshState();
+    let c0 = 0, c1 = 0, c2 = 0, c3 = 0;
+    const logIds = [];
+    const atomIds = [];
+    const episodeIds = [];
+    const personaKeys = [];
+    const policyIds = [];
+
+    for (const [id, log] of this.logs.entries()) {
+      if (log.userId === userId) { logIds.push(id); c0++; }
+    }
+    for (const [id, atom] of this.atoms.entries()) {
+      if (atom.userId === userId) { atomIds.push(id); c1++; }
+    }
+    for (const [id, ep] of this.episodes.entries()) {
+      if (ep.userId === userId) { episodeIds.push(id); c2++; }
+    }
+    for (const [key, persona] of this.personas.entries()) {
+      if (persona.userId === userId) { personaKeys.push(key); c3++; }
+    }
+    for (const [id, policy] of this.policies.entries()) {
+      if (policy.tenantId === userId) policyIds.push(id);
+    }
+
+    // Commit durable deletion before mutating the in-memory view. If SQLite
+    // rejects any statement, the transaction rolls back and this instance
+    // continues to expose the unchanged tenant state.
+    if (this._storage) {
+      this._storage.transaction(() => {
+        this._storage.prepare("DELETE FROM l0_logs WHERE user_id=?").run(userId);
+        this._storage.prepare("DELETE FROM l1_atom_relations WHERE user_id=?").run(userId);
+        this._storage.prepare("DELETE FROM l1_atoms WHERE user_id=?").run(userId);
+        this._storage.prepare("DELETE FROM l2_episodes WHERE user_id=?").run(userId);
+        this._storage.prepare("DELETE FROM l3_personas WHERE user_id=?").run(userId);
+        // L4 policies are stored as JSON payloads keyed by ID (not tenant_id columns).
+        const deletePolicy = this._storage.prepare("DELETE FROM l4_policies WHERE id=?");
+        for (const id of policyIds) deletePolicy.run(id);
+        this._storage.prepare("DELETE FROM l6_proofs WHERE source_log_id NOT IN (SELECT id FROM l0_logs)").run();
+      })();
+    }
+
+    for (const id of logIds) this.logs.delete(id);
+    for (const id of atomIds) {
+      this.atoms.delete(id);
+      this.proofs.delete(id);
+    }
+    for (const id of episodeIds) this.episodes.delete(id);
+    for (const key of personaKeys) this.personas.delete(key);
+    for (const id of policyIds) this.policies.delete(id);
+    this.relations = this.relations.filter(r => r.userId !== userId);
+
+    // The normalized rows were already deleted in the transaction above.
+    // Advance the persistence baseline without issuing a second write
+    // transaction, so a later persistence failure cannot split deletion
+    // across two commits or leave the snapshot describing deleted rows.
+    if (this._storage) {
+      this._persisted = {
+        logs: this._snapshotMap(this.logs),
+        atoms: this._snapshotMap(this.atoms),
+        episodes: this._snapshotMap(this.episodes),
+        personas: this._snapshotMap(this.personas),
+        policies: this._snapshotMap(this.policies),
+        proofs: this._snapshotMap(this.proofs),
+        legacyMemories: this._snapshotMap(this.legacyMemories),
+        relations: new Set(this.relations.map(r => `${r.oldAtomId}\\0${r.newAtomId}`)),
+      };
+    }
+    return {
+      l0LogsDeleted: c0,
+      l1AtomsDeleted: c1,
+      l2EpisodesDeleted: c2,
+      l3PersonaDeleted: c3,
+      l4TenantPoliciesDeleted: policyIds.length,
+    };
+  }
+
+  stats() {
+    this._refreshState();
+    return {
+      l0RawLogs: this.logs.size,
+      l1AtomFacts: this.atoms.size,
+      l2CausalEpisodes: this.episodes.size,
+      l3Personas: this.personas.size,
+      l4Policies: this.policies.size,
+      l6CryptographicProofs: this.proofs.size,
+      p95RecallTargetMs: "<5.0",
+    };
+  }
+}
+
+module.exports = { InfinityDB };