agentdb 3.0.0-alpha.1 → 3.0.0-alpha.11

package/README.md

@@ -1,6 +1,6 @@
 # AgentDB v3
 
-> Intelligent agentic vector database — learns from experience, optimizes itself, runs anywhere
+> Intelligent agentic vector memory — learns from experience, optimizes itself, runs anywhere
 
 [![npm version](https://img.shields.io/npm/v/agentdb.svg?style=flat-square)](https://www.npmjs.com/package/agentdb)
 [![npm downloads](https://img.shields.io/npm/dm/agentdb.svg?style=flat-square)](https://www.npmjs.com/package/agentdb)
@@ -12,30 +12,34 @@
 
 ## What is AgentDB?
 
-**AgentDB is a vector database that gets smarter every time you use it.**
+**AgentDB is a vector memory and database that gets smarter every time you use it.**
 
 Most vector databases store and retrieve embeddings. AgentDB does that too — 150x faster — but it also watches which results your AI agent actually used, learns from that feedback, and returns better results next time. Search quality improves by up to **36% automatically**, with zero manual tuning.
 
 Everything lives in a **single Cognitive Container** (`.rvf` file) — vectors, indexes, learning state, and a cryptographic audit trail. No external services. No API keys. No monthly bills.
 
 > **3 lines to self-learning search:**
+>
 > ```typescript
-> const backend = await SelfLearningRvfBackend.create({ learning: true, storagePath: './my.rvf' });
-> const results = await backend.searchAsync(query, 10);  // search
-> backend.recordFeedback('q1', 0.9);                     // learn — next search is smarter
+> const backend = await SelfLearningRvfBackend.create({
+>   learning: true,
+>   storagePath: "./my.rvf",
+> });
+> const results = await backend.searchAsync(query, 10); // search
+> backend.recordFeedback("q1", 0.9); // learn — next search is smarter
 > ```
 
 ### Who is it for?
 
-| If you're building... | AgentDB gives you... |
-| --- | --- |
-| **A RAG chatbot** | Search that learns which documents actually answer user questions |
-| **A code review agent** | Pattern memory that remembers what worked across 1000s of reviews |
-| **A research assistant** | Skill library that builds reusable tools from successful strategies |
-| **An RL-powered agent** | 9 algorithms from Q-Learning to PPO, with bandit-guided algorithm selection and transfer learning |
-| **A Claude Code / MCP tool** | 41 tools that plug in with one command |
-| **An offline or edge app** | Full vector DB in the browser via WASM — no server needed |
-| **An enterprise platform** | JWT auth, API key rotation, Argon2id hashing, SOC2/GDPR audit logs |
+| If you're building...        | AgentDB gives you...                                                                              |
+| ---------------------------- | ------------------------------------------------------------------------------------------------- |
+| **A RAG chatbot**            | Search that learns which documents actually answer user questions                                 |
+| **A code review agent**      | Pattern memory that remembers what worked across 1000s of reviews                                 |
+| **A research assistant**     | Skill library that builds reusable tools from successful strategies                               |
+| **An RL-powered agent**      | 9 algorithms from Q-Learning to PPO, with bandit-guided algorithm selection and transfer learning |
+| **A Claude Code / MCP tool** | 41 tools that plug in with one command                                                            |
+| **An offline or edge app**   | Full vector DB in the browser via WASM — no server needed                                         |
+| **An enterprise platform**   | JWT auth, API key rotation, Argon2id hashing, SOC2/GDPR audit logs                                |
 
 ---
 
@@ -43,50 +47,50 @@ Everything lives in a **single Cognitive Container** (`.rvf` file) — vectors,
 
 ### Intelligence
 
-| | |
-| --- | --- |
-| **Self-Learning Search** | Gets 36% better over time — learns from feedback, no manual tuning |
-| **Cognitive Memory** | 6 human-inspired patterns: learn from mistakes, build reusable skills, discover what causes what |
+|                           |                                                                                                                  |
+| ------------------------- | ---------------------------------------------------------------------------------------------------------------- |
+| **Self-Learning Search**  | Gets 36% better over time — learns from feedback, no manual tuning                                               |
+| **Cognitive Memory**      | 6 human-inspired patterns: learn from mistakes, build reusable skills, discover what causes what                 |
 | **Decision Intelligence** | Thompson Sampling bandit auto-tunes skill selection, pattern ranking, compression tiers, and RL algorithm choice |
-| **9 RL Algorithms** | Q-Learning, SARSA, DQN, PPO, Actor-Critic, Policy Gradient, Decision Transformer, MCTS, Model-Based RL |
-| **Hybrid Search** | BM25 keyword + vector with Reciprocal Rank Fusion — exact matches + semantic understanding |
-| **Graph Intelligence** | Cypher queries, causal reasoning, GNN 8-head attention (+12.4% recall) |
+| **9 RL Algorithms**       | Q-Learning, SARSA, DQN, PPO, Actor-Critic, Policy Gradient, Decision Transformer, MCTS, Model-Based RL           |
+| **Hybrid Search**         | BM25 keyword + vector with Reciprocal Rank Fusion — exact matches + semantic understanding                       |
+| **Graph Intelligence**    | Cypher queries, causal reasoning, GNN 8-head attention (+12.4% recall)                                           |
 
 ### Performance
 
-| | |
-| --- | --- |
-| **150x Faster** | 61us search with Rust+SIMD — 800x faster than Pinecone, 160x faster than Chroma |
-| **4 Backends** | Auto-selects best available: RuVector (Rust) > RVF > HNSWLib (C++) > sql.js (WASM) |
-| **Runs Anywhere** | Node.js, browsers (WASM), edge functions, fully offline |
-| **AgentDBFast** | 50-200x faster programmatic API — skip CLI overhead for production workloads |
+|                   |                                                                                    |
+| ----------------- | ---------------------------------------------------------------------------------- |
+| **150x Faster**   | 61us search with Rust+SIMD — 800x faster than Pinecone, 160x faster than Chroma    |
+| **4 Backends**    | Auto-selects best available: RuVector (Rust) > RVF > HNSWLib (C++) > sql.js (WASM) |
+| **Runs Anywhere** | Node.js, browsers (WASM), edge functions, fully offline                            |
+| **AgentDBFast**   | 50-200x faster programmatic API — skip CLI overhead for production workloads       |
 
 ### Storage & Data
 
-| | |
-| --- | --- |
-| **Cognitive Container (RVF)** | Single `.rvf` file — vectors, index, learning state, SHAKE-256 witness chain |
-| **COW Branching** | Instant copy-on-write branches for experiments, with full lineage tracking |
-| **Compression** | 5-tier auto-tiering (hot/warm/cool/cold/archive), scalar 8-bit/4-bit, product quantization |
-| **Metadata Filtering** | 10 MongoDB-style operators ($eq, $gt, $in, $contains, $exists, etc.) |
+|                               |                                                                                            |
+| ----------------------------- | ------------------------------------------------------------------------------------------ |
+| **Cognitive Container (RVF)** | Single `.rvf` file — vectors, index, learning state, SHAKE-256 witness chain               |
+| **COW Branching**             | Instant copy-on-write branches for experiments, with full lineage tracking                 |
+| **Compression**               | 5-tier auto-tiering (hot/warm/cool/cold/archive), scalar 8-bit/4-bit, product quantization |
+| **Metadata Filtering**        | 10 MongoDB-style operators ($eq, $gt, $in, $contains, $exists, etc.)                       |
 
 ### Integration & Tools
 
-| | |
-| --- | --- |
-| **41 MCP Tools** | One command to connect to Claude Code, Cursor, or any MCP-compatible assistant |
-| **Chat UI** | `@agentdb/chat` — deploy a self-learning RAG chatbot in one line |
-| **LLM Router** | Auto-selects best provider: RuvLLM (local), OpenRouter (200+ models), Gemini, Claude, ONNX |
-| **Real-Time Sync** | QUIC transport, multi-instance replication, 4 conflict resolution strategies |
+|                    |                                                                                            |
+| ------------------ | ------------------------------------------------------------------------------------------ |
+| **41 MCP Tools**   | One command to connect to Claude Code, Cursor, or any MCP-compatible assistant             |
+| **Chat UI**        | `@agentdb/chat` — deploy a self-learning RAG chatbot in one line                           |
+| **LLM Router**     | Auto-selects best provider: RuvLLM (local), OpenRouter (200+ models), Gemini, Claude, ONNX |
+| **Real-Time Sync** | QUIC transport, multi-instance replication, 4 conflict resolution strategies               |
 
 ### Enterprise & Security
 
-| | |
-| --- | --- |
-| **Auth & Audit** | JWT tokens, Argon2id hashing, API key rotation, SOC2/GDPR/HIPAA logging |
-| **Security** | Input validation, XSS/injection prevention, Cypher sanitization, witness chain verification |
-| **Observability** | OpenTelemetry traces, Prometheus metrics, structured logging |
-| **Benchmarking** | 5 built-in benchmarks, custom benchmark classes, Markdown/JSON reports |
+|                   |                                                                                             |
+| ----------------- | ------------------------------------------------------------------------------------------- |
+| **Auth & Audit**  | JWT tokens, Argon2id hashing, API key rotation, SOC2/GDPR/HIPAA logging                     |
+| **Security**      | Input validation, XSS/injection prevention, Cypher sanitization, witness chain verification |
+| **Observability** | OpenTelemetry traces, Prometheus metrics, structured logging                                |
+| **Benchmarking**  | 5 built-in benchmarks, custom benchmark classes, Markdown/JSON reports                      |
 
 > **Zero config, zero cost.** `npm install agentdb` and go — fully local, no API keys, no cloud fees.
 
@@ -97,8 +101,96 @@ npm install agentdb          # Latest stable (v2)
 npm install agentdb@alpha    # Latest alpha (v3 — unified .rvf, self-learning, SolverBandit)
 ```
 
+**Zero native dependencies.** AgentDB uses sql.js (WASM SQLite) — no Python, no C++ compiler, no `node-gyp`. Works on Windows, macOS, Linux, and CI containers out of the box. `better-sqlite3` is supported as an optional performance upgrade but never required.
+
 ---
 
+## 🧠 Agent Memory Intelligence
+
+AgentDB v3.0.0-alpha.6 introduces revolutionary **sparse attention** and **graph partitioning** capabilities that enable AI agents to handle massive knowledge graphs with 10-100x performance improvements.
+
+### Memory-Oriented Architecture
+
+AgentDB is designed as an **agent memory substrate** - a persistent, intelligent memory layer that agents can query, update, and learn from:
+
+**Core Memory Capabilities**:
+- 🎯 **Sparse Attention** - 10-100x speedup for large graphs using PPR, random walk, spectral sparsification
+- 📊 **Graph Partitioning** - 50-80% memory reduction with Stoer-Wagner, Karger, flow-based mincut
+- ⚡ **Fused Attention** - 10-50x faster kernel fusion (exceeded 20-25% target by 40x!)
+- 🔍 **Zero-Copy Indexing** - 90% fewer allocations, 40-50% speedup
+- 🏗️ **Clean Architecture** - 6 focused classes replacing 782-line god object
+
+### Agent Memory Pattern
+
+```typescript
+import { SparsificationService, MincutService, AttentionService } from 'agentdb';
+
+// Initialize agent memory layer
+const memory = new AttentionService();
+await memory.initialize();
+
+// Sparse attention for agent memory retrieval (10-100x faster)
+const relevantMemories = await memory.sparseAttention(
+  agentQuery,
+  memoryGraph,
+  {
+    method: 'ppr',          // Personalized PageRank
+    topK: 50,               // Top 50 most relevant
+    sparsificationRatio: 0.1 // Keep 10% of edges
+  }
+);
+
+// Partitioned attention for distributed agent teams
+const teamMemories = await memory.partitionedAttention(
+  teamQuery,
+  sharedKnowledge,
+  {
+    method: 'stoer-wagner',  // Optimal partitioning
+    maxPartitionSize: 1000   // Max 1000 nodes per partition
+  }
+);
+
+// Fused attention for rapid memory access (10-50x faster)
+const fastAccess = await memory.fusedAttention(
+  query,
+  keys,
+  values
+);
+```
+
+### Performance Metrics
+
+| Operation | Before | After | Improvement |
+|-----------|--------|-------|-------------|
+| Sparse Attention (N=10K) | 1000ms | 10-100ms | **10-100x** |
+| Memory Reduction | 100% | 20-50% | **50-80% less** |
+| Fused Attention | 1010ms | 21ms | **49x faster** |
+| Allocations | 100% | 10% | **90% fewer** |
+
+### Use Cases
+
+**Agent Episodic Memory**:
+```typescript
+// Store agent experiences as sparse graphs
+await sparsification.sparseByPPR(experienceGraph, {
+  alpha: 0.15,
+  topK: 100
+});
+```
+
+**Multi-Agent Knowledge Sharing**:
+```typescript
+// Partition knowledge for team collaboration
+const partitions = await mincut.computeStoerWagner(teamKnowledge);
+```
+
+**Rapid Context Retrieval**:
+```typescript
+// Fused attention for instant memory access
+const context = await attention.fusedAttention(Q, K, V);
+```
+
+---
 ## Comparison
 
 > **61 microseconds.** That's 800x faster than Pinecone, 160x faster than Chroma, and the only vector database that learns from your usage and gets better over time.
@@ -107,45 +199,45 @@ npm install agentdb@alpha    # Latest alpha (v3 — unified .rvf, self-learning,
 
 #### Intelligence
 
-| Feature | AgentDB v3 | Pinecone | Chroma | Weaviate | pgvector |
-| --- | --- | --- | --- | --- | --- |
-| Self-learning pipeline | SONA + contrastive + federated + bandit | No | No | No | No |
-| Reinforcement learning | 9 algorithms (Q-Learning to MCTS) | No | No | No | No |
-| Cognitive memory | 6 patterns | No | No | No | No |
-| Hybrid search | BM25 + vector (RRF fusion) | No | No | BM25 only | No |
-| Graph queries | Cypher | No | No | GraphQL | No |
+| Feature                | AgentDB v3                              | Pinecone | Chroma | Weaviate  | pgvector |
+| ---------------------- | --------------------------------------- | -------- | ------ | --------- | -------- |
+| Self-learning pipeline | SONA + contrastive + federated + bandit | No       | No     | No        | No       |
+| Reinforcement learning | 9 algorithms (Q-Learning to MCTS)       | No       | No     | No        | No       |
+| Cognitive memory       | 6 patterns                              | No       | No     | No        | No       |
+| Hybrid search          | BM25 + vector (RRF fusion)              | No       | No     | BM25 only | No       |
+| Graph queries          | Cypher                                  | No       | No     | GraphQL   | No       |
 
 #### Performance & Deployment
 
-| Feature | AgentDB v3 | Pinecone | Chroma | Weaviate | pgvector |
-| --- | --- | --- | --- | --- | --- |
-| Search latency | **61us** | ~50ms | ~10ms | ~5ms | ~2ms |
-| Runs offline | Full | No | Yes | Yes | Yes |
-| Browser (WASM) | Yes | No | No | No | No |
+| Feature        | AgentDB v3 | Pinecone | Chroma | Weaviate | pgvector |
+| -------------- | ---------- | -------- | ------ | -------- | -------- |
+| Search latency | **61us**   | ~50ms    | ~10ms  | ~5ms     | ~2ms     |
+| Runs offline   | Full       | No       | Yes    | Yes      | Yes      |
+| Browser (WASM) | Yes        | No       | No     | No       | No       |
 
 #### Storage
 
-| Feature | AgentDB v3 | Pinecone | Chroma | Weaviate | pgvector |
-| --- | --- | --- | --- | --- | --- |
-| Cognitive Container | Single `.rvf` file + COW branching | No | No | No | No |
-| Monthly cost | **$0** | $70+ | $0 | $0+ | $0+ |
+| Feature             | AgentDB v3                         | Pinecone | Chroma | Weaviate | pgvector |
+| ------------------- | ---------------------------------- | -------- | ------ | -------- | -------- |
+| Cognitive Container | Single `.rvf` file + COW branching | No       | No     | No       | No       |
+| Monthly cost        | **$0**                             | $70+     | $0     | $0+      | $0+      |
 
 #### Integration & Security
 
-| Feature | AgentDB v3 | Pinecone | Chroma | Weaviate | pgvector |
-| --- | --- | --- | --- | --- | --- |
-| MCP integration | 41 tools | No | No | No | No |
-| Auth & audit | JWT + Argon2id + compliance logs | No | No | No | No |
-| Local-first | Yes | Cloud only | Yes | Self-host | Postgres |
+| Feature         | AgentDB v3                       | Pinecone   | Chroma | Weaviate  | pgvector |
+| --------------- | -------------------------------- | ---------- | ------ | --------- | -------- |
+| MCP integration | 41 tools                         | No         | No     | No        | No       |
+| Auth & audit    | JWT + Argon2id + compliance logs | No         | No     | No        | No       |
+| Local-first     | Yes                              | Cloud only | Yes    | Self-host | Postgres |
 
 ### Backend Performance
 
-| Backend | Latency | Recall@10 | Native | Best For |
-| --- | --- | --- | --- | --- |
-| **RuVector** (Rust + SIMD) | 61us | 96.8% | Yes | Production, high throughput |
-| **Cognitive Container** (RVF) | ~100us | 96.8% | Yes | Portable, branching, lineage |
-| **HNSWLib** (C++) | ~500us | 95%+ | Yes | Compatibility |
-| **sql.js** (WASM) | ~5ms | 90%+ | No | Zero-dependency fallback |
+| Backend                       | Latency | Recall@10 | Native | Best For                     |
+| ----------------------------- | ------- | --------- | ------ | ---------------------------- |
+| **RuVector** (Rust + SIMD)    | 61us    | 96.8%     | Yes    | Production, high throughput  |
+| **Cognitive Container** (RVF) | ~100us  | 96.8%     | Yes    | Portable, branching, lineage |
+| **HNSWLib** (C++)             | ~500us  | 95%+      | Yes    | Compatibility                |
+| **sql.js** (WASM)             | ~5ms    | 90%+      | No     | Zero-dependency fallback     |
 
 AgentDB auto-selects the best available: RuVector > Cognitive Container (RVF) > HNSWLib > sql.js
 
@@ -162,30 +254,30 @@ npm install agentdb
 The `AgentDB` class is the simplest way to use AgentDB. Everything — vectors, relational data, learning state — lives in a single `.rvf` file:
 
 ```typescript
-import { AgentDB } from 'agentdb';
+import { AgentDB } from "agentdb";
 
-const db = new AgentDB({ dbPath: './knowledge.rvf' });
+const db = new AgentDB({ dbPath: "./knowledge.rvf" });
 await db.initialize();
 
 // All controllers are ready — reflexion memory, skill library, causal graph
-const reflexion = db.getController('reflexion');
-const skills = db.getController('skills');
-const causal = db.getController('causal');
+const reflexion = db.getController("reflexion");
+const skills = db.getController("skills");
+const causal = db.getController("causal");
 
 // Store an episode
 await reflexion.storeEpisode({
-  sessionId: 'session-1',
-  task: 'Fix auth bug',
+  sessionId: "session-1",
+  task: "Fix auth bug",
   reward: 0.95,
   success: true,
-  critique: 'OAuth2 PKCE was the right approach',
+  critique: "OAuth2 PKCE was the right approach",
 });
 
 // Create a reusable skill
 await skills.createSkill({
-  name: 'jwt_auth',
-  description: 'JWT authentication with refresh tokens',
-  code: 'implementation...',
+  name: "jwt_auth",
+  description: "JWT authentication with refresh tokens",
+  code: "implementation...",
   successRate: 0.92,
 });
 
@@ -196,13 +288,13 @@ await db.close();
 
 **Configuration options:**
 
-| Option | Default | Description |
-| --- | --- | --- |
-| `dbPath` | `':memory:'` | Path to `.rvf` file (or `.db` for legacy mode) |
-| `vectorBackend` | `'rvf'` | Backend: `'rvf'` (unified), `'auto'`, `'ruvector'`, `'hnswlib'` |
-| `vectorDimension` | `384` | Embedding dimension (384 for MiniLM, 768 for bge-base) |
-| `forceWasm` | `false` | Force sql.js WASM even if better-sqlite3 is available |
-| `enableAttention` | `false` | Enable GNN attention mechanisms |
+| Option            | Default      | Description                                                                                |
+| ----------------- | ------------ | ------------------------------------------------------------------------------------------ |
+| `dbPath`          | `':memory:'` | Path to `.rvf` file (or `.db` for legacy mode)                                             |
+| `vectorBackend`   | `'rvf'`      | Backend: `'rvf'` (unified), `'auto'`, `'ruvector'`, `'hnswlib'`                            |
+| `vectorDimension` | `384`        | Embedding dimension (384 for MiniLM, 768 for bge-base)                                     |
+| `forceWasm`       | `false`      | Force sql.js WASM backend (sql.js is the default; `better-sqlite3` used only if installed) |
+| `enableAttention` | `false`      | Enable GNN attention mechanisms                                                            |
 
 **Controllers:** `db.getController('reflexion')` (ReflexionMemory), `db.getController('skills')` (SkillLibrary), `db.getController('causal')` (CausalMemoryGraph)
 
@@ -293,26 +385,26 @@ npx agentdb mcp start --port 8080        # Custom port
 Most vector databases return the same results no matter how many times you query them. AgentDB closes the loop: after every search, you tell it which results were actually useful. A contrastive trainer (InfoNCE + hard-negative mining) adjusts a lightweight LoRA adapter in under 1 ms, and EWC++ consolidation keeps old knowledge intact. Over 500 feedback cycles, recall jumps from 54% to 90% — automatically.
 
 ```typescript
-import { SelfLearningRvfBackend } from 'agentdb/backends/rvf/SelfLearningRvfBackend';
+import { SelfLearningRvfBackend } from "agentdb/backends/rvf/SelfLearningRvfBackend";
 
 // Create a self-learning Cognitive Container
 const backend = await SelfLearningRvfBackend.create({
   dimension: 384,
-  metric: 'cosine',
-  storagePath: './knowledge.rvf',
-  learning: true,  // enable the learning pipeline
+  metric: "cosine",
+  storagePath: "./knowledge.rvf",
+  learning: true, // enable the learning pipeline
 });
 
 // Insert documents
-await backend.insertAsync('doc-1', embedding, { title: 'Auth Guide' });
-await backend.insertAsync('doc-2', embedding2, { title: 'API Reference' });
+await backend.insertAsync("doc-1", embedding, { title: "Auth Guide" });
+await backend.insertAsync("doc-2", embedding2, { title: "API Reference" });
 
 // Search — automatically routed through the learning pipeline
 const results = await backend.searchAsync(queryEmbedding, 10);
 
 // Tell AgentDB which results were useful — this drives learning
-backend.recordFeedback('query-1', 0.95);  // great result
-backend.recordFeedback('query-2', 0.2);   // poor result
+backend.recordFeedback("query-1", 0.95); // great result
+backend.recordFeedback("query-2", 0.2); // poor result
 
 // Run a learning tick — trains the model, updates adapters
 await backend.tick();
@@ -324,24 +416,24 @@ await backend.tick();
 Store and retrieve reasoning patterns — your agent remembers what worked:
 
 ```typescript
-import { createDatabase, ReasoningBank, EmbeddingService } from 'agentdb';
+import { createDatabase, ReasoningBank, EmbeddingService } from "agentdb";
 
-const db = await createDatabase('./agent-memory.db');
-const embedder = new EmbeddingService({ model: 'Xenova/all-MiniLM-L6-v2' });
+const db = await createDatabase("./agent-memory.db");
+const embedder = new EmbeddingService({ model: "Xenova/all-MiniLM-L6-v2" });
 await embedder.initialize();
 
 const reasoningBank = new ReasoningBank(db, embedder);
 
 // Store what your agent learned
 await reasoningBank.storePattern({
-  taskType: 'code_review',
-  approach: 'Security-first analysis',
+  taskType: "code_review",
+  approach: "Security-first analysis",
   successRate: 0.95,
 });
 
 // Find similar successful patterns
 const patterns = await reasoningBank.searchPatterns({
-  task: 'security code review',
+  task: "security code review",
   k: 10,
 });
 ```
@@ -351,25 +443,25 @@ const patterns = await reasoningBank.searchPatterns({
 In v3, `AgentDB` stores vectors, relational data, learning state, and metadata in a single `.rvf` file:
 
 ```typescript
-import { AgentDB } from 'agentdb';
+import { AgentDB } from "agentdb";
 
 // Single-file mode is the default — no configuration needed
-const db = new AgentDB({ dbPath: './agent.rvf' });
+const db = new AgentDB({ dbPath: "./agent.rvf" });
 await db.initialize();
 
 // Access the underlying database for advanced queries
 const raw = db.database;
-const stats = raw.prepare('SELECT COUNT(*) as c FROM episodes').get();
+const stats = raw.prepare("SELECT COUNT(*) as c FROM episodes").get();
 
 // Check mode
-console.log(db.isUnifiedMode);     // true — everything in one .rvf file
+console.log(db.isUnifiedMode); // true — everything in one .rvf file
 console.log(db.vectorBackendName); // 'rvf'
 
 // Save and reopen — all data persists in agent.rvf
 await db.save();
 await db.close();
 
-const db2 = new AgentDB({ dbPath: './agent.rvf' });
+const db2 = new AgentDB({ dbPath: "./agent.rvf" });
 await db2.initialize(); // All episodes, skills, vectors restored
 ```
 
@@ -447,15 +539,15 @@ Or add to `~/.config/claude/claude_desktop_config.json`:
 
 ### MCP Tools Overview
 
-| Category | Tools | Examples |
-| --- | --- | --- |
-| **Core DB** | 6 | init, insert, batch insert, search, delete, stats |
-| **Patterns** | 4 | store, search, batch store, statistics |
-| **Memory** | 9 | reflexion store/retrieve/batch, skill create/search/batch, causal edges/queries, nightly learner |
-| **Learning** | 10 | RL sessions, predictions, feedback, training, transfer learning, explainability |
-| **Recall** | 2 | explainable recall with provenance certificates, cache management |
-| **Solver** | 4 | solver train, acceptance testing, policy inspection, witness chain audit |
-| **Admin** | 6 | diagnostics, migration, pruning, experience recording, reward signals, legacy stats |
+| Category     | Tools | Examples                                                                                         |
+| ------------ | ----- | ------------------------------------------------------------------------------------------------ |
+| **Core DB**  | 6     | init, insert, batch insert, search, delete, stats                                                |
+| **Patterns** | 4     | store, search, batch store, statistics                                                           |
+| **Memory**   | 9     | reflexion store/retrieve/batch, skill create/search/batch, causal edges/queries, nightly learner |
+| **Learning** | 10    | RL sessions, predictions, feedback, training, transfer learning, explainability                  |
+| **Recall**   | 2     | explainable recall with provenance certificates, cache management                                |
+| **Solver**   | 4     | solver train, acceptance testing, policy inspection, witness chain audit                         |
+| **Admin**    | 6     | diagnostics, migration, pruning, experience recording, reward signals, legacy stats              |
 
 All 41 tools support parallel execution markers, batch operations, intelligent caching, and format parameters for token reduction.
 
@@ -473,15 +565,16 @@ npx @agentdb/chat serve --rvf ./kb.rvf --port 3000
 Programmatic usage:
 
 ```typescript
-import { createChatServer } from '@agentdb/chat';
+import { createChatServer } from "@agentdb/chat";
 
-const server = await createChatServer('./kb.rvf', {
+const server = await createChatServer("./kb.rvf", {
   port: 3000,
   learning: true,
 });
 ```
 
 The chat ecosystem includes:
+
 - **Chat Server** — streaming inference with any LLM provider
 - **Chat Persistence** — conversation history stored in Cognitive Containers
 - **MCP Bridge** — expose all 37 AgentDB tools through chat
@@ -566,16 +659,19 @@ npx agentdb doctor --fix
 Configure cross-session federated learning for continuous improvement:
 
 ```typescript
-import { FederatedLearningCoordinator, EphemeralLearningAgent } from 'agentdb/services/federated-learning';
+import {
+  FederatedLearningCoordinator,
+  EphemeralLearningAgent,
+} from "agentdb/services/federated-learning";
 
 const coordinator = new FederatedLearningCoordinator({
-  agentId: 'coordinator-1',
+  agentId: "coordinator-1",
   minQuality: 0.7,
   maxAgents: 100,
 });
 
 const agent = new EphemeralLearningAgent({
-  agentId: 'session-agent-1',
+  agentId: "session-agent-1",
   qualityFiltering: true,
 });
 
@@ -594,34 +690,39 @@ const merged = await coordinator.consolidate();
 #### Tutorial 1: Build a Learning Code Review Agent
 
 ```typescript
-import { createDatabase, ReasoningBank, ReflexionMemory, EmbeddingService } from 'agentdb';
-
-const db = await createDatabase('./code-reviewer.db');
-const embedder = new EmbeddingService({ model: 'Xenova/all-MiniLM-L6-v2' });
+import {
+  createDatabase,
+  ReasoningBank,
+  ReflexionMemory,
+  EmbeddingService,
+} from "agentdb";
+
+const db = await createDatabase("./code-reviewer.db");
+const embedder = new EmbeddingService({ model: "Xenova/all-MiniLM-L6-v2" });
 await embedder.initialize();
 
 const reasoningBank = new ReasoningBank(db, embedder);
 const reflexion = new ReflexionMemory(db, embedder);
 
 await reasoningBank.storePattern({
-  taskType: 'code_review',
-  approach: 'Security scan > Type safety > Code quality > Performance',
+  taskType: "code_review",
+  approach: "Security scan > Type safety > Code quality > Performance",
   successRate: 0.94,
 });
 
 const result = await performCodeReview(code);
 await reflexion.storeEpisode({
-  sessionId: 'review-1',
-  task: 'Review authentication PR',
+  sessionId: "review-1",
+  task: "Review authentication PR",
   reward: result.issuesFound > 0 ? 0.9 : 0.6,
   success: true,
-  critique: 'Found SQL injection — security checks work!',
+  critique: "Found SQL injection — security checks work!",
   input: code,
   output: result.findings,
 });
 
 const pastReviews = await reflexion.retrieveRelevant({
-  task: 'authentication code review',
+  task: "authentication code review",
   k: 5,
   onlySuccesses: true,
 });
@@ -630,23 +731,26 @@ const pastReviews = await reflexion.retrieveRelevant({
 #### Tutorial 2: RAG with Self-Learning Skills
 
 ```typescript
-import { createDatabase, SkillLibrary, EmbeddingService } from 'agentdb';
+import { createDatabase, SkillLibrary, EmbeddingService } from "agentdb";
 
-const db = await createDatabase('./rag-system.db');
-const embedder = new EmbeddingService({ model: 'Xenova/all-MiniLM-L6-v2' });
+const db = await createDatabase("./rag-system.db");
+const embedder = new EmbeddingService({ model: "Xenova/all-MiniLM-L6-v2" });
 await embedder.initialize();
 
 const skills = new SkillLibrary(db, embedder);
 
 await skills.createSkill({
-  name: 'expand_query',
-  description: 'Expand user query with domain-specific synonyms',
-  signature: { inputs: { query: 'string' }, outputs: { expanded: 'string[]' } },
+  name: "expand_query",
+  description: "Expand user query with domain-specific synonyms",
+  signature: { inputs: { query: "string" }, outputs: { expanded: "string[]" } },
   code: `const map = { 'bug': ['issue', 'defect', 'error'] }; ...`,
   successRate: 0.92,
 });
 
-const applicable = await skills.searchSkills({ task: 'find technical documentation', k: 10 });
+const applicable = await skills.searchSkills({
+  task: "find technical documentation",
+  k: 10,
+});
 ```
 
 #### Tutorial 3: Run Latent Space Simulations
@@ -661,27 +765,34 @@ npx agentdb simulate --wizard
 #### Tutorial 4: Cognitive Container Branching
 
 ```typescript
-import { RvfBackend } from 'agentdb/backends/rvf/RvfBackend';
+import { RvfBackend } from "agentdb/backends/rvf/RvfBackend";
 
-const main = new RvfBackend({ dimension: 384, metric: 'cosine', storagePath: './main.rvf' });
+const main = new RvfBackend({
+  dimension: 384,
+  metric: "cosine",
+  storagePath: "./main.rvf",
+});
 await main.initialize();
-await main.insertAsync('doc-1', embedding1, { source: 'production' });
+await main.insertAsync("doc-1", embedding1, { source: "production" });
 await main.flush();
 
 // Branch for experiment (copy-on-write, near-instant)
-const experiment = await main.derive('./experiment.rvf');
-await experiment.insertAsync('doc-exp-1', experimentEmbedding);
+const experiment = await main.derive("./experiment.rvf");
+await experiment.insertAsync("doc-exp-1", experimentEmbedding);
 console.log(`Lineage depth: ${await experiment.lineageDepth()}`);
 ```
 
 #### Tutorial 5: Self-Learning RAG Pipeline
 
 ```typescript
-import { SelfLearningRvfBackend } from 'agentdb/backends/rvf/SelfLearningRvfBackend';
+import { SelfLearningRvfBackend } from "agentdb/backends/rvf/SelfLearningRvfBackend";
 
 const backend = await SelfLearningRvfBackend.create({
-  dimension: 384, metric: 'cosine', storagePath: './rag-vectors.rvf',
-  learning: true, federated: true,
+  dimension: 384,
+  metric: "cosine",
+  storagePath: "./rag-vectors.rvf",
+  learning: true,
+  federated: true,
 });
 
 for (const doc of documents) {
@@ -689,7 +800,7 @@ for (const doc of documents) {
 }
 
 const results = await backend.searchAsync(queryEmbedding, 10);
-backend.recordFeedback('query-1', 0.95);
+backend.recordFeedback("query-1", 0.95);
 await backend.tick();
 ```
 
@@ -711,10 +822,11 @@ npx @agentdb/chat serve --rvf ./docs.rvf --port 3000
 #### Batch Operations
 
 ```typescript
-import { BatchOperations } from 'agentdb/optimizations/BatchOperations';
+import { BatchOperations } from "agentdb/optimizations/BatchOperations";
 
 const batchOps = new BatchOperations(db, embedder, {
-  batchSize: 100, parallelism: 4,
+  batchSize: 100,
+  parallelism: 4,
   progressCallback: (done, total) => console.log(`${done}/${total}`),
 });
 
@@ -726,21 +838,30 @@ await batchOps.insertPatterns([...patterns]);
 #### Custom Backend Selection
 
 ```typescript
-import { createBackend, detectBackends } from 'agentdb/backends/factory';
+import { createBackend, detectBackends } from "agentdb/backends/factory";
 
 const detection = await detectBackends();
 // { ruvector: { available, native, gnn }, rvf: { sdk, node, wasm }, hnswlib: { available } }
 
-const backend = await createBackend({ type: 'rvf', dimension: 384, metric: 'cosine', storagePath: './vectors.rvf' });
+const backend = await createBackend({
+  type: "rvf",
+  dimension: 384,
+  metric: "cosine",
+  storagePath: "./vectors.rvf",
+});
 ```
 
 #### Adaptive Index Tuning
 
 ```typescript
-import { AgentDBSolver } from 'agentdb/backends/rvf/RvfSolver';
+import { AgentDBSolver } from "agentdb/backends/rvf/RvfSolver";
 
 const solver = await AgentDBSolver.create();
-const trainResult = solver.train({ count: 50, minDifficulty: 1, maxDifficulty: 10 });
+const trainResult = solver.train({
+  count: 50,
+  minDifficulty: 1,
+  maxDifficulty: 10,
+});
 const policy = solver.policy();
 // 18 context buckets (3 range x 3 distractor x 2 noise)
 ```
@@ -748,10 +869,20 @@ const policy = solver.policy();
 #### Federated Session Manager
 
 ```typescript
-import { FederatedLearningCoordinator, EphemeralLearningAgent } from 'agentdb/services/federated-learning';
+import {
+  FederatedLearningCoordinator,
+  EphemeralLearningAgent,
+} from "agentdb/services/federated-learning";
 
-const coordinator = new FederatedLearningCoordinator({ agentId: 'coord-main', minQuality: 0.7, maxAgents: 100 });
-const sessionAgent = new EphemeralLearningAgent({ agentId: `session-${Date.now()}`, qualityFiltering: true });
+const coordinator = new FederatedLearningCoordinator({
+  agentId: "coord-main",
+  minQuality: 0.7,
+  maxAgents: 100,
+});
+const sessionAgent = new EphemeralLearningAgent({
+  agentId: `session-${Date.now()}`,
+  qualityFiltering: true,
+});
 
 await sessionAgent.processTask(embedding, 0.9);
 const state = sessionAgent.exportState();
@@ -762,7 +893,7 @@ const merged = await coordinator.consolidate();
 #### Context Synthesizer
 
 ```typescript
-import { ContextSynthesizer } from 'agentdb/controllers/ContextSynthesizer';
+import { ContextSynthesizer } from "agentdb/controllers/ContextSynthesizer";
 
 const synthesizer = new ContextSynthesizer();
 const context = await synthesizer.synthesize(memories);
@@ -772,11 +903,11 @@ const context = await synthesizer.synthesize(memories);
 #### GNN Learning Backend
 
 ```typescript
-import { LearningBackend } from 'agentdb/backends/LearningBackend';
+import { LearningBackend } from "agentdb/backends/LearningBackend";
 
 const learner = new LearningBackend({ dimension: 384 });
 const enhanced = learner.enhance(queryEmbedding, neighborEmbeddings, weights);
-learner.addSample(embedding, 'positive', 1.0, { source: 'feedback' });
+learner.addSample(embedding, "positive", 1.0, { source: "feedback" });
 const result = await learner.train(10);
 // { epochs: 10, finalLoss: 0.023, improvement: 15.2, durationMs: 340 }
 ```
@@ -815,8 +946,8 @@ The router also selects the adaptive ef-search arm for the query. Four ef-search
 
 ```typescript
 // Router learns intents from usage patterns
-router.addIntent('technical_search', embedding); // up to 100 exemplars per intent
-router.addIntent('conversational', embedding);
+router.addIntent("technical_search", embedding); // up to 100 exemplars per intent
+router.addIntent("conversational", embedding);
 const { intent, confidence } = await router.route(queryEmbedding, k);
 
 // Router state persists across restarts (debounced 5s save)
@@ -840,7 +971,11 @@ InfoNCE contrastive loss with hard negative mining inspired by NV-Retriever's po
 ```typescript
 // ContrastiveTrainer handles hard negative mining automatically
 const result = trainer.trainBatch([
-  { anchor: queryEmb, positive: goodResultEmb, negatives: [badResult1, badResult2] },
+  {
+    anchor: queryEmb,
+    positive: goodResultEmb,
+    negatives: [badResult1, badResult2],
+  },
 ]);
 // result: { loss, gradients, batchSize }
 ```
@@ -875,12 +1010,12 @@ Each learning tick performs these steps in sequence:
 ### Full Example
 
 ```typescript
-import { SelfLearningRvfBackend } from 'agentdb/backends/rvf/SelfLearningRvfBackend';
+import { SelfLearningRvfBackend } from "agentdb/backends/rvf/SelfLearningRvfBackend";
 
 const backend = await SelfLearningRvfBackend.create({
   dimension: 384,
-  metric: 'cosine',
-  storagePath: './vectors.rvf',
+  metric: "cosine",
+  storagePath: "./vectors.rvf",
   learning: true,
   federated: true,
   positiveThreshold: 0.7,
@@ -890,20 +1025,22 @@ const backend = await SelfLearningRvfBackend.create({
 });
 
 // Insert vectors
-await backend.insertAsync('doc-1', embedding, { source: 'docs' });
+await backend.insertAsync("doc-1", embedding, { source: "docs" });
 
 // Search (automatically enhanced by SONA + router)
 const results = await backend.searchAsync(queryEmbedding, 10);
 
 // Record feedback to drive learning
-backend.recordFeedback('query-123', 0.9); // high quality result
+backend.recordFeedback("query-123", 0.9); // high quality result
 
 // Run a learning tick (contrastive training + LoRA update + EWC consolidation)
 await backend.tick();
 
 // Check learning progress
 const stats = backend.getLearningStats();
-console.log(`Trajectories: ${stats.trajectoryCount}, LoRA rank: ${stats.loraRank}`);
+console.log(
+  `Trajectories: ${stats.trajectoryCount}, LoRA rank: ${stats.loraRank}`,
+);
 ```
 
 </details>
@@ -921,14 +1058,14 @@ Store successful reasoning patterns and retrieve them by semantic similarity. Th
 
 ```typescript
 await reasoningBank.storePattern({
-  taskType: 'bug_investigation',
-  approach: 'Check logs > Reproduce > Binary search for root cause',
+  taskType: "bug_investigation",
+  approach: "Check logs > Reproduce > Binary search for root cause",
   successRate: 0.92,
-  tags: ['debugging', 'systematic'],
+  tags: ["debugging", "systematic"],
 });
 
 const patterns = await reasoningBank.searchPatterns({
-  task: 'debug memory leak',
+  task: "debug memory leak",
   k: 10,
   threshold: 0.7,
 });
@@ -940,19 +1077,19 @@ Store complete task episodes with self-generated critiques, then replay them to
 
 ```typescript
 await reflexion.storeEpisode({
-  sessionId: 'session-1',
-  task: 'Fix authentication bug',
+  sessionId: "session-1",
+  task: "Fix authentication bug",
   reward: 0.95,
   success: true,
-  critique: 'OAuth2 PKCE flow was more secure than basic flow',
-  input: 'Users cannot log in',
-  output: 'Working OAuth2 implementation',
+  critique: "OAuth2 PKCE flow was more secure than basic flow",
+  input: "Users cannot log in",
+  output: "Working OAuth2 implementation",
   latencyMs: 1200,
   tokensUsed: 500,
 });
 
 const similar = await reflexion.retrieveRelevant({
-  task: 'authentication issues',
+  task: "authentication issues",
   k: 10,
   onlySuccesses: true,
 });
@@ -964,15 +1101,15 @@ Transform successful patterns into reusable, composable skills that improve over
 
 ```typescript
 await skills.createSkill({
-  name: 'jwt_authentication',
-  description: 'Generate and validate JWT tokens',
-  signature: { inputs: { userId: 'string' }, outputs: { token: 'string' } },
-  code: 'implementation...',
+  name: "jwt_authentication",
+  description: "Generate and validate JWT tokens",
+  signature: { inputs: { userId: "string" }, outputs: { token: "string" } },
+  code: "implementation...",
   successRate: 0.92,
 });
 
 const applicable = await skills.searchSkills({
-  task: 'user authentication',
+  task: "user authentication",
   k: 5,
   minSuccessRate: 0.7,
 });
@@ -983,19 +1120,19 @@ const applicable = await skills.searchSkills({
 Track `p(y|do(x))` using doubly robust estimation. Learn what interventions cause what outcomes.
 
 ```typescript
-import { CausalMemoryGraph } from 'agentdb';
+import { CausalMemoryGraph } from "agentdb";
 
 const causalGraph = new CausalMemoryGraph(db);
 
 const experimentId = causalGraph.createExperiment({
-  name: 'test_error_handling',
-  hypothesis: 'Try-catch reduces crash rate',
+  name: "test_error_handling",
+  hypothesis: "Try-catch reduces crash rate",
   treatmentId: 123,
-  treatmentType: 'episode',
+  treatmentType: "episode",
   controlId: 124,
   startTime: Date.now(),
   sampleSize: 0,
-  status: 'running',
+  status: "running",
 });
 
 const { uplift, pValue } = causalGraph.calculateUplift(experimentId);
@@ -1007,11 +1144,11 @@ Every retrieval comes with a cryptographic Merkle proof explaining why specific
 
 ```typescript
 const result = await causalRecall.recall(
-  'query-123',
-  'How to optimize API response time',
+  "query-123",
+  "How to optimize API response time",
   12,
-  ['performance'],
-  'internal',
+  ["performance"],
+  "internal",
 );
 
 console.log(`Certificate: ${result.certificate.id}`);
@@ -1066,44 +1203,44 @@ graph TB
 
 ### Key Capabilities
 
-| Feature | Description |
-| --- | --- |
-| **Single-file** | Everything in one Cognitive Container (`.rvf`) — vectors, index, metadata |
-| **Crash-safe** | Append-only log with checksums, safe concurrent access |
-| **COW Branching** | Create copy-on-write branches for experiments (near-instant) |
-| **Lineage Tracking** | `fileId()`, `parentId()`, `lineageDepth()` for file-level provenance |
-| **Progressive Indexing** | 3-layer HNSW quality tiers, index builds incrementally as data arrives |
-| **Witness Chains** | SHAKE-256 cryptographic verification (73 bytes per entry) |
-| **Filter Expressions** | 11 operators for metadata filtering, max 64 depth |
-| **Auto-Compaction** | `compact()` reclaims space, reports segments compacted & bytes reclaimed |
-| **Readonly Mode** | `openReadonly()` for concurrent readers without locks |
-| **Segment Introspection** | `segments()` returns id, type, and payload length per segment |
-| **Kernel Embedding** | Embed unikernel images directly into Cognitive Containers |
-| **eBPF Embedding** | Embed and extract eBPF bytecode for programmable queries |
+| Feature                   | Description                                                               |
+| ------------------------- | ------------------------------------------------------------------------- |
+| **Single-file**           | Everything in one Cognitive Container (`.rvf`) — vectors, index, metadata |
+| **Crash-safe**            | Append-only log with checksums, safe concurrent access                    |
+| **COW Branching**         | Create copy-on-write branches for experiments (near-instant)              |
+| **Lineage Tracking**      | `fileId()`, `parentId()`, `lineageDepth()` for file-level provenance      |
+| **Progressive Indexing**  | 3-layer HNSW quality tiers, index builds incrementally as data arrives    |
+| **Witness Chains**        | SHAKE-256 cryptographic verification (73 bytes per entry)                 |
+| **Filter Expressions**    | 11 operators for metadata filtering, max 64 depth                         |
+| **Auto-Compaction**       | `compact()` reclaims space, reports segments compacted & bytes reclaimed  |
+| **Readonly Mode**         | `openReadonly()` for concurrent readers without locks                     |
+| **Segment Introspection** | `segments()` returns id, type, and payload length per segment             |
+| **Kernel Embedding**      | Embed unikernel images directly into Cognitive Containers                 |
+| **eBPF Embedding**        | Embed and extract eBPF bytecode for programmable queries                  |
 
 ### Configuration
 
 ```typescript
 const backend = new RvfBackend({
   dimension: 384,
-  metric: 'cosine',             // 'cosine' | 'l2' | 'dotproduct'
-  storagePath: './vectors.rvf',
-  rvfBackend: 'auto',           // 'auto' | 'node' (N-API) | 'wasm' (browser)
-  batchThreshold: 100,          // Auto-flush after N sync inserts (1-10,000)
-  compression: 'none',          // 'none' (fp32) | 'scalar' (int8) | 'product' (PQ)
-  hardwareProfile: 0,           // 0=Generic | 1=Core | 2=Hot | 3=Full
-  enableStats: true,            // Track insert/search/flush/compaction timing
+  metric: "cosine", // 'cosine' | 'l2' | 'dotproduct'
+  storagePath: "./vectors.rvf",
+  rvfBackend: "auto", // 'auto' | 'node' (N-API) | 'wasm' (browser)
+  batchThreshold: 100, // Auto-flush after N sync inserts (1-10,000)
+  compression: "none", // 'none' (fp32) | 'scalar' (int8) | 'product' (PQ)
+  hardwareProfile: 0, // 0=Generic | 1=Core | 2=Hot | 3=Full
+  enableStats: true, // Track insert/search/flush/compaction timing
 });
 ```
 
 **Hardware profiles** tune internal parameters for your deployment:
 
-| Profile | Level | Best For |
-| --- | --- | --- |
-| Generic (0) | Conservative defaults | Unknown hardware |
-| Core (1) | Balanced throughput/latency | Developer machines |
-| Hot (2) | Aggressive caching | High-throughput servers |
-| Full (3) | Maximum parallelism | Dedicated vector search |
+| Profile     | Level                       | Best For                |
+| ----------- | --------------------------- | ----------------------- |
+| Generic (0) | Conservative defaults       | Unknown hardware        |
+| Core (1)    | Balanced throughput/latency | Developer machines      |
+| Hot (2)     | Aggressive caching          | High-throughput servers |
+| Full (3)    | Maximum parallelism         | Dedicated vector search |
 
 ### Witness Chains
 
@@ -1121,13 +1258,13 @@ const result = backend.verifyWitnessChain();
 RVF supports 11 filter operators for metadata-filtered search. Filters are serialized to a compact field-ID format with a maximum depth of 64 expressions for security:
 
 ```typescript
-import { FilterBuilder } from 'agentdb/backends/rvf/FilterBuilder';
+import { FilterBuilder } from "agentdb/backends/rvf/FilterBuilder";
 
 const filter = new FilterBuilder()
-  .eq('status', 'active')
-  .gt('score', 0.5)
-  .range('timestamp', startDate, endDate)
-  .in('category', ['research', 'engineering'])
+  .eq("status", "active")
+  .gt("score", 0.5)
+  .range("timestamp", startDate, endDate)
+  .in("category", ["research", "engineering"])
   .build();
 
 const results = await backend.searchAsync(queryVector, 10, { filter });
@@ -1158,12 +1295,12 @@ Cognitive Containers can embed unikernel images and eBPF bytecode directly, enab
 ```typescript
 // Embed a kernel image into the Cognitive Container
 await backend.embedKernel({
-  arch: 'x86_64',       // 'x86_64' | 'aarch64' | 'riscv64'
-  type: 'firecracker',  // 'firecracker' | 'qemu' | 'cloud-hypervisor'
+  arch: "x86_64", // 'x86_64' | 'aarch64' | 'riscv64'
+  type: "firecracker", // 'firecracker' | 'qemu' | 'cloud-hypervisor'
   flags: 0,
   image: kernelBuffer,
   apiPort: 8080,
-  cmdline: 'console=ttyS0',
+  cmdline: "console=ttyS0",
 });
 
 // Extract it later
@@ -1197,23 +1334,23 @@ npx agentdb rvf detect
 ### Programmatic Usage
 
 ```typescript
-import { RvfBackend } from 'agentdb/backends/rvf/RvfBackend';
+import { RvfBackend } from "agentdb/backends/rvf/RvfBackend";
 
 const backend = new RvfBackend({
   dimension: 384,
-  metric: 'cosine',
-  storagePath: './vectors.rvf',
-  rvfBackend: 'auto', // 'node' for N-API, 'wasm' for browser
+  metric: "cosine",
+  storagePath: "./vectors.rvf",
+  rvfBackend: "auto", // 'node' for N-API, 'wasm' for browser
 });
 await backend.initialize();
 
 // Async operations (native)
-await backend.insertAsync('vec-1', embedding, { tag: 'example' });
+await backend.insertAsync("vec-1", embedding, { tag: "example" });
 const results = await backend.searchAsync(queryVector, 10);
 await backend.flush();
 
 // COW branching
-const branch = await backend.derive('./experiment.rvf');
+const branch = await backend.derive("./experiment.rvf");
 const lineage = await backend.lineageDepth();
 ```
 
@@ -1248,30 +1385,30 @@ The `NativeAccelerator` provides 15 capability groups bridging 11 `@ruvector` pa
 
 ### Capability Groups
 
-| Group | Operations | Package |
-| --- | --- | --- |
-| **Vector Distance & Math** | cosine, dot, L2, hamming, add, mul, scale, normalize | `ruvector` |
-| **Activations** | softmax, relu, gelu, sigmoid, layerNorm | `@ruvector/ruvllm` |
-| **Loss Functions** | InfoNCE (contrastive) | `@ruvector/sona` |
-| **Optimizers** | AdamW step | `@ruvector/sona` |
-| **Quantization** | scalar 8-bit/4-bit, product quantization | `@ruvector/rvf` |
-| **WASM Store** | create, ingest, query, export, close | `@ruvector/rvf-wasm` |
-| **Verification** | witness chain, segment header | `@ruvector/rvf-node` |
-| **Graph Transactions** | begin, commit, rollback | `@ruvector/graph-node` |
-| **Graph Batch Insert** | high-throughput node/edge ingestion | `@ruvector/graph-node` |
-| **Graph Cypher** | pattern matching, path queries | `@ruvector/graph-node` |
-| **Core Batch Insert** | native vector batch ingestion | `ruvector` |
-| **EWC Memory** | penalty calculation, Fisher update | `@ruvector/sona` |
-| **Router** | save/load state persistence | `@ruvector/router` |
-| **SONA** | context addition, flush, base LoRA | `@ruvector/sona` |
-| **Compression** | tensor compress/decompress | `@ruvector/rvf` |
+| Group                      | Operations                                           | Package                |
+| -------------------------- | ---------------------------------------------------- | ---------------------- |
+| **Vector Distance & Math** | cosine, dot, L2, hamming, add, mul, scale, normalize | `ruvector`             |
+| **Activations**            | softmax, relu, gelu, sigmoid, layerNorm              | `@ruvector/ruvllm`     |
+| **Loss Functions**         | InfoNCE (contrastive)                                | `@ruvector/sona`       |
+| **Optimizers**             | AdamW step                                           | `@ruvector/sona`       |
+| **Quantization**           | scalar 8-bit/4-bit, product quantization             | `@ruvector/rvf`        |
+| **WASM Store**             | create, ingest, query, export, close                 | `@ruvector/rvf-wasm`   |
+| **Verification**           | witness chain, segment header                        | `@ruvector/rvf-node`   |
+| **Graph Transactions**     | begin, commit, rollback                              | `@ruvector/graph-node` |
+| **Graph Batch Insert**     | high-throughput node/edge ingestion                  | `@ruvector/graph-node` |
+| **Graph Cypher**           | pattern matching, path queries                       | `@ruvector/graph-node` |
+| **Core Batch Insert**      | native vector batch ingestion                        | `ruvector`             |
+| **EWC Memory**             | penalty calculation, Fisher update                   | `@ruvector/sona`       |
+| **Router**                 | save/load state persistence                          | `@ruvector/router`     |
+| **SONA**                   | context addition, flush, base LoRA                   | `@ruvector/sona`       |
+| **Compression**            | tensor compress/decompress                           | `@ruvector/rvf`        |
 
 ### Auto-Detection
 
 Each capability group is lazily loaded — only the packages actually installed on the system are loaded, and each load is tried independently so a missing package never blocks others:
 
 ```typescript
-import { NativeAccelerator } from 'agentdb/backends/rvf/NativeAccelerator';
+import { NativeAccelerator } from "agentdb/backends/rvf/NativeAccelerator";
 
 const accel = new NativeAccelerator();
 const stats = await accel.initialize();
@@ -1303,12 +1440,27 @@ console.log(stats);
 Every SIMD operation has a pure-JS fallback with 4-wide loop unrolling for reasonable performance even without native bindings:
 
 ```typescript
-import { SimdFallbacks } from 'agentdb/backends/rvf/SimdFallbacks';
+import { SimdFallbacks } from "agentdb/backends/rvf/SimdFallbacks";
 
 // Same API as native, ~10-50x slower but always available
 const similarity = SimdFallbacks.jsCosineSimilarity(vecA, vecB);
-const loss = SimdFallbacks.jsInfoNceLoss(anchor, positive, negatives, temperature);
-const result = SimdFallbacks.jsAdamWStep(params, grads, m, v, lr, beta1, beta2, weightDecay, t);
+const loss = SimdFallbacks.jsInfoNceLoss(
+  anchor,
+  positive,
+  negatives,
+  temperature,
+);
+const result = SimdFallbacks.jsAdamWStep(
+  params,
+  grads,
+  m,
+  v,
+  lr,
+  beta1,
+  beta2,
+  weightDecay,
+  t,
+);
 ```
 
 ### Additional SIMD Operations
@@ -1316,7 +1468,7 @@ const result = SimdFallbacks.jsAdamWStep(params, grads, m, v, lr, beta1, beta2,
 The `SIMDVectorOps` class provides batch operations and platform-specific detection:
 
 ```typescript
-import { SIMDVectorOps, detectSIMDSupport } from 'agentdb/simd';
+import { SIMDVectorOps, detectSIMDSupport } from "agentdb/simd";
 
 const simd = new SIMDVectorOps();
 const support = detectSIMDSupport();
@@ -1339,12 +1491,12 @@ AgentDB integrates `@ruvector/graph-node` for a full graph database with Cypher
 Full Neo4j-compatible Cypher syntax including MATCH, RETURN, WHERE, ORDER BY, LIMIT, relationship patterns, and graph traversal:
 
 ```typescript
-import { GraphDatabaseAdapter } from 'agentdb/backends/graph/GraphDatabaseAdapter';
+import { GraphDatabaseAdapter } from "agentdb/backends/graph/GraphDatabaseAdapter";
 
 const graph = new GraphDatabaseAdapter({
-  storagePath: './graph.db',
+  storagePath: "./graph.db",
   dimensions: 384,
-  distanceMetric: 'Cosine', // 'Cosine' | 'Euclidean' | 'DotProduct' | 'Manhattan'
+  distanceMetric: "Cosine", // 'Cosine' | 'Euclidean' | 'DotProduct' | 'Manhattan'
 });
 await graph.initialize();
 
@@ -1369,12 +1521,12 @@ Traverse relationships with direction control, depth limits, and label filtering
 
 ```typescript
 const paths = await graph.traverse({
-  startNodeId: 'episode-42',
-  pattern: '()-[:RELATES_TO]->(:Skill)',
-  direction: 'outgoing',  // 'outgoing' | 'incoming' | 'both'
+  startNodeId: "episode-42",
+  pattern: "()-[:RELATES_TO]->(:Skill)",
+  direction: "outgoing", // 'outgoing' | 'incoming' | 'both'
   maxDepth: 3,
-  relationshipTypes: ['CAUSED', 'RELATES_TO'],
-  nodeLabels: ['Episode', 'Skill'],
+  relationshipTypes: ["CAUSED", "RELATES_TO"],
+  nodeLabels: ["Episode", "Skill"],
 });
 ```
 
@@ -1389,9 +1541,9 @@ const results = await graph.vectorSearch(queryEmbedding, 10);
 
 // Nodes support multi-label classification
 await graph.createNode({
-  id: 'analysis-1',
-  label: ['Episode', 'Analyzed', 'Security'],
-  properties: { reward: 0.95, task: 'auth review' },
+  id: "analysis-1",
+  label: ["Episode", "Analyzed", "Security"],
+  properties: { reward: 0.95, task: "auth review" },
   embedding: embeddingVector,
 });
 ```
@@ -1404,8 +1556,13 @@ ACID-guaranteed batch operations with rollback support:
 const txId = await graph.beginTransaction();
 try {
   await graph.batchInsert(
-    nodes.map(n => ({ id: n.id, label: n.type, properties: n.data })),
-    edges.map(e => ({ from: e.source, to: e.target, label: e.type, properties: e.data })),
+    nodes.map((n) => ({ id: n.id, label: n.type, properties: n.data })),
+    edges.map((e) => ({
+      from: e.source,
+      to: e.target,
+      label: e.type,
+      properties: e.data,
+    })),
   );
   await graph.commitTransaction(txId);
 } catch (err) {
@@ -1417,19 +1574,19 @@ try {
 
 The GNN attention mechanism improves recall by +12.4% with a 3.8ms forward pass and 91% transfer learning retention. Three attention types are available:
 
-| Type | Algorithm | Best For |
-| --- | --- | --- |
-| `gat` | Graph Attention Network | Weighted neighbor aggregation |
-| `gcn` | Graph Convolutional Network | Uniform message passing |
-| `sage` | GraphSAGE | Inductive learning on unseen nodes |
+| Type   | Algorithm                   | Best For                           |
+| ------ | --------------------------- | ---------------------------------- |
+| `gat`  | Graph Attention Network     | Weighted neighbor aggregation      |
+| `gcn`  | Graph Convolutional Network | Uniform message passing            |
+| `sage` | GraphSAGE                   | Inductive learning on unseen nodes |
 
 ```typescript
-import { AttentionService } from 'agentdb/controllers/AttentionService';
+import { AttentionService } from "agentdb/controllers/AttentionService";
 
 const attention = new AttentionService({
   numHeads: 8,
   dimension: 384,
-  attentionType: 'gat', // 'gat' | 'gcn' | 'sage'
+  attentionType: "gat", // 'gat' | 'gcn' | 'sage'
 });
 const enhanced = await attention.forward(queryEmbedding, neighborEmbeddings);
 ```
@@ -1439,18 +1596,18 @@ const enhanced = await attention.forward(queryEmbedding, neighborEmbeddings);
 Track interventions with `p(y|do(x))` doubly robust estimation and optional Poincare embeddings for hierarchical relationships:
 
 ```typescript
-import { CausalMemoryGraph } from 'agentdb';
+import { CausalMemoryGraph } from "agentdb";
 
 const causal = new CausalMemoryGraph(db, graph, embedder, {
   ENABLE_HYPERBOLIC_ATTENTION: true, // Poincaré ball distance for hierarchies
 });
 
 await causal.addCausalEdge({
-  fromMemoryId: 'episode-1',
-  toMemoryType: 'skill',  // 'episode' | 'skill' | 'note' | 'fact'
-  uplift: 0.15,           // E[y|do(x)] - E[y]
+  fromMemoryId: "episode-1",
+  toMemoryType: "skill", // 'episode' | 'skill' | 'note' | 'fact'
+  uplift: 0.15, // E[y|do(x)] - E[y]
   confidence: 0.92,
-  mechanism: 'error-handling improvement',
+  mechanism: "error-handling improvement",
   sampleSize: 50,
   confounderScore: 0.03,
 });
@@ -1470,7 +1627,7 @@ AgentDB runs fully in the browser with WASM-backed vector storage, GNN attention
 The `WasmStoreBridge` provides a full HNSW vector database in the browser by wrapping `@ruvector/rvf-wasm`:
 
 ```typescript
-import { WasmStoreBridge } from 'agentdb/backends/rvf/WasmStoreBridge';
+import { WasmStoreBridge } from "agentdb/backends/rvf/WasmStoreBridge";
 
 const bridge = new WasmStoreBridge();
 await bridge.initialize();
@@ -1496,7 +1653,7 @@ bridge.wasmStoreClose(handle);
 The `AttentionBrowser` provides three advanced attention types compiled to WASM:
 
 ```typescript
-import { AttentionBrowser } from 'agentdb/browser/AttentionBrowser';
+import { AttentionBrowser } from "agentdb/browser/AttentionBrowser";
 
 const attention = new AttentionBrowser({ numHeads: 8 });
 // Loading states: 'idle' → 'loading' → 'loaded' | 'error'
@@ -1521,14 +1678,17 @@ const consolidated = await attention.consolidateMemories(memories, {
 
 Memory-efficient vector storage with three PQ compression levels:
 
-| Variant | Compression | Subvectors | Centroids | Best For |
-| --- | --- | --- | --- | --- |
-| **PQ8** | 4x | 8 | 256 | Balanced quality/memory |
-| **PQ16** | 8x | 16 | 256 | Medium datasets |
-| **PQ32** | 16x | 32 | 256 | Maximum compression |
+| Variant  | Compression | Subvectors | Centroids | Best For                |
+| -------- | ----------- | ---------- | --------- | ----------------------- |
+| **PQ8**  | 4x          | 8          | 256       | Balanced quality/memory |
+| **PQ16** | 8x          | 16         | 256       | Medium datasets         |
+| **PQ32** | 16x         | 32         | 256       | Maximum compression     |
 
 ```typescript
-import { createProductQuantizedStore, createScalar8BitStore } from 'agentdb/browser/ProductQuantization';
+import {
+  createProductQuantizedStore,
+  createScalar8BitStore,
+} from "agentdb/browser/ProductQuantization";
 
 // Product quantization with asymmetric distance computation (ADC)
 const pq = createProductQuantizedStore(384, {
@@ -1536,7 +1696,7 @@ const pq = createProductQuantizedStore(384, {
   bitsPerCode: 8,
   // Uses K-means++ initialization for codebook training
 });
-pq.add('doc-1', embedding);
+pq.add("doc-1", embedding);
 const results = pq.search(query, 10);
 ```
 
@@ -1544,25 +1704,25 @@ const results = pq.search(query, 10);
 
 Pre-tuned configurations for common scenarios:
 
-| Preset | Features | Target |
-| --- | --- | --- |
-| `SMALL_DATASET` | GNN only | <1K vectors |
-| `MEDIUM_DATASET` | HNSW + PQ8 | 1K-10K vectors |
-| `LARGE_DATASET` | Aggressive compression + HNSW | 10K-100K vectors |
-| `MEMORY_OPTIMIZED` | PQ32 + SVD (dim 64) | Memory-constrained |
-| `SPEED_OPTIMIZED` | HNSW max quality | Latency-critical |
-| `QUALITY_OPTIMIZED` | No compression, max attention heads | Accuracy-critical |
+| Preset              | Features                            | Target             |
+| ------------------- | ----------------------------------- | ------------------ |
+| `SMALL_DATASET`     | GNN only                            | <1K vectors        |
+| `MEDIUM_DATASET`    | HNSW + PQ8                          | 1K-10K vectors     |
+| `LARGE_DATASET`     | Aggressive compression + HNSW       | 10K-100K vectors   |
+| `MEMORY_OPTIMIZED`  | PQ32 + SVD (dim 64)                 | Memory-constrained |
+| `SPEED_OPTIMIZED`   | HNSW max quality                    | Latency-critical   |
+| `QUALITY_OPTIMIZED` | No compression, max attention heads | Accuracy-critical  |
 
 ### Maximal Marginal Relevance (MMR)
 
 Diversify search results to avoid returning near-duplicate items:
 
 ```typescript
-import { MMRDiversityRanker } from 'agentdb/controllers/MMRDiversityRanker';
+import { MMRDiversityRanker } from "agentdb/controllers/MMRDiversityRanker";
 
 const ranker = new MMRDiversityRanker({
-  lambda: 0.7,     // 0=max diversity, 1=max relevance
-  metric: 'cosine', // 'cosine' | 'euclidean' | 'dot'
+  lambda: 0.7, // 0=max diversity, 1=max relevance
+  metric: "cosine", // 'cosine' | 'euclidean' | 'dot'
 });
 
 // Rerank results: MMR = λ × Sim(Di,Q) - (1-λ) × max Sim(Di,Dj)
@@ -1573,12 +1733,12 @@ const score = ranker.diversityScore(diverse); // average pairwise distance
 ### Browser Bundle
 
 ```typescript
-import { AgentDB } from 'agentdb/browser';
+import { AgentDB } from "agentdb/browser";
 
 const db = new AgentDB({ dimension: 384 });
 await db.initialize();
 
-await db.insert('doc-1', embedding, { title: 'Getting Started' });
+await db.insert("doc-1", embedding, { title: "Getting Started" });
 const results = await db.search(queryEmbedding, 5);
 ```
 
@@ -1587,11 +1747,11 @@ const results = await db.search(queryEmbedding, 5);
 For zero-dependency environments, AgentDB falls back to `sql.js` (SQLite compiled to WASM) automatically. Non-WASM browsers get pure-JS implementations with 4-wide loop unrolling (~10-50x slower than native SIMD but fully functional):
 
 ```typescript
-import { createDatabase } from 'agentdb';
-import { detectSIMDSupport } from 'agentdb/simd';
+import { createDatabase } from "agentdb";
+import { detectSIMDSupport } from "agentdb/simd";
 
 // In browsers, automatically uses sql.js WASM backend
-const db = await createDatabase(':memory:');
+const db = await createDatabase(":memory:");
 
 const support = detectSIMDSupport();
 // { wasm: true, x64: false, avx2: false, neon: false }
@@ -1606,13 +1766,13 @@ const support = detectSIMDSupport();
 
 ### Core Operations
 
-| Operation | Throughput | Latency |
-| --- | --- | --- |
-| Pattern search | 32.6M ops/sec | <1ms |
-| Pattern storage | 388K ops/sec | ~2.5us |
-| Episode retrieval | 957 ops/sec | ~1ms |
-| Skill search | 694 ops/sec | ~1.4ms |
-| Batch insert | 5,556-7,692 ops/sec | 3-4x faster than sequential |
+| Operation         | Throughput          | Latency                     |
+| ----------------- | ------------------- | --------------------------- |
+| Pattern search    | 32.6M ops/sec       | <1ms                        |
+| Pattern storage   | 388K ops/sec        | ~2.5us                      |
+| Episode retrieval | 957 ops/sec         | ~1ms                        |
+| Skill search      | 694 ops/sec         | ~1.4ms                      |
+| Batch insert      | 5,556-7,692 ops/sec | 3-4x faster than sequential |
 
 ### Scaling Behavior
 
@@ -1633,12 +1793,12 @@ Adaptive Learning (10 sessions, 50 episodes each)
 
 ### Latent Space Validation (31 scenarios, 98.2% reproducibility)
 
-| Scenario | Result |
-| --- | --- |
-| HNSW Optimization | 61us p50, 96.8% recall@10, 8.2x vs hnswlib |
-| GNN Attention | +12.4% recall, 3.8ms forward pass, 91% transfer |
-| Self-Healing | 97.9% degradation prevention, <100ms repair |
-| Neural Augmentation | +29.4% improvement, -32% memory, -52% hops |
+| Scenario            | Result                                          |
+| ------------------- | ----------------------------------------------- |
+| HNSW Optimization   | 61us p50, 96.8% recall@10, 8.2x vs hnswlib      |
+| GNN Attention       | +12.4% recall, 3.8ms forward pass, 91% transfer |
+| Self-Healing        | 97.9% degradation prevention, <100ms repair     |
+| Neural Augmentation | +29.4% improvement, -32% memory, -52% hops      |
 
 ### Adaptive Solver (Thompson Sampling)
 
@@ -1664,6 +1824,7 @@ const chain = solver.witnessChain();
 ```
 
 Three-loop architecture:
+
 1. **Fast loop** — constraint propagation (~0.1ms)
 2. **Medium loop** — PolicyKernel with Thompson Sampling (~1ms)
 3. **Slow loop** — KnowledgeCompiler for long-term patterns (~10ms)
@@ -1672,29 +1833,37 @@ Three-loop architecture:
 
 The `SolverBandit` is a general-purpose Thompson Sampling bandit that provides explore/exploit decisions for any context-dependent selection problem. It powers adaptive decision-making in 5 AgentDB controllers:
 
-| Controller | What the Bandit Decides | Context Key |
-| --- | --- | --- |
-| **SkillLibrary** | Rerank retrieved skills by task type | `taskType` string |
-| **ReasoningBank** | Rerank matching patterns by task type | query text |
-| **NightlyLearner** | Prioritize experiment candidates | `'experiment'` |
-| **LearningSystem** | Select best RL algorithm (9 options) | task description |
+| Controller             | What the Bandit Decides                            | Context Key         |
+| ---------------------- | -------------------------------------------------- | ------------------- |
+| **SkillLibrary**       | Rerank retrieved skills by task type               | `taskType` string   |
+| **ReasoningBank**      | Rerank matching patterns by task type              | query text          |
+| **NightlyLearner**     | Prioritize experiment candidates                   | `'experiment'`      |
+| **LearningSystem**     | Select best RL algorithm (9 options)               | task description    |
 | **TemporalCompressor** | Choose compression tier (none/half/pq8/pq4/binary) | `hot`/`warm`/`cold` |
 
 Each controller uses the bandit optionally — when no bandit is provided, behavior is unchanged from v2. When present, the bandit reranks results using Thompson-sampled Beta distributions, and controllers feed outcomes back via `recordReward()`.
 
 ```typescript
-import { SolverBandit } from 'agentdb/backends/rvf/SolverBandit';
+import { SolverBandit } from "agentdb/backends/rvf/SolverBandit";
 
 const bandit = new SolverBandit();
 
 // Select best arm for a context
-const skill = bandit.selectArm('code_review', ['lint_first', 'test_first', 'security_scan']);
+const skill = bandit.selectArm("code_review", [
+  "lint_first",
+  "test_first",
+  "security_scan",
+]);
 
 // Record outcome
-bandit.recordReward('code_review', skill, 0.85, /* latencyMs */ 120);
+bandit.recordReward("code_review", skill, 0.85, /* latencyMs */ 120);
 
 // Rerank candidates by learned performance
-const ranked = bandit.rerank('code_review', ['lint_first', 'test_first', 'security_scan']);
+const ranked = bandit.rerank("code_review", [
+  "lint_first",
+  "test_first",
+  "security_scan",
+]);
 
 // Serialize for cross-session persistence
 const state = bandit.serialize(); // JSON-safe
@@ -1706,7 +1875,12 @@ const restored = SolverBandit.deserialize(state);
 **Wire into AgentDB controllers:**
 
 ```typescript
-import { SolverBandit, SkillLibrary, ReasoningBank, LearningSystem } from 'agentdb';
+import {
+  SolverBandit,
+  SkillLibrary,
+  ReasoningBank,
+  LearningSystem,
+} from "agentdb";
 
 const bandit = new SolverBandit({ costWeight: 0.01, explorationBonus: 0.1 });
 
@@ -1716,8 +1890,8 @@ const patterns = new ReasoningBank(db, embedder, undefined, bandit);
 const learning = new LearningSystem(db, undefined, bandit);
 
 // Controllers automatically rerank results and accept feedback
-const algorithm = learning.recommendAlgorithm('navigation task');
-learning.recordAlgorithmOutcome('navigation task', algorithm, 0.92, 340);
+const algorithm = learning.recommendAlgorithm("navigation task");
+learning.recordAlgorithmOutcome("navigation task", algorithm, 0.92, 340);
 ```
 
 </details>
@@ -1745,13 +1919,13 @@ import {
   validateCypherParams,
   validateLabel,
   validateBatchSize,
-} from 'agentdb/security/validation';
+} from "agentdb/security/validation";
 
 // Vector validation — prevents NaN/Infinity injection
-validateVector(embedding, 384, 'embedding');
+validateVector(embedding, 384, "embedding");
 
 // ID validation — prevents path traversal (../, etc.)
-validateVectorId('doc-123', 'id');
+validateVectorId("doc-123", "id");
 
 // Search bounds — k, threshold, efSearch range checking
 validateSearchOptions({ k: 10, threshold: 0.7 });
@@ -1773,27 +1947,27 @@ import {
   validateTaskString,
   validateNumericRange,
   validateEnum,
-} from 'agentdb/security/input-validation';
+} from "agentdb/security/input-validation";
 
-const task = validateTaskString(input, 'task'); // XSS pattern detection
-const k = validateNumericRange(kVal, 'k', 1, 100);
-const format = validateEnum(fmt, 'format', ['json', 'concise', 'detailed']);
+const task = validateTaskString(input, "task"); // XSS pattern detection
+const k = validateNumericRange(kVal, "k", 1, 100);
+const format = validateEnum(fmt, "format", ["json", "concise", "detailed"]);
 ```
 
 ### Security Limits
 
-| Parameter | Limit |
-| --- | --- |
-| Max vectors | 10,000,000 |
-| Max dimension | 4,096 |
-| Max batch size | 10,000 |
-| Max k | 10,000 |
-| Max metadata size | 64 KB |
-| Max ID length | 256 chars |
-| Filter expression depth | 64 |
-| ef-search range | 1 - 1,000 |
-| ef-construction range | 4 - 500 |
-| M range | 2 - 64 |
+| Parameter               | Limit      |
+| ----------------------- | ---------- |
+| Max vectors             | 10,000,000 |
+| Max dimension           | 4,096      |
+| Max batch size          | 10,000     |
+| Max k                   | 10,000     |
+| Max metadata size       | 64 KB      |
+| Max ID length           | 256 chars  |
+| Filter expression depth | 64         |
+| ef-search range         | 1 - 1,000  |
+| ef-construction range   | 4 - 500    |
+| M range                 | 2 - 64     |
 
 ### Witness Chain Verification
 
@@ -1802,7 +1976,7 @@ SHAKE-256 cryptographic witness chains provide tamper-evident audit trails:
 ```typescript
 const result = backend.verifyWitnessChain();
 if (!result.valid) {
-  console.error('Data integrity compromised!');
+  console.error("Data integrity compromised!");
 }
 ```
 
@@ -1812,11 +1986,11 @@ Every search result can include a Merkle proof explaining why it was selected:
 
 ```typescript
 const { results, certificate } = await causalRecall.recall(
-  'query-id',
-  'optimization strategies',
+  "query-id",
+  "optimization strategies",
   10,
-  ['performance'],
-  'internal',
+  ["performance"],
+  "internal",
 );
 console.log(`Certificate ID: ${certificate.id}`);
 console.log(`Completeness: ${certificate.completenessScore}`);
@@ -1836,16 +2010,22 @@ AgentDB supports multiple quantization strategies to reduce memory footprint whi
 8-bit and 4-bit scalar quantization for memory-efficient storage:
 
 ```typescript
-import { createScalar8BitStore, createProductQuantizedStore } from 'agentdb/browser/ProductQuantization';
+import {
+  createScalar8BitStore,
+  createProductQuantizedStore,
+} from "agentdb/browser/ProductQuantization";
 
 // 8-bit quantization — 4x memory reduction
 const store8 = createScalar8BitStore(384);
-store8.add('doc-1', embedding);
+store8.add("doc-1", embedding);
 const results = store8.search(query, 10);
 
 // Product quantization — up to 32x memory reduction
-const storePQ = createProductQuantizedStore(384, { numSubvectors: 48, bitsPerCode: 8 });
-storePQ.add('doc-1', embedding);
+const storePQ = createProductQuantizedStore(384, {
+  numSubvectors: 48,
+  bitsPerCode: 8,
+});
+storePQ.add("doc-1", embedding);
 const results = storePQ.search(query, 10);
 ```
 
@@ -1853,13 +2033,13 @@ const results = storePQ.search(query, 10);
 
 Vectors are automatically compressed based on age and access frequency:
 
-| Tier | Compression | Memory | Quality | Trigger |
-| --- | --- | --- | --- | --- |
-| **Hot** | None | 100% | 100% | Recent / frequently accessed |
-| **Warm** | Half-precision | 50% | ~99% | Moderate age |
-| **Cool** | PQ-8 | ~12% | ~95% | Older data |
-| **Cold** | PQ-4 | ~6% | ~90% | Rarely accessed |
-| **Archive** | Binary | ~3% | ~80% | Archival storage |
+| Tier        | Compression    | Memory | Quality | Trigger                      |
+| ----------- | -------------- | ------ | ------- | ---------------------------- |
+| **Hot**     | None           | 100%   | 100%    | Recent / frequently accessed |
+| **Warm**    | Half-precision | 50%    | ~99%    | Moderate age                 |
+| **Cool**    | PQ-8           | ~12%   | ~95%    | Older data                   |
+| **Cold**    | PQ-4           | ~6%    | ~90%    | Rarely accessed              |
+| **Archive** | Binary         | ~3%    | ~80%    | Archival storage             |
 
 ### Matryoshka Dimension Truncation
 
@@ -1903,13 +2083,13 @@ Connect AgentDB to LLM providers, embedding models, and distributed systems with
 
 AgentDB supports multiple embedding models. No API key required — all Xenova models run locally.
 
-| Model | Dimension | Quality | Speed | Best For |
-| --- | --- | --- | --- | --- |
-| **all-MiniLM-L6-v2** (default) | 384 | Good | Fastest | Prototyping |
-| **bge-small-en-v1.5** | 384 | Excellent | Fast | Best 384d quality |
-| **bge-base-en-v1.5** | 768 | Excellent | Moderate | Production |
-| **all-mpnet-base-v2** | 768 | Excellent | Moderate | All-around |
-| **e5-base-v2** | 768 | Excellent | Moderate | Multilingual |
+| Model                          | Dimension | Quality   | Speed    | Best For          |
+| ------------------------------ | --------- | --------- | -------- | ----------------- |
+| **all-MiniLM-L6-v2** (default) | 384       | Good      | Fastest  | Prototyping       |
+| **bge-small-en-v1.5**          | 384       | Excellent | Fast     | Best 384d quality |
+| **bge-base-en-v1.5**           | 768       | Excellent | Moderate | Production        |
+| **all-mpnet-base-v2**          | 768       | Excellent | Moderate | All-around        |
+| **e5-base-v2**                 | 768       | Excellent | Moderate | Multilingual      |
 
 ```bash
 # Default (384d, fast)
@@ -1919,12 +2099,49 @@ npx agentdb init
 npx agentdb init --dimension 768 --model "Xenova/bge-base-en-v1.5"
 ```
 
+### Offline Embeddings (Bundled Model)
+
+The default `all-MiniLM-L6-v2` model can be bundled into a `.rvf` file and shipped with the package. This eliminates the ~23MB first-run download and enables fully offline embedding generation.
+
+**Resolution order** (automatic, no config needed):
+
+1. `AGENTDB_MODEL_PATH` env var (user override)
+2. Bundled `.rvf` at `dist/models/all-MiniLM-L6-v2.rvf`
+3. Existing `@xenova/transformers` cache
+4. Network download (fallback)
+
+```bash
+# Build the bundled model .rvf (requires model to be downloaded first)
+npm run build:model
+
+# Or specify a custom source directory
+node scripts/build-model-rvf.mjs --source /path/to/model/files
+```
+
+```typescript
+// Programmatic access
+import { ModelCacheLoader } from "agentdb/model";
+
+const cached = await ModelCacheLoader.resolve("all-MiniLM-L6-v2");
+if (cached) {
+  console.log(cached.localPath); // path to extracted model
+  console.log(cached.fromBundle); // true if loaded from .rvf
+}
+```
+
+Set `AGENTDB_MODEL_PATH` to point to a custom model directory:
+
+```bash
+export AGENTDB_MODEL_PATH=/opt/models
+# expects: /opt/models/Xenova/all-MiniLM-L6-v2/onnx/model_quantized.onnx
+```
+
 ### LLM Router for Multi-Provider Integration
 
 AgentDB can route queries through multiple LLM providers via `@ruvector/ruvllm`:
 
 ```typescript
-import { isRuvLLMInstalled } from 'agentdb/wrappers';
+import { isRuvLLMInstalled } from "agentdb/wrappers";
 
 if (await isRuvLLMInstalled()) {
   // LLM router available for enrichment and reranking
@@ -2009,34 +2226,38 @@ Multi-database coordination, real-time replication, and production observability
 The `MultiDatabaseCoordinator` enables distributed sync between multiple AgentDB instances with configurable conflict resolution.
 
 ```typescript
-import { MultiDatabaseCoordinator } from 'agentdb/coordination/MultiDatabaseCoordinator';
+import { MultiDatabaseCoordinator } from "agentdb/coordination/MultiDatabaseCoordinator";
 
 const coordinator = new MultiDatabaseCoordinator({
   replicationFactor: 3,
   syncIntervalMs: 5000,
-  conflictResolution: 'merge',   // 'last-write-wins' | 'merge' | 'manual'
+  conflictResolution: "merge", // 'last-write-wins' | 'merge' | 'manual'
   autoFailover: true,
   maxRetries: 3,
 });
 
 // Register database instances
 await coordinator.registerInstance({
-  id: 'primary',
-  url: 'file:///data/primary.rvf',
-  role: 'primary',
+  id: "primary",
+  url: "file:///data/primary.rvf",
+  role: "primary",
 });
 await coordinator.registerInstance({
-  id: 'replica-1',
-  url: 'file:///data/replica-1.rvf',
-  role: 'replica',
+  id: "replica-1",
+  url: "file:///data/replica-1.rvf",
+  role: "replica",
 });
 
 // Sync a specific instance
-const result = await coordinator.syncInstance('replica-1');
+const result = await coordinator.syncInstance("replica-1");
 console.log(`Synced: ${result.recordsSynced}, Conflicts: ${result.conflicts}`);
 
 // Broadcast operations to all instances
-await coordinator.broadcast('insertAsync', ['doc-1', embedding, { source: 'api' }]);
+await coordinator.broadcast("insertAsync", [
+  "doc-1",
+  embedding,
+  { source: "api" },
+]);
 
 // Monitor instance status
 coordinator.onStatusChange((instanceId, status) => {
@@ -2046,11 +2267,11 @@ coordinator.onStatusChange((instanceId, status) => {
 
 ### Conflict Resolution Strategies
 
-| Strategy | Description | Best For |
-| --- | --- | --- |
-| **last-write-wins** | Most recent write wins (LWW) | Simple setups, eventual consistency |
-| **merge** | Quality-based weighted average | Learning systems, federated aggregation |
-| **manual** | Returns conflicts for user resolution | Critical data, compliance requirements |
+| Strategy            | Description                           | Best For                                |
+| ------------------- | ------------------------------------- | --------------------------------------- |
+| **last-write-wins** | Most recent write wins (LWW)          | Simple setups, eventual consistency     |
+| **merge**           | Quality-based weighted average        | Learning systems, federated aggregation |
+| **manual**          | Returns conflicts for user resolution | Critical data, compliance requirements  |
 
 </details>
 
@@ -2066,7 +2287,7 @@ AgentDB supports real-time bidirectional sync between instances using QUIC trans
 QUIC provides multiplexed streams over a single connection with zero head-of-line blocking, connection migration between networks, and 0-RTT session resumption:
 
 ```typescript
-import { QUICServer } from 'agentdb/controllers/QUICServer';
+import { QUICServer } from "agentdb/controllers/QUICServer";
 
 const server = new QUICServer({
   port: 4433,
@@ -2075,7 +2296,7 @@ const server = new QUICServer({
     requestsPerMin: 1000,
     bytesPerMin: 10_000_000,
   },
-  authToken: 'secret',  // optional token validation
+  authToken: "secret", // optional token validation
 });
 
 // Stale connections auto-cleaned after 5 minutes idle
@@ -2088,12 +2309,12 @@ const server = new QUICServer({
 High-level bidirectional sync with conflict resolution, progress tracking, and auto-sync:
 
 ```typescript
-import { SyncCoordinator } from 'agentdb/controllers/SyncCoordinator';
+import { SyncCoordinator } from "agentdb/controllers/SyncCoordinator";
 
 const sync = new SyncCoordinator({
-  conflictStrategy: 'latest-wins', // 'local-wins' | 'remote-wins' | 'latest-wins' | 'merge'
+  conflictStrategy: "latest-wins", // 'local-wins' | 'remote-wins' | 'latest-wins' | 'merge'
   batchSize: 100,
-  autoSyncInterval: 60000,         // Auto-sync every 60 seconds
+  autoSyncInterval: 60000, // Auto-sync every 60 seconds
 });
 
 // Push local changes, pull remote changes, resolve conflicts
@@ -2120,12 +2341,12 @@ await sync.saveSyncState();
 
 ### Conflict Resolution
 
-| Strategy | Behavior |
-| --- | --- |
-| `local-wins` | Local version always kept |
-| `remote-wins` | Remote version always accepted |
-| `latest-wins` | Most recent timestamp wins |
-| `merge` | Quality-weighted merge of both versions |
+| Strategy      | Behavior                                |
+| ------------- | --------------------------------------- |
+| `local-wins`  | Local version always kept               |
+| `remote-wins` | Remote version always accepted          |
+| `latest-wins` | Most recent timestamp wins              |
+| `merge`       | Quality-weighted merge of both versions |
 
 </details>
 
@@ -2141,11 +2362,11 @@ AgentDB integrates with OpenTelemetry for production monitoring.
 Automatic span creation for search, insert, and sync operations:
 
 ```typescript
-import { initTelemetry } from 'agentdb/observability';
+import { initTelemetry } from "agentdb/observability";
 
 initTelemetry({
-  serviceName: 'my-agent',
-  exporterUrl: 'http://localhost:4318', // OTLP HTTP endpoint
+  serviceName: "my-agent",
+  exporterUrl: "http://localhost:4318", // OTLP HTTP endpoint
 });
 
 // All AgentDB operations automatically generate spans:
@@ -2179,25 +2400,25 @@ AgentDB includes a complete reinforcement learning system with 9 algorithms for
 
 ### Available Algorithms
 
-| Algorithm | Type | Best For |
-| --- | --- | --- |
-| **Q-Learning** | Value-based | Simple discrete action spaces |
-| **SARSA** | Value-based | On-policy learning, safer exploration |
-| **Deep Q-Network (DQN)** | Value-based | Complex state spaces with neural function approximation |
-| **Policy Gradient** | Policy-based | Continuous action spaces |
-| **Actor-Critic** | Hybrid | Balances value and policy learning |
-| **PPO** | Policy-based | Stable training with clipped objectives |
-| **Decision Transformer** | Sequence-based | Offline RL from logged trajectories |
-| **Monte Carlo Tree Search** | Planning | Game-like decision trees, look-ahead planning |
-| **Model-Based RL** | Model-based | Sample-efficient learning with world models |
+| Algorithm                   | Type           | Best For                                                |
+| --------------------------- | -------------- | ------------------------------------------------------- |
+| **Q-Learning**              | Value-based    | Simple discrete action spaces                           |
+| **SARSA**                   | Value-based    | On-policy learning, safer exploration                   |
+| **Deep Q-Network (DQN)**    | Value-based    | Complex state spaces with neural function approximation |
+| **Policy Gradient**         | Policy-based   | Continuous action spaces                                |
+| **Actor-Critic**            | Hybrid         | Balances value and policy learning                      |
+| **PPO**                     | Policy-based   | Stable training with clipped objectives                 |
+| **Decision Transformer**    | Sequence-based | Offline RL from logged trajectories                     |
+| **Monte Carlo Tree Search** | Planning       | Game-like decision trees, look-ahead planning           |
+| **Model-Based RL**          | Model-based    | Sample-efficient learning with world models             |
 
 ### Usage
 
 ```typescript
-import { LearningSystem } from 'agentdb';
+import { LearningSystem } from "agentdb";
 
 const learner = new LearningSystem(db, {
-  algorithm: 'ppo',         // any of the 9 algorithms
+  algorithm: "ppo", // any of the 9 algorithms
   learningRate: 0.001,
   discountFactor: 0.99,
   explorationRate: 0.1,
@@ -2205,7 +2426,7 @@ const learner = new LearningSystem(db, {
 
 // Start a learning session
 const session = await learner.createSession({
-  task: 'optimize_api_responses',
+  task: "optimize_api_responses",
   maxEpisodes: 100,
 });
 
@@ -2226,6 +2447,7 @@ await learner.transfer(sourceSessionId, targetSessionId);
 ### MCP Tools for RL
 
 All 9 algorithms are accessible through MCP tools:
+
 - `agentdb_rl_create_session` — start a new learning session
 - `agentdb_rl_predict` — get next action recommendation
 - `agentdb_rl_record_reward` — record outcome feedback
@@ -2243,30 +2465,30 @@ All 9 algorithms are accessible through MCP tools:
 Combine traditional keyword search (BM25) with vector similarity for retrieval that handles both exact matches and semantic meaning:
 
 ```typescript
-import { createHybridSearch, createKeywordIndex } from 'agentdb';
+import { createHybridSearch, createKeywordIndex } from "agentdb";
 
 // Create keyword index (BM25)
 const keywordIndex = createKeywordIndex({
-  k1: 1.2,        // term frequency saturation
-  b: 0.75,        // document length normalization
+  k1: 1.2, // term frequency saturation
+  b: 0.75, // document length normalization
   avgDocLength: 100,
 });
 
 // Index documents
-keywordIndex.add('doc-1', 'JWT authentication with refresh token rotation');
-keywordIndex.add('doc-2', 'OAuth2 PKCE flow for mobile applications');
+keywordIndex.add("doc-1", "JWT authentication with refresh token rotation");
+keywordIndex.add("doc-2", "OAuth2 PKCE flow for mobile applications");
 
 // Create hybrid search (keyword + vector)
 const hybrid = createHybridSearch(keywordIndex, vectorBackend, {
-  fusion: 'rrf',      // 'rrf' (Reciprocal Rank Fusion) | 'linear' | 'max'
-  keywordWeight: 0.3,  // 30% keyword, 70% vector
+  fusion: "rrf", // 'rrf' (Reciprocal Rank Fusion) | 'linear' | 'max'
+  keywordWeight: 0.3, // 30% keyword, 70% vector
   vectorWeight: 0.7,
 });
 
 // Search with both keyword and semantic matching
 const results = await hybrid.search({
-  text: 'JWT refresh token',       // keyword query
-  embedding: queryEmbedding,       // vector query
+  text: "JWT refresh token", // keyword query
+  embedding: queryEmbedding, // vector query
   k: 10,
 });
 // Results fused from both sources — exact term matches + semantic similarity
@@ -2274,11 +2496,11 @@ const results = await hybrid.search({
 
 ### Fusion Strategies
 
-| Strategy | How it works | Best For |
-| --- | --- | --- |
-| **RRF** (default) | `1/(k + rank)` — rank-based fusion, no score calibration needed | General use |
-| **Linear** | `α × keyword_score + β × vector_score` — weighted score combination | When you know the right balance |
-| **Max** | `max(keyword_score, vector_score)` — takes highest signal | When either source is sufficient |
+| Strategy          | How it works                                                        | Best For                         |
+| ----------------- | ------------------------------------------------------------------- | -------------------------------- |
+| **RRF** (default) | `1/(k + rank)` — rank-based fusion, no score calibration needed     | General use                      |
+| **Linear**        | `α × keyword_score + β × vector_score` — weighted score combination | When you know the right balance  |
+| **Max**           | `max(keyword_score, vector_score)` — takes highest signal           | When either source is sufficient |
 
 > **When to use hybrid search:** When your data contains domain-specific terms (function names, error codes, product IDs) that vector embeddings might miss, but you also want semantic understanding for natural language queries.
 
@@ -2292,26 +2514,26 @@ const results = await hybrid.search({
 AgentDB can route LLM queries to the optimal provider based on your constraints:
 
 ```typescript
-import { LLMRouter } from 'agentdb';
+import { LLMRouter } from "agentdb";
 
 const router = new LLMRouter({
   providers: {
-    ruvllm: { enabled: true },                              // Local, SIMD-optimized, free
-    openrouter: { apiKey: process.env.OPENROUTER_KEY },     // 200+ models, 99% cost savings
-    gemini: { apiKey: process.env.GEMINI_KEY },             // Free tier available
-    anthropic: { apiKey: process.env.ANTHROPIC_KEY },       // Claude models
-    onnx: { enabled: true },                                // Local models via transformers.js
+    ruvllm: { enabled: true }, // Local, SIMD-optimized, free
+    openrouter: { apiKey: process.env.OPENROUTER_KEY }, // 200+ models, 99% cost savings
+    gemini: { apiKey: process.env.GEMINI_KEY }, // Free tier available
+    anthropic: { apiKey: process.env.ANTHROPIC_KEY }, // Claude models
+    onnx: { enabled: true }, // Local models via transformers.js
   },
-  strategy: 'auto',  // auto-selects based on constraints below
+  strategy: "auto", // auto-selects based on constraints below
   constraints: {
-    maxCostPerQuery: 0.001,   // max $0.001 per query
-    minQuality: 0.8,          // minimum quality score
-    preferLocal: true,        // prefer local models when possible
-    requirePrivacy: false,    // if true, only uses local providers
+    maxCostPerQuery: 0.001, // max $0.001 per query
+    minQuality: 0.8, // minimum quality score
+    preferLocal: true, // prefer local models when possible
+    requirePrivacy: false, // if true, only uses local providers
   },
 });
 
-const response = await router.generate('Summarize this document...', {
+const response = await router.generate("Summarize this document...", {
   maxTokens: 500,
   temperature: 0.7,
 });
@@ -2319,17 +2541,17 @@ const response = await router.generate('Summarize this document...', {
 
 ### Provider Comparison
 
-| Provider | Latency | Cost | Privacy | Models |
-| --- | --- | --- | --- | --- |
-| **RuvLLM** | Fastest | Free | Full (local) | SIMD-optimized local models |
-| **ONNX** | Fast | Free | Full (local) | transformers.js models |
-| **OpenRouter** | ~500ms | $0.0001+ | Cloud | 200+ models (GPT-4, Claude, Llama, etc.) |
-| **Gemini** | ~300ms | Free tier | Cloud | Gemini Pro, Flash |
-| **Anthropic** | ~1s | $0.003+ | Cloud | Claude Opus, Sonnet, Haiku |
+| Provider       | Latency | Cost      | Privacy      | Models                                   |
+| -------------- | ------- | --------- | ------------ | ---------------------------------------- |
+| **RuvLLM**     | Fastest | Free      | Full (local) | SIMD-optimized local models              |
+| **ONNX**       | Fast    | Free      | Full (local) | transformers.js models                   |
+| **OpenRouter** | ~500ms  | $0.0001+  | Cloud        | 200+ models (GPT-4, Claude, Llama, etc.) |
+| **Gemini**     | ~300ms  | Free tier | Cloud        | Gemini Pro, Flash                        |
+| **Anthropic**  | ~1s     | $0.003+   | Cloud        | Claude Opus, Sonnet, Haiku               |
 
 ```typescript
 // Check what's available locally
-import { isRuvLLMInstalled } from 'agentdb';
+import { isRuvLLMInstalled } from "agentdb";
 if (await isRuvLLMInstalled()) {
   // Local inference available — no API keys needed
 }
@@ -2347,18 +2569,18 @@ Enterprise-ready authentication and audit logging for production deployments.
 ### Authentication
 
 ```typescript
-import { AuthService } from 'agentdb/services/auth';
+import { AuthService } from "agentdb/services/auth";
 
 const auth = new AuthService(db, {
   jwtSecret: process.env.JWT_SECRET,
-  accessTokenTTL: '15m',
-  refreshTokenTTL: '7d',
-  maxLoginAttempts: 5,     // account lockout after 5 failures
-  lockoutDuration: '30m',
+  accessTokenTTL: "15m",
+  refreshTokenTTL: "7d",
+  maxLoginAttempts: 5, // account lockout after 5 failures
+  lockoutDuration: "30m",
 });
 
 // User registration (Argon2id password hashing)
-const user = await auth.register({ email, password, role: 'user' });
+const user = await auth.register({ email, password, role: "user" });
 
 // Login — returns access + refresh token pair
 const { accessToken, refreshToken } = await auth.login(email, password);
@@ -2367,19 +2589,22 @@ const { accessToken, refreshToken } = await auth.login(email, password);
 const payload = await auth.verifyAccessToken(accessToken);
 
 // API key management
-const apiKey = await auth.generateApiKey(userId, { name: 'prod-key', scopes: ['read', 'write'] });
-await auth.rotateApiKey(apiKey.id);  // automatic rotation
+const apiKey = await auth.generateApiKey(userId, {
+  name: "prod-key",
+  scopes: ["read", "write"],
+});
+await auth.rotateApiKey(apiKey.id); // automatic rotation
 ```
 
 ### Audit Logging
 
 ```typescript
-import { AuditLogger } from 'agentdb/services/audit-logger';
+import { AuditLogger } from "agentdb/services/audit-logger";
 
 const audit = new AuditLogger({
-  retention: '90d',        // log retention period
-  compliance: ['SOC2', 'GDPR'],  // compliance frameworks
-  autoRotate: true,        // automatic log rotation
+  retention: "90d", // log retention period
+  compliance: ["SOC2", "GDPR"], // compliance frameworks
+  autoRotate: true, // automatic log rotation
 });
 
 // 13 audit event types tracked automatically:
@@ -2393,11 +2618,15 @@ const audit = new AuditLogger({
 ### Security Utilities
 
 ```typescript
-import { hashPassword, verifyPassword, generateApiKey } from 'agentdb/utils/crypto';
+import {
+  hashPassword,
+  verifyPassword,
+  generateApiKey,
+} from "agentdb/utils/crypto";
 
-const hash = await hashPassword('user-password');       // Argon2id
-const valid = await verifyPassword('user-password', hash);
-const key = generateApiKey();                           // cryptographically random
+const hash = await hashPassword("user-password"); // Argon2id
+const valid = await verifyPassword("user-password", hash);
+const key = generateApiKey(); // cryptographically random
 ```
 
 </details>
@@ -2410,40 +2639,40 @@ const key = generateApiKey();                           // cryptographically ran
 Filter search results and database queries using MongoDB-style operators:
 
 ```typescript
-import { MetadataFilter } from 'agentdb';
+import { MetadataFilter } from "agentdb";
 
 const filter = new MetadataFilter();
 
 // Episodes with reward > 0.8 and specific tags
 const episodes = await filter.filterEpisodes(db, {
   reward: { $gt: 0.8 },
-  tags: { $contains: 'security' },
-  status: { $in: ['success', 'partial'] },
+  tags: { $contains: "security" },
+  status: { $in: ["success", "partial"] },
   archived: { $exists: false },
 });
 
 // Patterns matching complex criteria
 const patterns = await filter.filterPatterns(db, {
   successRate: { $gte: 0.7, $lte: 1.0 },
-  taskType: { $ne: 'deprecated' },
+  taskType: { $ne: "deprecated" },
   createdAt: { $gt: lastWeekTimestamp },
 });
 ```
 
 ### Supported Operators
 
-| Operator | Description | Example |
-| --- | --- | --- |
-| `$eq` | Equal | `{ status: { $eq: 'active' } }` |
-| `$ne` | Not equal | `{ role: { $ne: 'admin' } }` |
-| `$gt` | Greater than | `{ reward: { $gt: 0.5 } }` |
-| `$gte` | Greater than or equal | `{ score: { $gte: 0.8 } }` |
-| `$lt` | Less than | `{ age: { $lt: 90 } }` |
-| `$lte` | Less than or equal | `{ priority: { $lte: 3 } }` |
-| `$in` | In array | `{ type: { $in: ['a', 'b'] } }` |
-| `$nin` | Not in array | `{ status: { $nin: ['deleted'] } }` |
-| `$contains` | Contains substring | `{ tags: { $contains: 'auth' } }` |
-| `$exists` | Field exists | `{ metadata: { $exists: true } }` |
+| Operator    | Description           | Example                             |
+| ----------- | --------------------- | ----------------------------------- |
+| `$eq`       | Equal                 | `{ status: { $eq: 'active' } }`     |
+| `$ne`       | Not equal             | `{ role: { $ne: 'admin' } }`        |
+| `$gt`       | Greater than          | `{ reward: { $gt: 0.5 } }`          |
+| `$gte`      | Greater than or equal | `{ score: { $gte: 0.8 } }`          |
+| `$lt`       | Less than             | `{ age: { $lt: 90 } }`              |
+| `$lte`      | Less than or equal    | `{ priority: { $lte: 3 } }`         |
+| `$in`       | In array              | `{ type: { $in: ['a', 'b'] } }`     |
+| `$nin`      | Not in array          | `{ status: { $nin: ['deleted'] } }` |
+| `$contains` | Contains substring    | `{ tags: { $contains: 'auth' } }`   |
+| `$exists`   | Field exists          | `{ metadata: { $exists: true } }`   |
 
 </details>
 
@@ -2455,16 +2684,16 @@ const patterns = await filter.filterPatterns(db, {
 The `AgentDBFast` wrapper provides direct programmatic access that's 50-200x faster than going through the CLI:
 
 ```typescript
-import { createFastAgentDB } from 'agentdb/wrappers/agentdb-fast';
+import { createFastAgentDB } from "agentdb/wrappers/agentdb-fast";
 
 const db = await createFastAgentDB({
-  path: './agent-memory.db',
+  path: "./agent-memory.db",
   dimension: 384,
-  model: 'Xenova/all-MiniLM-L6-v2',
+  model: "Xenova/all-MiniLM-L6-v2",
 });
 
 // All operations bypass CLI parsing overhead
-await db.insert('doc-1', embedding, metadata);
+await db.insert("doc-1", embedding, metadata);
 const results = await db.search(queryEmbedding, 10);
 await db.batchInsert(documents);
 
@@ -2477,11 +2706,11 @@ await db.batchInsert(documents);
 
 ### Wrapper Performance vs CLI
 
-| Operation | CLI | AgentDBFast | Speedup |
-| --- | --- | --- | --- |
-| Single insert | ~20ms | ~0.1ms | 200x |
-| Search (k=10) | ~15ms | ~0.08ms | 187x |
-| Batch insert (100) | ~500ms | ~10ms | 50x |
+| Operation          | CLI    | AgentDBFast | Speedup |
+| ------------------ | ------ | ----------- | ------- |
+| Single insert      | ~20ms  | ~0.1ms      | 200x    |
+| Search (k=10)      | ~15ms  | ~0.08ms     | 187x    |
+| Batch insert (100) | ~500ms | ~10ms       | 50x     |
 
 ### Attention Wrappers
 
@@ -2494,7 +2723,7 @@ import {
   LinearAttention,
   HyperbolicAttention,
   MoEAttention,
-} from 'agentdb/wrappers';
+} from "agentdb/wrappers";
 
 // Flash Attention — O(N) memory instead of O(N^2)
 const flash = new FlashAttention({ numHeads: 8 });
@@ -2514,13 +2743,15 @@ import {
   OpenAIEmbeddingService,
   TransformersEmbeddingService,
   MockEmbeddingService,
-} from 'agentdb/wrappers';
+} from "agentdb/wrappers";
 
 // OpenAI (cloud)
 const openai = new OpenAIEmbeddingService({ apiKey: process.env.OPENAI_KEY });
 
 // Transformers.js (local, free)
-const local = new TransformersEmbeddingService({ model: 'Xenova/all-MiniLM-L6-v2' });
+const local = new TransformersEmbeddingService({
+  model: "Xenova/all-MiniLM-L6-v2",
+});
 
 // Mock (testing)
 const mock = new MockEmbeddingService({ dimension: 384 });
@@ -2536,7 +2767,7 @@ const mock = new MockEmbeddingService({ dimension: 384 });
 Run performance benchmarks to validate your deployment:
 
 ```typescript
-import { BenchmarkSuite, runBenchmarks, formatReportAsMarkdown } from 'agentdb';
+import { BenchmarkSuite, runBenchmarks, formatReportAsMarkdown } from "agentdb";
 
 // Run all built-in benchmarks
 const report = await runBenchmarks({
@@ -2550,25 +2781,31 @@ console.log(formatReportAsMarkdown(report));
 
 ### Built-in Benchmarks
 
-| Benchmark | Measures | Key Metrics |
-| --- | --- | --- |
-| **VectorInsertBenchmark** | Insert throughput | ops/sec, p50/p99 latency |
-| **VectorSearchBenchmark** | Search performance | ops/sec, recall@k, latency distribution |
-| **MemoryUsageBenchmark** | RAM consumption | bytes per vector, total footprint |
-| **ConcurrencyBenchmark** | Parallel performance | throughput under load, contention |
-| **QuantizationBenchmark** | Compression tradeoffs | quality loss vs memory savings |
+| Benchmark                 | Measures              | Key Metrics                             |
+| ------------------------- | --------------------- | --------------------------------------- |
+| **VectorInsertBenchmark** | Insert throughput     | ops/sec, p50/p99 latency                |
+| **VectorSearchBenchmark** | Search performance    | ops/sec, recall@k, latency distribution |
+| **MemoryUsageBenchmark**  | RAM consumption       | bytes per vector, total footprint       |
+| **ConcurrencyBenchmark**  | Parallel performance  | throughput under load, contention       |
+| **QuantizationBenchmark** | Compression tradeoffs | quality loss vs memory savings          |
 
 ### Custom Benchmarks
 
 ```typescript
-import { Benchmark, BenchmarkSuite } from 'agentdb';
+import { Benchmark, BenchmarkSuite } from "agentdb";
 
 class MyBenchmark extends Benchmark {
-  name = 'my-custom-benchmark';
+  name = "my-custom-benchmark";
 
-  async setup() { /* prepare data */ }
-  async run() { /* measure this */ }
-  async teardown() { /* cleanup */ }
+  async setup() {
+    /* prepare data */
+  }
+  async run() {
+    /* measure this */
+  }
+  async teardown() {
+    /* cleanup */
+  }
 }
 
 const suite = new BenchmarkSuite();
@@ -2576,7 +2813,7 @@ suite.add(new MyBenchmark());
 const report = await suite.run({ iterations: 50 });
 
 // Compare reports across runs
-import { formatComparisonAsMarkdown } from 'agentdb';
+import { formatComparisonAsMarkdown } from "agentdb";
 console.log(formatComparisonAsMarkdown(reportBefore, reportAfter));
 ```
 
@@ -2613,13 +2850,13 @@ npm run test:ci                  # CI pipeline: browser tests + build + bundle v
 
 ### What's Tested
 
-| Suite | Coverage | What it validates |
-| --- | --- | --- |
-| **Unit tests** | Core controllers, memory patterns, embedding service, quantization | All 6 cognitive memory patterns, 9 RL algorithms, filter expressions, security validators |
-| **Browser tests** | WASM store, attention mechanisms, product quantization, SIMD fallbacks | Full vector DB in browser, Flash/Hyperbolic/MoE attention, PQ8/PQ16/PQ32 compression |
-| **Integration tests** | End-to-end flows, backend auto-selection, MCP tool execution | Self-learning pipeline, Cognitive Container operations, federated aggregation |
-| **Performance tests** | Latency benchmarks, throughput, scaling behavior | 61us search target, 32.6M ops/sec pattern search, batch insert speedup |
-| **Security tests** | Input validation, injection prevention, witness chain verification | XSS patterns, SQL injection, path traversal, Cypher sanitization, SHAKE-256 |
+| Suite                 | Coverage                                                               | What it validates                                                                         |
+| --------------------- | ---------------------------------------------------------------------- | ----------------------------------------------------------------------------------------- |
+| **Unit tests**        | Core controllers, memory patterns, embedding service, quantization     | All 6 cognitive memory patterns, 9 RL algorithms, filter expressions, security validators |
+| **Browser tests**     | WASM store, attention mechanisms, product quantization, SIMD fallbacks | Full vector DB in browser, Flash/Hyperbolic/MoE attention, PQ8/PQ16/PQ32 compression      |
+| **Integration tests** | End-to-end flows, backend auto-selection, MCP tool execution           | Self-learning pipeline, Cognitive Container operations, federated aggregation             |
+| **Performance tests** | Latency benchmarks, throughput, scaling behavior                       | 61us search target, 32.6M ops/sec pattern search, batch insert speedup                    |
+| **Security tests**    | Input validation, injection prevention, witness chain verification     | XSS patterns, SQL injection, path traversal, Cypher sanitization, SHAKE-256               |
 
 ### Benchmarks
 
@@ -2635,6 +2872,7 @@ npm run benchmark:all            # Run everything
 ### CI Pipeline
 
 The CI pipeline runs `test:ci` which executes:
+
 1. **Browser bundle tests** — verifies WASM and JS fallbacks work
 2. **TypeScript build** — full `tsc` compilation
 3. **Bundle verification** — ensures all export paths resolve correctly
@@ -2642,19 +2880,23 @@ The CI pipeline runs `test:ci` which executes:
 ### Writing Custom Tests
 
 ```typescript
-import { describe, it, expect } from 'vitest';
-import { createDatabase, ReasoningBank, EmbeddingService } from 'agentdb';
+import { describe, it, expect } from "vitest";
+import { createDatabase, ReasoningBank, EmbeddingService } from "agentdb";
 
-describe('My Agent Memory', () => {
-  it('stores and retrieves patterns', async () => {
-    const db = await createDatabase(':memory:');
-    const embedder = new EmbeddingService({ model: 'Xenova/all-MiniLM-L6-v2' });
+describe("My Agent Memory", () => {
+  it("stores and retrieves patterns", async () => {
+    const db = await createDatabase(":memory:");
+    const embedder = new EmbeddingService({ model: "Xenova/all-MiniLM-L6-v2" });
     await embedder.initialize();
 
     const bank = new ReasoningBank(db, embedder);
-    await bank.storePattern({ taskType: 'test', approach: 'TDD', successRate: 0.95 });
+    await bank.storePattern({
+      taskType: "test",
+      approach: "TDD",
+      successRate: 0.95,
+    });
 
-    const results = await bank.searchPatterns({ task: 'testing', k: 5 });
+    const results = await bank.searchPatterns({ task: "testing", k: 5 });
     expect(results.length).toBeGreaterThan(0);
   });
 });
@@ -2666,13 +2908,13 @@ describe('My Agent Memory', () => {
 
 ## Documentation
 
-| Document | Description |
-| --- | --- |
-| [MCP Tool Optimization Guide](docs/guides/) | Comprehensive MCP patterns |
-| [Embedding Models Guide](docs/guides/) | Model selection and benchmarks |
-| [Simulation System](simulation/README.md) | 31 scenarios, interactive wizard |
-| [Security Hardening](docs/guides/) | Input validation and security patterns |
-| [Chat Ecosystem](../agentdb-chat/README.md) | `@agentdb/chat` integration guide |
+| Document                                                                             | Description                                |
+| ------------------------------------------------------------------------------------ | ------------------------------------------ |
+| [MCP Tool Optimization Guide](docs/guides/)                                          | Comprehensive MCP patterns                 |
+| [Embedding Models Guide](docs/guides/)                                               | Model selection and benchmarks             |
+| [Simulation System](simulation/README.md)                                            | 31 scenarios, interactive wizard           |
+| [Security Hardening](docs/guides/)                                                   | Input validation and security patterns     |
+| [Chat Ecosystem](../agentdb-chat/README.md)                                          | `@agentdb/chat` integration guide          |
 | [ADR-010: Solver Integration](docs/adrs/ADR-010-rvf-solver-v014-deep-integration.md) | SolverBandit + rvf-solver deep integration |
 
 ---