infinitydb 0.0.0-stage → 1.4.0

package/LICENSE

@@ -0,0 +1,119 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work.
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      shall any Contributor be liable to You for damages, including any
+      direct, indirect, special, incidental, or exemplary damages of any
+      character arising as a result of this License or out of the use or
+      inability to use the Work.
+
+   END OF TERMS AND CONDITIONS
+
+   Copyright (c) 2026 InfinityDB AI Contributors
+

package/README.md

@@ -1,3 +1,186 @@
-# Temporary Holding Version
-
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+# InfinityDB
+
+> High-Performance Neurosymbolic Agent Memory Engine for JavaScript and TypeScript.
+
+[![NPM Version](https://img.shields.io/npm/v/infinitydb?color=blue)](https://www.npmjs.com/package/infinitydb)
+[![License: Apache 2.0](https://img.shields.io/badge/License-Apache_2.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)
+[![TypeScript](https://img.shields.io/badge/TypeScript-Ready-3178C6?logo=typescript&logoColor=white)](https://www.typescriptlang.org/)
+
+InfinityDB gives AI agents long-term neurosymbolic memory with deterministic recall, dynamic persona conflict resolution, and cryptographic SHA-256 audit proofs. Recall and write latency depend on dataset size, hardware, storage configuration, and workload.
+
+---
+
+## Installation
+
+```bash
+npm install infinitydb
+```
+
+```bash
+yarn add infinitydb
+# or
+pnpm add infinitydb
+```
+
+---
+
+## Quick Start
+
+### 1. Ingestion and Causal Recall
+
+```javascript
+const { InfinityDB } = require("infinitydb");
+// Or in TypeScript:
+// import { InfinityDB } from "infinitydb";
+
+const db = new InfinityDB();
+
+// Ingest agent dialogue / user interactions (L0 Log -> L1 Atomic Facts -> L2 Episode Graph)
+const logId = db.add(
+  "Sarah prefers TypeScript over JavaScript because of strict static typing. Her project budget is $15,000.",
+  "usr_sarah"
+);
+
+// Recall relevant memory with causal facts, policy checks, and proof chains
+const memory = db.recall("what language does Sarah prefer?", { userId: "usr_sarah" });
+
+console.log("Latency:", memory.latencyMs, "ms");
+console.log("Recalled Facts:", memory.results);
+console.log("Causal Graph:", memory.causalGraph);
+```
+
+### 2. Dynamic Persona & Automatic Conflict Resolution
+
+```javascript
+// Initial preference
+db.add("I prefer TypeScript for backend APIs", "usr_sarah");
+console.log(db.getPersona("usr_sarah")); 
+// => { preference: ["TypeScript for backend APIs"] }
+
+// User changes their mind later:
+db.add("I now prefer Rust for mission-critical core engines", "usr_sarah");
+
+// Conflicting older preference is automatically reconciled
+console.log(db.getPersona("usr_sarah"));
+// => { preference: ["Rust for mission-critical core engines"] }
+```
+
+### 3. Explicit temporal supersession and historical recall
+
+When a user explicitly replaces a fact, preserve the original fact and its provenance while marking the newer fact as its successor:
+
+```javascript
+const oldLog = db.add("I prefer Python for data work.", "usr_sarah");
+const oldFact = Array.from(db.atoms.values()).find(a => a.sourceId === oldLog);
+const cutoff = oldFact.ts + 0.001;
+
+const newLog = db.add("I prefer Rust for systems work.", "usr_sarah");
+const newFact = Array.from(db.atoms.values()).find(a => a.sourceId === newLog);
+
+db.supersedeFact(oldFact.id, newFact.id, "usr_sarah");
+
+// Current recall returns the active fact; historical recall can still see the old one.
+db.recall("Python", { userId: "usr_sarah" }).results; // []
+db.recall("Python", { userId: "usr_sarah", asOf: cutoff }).results;
+```
+
+Supersession is explicit; the SDK does not infer semantic contradictions. Both facts and their proof records remain stored. Relations are tenant-scoped and cycle-checked. SQLite mode persists relations across reopen.
+
+### 4. Cryptographic Audit Proofs (SHA-256 Chain)
+
+Every atomic fact is hashed and anchored into an immutable tamper-evident proof chain:
+
+```javascript
+const atomId = memory.results[0].id;
+const proof = db.getProof(atomId);
+
+console.log(proof);
+// {
+//   atomId: "ATOM_...",
+//   hash: "a4f8c2...",
+//   verified: true,
+//   timestamp: 1729100000000
+// }
+```
+
+### 5. Enterprise Policies & Guardrails
+
+```javascript
+// Register a global policy or a tenant-scoped policy
+db.addPolicy("Never log plaintext passwords or API keys", "security", 2.0);
+db.addPolicy("Tenant-specific retention rule", "retention", 1.5, "usr_sarah");
+
+const recall = db.recall("database credentials", { userId: "usr_sarah" });
+console.log(recall.policies); // Global + usr_sarah policies only
+```
+
+### 6. Tenant data deletion
+
+```javascript
+// Remove this tenant’s stored logs, facts, episodes, and persona state
+const result = db.deleteUser("usr_sarah");
+console.log(result); // Per-layer deletion counts
+```
+
+This API reports database deletion results only; it does not certify legal or regulatory compliance.
+
+### 7. Backwards-Compatible Key-Value Store
+
+```javascript
+db.put("session:123", "active");
+const val = db.get("session:123");
+db.delete("session:123");
+```
+
+
+### 8. Durable SQLite storage (Node.js)
+
+Install the package dependencies, then provide a database path to enable durable storage:
+
+```javascript
+const { InfinityDB } = require("infinitydb");
+const db = new InfinityDB({ dbPath: "./data/infinitydb.sqlite" });
+
+db.add("I prefer SQLite for durable memory.", "user_123");
+console.log(db.recall("SQLite", { userId: "user_123" }).results);
+
+// Close cleanly before process shutdown. Reopen with the same dbPath to recover state.
+db.close();
+```
+
+When `dbPath` is omitted, the SDK remains in-memory for backwards compatibility.
+The SQLite-backed mode uses WAL, FULL synchronous commits, a busy timeout, and normalized
+L0/L1/L2/L3/L4/L6 tables with transactional row upserts. Existing v1 JSON-snapshot databases
+are migrated transactionally to schema v2 on first open. SDK instances refresh their view
+from SQLite before public reads and mutations, and sequence allocation is serialized by a
+SQLite write transaction. This is not yet a guarantee of serializable concurrent read-modify-write
+operations across processes; use a single writer until that coordination layer is added.
+Back up the database using SQLite's backup facilities.
+
+---
+
+## Architecture (L0 – L6 Brain)
+
+| Layer | Component | Function |
+| :--- | :--- | :--- |
+| **L0** | Raw Interaction Store | Append-only raw interaction logs |
+| **L1** | Atomic Fact Extractor | Deterministic, zero-hallucination semantic extraction |
+| **L2** | Episodic Graph | Causal edge tracking between related memory episodes |
+| **L3** | Dynamic Persona | Identity state with automatic chronological conflict resolution |
+| **L4** | Enterprise Policy Engine | Real-time policy and compliance injection |
+| **L5** | Ebbinghaus Decay | Recency and frequency weighted memory decay |
+| **L6** | SHA-256 Proof Chain | Cryptographically verifiable audit trail |
+
+---
+
+## TypeScript Support
+
+InfinityDB includes full type definitions out of the box (`index.d.ts`). No `@types/infinitydb` required.
+
+---
+
+## Links
+
+- **Documentation & Benchmarks**: [https://github.com/infinitydb-ai/infinitydb](https://github.com/infinitydb-ai/infinitydb)
+- **Python Package (PyPI)**: [`pip install infinitydb-ai`](https://pypi.org/project/infinitydb-ai/)
+- **License**: Apache 2.0

package/index.d.ts

@@ -0,0 +1,45 @@
+export interface MemoryResult {
+  id: string;
+  fact: string;
+  category: string;
+  sourceId: string;
+  score: number;
+  retention: number;
+  ts: number;
+}
+
+export interface RecallResponse {
+  results: MemoryResult[];
+  causalGraph: Array<{ cause: string; effect: string; relation: string }>;
+  policies: Array<{ id: string; rule: string; domain: string; priority: number }>;
+  latencyMs: number;
+  tokensSaved: string | null;
+  proofAvailable: boolean;
+}
+
+export interface ProofResponse {
+  atomId: string;
+  hash: string;
+  sourceLogId: string;
+  rawSnippet: string;
+  charRange: [number, number];
+  verified: boolean;
+  timestamp: number;
+}
+
+export class InfinityDB {
+  constructor(options?: { dbPath?: string } & Record<string, any>);
+  add(conversation: string, userId?: string, sessionId?: string | null, importance?: number): string;
+  recall(query: string, options?: { n?: number; userId?: string | null; asOf?: number }): RecallResponse;
+  supersedeFact(oldAtomId: string, newAtomId: string, userId: string): string;
+  getProof(atomId: string): ProofResponse | null;
+  getPersona(userId?: string): Record<string, string>;
+  addPolicy(rule: string, domain?: string, priority?: number, tenantId?: string | null): string;
+  exportGraph(userId?: string): string;
+  deleteUser(userId: string): Record<string, any>;
+  stats(): Record<string, any>;
+  close(): void;
+  put(key: string, content: string): { key: string; content: string; createdAt: string };
+  get(key: string): { key: string; content: string; createdAt: string } | null;
+  delete(key: string): boolean;
+}

package/index.js

@@ -0,0 +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._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 };

package/package.json

@@ -1,6 +1,39 @@
-{
-  "name": "infinitydb",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+{
+  "name": "infinitydb",
+  "version": "1.4.0",
+  "description": "InfinityDB - High-performance agent memory engine. Remember Everything. Forget Nothing That Matters.",
+  "main": "index.js",
+  "types": "index.d.ts",
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/infinitydb-ai/infinitydb.git"
+  },
+  "homepage": "https://github.com/infinitydb-ai/infinitydb#readme",
+  "bugs": {
+    "url": "https://github.com/infinitydb-ai/infinitydb/issues"
+  },
+  "keywords": [
+    "agent-memory",
+    "ai-agents",
+    "llm-memory",
+    "vector-database",
+    "rag",
+    "sqlite",
+    "long-term-memory"
+  ],
+  "author": "InfinityDB AI <contact@infinitydb.ai>",
+  "files": [
+    "index.js",
+    "index.d.ts",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "test": "node test.js && node benchmark.test.js",
+    "benchmark": "node benchmark.js"
+  },
+  "dependencies": {
+    "better-sqlite3": "^11.10.0"
+  }
+}