wolbarg 0.3.2 → 0.4.0

package/dist/index.cjs

@@ -1,11 +1,13 @@
 'use strict';
 
 var path5 = require("node:path");
+var crypto$1 = require('crypto');
 var fs = require('fs/promises');
 var fs5 = require("node:fs");
 var sqlite$1 = require("node:sqlite");
 var sqliteVec = require('sqlite-vec');
 var async_hooks = require('async_hooks');
+var events = require('events');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
@@ -74,6 +76,12 @@ var DatabaseError = class extends WolbargError {
     this.name = "DatabaseError";
   }
 };
+var StorageLockedError = class extends WolbargError {
+  constructor(message, options) {
+    super(message, "WOLBARG_STORAGE_LOCKED", options);
+    this.name = "StorageLockedError";
+  }
+};
 var EmbeddingError = class extends WolbargError {
   constructor(message, options) {
     super(message, "EMBEDDING_ERROR", options);
@@ -111,11 +119,11 @@ function wrapOperationError(operation, error) {
   const raw = error instanceof Error ? error.message : String(error);
   const lower = raw.toLowerCase();
   if (lower.includes("database is locked") || lower.includes("sqlite_busy")) {
-    return new DatabaseError(formatOperationMessage(operation, raw), {
+    return new StorageLockedError(formatOperationMessage(operation, raw), {
       cause: error instanceof Error ? error : void 0,
       operation,
       reason: "SQLite database locked",
-      suggestion: "Increase timeout or reduce concurrent writes."
+      suggestion: "Increase concurrency.maxRetries or concurrency.lockTimeoutMs, or consider the Postgres backend for high-concurrency multi-agent workloads."
     });
   }
   if (lower.includes("no such file") || lower.includes("enoent")) {
@@ -575,6 +583,404 @@ async function embedMany(provider, texts, concurrency = 8) {
   );
   return out;
 }
+function resolveEmbeddingCacheConfig(input) {
+  return {
+    enabled: input?.enabled ?? true,
+    ttlMs: input?.ttlMs ?? null,
+    maxEntries: input?.maxEntries ?? null
+  };
+}
+function embeddingCacheKey(content, model) {
+  const hash = crypto$1.createHash("sha256").update(content, "utf8").digest("hex");
+  return `${hash}:${model}`;
+}
+function withEmbeddingCache(provider, store, config) {
+  let cacheHits = 0;
+  let cacheMisses = 0;
+  async function embedOne(text) {
+    if (!config.enabled) {
+      cacheMisses += 1;
+      return provider.embed(text);
+    }
+    const key = embeddingCacheKey(text, provider.model);
+    const cached = await store.get(key);
+    if (cached) {
+      cacheHits += 1;
+      return cached;
+    }
+    cacheMisses += 1;
+    const vector = await provider.embed(text);
+    void store.set(key, provider.model, vector);
+    if (config.maxEntries !== null) {
+      void store.evictIfNeeded(config.maxEntries);
+    }
+    return vector;
+  }
+  async function embedBatch(texts) {
+    if (!config.enabled || texts.length === 0) {
+      if (provider.embedBatch) {
+        cacheMisses += texts.length;
+        return provider.embedBatch(texts);
+      }
+      return Promise.all(texts.map((t) => embedOne(t)));
+    }
+    const results = new Array(texts.length).fill(
+      null
+    );
+    const missIndexes = [];
+    const missTexts = [];
+    for (let i = 0; i < texts.length; i += 1) {
+      const text = texts[i];
+      const key = embeddingCacheKey(text, provider.model);
+      const cached = await store.get(key);
+      if (cached) {
+        cacheHits += 1;
+        results[i] = cached;
+      } else {
+        missIndexes.push(i);
+        missTexts.push(text);
+      }
+    }
+    if (missTexts.length > 0) {
+      cacheMisses += missTexts.length;
+      const vectors = provider.embedBatch ? await provider.embedBatch(missTexts) : await Promise.all(missTexts.map((t) => provider.embed(t)));
+      for (let j = 0; j < missIndexes.length; j += 1) {
+        const idx = missIndexes[j];
+        const vector = vectors[j];
+        results[idx] = vector;
+        const key = embeddingCacheKey(missTexts[j], provider.model);
+        void store.set(key, provider.model, vector);
+      }
+      if (config.maxEntries !== null) {
+        void store.evictIfNeeded(config.maxEntries);
+      }
+    }
+    return results;
+  }
+  return {
+    model: provider.model,
+    embed: embedOne,
+    embedBatch,
+    validate: () => provider.validate(),
+    get cacheHits() {
+      return cacheHits;
+    },
+    get cacheMisses() {
+      return cacheMisses;
+    },
+    resetCacheStats() {
+      cacheHits = 0;
+      cacheMisses = 0;
+    }
+  };
+}
+
+// src/embedding/cache-store.ts
+var TOUCH_FLUSH_THRESHOLD = 64;
+var L1_DEFAULT_MAX = 5e4;
+var L1Cache = class {
+  map = /* @__PURE__ */ new Map();
+  maxEntries;
+  constructor(maxEntries = L1_DEFAULT_MAX) {
+    this.maxEntries = maxEntries;
+  }
+  get(cacheKey, ttlMs) {
+    const entry = this.map.get(cacheKey);
+    if (!entry) {
+      return null;
+    }
+    if (ttlMs !== null && Date.now() - entry.createdAt > ttlMs) {
+      this.map.delete(cacheKey);
+      return null;
+    }
+    entry.lastUsedAt = Date.now();
+    this.map.delete(cacheKey);
+    this.map.set(cacheKey, entry);
+    return entry.vector;
+  }
+  set(cacheKey, model, vector) {
+    const now = Date.now();
+    if (this.map.has(cacheKey)) {
+      this.map.delete(cacheKey);
+    }
+    this.map.set(cacheKey, {
+      model,
+      vector,
+      createdAt: now,
+      lastUsedAt: now
+    });
+    this.evictIfNeeded();
+  }
+  touch(cacheKey) {
+    const entry = this.map.get(cacheKey);
+    if (!entry) {
+      return;
+    }
+    entry.lastUsedAt = Date.now();
+    this.map.delete(cacheKey);
+    this.map.set(cacheKey, entry);
+  }
+  evictIfNeeded(maxEntries) {
+    const limit = maxEntries ?? this.maxEntries;
+    while (this.map.size > limit) {
+      const oldest = this.map.keys().next().value;
+      if (oldest === void 0) {
+        break;
+      }
+      this.map.delete(oldest);
+    }
+  }
+  get size() {
+    return this.map.size;
+  }
+};
+var SqliteEmbeddingCacheStore = class {
+  ttlMs;
+  getDb;
+  l1 = new L1Cache();
+  pendingTouches = /* @__PURE__ */ new Set();
+  pendingSets = /* @__PURE__ */ new Map();
+  persistScheduled = false;
+  stmts = null;
+  constructor(dbOrGetter, options) {
+    this.ttlMs = options?.ttlMs ?? null;
+    this.getDb = typeof dbOrGetter === "function" ? dbOrGetter : () => dbOrGetter;
+  }
+  requireDb() {
+    try {
+      return this.getDb();
+    } catch {
+      return null;
+    }
+  }
+  ensureStatements(db) {
+    if (this.stmts) {
+      return this.stmts;
+    }
+    this.stmts = {
+      get: db.prepare(
+        `SELECT vector, last_used_at, created_at FROM embedding_cache WHERE cache_key = ?`
+      ),
+      delete: db.prepare(`DELETE FROM embedding_cache WHERE cache_key = ?`),
+      set: db.prepare(
+        `INSERT INTO embedding_cache (cache_key, model, vector, created_at, last_used_at)
+         VALUES (?, ?, ?, ?, ?)
+         ON CONFLICT(cache_key) DO UPDATE SET
+           model = excluded.model,
+           vector = excluded.vector,
+           last_used_at = excluded.last_used_at`
+      ),
+      touch: db.prepare(
+        `UPDATE embedding_cache SET last_used_at = ? WHERE cache_key = ?`
+      ),
+      count: db.prepare(`SELECT COUNT(*) AS c FROM embedding_cache`),
+      evict: db.prepare(
+        `DELETE FROM embedding_cache WHERE cache_key IN (
+           SELECT cache_key FROM embedding_cache
+           ORDER BY last_used_at ASC
+           LIMIT ?
+         )`
+      )
+    };
+    return this.stmts;
+  }
+  async get(cacheKey) {
+    const l1Hit = this.l1.get(cacheKey, this.ttlMs);
+    if (l1Hit) {
+      return l1Hit;
+    }
+    const pending = this.pendingSets.get(cacheKey);
+    if (pending) {
+      this.l1.set(cacheKey, pending.model, pending.vector);
+      return pending.vector;
+    }
+    return null;
+  }
+  async set(cacheKey, model, vector) {
+    this.l1.set(cacheKey, model, vector);
+    this.pendingSets.set(cacheKey, {
+      model,
+      vector,
+      createdAt: Date.now()
+    });
+    this.pendingTouches.delete(cacheKey);
+    this.schedulePersist();
+  }
+  async touch(cacheKey) {
+    this.l1.touch(cacheKey);
+    if (this.pendingSets.has(cacheKey)) {
+      return;
+    }
+    this.pendingTouches.add(cacheKey);
+    if (this.pendingTouches.size >= TOUCH_FLUSH_THRESHOLD) {
+      this.schedulePersist();
+    }
+  }
+  async flushTouches() {
+    await this.flushPending();
+  }
+  async evictIfNeeded(maxEntries) {
+    this.l1.evictIfNeeded(maxEntries);
+  }
+  schedulePersist() {
+    if (this.persistScheduled) {
+      return;
+    }
+    this.persistScheduled = true;
+    queueMicrotask(() => {
+      this.persistScheduled = false;
+      void this.flushPending();
+    });
+  }
+  async flushPending() {
+    if (this.pendingSets.size === 0 && this.pendingTouches.size === 0) {
+      return;
+    }
+    const db = this.requireDb();
+    if (!db) {
+      this.pendingSets.clear();
+      this.pendingTouches.clear();
+      return;
+    }
+    const sets = [...this.pendingSets.entries()];
+    this.pendingSets.clear();
+    const touches = [...this.pendingTouches];
+    this.pendingTouches.clear();
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    try {
+      const stmts = this.ensureStatements(db);
+      try {
+        db.exec("BEGIN IMMEDIATE");
+      } catch {
+        for (const [key, value] of sets) {
+          this.pendingSets.set(key, value);
+        }
+        for (const key of touches) {
+          this.pendingTouches.add(key);
+        }
+        this.schedulePersist();
+        return;
+      }
+      try {
+        for (const [key, value] of sets) {
+          stmts.set.run(
+            key,
+            value.model,
+            embeddingToBuffer(value.vector),
+            new Date(value.createdAt).toISOString(),
+            now
+          );
+        }
+        for (const key of touches) {
+          stmts.touch.run(now, key);
+        }
+        db.exec("COMMIT");
+      } catch {
+        try {
+          db.exec("ROLLBACK");
+        } catch {
+        }
+        this.stmts = null;
+      }
+    } catch {
+      this.stmts = null;
+    }
+  }
+};
+var MemoryEmbeddingCacheStore = class {
+  l1;
+  ttlMs;
+  constructor(options) {
+    this.ttlMs = options?.ttlMs ?? null;
+    this.l1 = new L1Cache(options?.maxEntries ?? L1_DEFAULT_MAX);
+  }
+  async get(cacheKey) {
+    return this.l1.get(cacheKey, this.ttlMs);
+  }
+  async set(cacheKey, model, vector) {
+    this.l1.set(cacheKey, model, vector);
+  }
+  async touch(cacheKey) {
+    this.l1.touch(cacheKey);
+  }
+  async evictIfNeeded(maxEntries) {
+    this.l1.evictIfNeeded(maxEntries);
+  }
+};
+var PostgresEmbeddingCacheStore = class {
+  ttlMs;
+  getClient;
+  l1 = new L1Cache();
+  pendingTouches = /* @__PURE__ */ new Set();
+  persistChain = Promise.resolve();
+  durableEnabled;
+  constructor(getClient, options) {
+    this.getClient = getClient;
+    this.ttlMs = options?.ttlMs ?? null;
+    this.durableEnabled = options?.durable === true;
+  }
+  async get(cacheKey) {
+    return this.l1.get(cacheKey, this.ttlMs);
+  }
+  async set(cacheKey, model, vector) {
+    this.l1.set(cacheKey, model, vector);
+    if (!this.durableEnabled) {
+      return;
+    }
+    const now = Date.now();
+    this.enqueuePersist(async (client) => {
+      const iso = new Date(now).toISOString();
+      await client.query(
+        `INSERT INTO embedding_cache (cache_key, model, vector, created_at, last_used_at)
+         VALUES ($1, $2, $3, $4::timestamptz, $5::timestamptz)
+         ON CONFLICT (cache_key) DO UPDATE SET
+           model = EXCLUDED.model,
+           vector = EXCLUDED.vector,
+           last_used_at = EXCLUDED.last_used_at`,
+        [cacheKey, model, embeddingToBuffer(vector), iso, iso]
+      );
+    });
+  }
+  async touch(cacheKey) {
+    this.l1.touch(cacheKey);
+    if (!this.durableEnabled) {
+      return;
+    }
+    this.pendingTouches.add(cacheKey);
+    if (this.pendingTouches.size >= TOUCH_FLUSH_THRESHOLD) {
+      void this.flushTouches();
+    }
+  }
+  async flushTouches() {
+    if (!this.durableEnabled || this.pendingTouches.size === 0) {
+      this.pendingTouches.clear();
+      return;
+    }
+    const keys = [...this.pendingTouches];
+    this.pendingTouches.clear();
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    this.enqueuePersist(async (client) => {
+      await client.query(
+        `UPDATE embedding_cache
+         SET last_used_at = $1::timestamptz
+         WHERE cache_key = ANY($2::text[])`,
+        [now, keys]
+      );
+    });
+  }
+  async evictIfNeeded(maxEntries) {
+    this.l1.evictIfNeeded(maxEntries);
+  }
+  enqueuePersist(work) {
+    this.persistChain = this.persistChain.then(async () => {
+      const client = this.getClient();
+      if (!client) {
+        return;
+      }
+      await work(client);
+    }).catch(() => void 0);
+  }
+};
 
 // src/llm/index.ts
 var OpenAICompatibleLlmProvider = class {
@@ -929,8 +1335,104 @@ function matchesMetadata(metadata, filter) {
   return compare(getField(metadata, filter.field), filter.op);
 }
 
+// src/filters/sql-compile.ts
+var FIELD_RE = /^[a-zA-Z_][a-zA-Z0-9_]*(\.[a-zA-Z_][a-zA-Z0-9_]*)*$/;
+function jsonPath(field) {
+  if (!FIELD_RE.test(field)) {
+    return null;
+  }
+  return `$.${field}`;
+}
+function compileComparison(field, op) {
+  const path7 = jsonPath(field);
+  if (!path7) {
+    return null;
+  }
+  const extract = `json_extract(metadata_json, '${path7}')`;
+  if ("eq" in op) {
+    const value = op.eq;
+    if (value !== null && typeof value !== "string" && typeof value !== "number" && typeof value !== "boolean") {
+      return null;
+    }
+    return { expression: `${extract} = ?`, params: [value] };
+  }
+  if ("contains" in op) {
+    return {
+      expression: `CAST(${extract} AS TEXT) LIKE '%' || ? || '%'`,
+      params: [op.contains]
+    };
+  }
+  if ("gt" in op) {
+    return { expression: `${extract} > ?`, params: [op.gt] };
+  }
+  if ("gte" in op) {
+    return { expression: `${extract} >= ?`, params: [op.gte] };
+  }
+  if ("lt" in op) {
+    return { expression: `${extract} < ?`, params: [op.lt] };
+  }
+  if ("lte" in op) {
+    return { expression: `${extract} <= ?`, params: [op.lte] };
+  }
+  if ("between" in op) {
+    const [lo, hi] = op.between;
+    return {
+      expression: `${extract} >= ? AND ${extract} <= ?`,
+      params: [lo, hi]
+    };
+  }
+  return null;
+}
+function compileMetadataFilterToSql(filter) {
+  if ("and" in filter) {
+    if (filter.and.length === 0) {
+      return { expression: "1", params: [] };
+    }
+    const parts = [];
+    for (const child of filter.and) {
+      const compiled = compileMetadataFilterToSql(child);
+      if (!compiled) {
+        return null;
+      }
+      parts.push(compiled);
+    }
+    return {
+      expression: parts.map((p) => `(${p.expression})`).join(" AND "),
+      params: parts.flatMap((p) => p.params)
+    };
+  }
+  if ("or" in filter) {
+    if (filter.or.length === 0) {
+      return { expression: "0", params: [] };
+    }
+    const parts = [];
+    for (const child of filter.or) {
+      const compiled = compileMetadataFilterToSql(child);
+      if (!compiled) {
+        return null;
+      }
+      parts.push(compiled);
+    }
+    return {
+      expression: parts.map((p) => `(${p.expression})`).join(" OR "),
+      params: parts.flatMap((p) => p.params)
+    };
+  }
+  if ("not" in filter) {
+    const inner = compileMetadataFilterToSql(filter.not);
+    if (!inner) {
+      return null;
+    }
+    return {
+      expression: `NOT (${inner.expression})`,
+      params: inner.params
+    };
+  }
+  return compileComparison(filter.field, filter.op);
+}
+
 // src/schema/index.ts
-var SCHEMA_VERSION = 2;
+var SCHEMA_VERSION = 4;
 var META_KEYS = {
   schemaVersion: "schema_version",
   embeddingDimensions: "embedding_dimensions",
@@ -951,6 +1453,7 @@ CREATE TABLE IF NOT EXISTS memories (
   metadata_json TEXT NOT NULL DEFAULT '{}',
   archived INTEGER NOT NULL DEFAULT 0 CHECK (archived IN (0, 1)),
   compressed_into TEXT NULL,
+  content_hash TEXT NULL,
   created_at TEXT NOT NULL,
   updated_at TEXT NOT NULL,
   FOREIGN KEY (compressed_into) REFERENCES memories(id) ON DELETE SET NULL
@@ -960,7 +1463,7 @@ var CREATE_HISTORY_TABLE = `
 CREATE TABLE IF NOT EXISTS memory_history (
   id TEXT PRIMARY KEY NOT NULL,
   memory_id TEXT NOT NULL,
-  event_type TEXT NOT NULL CHECK (event_type IN ('created', 'archived', 'compressed')),
+  event_type TEXT NOT NULL CHECK (event_type IN ('created', 'archived', 'compressed', 'updated')),
   related_memory_id TEXT NULL,
   created_at TEXT NOT NULL,
   FOREIGN KEY (memory_id) REFERENCES memories(id) ON DELETE CASCADE
@@ -981,14 +1484,33 @@ CREATE VIRTUAL TABLE IF NOT EXISTS memories_fts USING fts5(
   tokenize = 'porter unicode61'
 );
 `;
+var CREATE_EMBEDDING_CACHE_TABLE = `
+CREATE TABLE IF NOT EXISTS embedding_cache (
+  cache_key TEXT PRIMARY KEY NOT NULL,
+  model TEXT NOT NULL,
+  vector BLOB NOT NULL,
+  created_at TEXT NOT NULL,
+  last_used_at TEXT NOT NULL
+);
+`;
 var CREATE_INDEXES = [
   `CREATE INDEX IF NOT EXISTS idx_memories_org_agent ON memories(organization, agent);`,
   `CREATE INDEX IF NOT EXISTS idx_memories_org_archived ON memories(organization, archived);`,
-  /** Active-set covering path for org-scoped list / stats / compress. */
+  /** Active-set path for org-scoped list / stats / compress. */
   `CREATE INDEX IF NOT EXISTS idx_memories_org_active_created
      ON memories(organization, created_at) WHERE archived = 0;`,
-  `CREATE INDEX IF NOT EXISTS idx_memories_created_at ON memories(created_at);`,
-  `CREATE INDEX IF NOT EXISTS idx_history_memory_id ON memory_history(memory_id);`
+  /** Agent-scoped active list (compress / forget-by-agent). */
+  `CREATE INDEX IF NOT EXISTS idx_memories_org_agent_active_created
+     ON memories(organization, agent, created_at) WHERE archived = 0;`,
+  `CREATE INDEX IF NOT EXISTS idx_history_memory_id ON memory_history(memory_id);`,
+  `CREATE UNIQUE INDEX IF NOT EXISTS idx_memories_org_agent_hash_active
+     ON memories(organization, agent, content_hash)
+     WHERE archived = 0 AND content_hash IS NOT NULL;`,
+  `CREATE INDEX IF NOT EXISTS idx_embedding_cache_last_used
+     ON embedding_cache(last_used_at);`
+];
+var DROP_REDUNDANT_INDEXES_V4 = [
+  `DROP INDEX IF EXISTS idx_memories_created_at;`
 ];
 function buildVectorTableSql(dimensions) {
   if (!Number.isInteger(dimensions) || dimensions <= 0) {
@@ -1012,35 +1534,42 @@ var SQL = {
   insertMemory: `
     INSERT INTO memories (
       id, organization, agent, content_text, metadata_json,
-      archived, compressed_into, created_at, updated_at
-    ) VALUES (?, ?, ?, ?, ?, 0, NULL, ?, ?)
+      archived, compressed_into, content_hash, created_at, updated_at
+    ) VALUES (?, ?, ?, ?, ?, 0, NULL, ?, ?, ?)
     RETURNING rowid, id, organization, agent, content_text, metadata_json,
-              archived, compressed_into, created_at, updated_at
+              archived, compressed_into, content_hash, created_at, updated_at
   `,
   getMemoryById: `
     SELECT rowid, id, organization, agent, content_text, metadata_json,
-           archived, compressed_into, created_at, updated_at
+           archived, compressed_into, content_hash, created_at, updated_at
     FROM memories
     WHERE id = ? AND organization = ?
   `,
   getMemoryByRowid: `
     SELECT rowid, id, organization, agent, content_text, metadata_json,
-           archived, compressed_into, created_at, updated_at
+           archived, compressed_into, content_hash, created_at, updated_at
     FROM memories
     WHERE rowid = ? AND organization = ?
   `,
   getMemoriesByRowidsPrefix: `
     SELECT rowid, id, organization, agent, content_text, metadata_json,
-           archived, compressed_into, created_at, updated_at
+           archived, compressed_into, content_hash, created_at, updated_at
     FROM memories
     WHERE organization = ? AND rowid IN (
   `,
   listMemoriesBase: `
     SELECT rowid, id, organization, agent, content_text, metadata_json,
-           archived, compressed_into, created_at, updated_at
+           archived, compressed_into, content_hash, created_at, updated_at
     FROM memories
     WHERE organization = ?
   `,
+  findActiveByContentHash: `
+    SELECT rowid, id, organization, agent, content_text, metadata_json,
+           archived, compressed_into, content_hash, created_at, updated_at
+    FROM memories
+    WHERE organization = ? AND agent = ? AND content_hash = ? AND archived = 0
+    LIMIT 1
+  `,
   insertEmbedding: `
     INSERT INTO memory_embeddings (memory_rowid, embedding) VALUES (?, ?)
   `,
@@ -1123,6 +1652,7 @@ var SQL = {
     UPDATE memories
     SET content_text = COALESCE(?, content_text),
         metadata_json = COALESCE(?, metadata_json),
+        content_hash = COALESCE(?, content_hash),
         updated_at = ?
     WHERE id = ? AND organization = ?
   `,
@@ -1132,6 +1662,52 @@ var SQL = {
   `,
   deleteFts: `
     DELETE FROM memories_fts WHERE memory_id = ?
+  `,
+  deleteFtsByOrg: `
+    DELETE FROM memories_fts WHERE organization = ?
+  `,
+  deleteFtsByOrgAgent: `
+    DELETE FROM memories_fts WHERE organization = ? AND agent = ?
+  `,
+  deleteEmbeddingsByOrg: `
+    DELETE FROM memory_embeddings WHERE memory_rowid IN (
+      SELECT rowid FROM memories WHERE organization = ?
+    )
+  `,
+  deleteEmbeddingsByOrgAgent: `
+    DELETE FROM memory_embeddings WHERE memory_rowid IN (
+      SELECT rowid FROM memories WHERE organization = ? AND agent = ?
+    )
+  `,
+  deleteEmbeddingsBlobByOrg: `
+    DELETE FROM memory_embeddings_blob WHERE memory_rowid IN (
+      SELECT rowid FROM memories WHERE organization = ?
+    )
+  `,
+  deleteEmbeddingsBlobByOrgAgent: `
+    DELETE FROM memory_embeddings_blob WHERE memory_rowid IN (
+      SELECT rowid FROM memories WHERE organization = ? AND agent = ?
+    )
+  `,
+  deleteArchivedEmbeddings: `
+    DELETE FROM memory_embeddings WHERE memory_rowid IN (
+      SELECT rowid FROM memories WHERE archived = 1
+    )
+  `,
+  deleteArchivedEmbeddingsBlob: `
+    DELETE FROM memory_embeddings_blob WHERE memory_rowid IN (
+      SELECT rowid FROM memories WHERE archived = 1
+    )
+  `,
+  /** Single-pass org stats (avoids 4 separate COUNT queries). */
+  getStats: `
+    SELECT
+      COUNT(*) AS total,
+      COALESCE(SUM(CASE WHEN archived = 0 THEN 1 ELSE 0 END), 0) AS active,
+      COALESCE(SUM(CASE WHEN archived = 1 THEN 1 ELSE 0 END), 0) AS archived,
+      COUNT(DISTINCT CASE WHEN archived = 0 THEN agent END) AS agents
+    FROM memories
+    WHERE organization = ?
   `
 };
 
@@ -1337,10 +1913,140 @@ function siftDown(dist, rows, i, n) {
   }
 }
 
+// src/storage/sqlite/concurrency-config.ts
+var DEFAULT_CONCURRENCY = {
+  maxRetries: 5,
+  baseBackoffMs: 50,
+  maxBackoffMs: 2e3,
+  lockTimeoutMs: 5e3
+};
+function resolveConcurrencyConfig(input) {
+  const resolved = {
+    maxRetries: input?.maxRetries ?? DEFAULT_CONCURRENCY.maxRetries,
+    baseBackoffMs: input?.baseBackoffMs ?? DEFAULT_CONCURRENCY.baseBackoffMs,
+    maxBackoffMs: input?.maxBackoffMs ?? DEFAULT_CONCURRENCY.maxBackoffMs,
+    lockTimeoutMs: input?.lockTimeoutMs ?? DEFAULT_CONCURRENCY.lockTimeoutMs
+  };
+  assertPositiveInt(resolved.maxRetries, "concurrency.maxRetries");
+  assertPositiveNumber(resolved.baseBackoffMs, "concurrency.baseBackoffMs");
+  assertPositiveNumber(resolved.maxBackoffMs, "concurrency.maxBackoffMs");
+  assertPositiveInt(resolved.lockTimeoutMs, "concurrency.lockTimeoutMs");
+  if (resolved.maxBackoffMs < resolved.baseBackoffMs) {
+    throw new ConfigurationError(
+      "concurrency.maxBackoffMs must be >= concurrency.baseBackoffMs"
+    );
+  }
+  return resolved;
+}
+function assertPositiveInt(value, field) {
+  if (!Number.isInteger(value) || value < 0) {
+    throw new ConfigurationError(`${field} must be a non-negative integer`);
+  }
+}
+function assertPositiveNumber(value, field) {
+  if (!Number.isFinite(value) || value < 0) {
+    throw new ConfigurationError(`${field} must be a non-negative number`);
+  }
+}
+
+// src/storage/sqlite/transaction.ts
+function isSqliteBusyError(error) {
+  const raw = error instanceof Error ? error.message : String(error);
+  const lower = raw.toLowerCase();
+  return lower.includes("database is locked") || lower.includes("sqlite_busy") || lower.includes("busy");
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function backoffDelay(attempt, config) {
+  const exp = Math.min(
+    config.maxBackoffMs,
+    config.baseBackoffMs * 2 ** attempt
+  );
+  const jitter = Math.random() * config.baseBackoffMs;
+  return Math.min(config.maxBackoffMs, exp + jitter);
+}
+async function withImmediateTransaction(db, config, fn, onRetry) {
+  let lastError;
+  for (let attempt = 0; attempt <= config.maxRetries; attempt += 1) {
+    try {
+      db.exec("BEGIN IMMEDIATE");
+      try {
+        const result = await fn();
+        db.exec("COMMIT");
+        return result;
+      } catch (error) {
+        try {
+          db.exec("ROLLBACK");
+        } catch {
+        }
+        throw error;
+      }
+    } catch (error) {
+      lastError = error;
+      const isBusy = isSqliteBusyError(error);
+      if (!isBusy) {
+        throw error;
+      }
+      if (attempt >= config.maxRetries) {
+        break;
+      }
+      const delay = backoffDelay(attempt, config);
+      onRetry?.(attempt + 1, delay, error);
+      await sleep(delay);
+    }
+  }
+  throw new StorageLockedError(
+    `SQLite write lock could not be acquired after ${config.maxRetries} retries`,
+    {
+      cause: lastError instanceof Error ? lastError : void 0,
+      reason: "SQLITE_BUSY exhausted retries",
+      suggestion: "Increase concurrency.maxRetries or concurrency.lockTimeoutMs, or consider the Postgres backend for high-concurrency multi-agent workloads."
+    }
+  );
+}
+function normalizeMemoryContent(text) {
+  return text.normalize("NFC").trim().replace(/\s+/g, " ");
+}
+function hashMemoryContent(text) {
+  const normalized = normalizeMemoryContent(text);
+  return crypto$1.createHash("sha256").update(normalized, "utf8").digest("hex");
+}
+var DEFAULT_MEMORY_DEDUPE = {
+  enabled: false,
+  strategy: "exact-or-near",
+  nearThreshold: 0.92,
+  nearCandidateLimit: 8
+};
+function resolveMemoryDedupeConfig(input) {
+  if (input === void 0) {
+    return { ...DEFAULT_MEMORY_DEDUPE };
+  }
+  if (typeof input === "boolean") {
+    return { ...DEFAULT_MEMORY_DEDUPE, enabled: input };
+  }
+  return {
+    enabled: input.enabled ?? true,
+    strategy: input.strategy ?? DEFAULT_MEMORY_DEDUPE.strategy,
+    nearThreshold: input.nearThreshold ?? DEFAULT_MEMORY_DEDUPE.nearThreshold,
+    nearCandidateLimit: input.nearCandidateLimit ?? DEFAULT_MEMORY_DEDUPE.nearCandidateLimit
+  };
+}
+function mergeMemoryMetadata(existing, incoming) {
+  return { ...existing, ...incoming };
+}
+
 // src/storage/providers/sqlite.ts
-var SqliteStorageProvider = class {
+var MAX_METADATA_SCAN = 5e4;
+var METADATA_PAGE_SIZE = 500;
+var BATCH_INSERT_CHUNK = 96;
+var MAX_ANN_OVERFETCH = 8192;
+var INSERT_COALESCE_THRESHOLD = 24;
+var INSERT_COALESCE_MAX = 96;
+var SqliteStorageProvider = class _SqliteStorageProvider {
   name = "sqlite";
   connectionString;
+  concurrency;
   db = null;
   statements = null;
   vectorDimensions = null;
@@ -1351,13 +2057,37 @@ var SqliteStorageProvider = class {
   memoryIndexDirty = false;
   /** Resolved absolute path (or `:memory:`) — avoid re-resolving on size checks. */
   resolvedPath = null;
+  retryLog = null;
+  /** Cached prepared statements for `rowid IN (…)` lookups keyed by list length. */
+  rowidInStatements = /* @__PURE__ */ new Map();
+  /** Cached list SQL statements keyed by clause shape. */
+  listStatements = /* @__PURE__ */ new Map();
+  /** Cached multi-row insert statements keyed by row count. */
+  batchInsertStatements = /* @__PURE__ */ new Map();
+  /** Cached multi-row history inserts keyed by row count. */
+  batchHistoryStatements = /* @__PURE__ */ new Map();
+  /** Cached multi-row FTS inserts keyed by row count. */
+  batchFtsStatements = /* @__PURE__ */ new Map();
+  /** Cached multi-row blob embedding inserts keyed by row count. */
+  batchBlobEmbStatements = /* @__PURE__ */ new Map();
+  /** Coalesce concurrent insertMemory callers into one IMMEDIATE transaction. */
+  insertQueue = [];
+  insertFlushScheduled = false;
   constructor(options) {
     this.connectionString = options.connectionString;
+    this.concurrency = resolveConcurrencyConfig(options.concurrency);
   }
   /** Absolute or relative path / `:memory:` used by this provider. */
   get path() {
     return this.connectionString;
   }
+  /** Expose DB for embedding cache store (same connection). */
+  getDatabase() {
+    return this.db;
+  }
+  setRetryLogger(fn) {
+    this.retryLog = fn;
+  }
   async open() {
     try {
       const dbPath = this.resolvePath(this.connectionString);
@@ -1371,17 +2101,16 @@ var SqliteStorageProvider = class {
       db.exec(`
         PRAGMA synchronous = NORMAL;
         PRAGMA foreign_keys = ON;
-        PRAGMA busy_timeout = 5000;
+        PRAGMA busy_timeout = ${this.concurrency.lockTimeoutMs};
         PRAGMA temp_store = MEMORY;
-        PRAGMA cache_size = -65536;
-        PRAGMA mmap_size = 268435456;
-        PRAGMA wal_autocheckpoint = 1000;
+        PRAGMA cache_size = -32768;
+        PRAGMA mmap_size = 134217728;
+        PRAGMA wal_autocheckpoint = 2000;
         PRAGMA recursive_triggers = OFF;
       `);
       this.sqliteVecLoaded = this.tryLoadSqliteVec(db);
       this.runMigrations(db);
       this.statements = this.prepareStatements(db);
-      this.ensureFtsConsistency(db);
       const backend = this.readMetaString(META_KEYS.vectorBackend);
       const dims = this.readMetaNumber(META_KEYS.embeddingDimensions);
       if (backend) {
@@ -1413,10 +2142,18 @@ var SqliteStorageProvider = class {
     }
   }
   async close() {
+    const deadline = Date.now() + 2e3;
+    while (this.insertQueue.length > 0 && Date.now() < deadline) {
+      await this.flushInsertQueue();
+    }
     if (!this.db) {
       return;
     }
     try {
+      try {
+        this.db.exec("PRAGMA optimize;");
+      } catch {
+      }
       this.db.close();
     } catch (error) {
       throw new DatabaseError(`Failed to close database: ${this.describe(error)}`, {
@@ -1426,6 +2163,12 @@ var SqliteStorageProvider = class {
       this.db = null;
       this.statements = null;
       this.memoryIndex = null;
+      this.rowidInStatements.clear();
+      this.listStatements.clear();
+      this.batchInsertStatements.clear();
+      this.batchHistoryStatements.clear();
+      this.batchFtsStatements.clear();
+      this.batchBlobEmbStatements.clear();
     }
   }
   async ensureVectorSchema(dimensions) {
@@ -1458,16 +2201,64 @@ var SqliteStorageProvider = class {
     this.vectorDimensions = dimensions;
   }
   async insertMemory(input) {
-    const stmts = this.requireStatements();
     this.requireVectorReady();
-    return this.withTransaction(() => {
-      const row = stmts.insertMemory.get(
-        input.id,
-        input.organization,
-        input.agent,
-        input.contentText,
-        serializeMetadata(input.metadata),
-        input.createdAt,
+    return new Promise((resolve, reject) => {
+      this.insertQueue.push({ input, resolve, reject });
+      if (this.insertQueue.length >= INSERT_COALESCE_THRESHOLD) {
+        this.insertFlushScheduled = false;
+        void this.flushInsertQueue();
+        return;
+      }
+      this.scheduleInsertFlush();
+    });
+  }
+  scheduleInsertFlush() {
+    if (this.insertFlushScheduled) {
+      return;
+    }
+    this.insertFlushScheduled = true;
+    setImmediate(() => {
+      this.insertFlushScheduled = false;
+      void this.flushInsertQueue();
+    });
+  }
+  async flushInsertQueue() {
+    if (this.insertQueue.length === 0) {
+      return;
+    }
+    const batch = this.insertQueue.splice(0, INSERT_COALESCE_MAX);
+    try {
+      if (batch.length === 1) {
+        const row = await this.insertMemoryImmediate(batch[0].input);
+        batch[0].resolve(row);
+      } else {
+        const rows = await this.insertMemoriesBatch(batch.map((b) => b.input));
+        for (let i = 0; i < batch.length; i += 1) {
+          batch[i].resolve(rows[i]);
+        }
+      }
+    } catch (error) {
+      for (const item of batch) {
+        item.reject(error);
+      }
+    }
+    if (this.insertQueue.length > 0) {
+      void this.flushInsertQueue();
+    }
+  }
+  /** Single-row insert without coalescing (used by flush of size 1). */
+  async insertMemoryImmediate(input) {
+    const stmts = this.requireStatements();
+    const contentHash = input.contentHash !== void 0 ? input.contentHash : hashMemoryContent(input.contentText);
+    return this.withTransaction(() => {
+      const row = stmts.insertMemory.get(
+        input.id,
+        input.organization,
+        input.agent,
+        input.contentText,
+        serializeMetadata(input.metadata),
+        contentHash,
+        input.createdAt,
         input.updatedAt
       );
       if (!row || row.rowid === void 0) {
@@ -1494,38 +2285,13 @@ var SqliteStorageProvider = class {
     if (inputs.length === 0) {
       return [];
     }
-    const stmts = this.requireStatements();
     this.requireVectorReady();
     return this.withTransaction(() => {
       const rows = [];
-      for (const input of inputs) {
-        const row = stmts.insertMemory.get(
-          input.id,
-          input.organization,
-          input.agent,
-          input.contentText,
-          serializeMetadata(input.metadata),
-          input.createdAt,
-          input.updatedAt
-        );
-        if (!row || row.rowid === void 0) {
-          throw new DatabaseError("Failed to read memory after batch insert");
-        }
-        this.insertEmbedding(row.rowid, input.embedding);
-        this.insertFtsRow(
-          input.id,
-          input.organization,
-          input.agent,
-          input.contentText
-        );
-        stmts.insertHistory.run(
-          crypto.randomUUID(),
-          input.id,
-          "created",
-          null,
-          input.createdAt
-        );
-        rows.push(row);
+      for (let offset = 0; offset < inputs.length; offset += BATCH_INSERT_CHUNK) {
+        const chunk = inputs.slice(offset, offset + BATCH_INSERT_CHUNK);
+        const inserted = this.insertMemoryChunk(chunk);
+        rows.push(...inserted);
       }
       return rows;
     });
@@ -1542,9 +2308,11 @@ var SqliteStorageProvider = class {
       }
       const contentText = input.contentText ?? existing.content_text;
       const metadataJson = input.metadata !== void 0 ? serializeMetadata(input.metadata) : existing.metadata_json;
+      const contentHash = input.contentHash !== void 0 ? input.contentHash : input.contentText !== void 0 ? hashMemoryContent(input.contentText) : existing.content_hash ?? null;
       stmts.updateMemoryContent.run(
         input.contentText ?? null,
         input.metadata !== void 0 ? metadataJson : null,
+        contentHash,
         input.updatedAt,
         input.id,
         input.organization
@@ -1561,9 +2329,25 @@ var SqliteStorageProvider = class {
           contentText
         );
       }
+      stmts.insertHistory.run(
+        crypto.randomUUID(),
+        input.id,
+        "updated",
+        null,
+        input.updatedAt
+      );
       return stmts.getMemoryById.get(input.id, input.organization);
     });
   }
+  async findActiveByContentHash(organization, agent, contentHash) {
+    const stmts = this.requireStatements();
+    const row = stmts.findActiveByContentHash.get(
+      organization,
+      agent,
+      contentHash
+    );
+    return row ?? null;
+  }
   async searchByMetadata(filter, limit) {
     const rows = await this.listMemories(filter, limit);
     if (!filter.metadata) {
@@ -1609,13 +2393,11 @@ var SqliteStorageProvider = class {
     if (rowids.length === 0) {
       return out;
     }
-    const db = this.requireDb();
     const chunkSize = 400;
     for (let offset = 0; offset < rowids.length; offset += chunkSize) {
       const chunk = rowids.slice(offset, offset + chunkSize);
-      const placeholders = chunk.map(() => "?").join(",");
-      const sql = `${SQL.getMemoriesByRowidsPrefix}${placeholders})`;
-      const rows = db.prepare(sql).all(organization, ...chunk);
+      const stmt = this.getRowidInStatement(chunk.length);
+      const rows = stmt.all(organization, ...chunk);
       for (const row of rows) {
         if (row.rowid !== void 0) {
           out.set(row.rowid, row);
@@ -1625,41 +2407,11 @@ var SqliteStorageProvider = class {
     return out;
   }
   async listMemories(filter, limit) {
-    const db = this.requireDb();
-    const clauses = [`organization = ?`];
-    const params = [filter.organization];
-    if (filter.agent) {
-      clauses.push(`agent = ?`);
-      params.push(filter.agent);
-    }
-    if (!filter.includeArchived) {
-      clauses.push(`archived = 0`);
-    }
-    let sql = `
-      SELECT rowid, id, organization, agent, content_text, metadata_json,
-             archived, compressed_into, created_at, updated_at
-      FROM memories
-      WHERE ${clauses.join(" AND ")}
-      ORDER BY created_at ASC
-    `;
-    if (limit !== void 0 && !filter.metadata) {
-      sql += ` LIMIT ?`;
-      params.push(limit);
-    }
     try {
-      let rows = db.prepare(sql).all(...params);
       if (filter.metadata) {
-        rows = rows.filter(
-          (row) => matchesMetadata(
-            deserializeMetadata(row.metadata_json),
-            filter.metadata
-          )
-        );
-        if (limit !== void 0) {
-          rows = rows.slice(0, limit);
-        }
+        return this.listMemoriesWithMetadata(filter, limit);
       }
-      return rows;
+      return this.listMemoriesIndexed(filter, limit);
     } catch (error) {
       throw new DatabaseError(`Failed to list memories: ${this.describe(error)}`, {
         cause: error instanceof Error ? error : void 0
@@ -1674,26 +2426,44 @@ var SqliteStorageProvider = class {
     return this.searchWithBlobFallback(embedding, topK);
   }
   /**
-   * Org-scoped KNN + memory rows.
-   * Caller (Wolbarg.recall) already passes an overfetched topK — do not multiply again.
+   * Org-scoped KNN + memory rows with adaptive overfetch.
+   * Global ANN is post-filtered by org/agent/archived; underfill triggers larger k.
    */
   async searchVectorsWithMemories(embedding, topK, organization, options) {
     this.requireVectorReady();
-    const hits = await this.searchVectors(embedding, topK);
-    if (hits.length === 0) {
+    if (topK <= 0) {
       return [];
     }
-    const map = await this.getMemoriesByRowids(
-      hits.map((h) => h.memoryRowid),
-      organization
-    );
-    const out = [];
-    for (const hit of hits) {
-      const row = map.get(hit.memoryRowid);
-      if (!row) continue;
-      if (options?.agent && row.agent !== options.agent) continue;
-      if (!options?.includeArchived && row.archived === 1) continue;
-      out.push({ row, distance: hit.distance });
+    let fetchK = topK;
+    const maxFetch = Math.min(Math.max(topK * 64, 512), MAX_ANN_OVERFETCH);
+    let out = [];
+    while (true) {
+      const hits = await this.searchVectors(embedding, fetchK);
+      if (hits.length === 0) {
+        return [];
+      }
+      const map = await this.getMemoriesByRowids(
+        hits.map((h) => h.memoryRowid),
+        organization
+      );
+      out = [];
+      for (const hit of hits) {
+        const row = map.get(hit.memoryRowid);
+        if (!row) continue;
+        if (options?.agent && row.agent !== options.agent) continue;
+        if (!options?.includeArchived && row.archived === 1) continue;
+        out.push({ row, distance: hit.distance });
+        if (out.length >= topK) {
+          return out;
+        }
+      }
+      if (hits.length < fetchK) {
+        break;
+      }
+      if (fetchK >= maxFetch) {
+        break;
+      }
+      fetchK = Math.min(fetchK * 4, maxFetch);
     }
     return out;
   }
@@ -1702,6 +2472,7 @@ var SqliteStorageProvider = class {
     const archived = [];
     return this.withTransaction(() => {
       for (const id of ids) {
+        const existing = stmts.getMemoryById.get(id, organization);
         const result = stmts.archiveMemory.run(
           compressedIntoId,
           archivedAt,
@@ -1710,6 +2481,9 @@ var SqliteStorageProvider = class {
         );
         if (Number(result.changes) > 0) {
           archived.push(id);
+          if (existing?.rowid !== void 0) {
+            this.deleteEmbedding(existing.rowid);
+          }
           this.deleteFts(id);
           stmts.insertHistory.run(
             crypto.randomUUID(),
@@ -1750,17 +2524,8 @@ var SqliteStorageProvider = class {
       throw new DatabaseError("deleteMemoriesByFilter requires an agent filter");
     }
     return this.withTransaction(() => {
-      const listed = this.listMemoriesSync({
-        organization: filter.organization,
-        agent,
-        includeArchived: true
-      });
-      for (const memory of listed) {
-        if (memory.rowid !== void 0) {
-          this.deleteEmbedding(memory.rowid);
-        }
-        this.deleteFts(memory.id);
-      }
+      this.deleteEmbeddingsForScope(filter.organization, agent);
+      this.deleteFtsForScope(filter.organization, agent);
       const result = stmts.deleteMemoriesByOrgAgent.run(
         filter.organization,
         agent
@@ -1771,13 +2536,8 @@ var SqliteStorageProvider = class {
   async clearOrganization(organization) {
     const stmts = this.requireStatements();
     return this.withTransaction(() => {
-      const listed = this.listMemoriesSync({ organization, includeArchived: true });
-      for (const memory of listed) {
-        if (memory.rowid !== void 0) {
-          this.deleteEmbedding(memory.rowid);
-        }
-        this.deleteFts(memory.id);
-      }
+      this.deleteEmbeddingsForScope(organization);
+      this.deleteFtsForScope(organization);
       const result = stmts.deleteMemoriesByOrg.run(organization);
       return Number(result.changes);
     });
@@ -1798,15 +2558,12 @@ var SqliteStorageProvider = class {
   }
   async getStats(organization) {
     const stmts = this.requireStatements();
-    const memories = stmts.countMemories.get(organization);
-    const active = stmts.countActiveMemories.get(organization);
-    const archived = stmts.countArchivedMemories.get(organization);
-    const agents = stmts.countAgents.get(organization);
+    const row = stmts.getStats.get(organization);
     return {
-      totalMemories: Number(memories.count),
-      activeMemories: Number(active.count),
-      archivedMemories: Number(archived.count),
-      totalAgents: Number(agents.count)
+      totalMemories: Number(row.total),
+      activeMemories: Number(row.active),
+      archivedMemories: Number(row.archived),
+      totalAgents: Number(row.agents)
     };
   }
   async getDatabaseSizeBytes() {
@@ -1839,59 +2596,159 @@ var SqliteStorageProvider = class {
       );
     }
   }
-  withTransaction(fn) {
+  async withTransaction(fn) {
     const db = this.requireDb();
-    db.exec("BEGIN");
-    try {
-      const result = fn();
-      db.exec("COMMIT");
-      return result;
-    } catch (error) {
-      try {
-        db.exec("ROLLBACK");
-      } catch {
-      }
-      if (error instanceof DatabaseError || error instanceof InitializationError) {
-        throw error;
+    return withImmediateTransaction(
+      db,
+      this.concurrency,
+      fn,
+      (attempt, delayMs) => {
+        this.retryLog?.(
+          `SQLITE_BUSY retry attempt=${attempt} backoffMs=${Math.round(delayMs)}`
+        );
       }
-      throw new DatabaseError(`Transaction failed: ${this.describe(error)}`, {
-        cause: error instanceof Error ? error : void 0
-      });
-    }
+    );
   }
   // ─── internals ───────────────────────────────────────────────────────────
   tryLoadSqliteVec(db) {
+    const plat = `${process.platform}-${process.arch}`;
+    if (_SqliteStorageProvider.sqliteVecUnsupported.has(plat)) {
+      return false;
+    }
     try {
       sqliteVec__namespace.load(db);
       return true;
     } catch {
+      _SqliteStorageProvider.sqliteVecUnsupported.add(plat);
       return false;
     }
   }
+  static sqliteVecUnsupported = /* @__PURE__ */ new Set();
   runMigrations(db) {
     db.exec(CREATE_META_TABLE);
     db.exec(CREATE_MEMORIES_TABLE);
     db.exec(CREATE_HISTORY_TABLE);
     db.exec(CREATE_BLOB_EMBEDDINGS_TABLE);
-    for (const indexSql of CREATE_INDEXES) {
-      db.exec(indexSql);
-    }
+    db.exec(CREATE_EMBEDDING_CACHE_TABLE);
     const current = this.readMetaNumberFromDb(db, META_KEYS.schemaVersion);
     if (current === null) {
       db.exec(CREATE_FTS_TABLE);
       this.backfillFts(db);
+      this.migrateToV3(db);
+      for (const dropSql of DROP_REDUNDANT_INDEXES_V4) {
+        db.exec(dropSql);
+      }
+      for (const indexSql of CREATE_INDEXES) {
+        db.exec(indexSql);
+      }
       db.prepare(SQL.setMeta).run(META_KEYS.schemaVersion, String(SCHEMA_VERSION));
+      this.ensureFtsConsistency(db);
     } else if (current > SCHEMA_VERSION) {
       throw new InitializationError(
         `Database schema version ${current} is newer than this SDK (supports ${SCHEMA_VERSION}).`
       );
     } else if (current < SCHEMA_VERSION) {
-      db.exec(CREATE_FTS_TABLE);
-      this.backfillFts(db);
+      if (current < 3) {
+        db.exec(CREATE_FTS_TABLE);
+        this.backfillFts(db);
+        this.migrateToV3(db);
+      }
+      if (current < 4) {
+        this.migrateToV4(db);
+      }
+      for (const indexSql of CREATE_INDEXES) {
+        db.exec(indexSql);
+      }
       db.prepare(SQL.setMeta).run(META_KEYS.schemaVersion, String(SCHEMA_VERSION));
-    } else {
-      db.exec(CREATE_FTS_TABLE);
+      this.ensureFtsConsistency(db);
+    }
+  }
+  /**
+   * Schema v4: drop unused global created_at index, strip archived vectors
+   * from ANN, add agent-active covering index (via CREATE_INDEXES).
+   */
+  migrateToV4(db) {
+    for (const dropSql of DROP_REDUNDANT_INDEXES_V4) {
+      db.exec(dropSql);
+    }
+    try {
+      db.prepare(SQL.deleteArchivedEmbeddings).run();
+    } catch {
+    }
+    try {
+      db.prepare(SQL.deleteArchivedEmbeddingsBlob).run();
+    } catch {
     }
+    this.memoryIndexDirty = true;
+  }
+  /**
+   * Schema v3: content_hash column, history 'updated' event, embedding_cache.
+   * SQLite cannot ALTER CHECK constraints — rebuild memory_history when needed.
+   */
+  migrateToV3(db) {
+    const cols = db.prepare(`PRAGMA table_info(memories)`).all();
+    const hasHash = cols.some((c) => c.name === "content_hash");
+    if (!hasHash) {
+      db.exec(`ALTER TABLE memories ADD COLUMN content_hash TEXT`);
+    }
+    const active = db.prepare(
+      `SELECT id, content_text, updated_at FROM memories WHERE archived = 0 ORDER BY updated_at DESC`
+    ).all();
+    const seen = /* @__PURE__ */ new Set();
+    const updateHash = db.prepare(
+      `UPDATE memories SET content_hash = ? WHERE id = ?`
+    );
+    for (const row of active) {
+      const hash = hashMemoryContent(row.content_text);
+      updateHash.run(hash, row.id);
+    }
+    const activeFull = db.prepare(
+      `SELECT id, organization, agent, content_text, updated_at
+         FROM memories WHERE archived = 0
+         ORDER BY updated_at DESC`
+    ).all();
+    seen.clear();
+    const clearHash = db.prepare(
+      `UPDATE memories SET content_hash = NULL WHERE id = ?`
+    );
+    const setHash = db.prepare(
+      `UPDATE memories SET content_hash = ? WHERE id = ?`
+    );
+    for (const row of activeFull) {
+      const hash = hashMemoryContent(row.content_text);
+      const key = `${row.organization}\0${row.agent}\0${hash}`;
+      if (seen.has(key)) {
+        clearHash.run(row.id);
+      } else {
+        seen.add(key);
+        setHash.run(hash, row.id);
+      }
+    }
+    this.migrateHistoryAllowUpdated(db);
+    db.exec(CREATE_EMBEDDING_CACHE_TABLE);
+  }
+  migrateHistoryAllowUpdated(db) {
+    const sql = db.prepare(
+      `SELECT sql FROM sqlite_master WHERE type='table' AND name='memory_history'`
+    ).get();
+    if (sql?.sql?.includes("'updated'")) {
+      return;
+    }
+    db.exec(`
+      CREATE TABLE IF NOT EXISTS memory_history_v3 (
+        id TEXT PRIMARY KEY NOT NULL,
+        memory_id TEXT NOT NULL,
+        event_type TEXT NOT NULL CHECK (event_type IN ('created', 'archived', 'compressed', 'updated')),
+        related_memory_id TEXT NULL,
+        created_at TEXT NOT NULL,
+        FOREIGN KEY (memory_id) REFERENCES memories(id) ON DELETE CASCADE
+      );
+      INSERT INTO memory_history_v3 (id, memory_id, event_type, related_memory_id, created_at)
+        SELECT id, memory_id, event_type, related_memory_id, created_at FROM memory_history;
+      DROP TABLE memory_history;
+      ALTER TABLE memory_history_v3 RENAME TO memory_history;
+      CREATE INDEX IF NOT EXISTS idx_history_memory_id ON memory_history(memory_id);
+    `);
   }
   /**
    * Rebuild FTS from active (non-archived) memories when counts diverge.
@@ -1923,13 +2780,33 @@ var SqliteStorageProvider = class {
   prepareStatements(db) {
     let insertFts = null;
     let deleteFts = null;
+    let deleteFtsByOrg = null;
+    let deleteFtsByOrgAgent = null;
     let searchFts = null;
     try {
       insertFts = db.prepare(SQL.insertFts);
       deleteFts = db.prepare(SQL.deleteFts);
+      deleteFtsByOrg = db.prepare(SQL.deleteFtsByOrg);
+      deleteFtsByOrgAgent = db.prepare(SQL.deleteFtsByOrgAgent);
       searchFts = db.prepare(SQL.searchFts);
     } catch {
     }
+    let deleteEmbeddingsByOrg = null;
+    let deleteEmbeddingsByOrgAgent = null;
+    let deleteEmbeddingsBlobByOrg = null;
+    let deleteEmbeddingsBlobByOrgAgent = null;
+    try {
+      deleteEmbeddingsByOrg = db.prepare(SQL.deleteEmbeddingsByOrg);
+      deleteEmbeddingsByOrgAgent = db.prepare(SQL.deleteEmbeddingsByOrgAgent);
+    } catch {
+    }
+    try {
+      deleteEmbeddingsBlobByOrg = db.prepare(SQL.deleteEmbeddingsBlobByOrg);
+      deleteEmbeddingsBlobByOrgAgent = db.prepare(
+        SQL.deleteEmbeddingsBlobByOrgAgent
+      );
+    } catch {
+    }
     return {
       getMeta: db.prepare(SQL.getMeta),
       setMeta: db.prepare(SQL.setMeta),
@@ -1937,6 +2814,7 @@ var SqliteStorageProvider = class {
       updateMemoryContent: db.prepare(SQL.updateMemoryContent),
       getMemoryById: db.prepare(SQL.getMemoryById),
       getMemoryByRowid: db.prepare(SQL.getMemoryByRowid),
+      findActiveByContentHash: db.prepare(SQL.findActiveByContentHash),
       insertEmbedding: null,
       deleteEmbedding: null,
       searchVectors: null,
@@ -1949,10 +2827,7 @@ var SqliteStorageProvider = class {
       deleteMemoriesByOrgAgent: db.prepare(SQL.deleteMemoriesByOrgAgent),
       insertHistory: db.prepare(SQL.insertHistory),
       getHistory: db.prepare(SQL.getHistory),
-      countMemories: db.prepare(SQL.countMemories),
-      countActiveMemories: db.prepare(SQL.countActiveMemories),
-      countArchivedMemories: db.prepare(SQL.countArchivedMemories),
-      countAgents: db.prepare(SQL.countAgents),
+      getStats: db.prepare(SQL.getStats),
       listRowidsForOrg: db.prepare(SQL.listRowidsForOrg),
       listRowidsForOrgAgent: db.prepare(SQL.listRowidsForOrgAgent),
       vectorTableExists: db.prepare(SQL.vectorTableExists),
@@ -1961,11 +2836,16 @@ var SqliteStorageProvider = class {
       ),
       insertFts,
       deleteFts,
-      searchFts
+      deleteFtsByOrg,
+      deleteFtsByOrgAgent,
+      searchFts,
+      deleteEmbeddingsByOrg,
+      deleteEmbeddingsByOrgAgent,
+      deleteEmbeddingsBlobByOrg,
+      deleteEmbeddingsBlobByOrgAgent
     };
   }
-  listMemoriesSync(filter) {
-    const db = this.requireDb();
+  listMemoriesIndexed(filter, limit) {
     const clauses = [`organization = ?`];
     const params = [filter.organization];
     if (filter.agent) {
@@ -1975,13 +2855,316 @@ var SqliteStorageProvider = class {
     if (!filter.includeArchived) {
       clauses.push(`archived = 0`);
     }
-    const sql = `
+    const key = `${filter.agent ? "a" : "_"}:${filter.includeArchived ? "A" : "0"}:${limit !== void 0 ? "L" : "_"}`;
+    let stmt = this.listStatements.get(key);
+    if (!stmt) {
+      let sql = `
+        SELECT rowid, id, organization, agent, content_text, metadata_json,
+               archived, compressed_into, content_hash, created_at, updated_at
+        FROM memories
+        WHERE ${clauses.join(" AND ")}
+        ORDER BY created_at ASC
+      `;
+      if (limit !== void 0) {
+        sql += ` LIMIT ?`;
+      }
+      stmt = this.requireDb().prepare(sql);
+      this.listStatements.set(key, stmt);
+    }
+    if (limit !== void 0) {
+      return stmt.all(...params, limit);
+    }
+    return stmt.all(...params);
+  }
+  /**
+   * Metadata-filtered list: push filters to json_extract when possible;
+   * otherwise page with a hard scan cap (never load unbounded orgs into RAM).
+   */
+  listMemoriesWithMetadata(filter, limit) {
+    const want = limit ?? MAX_METADATA_SCAN;
+    const compiled = filter.metadata ? compileMetadataFilterToSql(filter.metadata) : null;
+    if (compiled) {
+      const clauses2 = [`organization = ?`, `(${compiled.expression})`];
+      const params = [filter.organization, ...compiled.params];
+      if (filter.agent) {
+        clauses2.push(`agent = ?`);
+        params.push(filter.agent);
+      }
+      if (!filter.includeArchived) {
+        clauses2.push(`archived = 0`);
+      }
+      const sql = `
+        SELECT rowid, id, organization, agent, content_text, metadata_json,
+               archived, compressed_into, content_hash, created_at, updated_at
+        FROM memories
+        WHERE ${clauses2.join(" AND ")}
+        ORDER BY created_at ASC
+        LIMIT ?
+      `;
+      params.push(want);
+      return this.requireDb().prepare(sql).all(...params);
+    }
+    const matched = [];
+    let offset = 0;
+    const db = this.requireDb();
+    const clauses = [`organization = ?`];
+    const baseParams = [filter.organization];
+    if (filter.agent) {
+      clauses.push(`agent = ?`);
+      baseParams.push(filter.agent);
+    }
+    if (!filter.includeArchived) {
+      clauses.push(`archived = 0`);
+    }
+    const pageSql = `
       SELECT rowid, id, organization, agent, content_text, metadata_json,
-             archived, compressed_into, created_at, updated_at
+             archived, compressed_into, content_hash, created_at, updated_at
       FROM memories
       WHERE ${clauses.join(" AND ")}
+      ORDER BY created_at ASC
+      LIMIT ? OFFSET ?
     `;
-    return db.prepare(sql).all(...params);
+    const pageStmt = db.prepare(pageSql);
+    while (matched.length < want && offset < MAX_METADATA_SCAN) {
+      const pageLimit = Math.min(METADATA_PAGE_SIZE, MAX_METADATA_SCAN - offset);
+      const page = pageStmt.all(
+        ...baseParams,
+        pageLimit,
+        offset
+      );
+      if (page.length === 0) {
+        break;
+      }
+      for (const row of page) {
+        if (matchesMetadata(
+          deserializeMetadata(row.metadata_json),
+          filter.metadata
+        )) {
+          matched.push(row);
+          if (matched.length >= want) {
+            return matched;
+          }
+        }
+      }
+      offset += page.length;
+      if (page.length < pageLimit) {
+        break;
+      }
+    }
+    return matched;
+  }
+  getRowidInStatement(count) {
+    let stmt = this.rowidInStatements.get(count);
+    if (!stmt) {
+      const placeholders = Array.from({ length: count }, () => "?").join(",");
+      const sql = `${SQL.getMemoriesByRowidsPrefix}${placeholders})`;
+      stmt = this.requireDb().prepare(sql);
+      this.rowidInStatements.set(count, stmt);
+    }
+    return stmt;
+  }
+  insertMemoryChunk(inputs) {
+    const stmts = this.requireStatements();
+    const n = inputs.length;
+    if (n === 1) {
+      const input = inputs[0];
+      const contentHash = input.contentHash !== void 0 ? input.contentHash : hashMemoryContent(input.contentText);
+      const row = stmts.insertMemory.get(
+        input.id,
+        input.organization,
+        input.agent,
+        input.contentText,
+        serializeMetadata(input.metadata),
+        contentHash,
+        input.createdAt,
+        input.updatedAt
+      );
+      if (!row || row.rowid === void 0) {
+        throw new DatabaseError("Failed to read memory after batch insert");
+      }
+      this.insertEmbedding(row.rowid, input.embedding);
+      this.insertFtsRow(
+        input.id,
+        input.organization,
+        input.agent,
+        input.contentText
+      );
+      stmts.insertHistory.run(
+        crypto.randomUUID(),
+        input.id,
+        "created",
+        null,
+        input.createdAt
+      );
+      return [row];
+    }
+    let stmt = this.batchInsertStatements.get(n);
+    if (!stmt) {
+      const valueRow = "(?, ?, ?, ?, ?, 0, NULL, ?, ?, ?)";
+      const values = Array.from({ length: n }, () => valueRow).join(", ");
+      const sql = `
+        INSERT INTO memories (
+          id, organization, agent, content_text, metadata_json,
+          archived, compressed_into, content_hash, created_at, updated_at
+        ) VALUES ${values}
+        RETURNING rowid, id, organization, agent, content_text, metadata_json,
+                  archived, compressed_into, content_hash, created_at, updated_at
+      `;
+      stmt = this.requireDb().prepare(sql);
+      this.batchInsertStatements.set(n, stmt);
+    }
+    const binds = [];
+    for (const input of inputs) {
+      const contentHash = input.contentHash !== void 0 ? input.contentHash : hashMemoryContent(input.contentText);
+      binds.push(
+        input.id,
+        input.organization,
+        input.agent,
+        input.contentText,
+        serializeMetadata(input.metadata),
+        contentHash,
+        input.createdAt,
+        input.updatedAt
+      );
+    }
+    const rows = stmt.all(...binds);
+    if (rows.length !== n) {
+      throw new DatabaseError("Failed to read memories after batch insert");
+    }
+    for (const row of rows) {
+      if (row.rowid === void 0) {
+        throw new DatabaseError("Failed to read memory rowid after batch insert");
+      }
+    }
+    this.insertEmbeddingsBatch(rows, inputs);
+    this.insertFtsBatch(inputs);
+    this.insertHistoryBatch(inputs);
+    return rows;
+  }
+  insertEmbeddingsBatch(rows, inputs) {
+    const n = rows.length;
+    if (this.vectorBackend === "sqlite-vec") {
+      for (let i = 0; i < n; i += 1) {
+        this.insertEmbedding(rows[i].rowid, inputs[i].embedding);
+      }
+      return;
+    }
+    let stmt = this.batchBlobEmbStatements.get(n);
+    if (!stmt) {
+      const values = Array.from({ length: n }, () => "(?, ?)").join(", ");
+      stmt = this.requireDb().prepare(
+        `INSERT INTO memory_embeddings_blob (memory_rowid, embedding) VALUES ${values}`
+      );
+      this.batchBlobEmbStatements.set(n, stmt);
+    }
+    const binds = [];
+    for (let i = 0; i < n; i += 1) {
+      binds.push(rows[i].rowid, embeddingToBuffer(inputs[i].embedding));
+    }
+    stmt.run(...binds);
+    if (this.memoryIndex && this.vectorDimensions !== null) {
+      for (let i = 0; i < n; i += 1) {
+        this.memoryIndex.upsert(rows[i].rowid, inputs[i].embedding);
+      }
+      this.memoryIndexDirty = false;
+    } else {
+      this.memoryIndexDirty = true;
+    }
+  }
+  insertFtsBatch(inputs) {
+    const stmts = this.requireStatements();
+    if (!stmts.insertFts) {
+      return;
+    }
+    const n = inputs.length;
+    let stmt = this.batchFtsStatements.get(n);
+    if (!stmt) {
+      const values = Array.from({ length: n }, () => "(?, ?, ?, ?)").join(", ");
+      stmt = this.requireDb().prepare(
+        `INSERT INTO memories_fts (content_text, memory_id, organization, agent) VALUES ${values}`
+      );
+      this.batchFtsStatements.set(n, stmt);
+    }
+    const binds = [];
+    for (const input of inputs) {
+      binds.push(
+        input.contentText,
+        input.id,
+        input.organization,
+        input.agent
+      );
+    }
+    try {
+      stmt.run(...binds);
+    } catch {
+      for (const input of inputs) {
+        this.insertFtsRow(
+          input.id,
+          input.organization,
+          input.agent,
+          input.contentText
+        );
+      }
+    }
+  }
+  insertHistoryBatch(inputs) {
+    const n = inputs.length;
+    let stmt = this.batchHistoryStatements.get(n);
+    if (!stmt) {
+      const values = Array.from({ length: n }, () => "(?, ?, ?, ?, ?)").join(
+        ", "
+      );
+      stmt = this.requireDb().prepare(
+        `INSERT INTO memory_history (id, memory_id, event_type, related_memory_id, created_at)
+         VALUES ${values}`
+      );
+      this.batchHistoryStatements.set(n, stmt);
+    }
+    const binds = [];
+    for (const input of inputs) {
+      binds.push(
+        crypto.randomUUID(),
+        input.id,
+        "created",
+        null,
+        input.createdAt
+      );
+    }
+    stmt.run(...binds);
+  }
+  deleteEmbeddingsForScope(organization, agent) {
+    const stmts = this.requireStatements();
+    try {
+      if (this.vectorBackend === "sqlite-vec") {
+        if (agent) {
+          stmts.deleteEmbeddingsByOrgAgent?.run(organization, agent);
+        } else {
+          stmts.deleteEmbeddingsByOrg?.run(organization);
+        }
+      } else {
+        if (agent) {
+          stmts.deleteEmbeddingsBlobByOrgAgent?.run(organization, agent);
+        } else {
+          stmts.deleteEmbeddingsBlobByOrg?.run(organization);
+        }
+        this.memoryIndexDirty = true;
+        if (!agent) {
+          this.memoryIndex?.clear();
+        }
+      }
+    } catch {
+    }
+  }
+  deleteFtsForScope(organization, agent) {
+    const stmts = this.requireStatements();
+    try {
+      if (agent) {
+        stmts.deleteFtsByOrgAgent?.run(organization, agent);
+      } else {
+        stmts.deleteFtsByOrg?.run(organization);
+      }
+    } catch {
+    }
   }
   /** Insert-only FTS row (new memory IDs never collide). */
   insertFtsRow(memoryId, organization, agent, contentText) {
@@ -2065,6 +3248,13 @@ var SqliteStorageProvider = class {
       stmts.insertEmbeddingBlob = null;
       stmts.deleteEmbeddingBlob = null;
       stmts.listEmbeddingsBlob = null;
+      try {
+        stmts.deleteEmbeddingsByOrg = db.prepare(SQL.deleteEmbeddingsByOrg);
+        stmts.deleteEmbeddingsByOrgAgent = db.prepare(
+          SQL.deleteEmbeddingsByOrgAgent
+        );
+      } catch {
+      }
       return;
     }
     stmts.insertEmbeddingBlob = db.prepare(SQL.insertEmbeddingBlob);
@@ -2073,6 +3263,13 @@ var SqliteStorageProvider = class {
     stmts.insertEmbedding = null;
     stmts.deleteEmbedding = null;
     stmts.searchVectors = null;
+    try {
+      stmts.deleteEmbeddingsBlobByOrg = db.prepare(SQL.deleteEmbeddingsBlobByOrg);
+      stmts.deleteEmbeddingsBlobByOrgAgent = db.prepare(
+        SQL.deleteEmbeddingsBlobByOrgAgent
+      );
+    } catch {
+    }
   }
   insertEmbedding(rowid, embedding) {
     const stmts = this.requireStatements();
@@ -2081,7 +3278,12 @@ var SqliteStorageProvider = class {
       return;
     }
     stmts.insertEmbeddingBlob.run(rowid, embeddingToBuffer(embedding));
-    this.memoryIndexDirty = true;
+    if (this.memoryIndex) {
+      this.memoryIndex.upsert(rowid, embedding);
+      this.memoryIndexDirty = false;
+    } else {
+      this.memoryIndexDirty = true;
+    }
   }
   deleteEmbedding(rowid) {
     const stmts = this.requireStatements();
@@ -2152,58 +3354,418 @@ var SqliteStorageProvider = class {
     if (!row) {
       return null;
     }
-    const parsed = Number(row.value);
-    return Number.isFinite(parsed) ? parsed : null;
+    const parsed = Number(row.value);
+    return Number.isFinite(parsed) ? parsed : null;
+  }
+  resolvePath(connectionString) {
+    if (connectionString === ":memory:") {
+      return ":memory:";
+    }
+    return path5__default.default.isAbsolute(connectionString) ? connectionString : path5__default.default.resolve(process.cwd(), connectionString);
+  }
+  requireDb() {
+    if (!this.db) {
+      throw new DatabaseError("Database is not open. Call init() first.");
+    }
+    return this.db;
+  }
+  requireStatements() {
+    if (!this.statements) {
+      throw new DatabaseError("Database statements are not prepared. Call init() first.");
+    }
+    return this.statements;
+  }
+  requireVectorReady() {
+    if (!this.vectorBackend || this.vectorDimensions === null) {
+      throw new DatabaseError(
+        "Vector index is not ready. Embedding dimensions have not been initialized."
+      );
+    }
+  }
+  toVectorParam(embedding) {
+    const buffer = embeddingToBuffer(embedding);
+    return new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+  }
+  describe(error) {
+    if (error instanceof Error) {
+      return error.message;
+    }
+    return String(error);
+  }
+};
+var SqliteDatabaseProvider = SqliteStorageProvider;
+function sanitizeFtsQuery(query) {
+  const terms = query.split(/\s+/).map((t) => t.replace(/["']/g, "").replace(/[^\p{L}\p{N}_-]/gu, "")).filter((t) => t.length > 0);
+  if (terms.length === 0) {
+    return "";
+  }
+  return terms.map((t) => `"${t}"`).join(" OR ");
+}
+
+// src/filters/sql-compile-postgres.ts
+var FIELD_RE2 = /^[a-zA-Z_][a-zA-Z0-9_]*(\.[a-zA-Z_][a-zA-Z0-9_]*)*$/;
+function jsonbTextExtract(field) {
+  if (!FIELD_RE2.test(field)) {
+    return null;
+  }
+  const parts = field.split(".");
+  if (parts.length === 1) {
+    return `metadata_json->>'${parts[0]}'`;
+  }
+  const path7 = parts.join(",");
+  return `metadata_json #>> '{${path7}}'`;
+}
+function jsonbContainment(field, value, paramIndex) {
+  if (!FIELD_RE2.test(field)) {
+    return null;
+  }
+  const parts = field.split(".");
+  let obj = value;
+  for (let i = parts.length - 1; i >= 0; i -= 1) {
+    obj = { [parts[i]]: obj };
+  }
+  return {
+    expression: `metadata_json @> $${paramIndex}::jsonb`,
+    params: [JSON.stringify(obj)]
+  };
+}
+function compileComparison2(field, op, startIndex) {
+  if ("eq" in op) {
+    const value = op.eq;
+    if (value !== null && typeof value !== "string" && typeof value !== "number" && typeof value !== "boolean") {
+      return null;
+    }
+    return jsonbContainment(field, value, startIndex);
+  }
+  const extract = jsonbTextExtract(field);
+  if (!extract) {
+    return null;
+  }
+  if ("contains" in op) {
+    return {
+      expression: `${extract} LIKE '%' || $${startIndex} || '%'`,
+      params: [op.contains]
+    };
+  }
+  if ("gt" in op) {
+    return {
+      expression: `(${extract})::numeric > $${startIndex}`,
+      params: [op.gt]
+    };
+  }
+  if ("gte" in op) {
+    return {
+      expression: `(${extract})::numeric >= $${startIndex}`,
+      params: [op.gte]
+    };
+  }
+  if ("lt" in op) {
+    return {
+      expression: `(${extract})::numeric < $${startIndex}`,
+      params: [op.lt]
+    };
+  }
+  if ("lte" in op) {
+    return {
+      expression: `(${extract})::numeric <= $${startIndex}`,
+      params: [op.lte]
+    };
+  }
+  if ("between" in op) {
+    const [lo, hi] = op.between;
+    return {
+      expression: `(${extract})::numeric >= $${startIndex} AND (${extract})::numeric <= $${startIndex + 1}`,
+      params: [lo, hi]
+    };
+  }
+  return null;
+}
+function compileInner(filter, startIndex) {
+  if ("and" in filter) {
+    if (filter.and.length === 0) {
+      return { expression: "TRUE", params: [] };
+    }
+    const parts = [];
+    let idx = startIndex;
+    for (const child of filter.and) {
+      const compiled = compileInner(child, idx);
+      if (!compiled) {
+        return null;
+      }
+      parts.push(compiled);
+      idx += compiled.params.length;
+    }
+    return {
+      expression: parts.map((p) => `(${p.expression})`).join(" AND "),
+      params: parts.flatMap((p) => p.params)
+    };
+  }
+  if ("or" in filter) {
+    if (filter.or.length === 0) {
+      return { expression: "FALSE", params: [] };
+    }
+    const parts = [];
+    let idx = startIndex;
+    for (const child of filter.or) {
+      const compiled = compileInner(child, idx);
+      if (!compiled) {
+        return null;
+      }
+      parts.push(compiled);
+      idx += compiled.params.length;
+    }
+    return {
+      expression: parts.map((p) => `(${p.expression})`).join(" OR "),
+      params: parts.flatMap((p) => p.params)
+    };
+  }
+  if ("not" in filter) {
+    const inner = compileInner(filter.not, startIndex);
+    if (!inner) {
+      return null;
+    }
+    return {
+      expression: `NOT (${inner.expression})`,
+      params: inner.params
+    };
+  }
+  return compileComparison2(filter.field, filter.op, startIndex);
+}
+function compileMetadataFilterToPostgres(filter, startIndex = 1) {
+  return compileInner(filter, startIndex);
+}
+
+// src/subscribe/postgres-listener.ts
+var WOLBARG_NOTIFY_CHANNEL = "wolbarg_events";
+function matchesFilter(filter, event) {
+  if (filter.organization !== event.organization) {
+    return false;
+  }
+  if (filter.agent !== void 0 && filter.agent !== event.agent) {
+    return false;
+  }
+  if (filter.event === void 0) {
+    return true;
+  }
+  const events = Array.isArray(filter.event) ? filter.event : [filter.event];
+  return events.some(
+    (e) => e === "*" || e === event.event
+  );
+}
+function serializeNotifyPayload(event) {
+  const payload = JSON.stringify({
+    event: event.event,
+    organization: event.organization,
+    agent: event.agent,
+    memoryId: event.memoryId,
+    timestamp: event.timestamp,
+    traceId: event.traceId,
+    sessionId: event.sessionId,
+    upsertAction: event.upsertAction
+  });
+  if (payload.length > 7900) {
+    return JSON.stringify({
+      event: event.event,
+      organization: event.organization,
+      agent: event.agent,
+      memoryId: Array.isArray(event.memoryId) ? event.memoryId.slice(0, 20) : event.memoryId,
+      timestamp: event.timestamp
+    });
+  }
+  return payload;
+}
+function parseNotifyPayload(raw) {
+  try {
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed.event !== "string" || typeof parsed.organization !== "string" || typeof parsed.agent !== "string" || typeof parsed.timestamp !== "string") {
+      return null;
+    }
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+var PostgresSubscribeListener = class {
+  subscriptions = /* @__PURE__ */ new Map();
+  nextId = 1;
+  client = null;
+  closed = false;
+  reconnecting = false;
+  listenInFlight = null;
+  reconnectDelayMs;
+  connect;
+  onError;
+  constructor(options) {
+    this.connect = options.connect;
+    this.reconnectDelayMs = options.reconnectDelayMs ?? 1e3;
+    this.onError = options.onError;
+  }
+  async start() {
+    if (this.closed) {
+      return;
+    }
+    await this.ensureListening();
+  }
+  async ensureListening() {
+    if (this.client || this.closed) {
+      return;
+    }
+    if (this.listenInFlight) {
+      await this.listenInFlight;
+      return;
+    }
+    this.listenInFlight = this.openListenConnection();
+    try {
+      await this.listenInFlight;
+    } finally {
+      this.listenInFlight = null;
+    }
+  }
+  async openListenConnection() {
+    if (this.client || this.closed) {
+      return;
+    }
+    const client = await this.connect();
+    if (this.closed) {
+      try {
+        client.release(true);
+      } catch {
+      }
+      return;
+    }
+    this.client = client;
+    client.on("notification", (msg) => {
+      if (msg.channel !== WOLBARG_NOTIFY_CHANNEL || !msg.payload) {
+        return;
+      }
+      const event = parseNotifyPayload(msg.payload);
+      if (!event) {
+        return;
+      }
+      this.dispatch(event);
+    });
+    client.on("error", (error) => {
+      this.onError?.(error);
+      void this.handleDisconnect();
+    });
+    client.on("end", () => {
+      void this.handleDisconnect();
+    });
+    await client.query(`LISTEN ${WOLBARG_NOTIFY_CHANNEL}`);
   }
-  resolvePath(connectionString) {
-    if (connectionString === ":memory:") {
-      return ":memory:";
+  async handleDisconnect() {
+    if (this.closed || this.reconnecting) {
+      return;
     }
-    return path5__default.default.isAbsolute(connectionString) ? connectionString : path5__default.default.resolve(process.cwd(), connectionString);
-  }
-  requireDb() {
-    if (!this.db) {
-      throw new DatabaseError("Database is not open. Call init() first.");
+    this.reconnecting = true;
+    const prev = this.client;
+    this.client = null;
+    if (prev) {
+      try {
+        prev.release(true);
+      } catch {
+      }
     }
-    return this.db;
+    try {
+      await new Promise((r) => setTimeout(r, this.reconnectDelayMs));
+      if (!this.closed) {
+        await this.ensureListening();
+      }
+    } catch (error) {
+      this.onError?.(error);
+      this.reconnecting = false;
+      if (!this.closed) {
+        void this.handleDisconnect();
+      }
+      return;
+    }
+    this.reconnecting = false;
   }
-  requireStatements() {
-    if (!this.statements) {
-      throw new DatabaseError("Database statements are not prepared. Call init() first.");
+  dispatch(event) {
+    for (const sub of this.subscriptions.values()) {
+      if (!matchesFilter(sub.filter, event)) {
+        continue;
+      }
+      try {
+        sub.callback(event);
+      } catch (error) {
+        console.error(
+          "[wolbarg] subscribe callback error:",
+          error instanceof Error ? error.message : error
+        );
+      }
     }
-    return this.statements;
   }
-  requireVectorReady() {
-    if (!this.vectorBackend || this.vectorDimensions === null) {
-      throw new DatabaseError(
-        "Vector index is not ready. Embedding dimensions have not been initialized."
-      );
+  subscribe(filter, callback) {
+    if (this.closed) {
+      throw new Error("Subscribe backend is closed");
     }
+    const id = this.nextId++;
+    this.subscriptions.set(id, { filter, callback });
+    void this.ensureListening();
+    return () => {
+      this.subscriptions.delete(id);
+    };
   }
-  toVectorParam(embedding) {
-    const buffer = embeddingToBuffer(embedding);
-    return new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+  /** True when at least one subscribe() callback is registered. */
+  hasSubscribers() {
+    return this.subscriptions.size > 0;
   }
-  describe(error) {
-    if (error instanceof Error) {
-      return error.message;
+  /**
+   * Local emit is a no-op for Postgres — writers use NOTIFY in-transaction.
+   * Kept so the shared SubscribeBackend interface is uniform.
+   */
+  emit(_event) {
+  }
+  async close() {
+    this.closed = true;
+    this.subscriptions.clear();
+    const pending = this.listenInFlight;
+    if (pending) {
+      await pending.catch(() => void 0);
+    }
+    const client = this.client;
+    this.client = null;
+    if (!client) {
+      return;
+    }
+    try {
+      client.release(true);
+    } catch {
+      try {
+        client.end?.();
+      } catch {
+      }
     }
-    return String(error);
   }
 };
-var SqliteDatabaseProvider = SqliteStorageProvider;
-function sanitizeFtsQuery(query) {
-  const terms = query.split(/\s+/).map((t) => t.replace(/["']/g, "").replace(/[^\p{L}\p{N}_-]/gu, "")).filter((t) => t.length > 0);
-  if (terms.length === 0) {
-    return "";
-  }
-  return terms.map((t) => `"${t}"`).join(" OR ");
+async function notifyMemoryChange(client, event) {
+  const payload = serializeNotifyPayload(event);
+  await client.query(`SELECT pg_notify($1, $2)`, [
+    WOLBARG_NOTIFY_CHANNEL,
+    payload
+  ]);
 }
+function createPostgresListenerFromPool(pool, onError) {
+  return new PostgresSubscribeListener({
+    connect: () => pool.connect(),
+    onError
+  });
+}
+
+// src/storage/providers/postgres.ts
 var txStore = new async_hooks.AsyncLocalStorage();
 var STMT = {
-  insertOne: "Wolbarg_insert_one_v1",
-  insertBatch: "Wolbarg_insert_batch_v1"
+  insertOne: "Wolbarg_insert_one_v5",
+  insertBatch: "Wolbarg_insert_batch_v5"
 };
+function toFloat4Param(embedding) {
+  const out = new Array(embedding.length);
+  for (let i = 0; i < embedding.length; i += 1) {
+    out[i] = embedding[i];
+  }
+  return out;
+}
 function toVectorLiteral(embedding) {
   const n = embedding.length;
   let s = "[";
@@ -2213,17 +3775,45 @@ function toVectorLiteral(embedding) {
   }
   return s + "]";
 }
+function appendConnectionOption(connectionString, key, value) {
+  try {
+    const url = new URL(connectionString);
+    if (key === "options") {
+      const existing = url.searchParams.get("options");
+      url.searchParams.set(
+        "options",
+        existing ? `${existing} ${value}`.trim() : value
+      );
+    }
+    return url.toString();
+  } catch {
+    const sep = connectionString.includes("?") ? "&" : "?";
+    return `${connectionString}${sep}${encodeURIComponent(key)}=${encodeURIComponent(value)}`;
+  }
+}
+function withPoolStartupOptions(connectionString, durableWrites) {
+  const flags = [
+    "-c jit=off",
+    // Bake HNSW search GUCs into the connection — avoids per-recall set_config.
+    "-c hnsw.ef_search=40",
+    "-c hnsw.iterative_scan=relaxed_order"
+  ];
+  if (!durableWrites) {
+    flags.unshift("-c synchronous_commit=off");
+  }
+  return appendConnectionOption(connectionString, "options", flags.join(" "));
+}
 var INSERT_ONE_SQL = `WITH mem AS (
    INSERT INTO memories (
      id, organization, agent, content_text, metadata_json,
-     archived, compressed_into, created_at, updated_at
-   ) VALUES ($1,$2,$3,$4,$5::jsonb,false,NULL,$6,$7)
+     archived, compressed_into, content_hash, created_at, updated_at
+   ) VALUES ($1,$2,$3,$4,$5::jsonb,false,NULL,$9,$6,$7)
    RETURNING id, organization, agent, content_text, metadata_json,
-             archived::int AS archived, compressed_into, created_at, updated_at
+             archived::int AS archived, compressed_into, content_hash, created_at, updated_at
  ),
  hist AS (
    INSERT INTO memory_history (id, memory_id, event_type, related_memory_id, created_at)
-   SELECT $8, id, 'created', NULL, $6 FROM mem
+   SELECT gen_random_uuid()::text, id, 'created', NULL, $6 FROM mem
  ),
  mapped AS (
    INSERT INTO memory_row_map (memory_id)
@@ -2231,9 +3821,8 @@ var INSERT_ONE_SQL = `WITH mem AS (
    ON CONFLICT (memory_id) DO NOTHING
  ),
  emb AS (
-   INSERT INTO memory_embeddings (memory_id, embedding)
-   SELECT id, $9::vector FROM mem
-   ON CONFLICT (memory_id) DO UPDATE SET embedding = EXCLUDED.embedding
+   INSERT INTO memory_embeddings (memory_id, embedding, organization, agent, archived)
+   SELECT id, $8::float4[]::vector, $2, $3, false FROM mem
  )
  SELECT * FROM mem`;
 var INSERT_BATCH_SQL = `WITH mem AS (
@@ -2246,13 +3835,12 @@ var INSERT_BATCH_SQL = `WITH mem AS (
      $1::text[], $2::text[], $3::text[], $4::text[],
      $5::text[], $6::timestamptz[], $7::timestamptz[]
    ) AS t(id, org, agent, txt, meta, c, u)
-   RETURNING id, organization, agent, content_text, metadata_json,
-             archived::int AS archived, compressed_into, created_at, updated_at
+   RETURNING id
  ),
  hist AS (
    INSERT INTO memory_history (id, memory_id, event_type, related_memory_id, created_at)
-   SELECT h, m, 'created', NULL, c
-   FROM unnest($8::text[], $1::text[], $6::timestamptz[]) AS t(h, m, c)
+   SELECT gen_random_uuid()::text, id, 'created', NULL, c
+   FROM unnest($1::text[], $6::timestamptz[]) AS t(id, c)
  ),
  mapped AS (
    INSERT INTO memory_row_map (memory_id)
@@ -2260,31 +3848,42 @@ var INSERT_BATCH_SQL = `WITH mem AS (
    ON CONFLICT (memory_id) DO NOTHING
  ),
  emb AS (
-   INSERT INTO memory_embeddings (memory_id, embedding)
-   SELECT id, emb::vector
-   FROM unnest($1::text[], $9::text[]) AS t(id, emb)
-   ON CONFLICT (memory_id) DO UPDATE SET embedding = EXCLUDED.embedding
+   INSERT INTO memory_embeddings (memory_id, embedding, organization, agent, archived)
+   SELECT id, emb::vector, org, agent, false
+   FROM unnest($1::text[], $8::text[], $2::text[], $3::text[]) AS t(id, emb, org, agent)
  )
- SELECT * FROM mem`;
-var COPY_BATCH_THRESHOLD = 64;
-var PostgresStorageProvider = class {
+ SELECT id FROM mem`;
+var COALESCE_FLUSH_MAX = 128;
+var COALESCE_FLUSH_THRESHOLD = 48;
+var COALESCE_MAX_PARALLEL = 24;
+var BULK_CHUNK_NO_HNSW = 500;
+var BULK_CHUNK_WITH_HNSW = 250;
+var COPY_BATCH_THRESHOLD = 48;
+var PostgresStorageProvider = class _PostgresStorageProvider {
   name = "postgres";
   connectionString;
   maxPoolSize;
+  durableWrites;
   pool = null;
   vectorDimensions = null;
   hasPgvector = false;
   hnswIndexEnsured = false;
   hnswCreateFailures = 0;
+  /** Dedup concurrent CREATE INDEX so mixed read/write storms don't pile up. */
+  hnswBuildInFlight = null;
   hasContentTsv = false;
-  iterativeScanEnabled = false;
   /** Coalesce concurrent insertMemory callers into one unnest batch. */
   insertQueue = [];
   insertFlushScheduled = false;
-  insertFlushInFlight = false;
+  insertFlushTimer = null;
+  insertFlushInFlight = 0;
   constructor(options) {
-    this.connectionString = options.connectionString;
-    this.maxPoolSize = options.maxPoolSize ?? 32;
+    this.maxPoolSize = options.maxPoolSize ?? 64;
+    this.durableWrites = options.durableWrites !== false;
+    this.connectionString = withPoolStartupOptions(
+      options.connectionString,
+      this.durableWrites
+    );
   }
   getPoolStats() {
     const pool = this.pool;
@@ -2295,6 +3894,10 @@ var PostgresStorageProvider = class {
       waiting: pool?.waitingCount ?? 0
     };
   }
+  /** Dedicated pool accessor for LISTEN/NOTIFY subscribe backend. */
+  getPool() {
+    return this.pool;
+  }
   async open() {
     let PoolCtor;
     try {
@@ -2310,6 +3913,7 @@ var PostgresStorageProvider = class {
         connectionString: this.connectionString,
         max: this.maxPoolSize,
         idleTimeoutMillis: 3e4,
+        connectionTimeoutMillis: 1e4,
         allowExitOnIdle: true,
         keepAlive: true
       });
@@ -2318,7 +3922,17 @@ var PostgresStorageProvider = class {
       const dims = await this.getEmbeddingDimensions();
       if (dims !== null) {
         this.vectorDimensions = dims;
-        await this.ensureVectorTables(dims);
+        const schemaKey = `${this.connectionString}::${dims}`;
+        if (!_PostgresStorageProvider.vectorSchemaReady.has(schemaKey)) {
+          await this.ensureVectorTables(dims);
+          _PostgresStorageProvider.vectorSchemaReady.add(schemaKey);
+        } else {
+          this.hasPgvector = true;
+          const idx = await this.query(
+            `SELECT 1 FROM pg_indexes WHERE indexname = 'idx_memory_embeddings_hnsw' LIMIT 1`
+          ).catch(() => ({ rows: [] }));
+          this.hnswIndexEnsured = idx.rows.length > 0;
+        }
       }
     } catch (error) {
       await this.pool?.end().catch(() => void 0);
@@ -2333,12 +3947,45 @@ var PostgresStorageProvider = class {
     }
   }
   async close() {
+    if (this.insertFlushTimer) {
+      clearTimeout(this.insertFlushTimer);
+      this.insertFlushTimer = null;
+    }
+    const deadline = Date.now() + 5e3;
+    while ((this.insertQueue.length > 0 || this.insertFlushInFlight > 0) && Date.now() < deadline) {
+      if (this.insertQueue.length > 0) {
+        await this.flushInsertQueue();
+      } else {
+        await new Promise((r) => setTimeout(r, 5));
+      }
+    }
     if (!this.pool) {
       return;
     }
     await this.pool.end();
     this.pool = null;
   }
+  /**
+   * Run a search query. HNSW GUCs are baked into pool startup options —
+   * no per-recall connect()+set_config round-trip.
+   */
+  async withSearchSession(fn) {
+    return fn(this.requirePool());
+  }
+  /**
+   * Drop HNSW so bulk / concurrent inserts avoid graph maintenance.
+   * Next recall rebuilds the index (lazy).
+   */
+  async dropVectorIndex() {
+    await this.query(`DROP INDEX IF EXISTS idx_memory_embeddings_hnsw`).catch(
+      () => void 0
+    );
+    this.hnswIndexEnsured = false;
+  }
+  /** Force HNSW build now (e.g. before timed recall benches). */
+  async ensureVectorIndex() {
+    await this.ensureHnswIndex();
+  }
   async ensureVectorSchema(dimensions) {
     const existing = await this.getEmbeddingDimensions();
     if (existing !== null && existing !== dimensions) {
@@ -2361,6 +4008,34 @@ var PostgresStorageProvider = class {
           embedding vector(${dimensions})
         )
       `);
+      await this.query(
+        `ALTER TABLE memory_embeddings ADD COLUMN IF NOT EXISTS organization TEXT`
+      ).catch(() => void 0);
+      await this.query(
+        `ALTER TABLE memory_embeddings ADD COLUMN IF NOT EXISTS agent TEXT`
+      ).catch(() => void 0);
+      await this.query(
+        `ALTER TABLE memory_embeddings ADD COLUMN IF NOT EXISTS archived BOOLEAN NOT NULL DEFAULT false`
+      ).catch(() => void 0);
+      const needsBackfill = await this.query(
+        `SELECT 1 FROM memory_embeddings WHERE organization IS NULL LIMIT 1`
+      ).catch(() => ({ rows: [] }));
+      if (needsBackfill.rows.length > 0) {
+        await this.query(`
+          UPDATE memory_embeddings e
+          SET organization = m.organization,
+              agent = m.agent,
+              archived = m.archived
+          FROM memories m
+          WHERE m.id = e.memory_id
+            AND e.organization IS NULL
+        `).catch(() => void 0);
+      }
+      await this.query(
+        `CREATE INDEX IF NOT EXISTS idx_memory_embeddings_org_active
+         ON memory_embeddings (organization)
+         WHERE archived = false`
+      ).catch(() => void 0);
       const idx = await this.query(
         `SELECT 1 FROM pg_indexes WHERE indexname = 'idx_memory_embeddings_hnsw' LIMIT 1`
       );
@@ -2374,6 +4049,10 @@ var PostgresStorageProvider = class {
       `);
     }
   }
+  /** Cross-process subscribe: NOTIFY after a committed write. */
+  async notifyChange(event) {
+    await notifyMemoryChange(this.requirePool(), event);
+  }
   /**
    * Soft reset for a single organization. Drops HNSW only when the embeddings
    * table is empty so other corpora on a shared bench DB stay intact.
@@ -2407,22 +4086,38 @@ var PostgresStorageProvider = class {
     if (!this.hasPgvector || this.hnswIndexEnsured) {
       return;
     }
+    if (this.hnswBuildInFlight) {
+      await this.hnswBuildInFlight;
+      return;
+    }
+    this.hnswBuildInFlight = this.buildHnswIndex();
+    try {
+      await this.hnswBuildInFlight;
+    } finally {
+      this.hnswBuildInFlight = null;
+    }
+  }
+  async buildHnswIndex() {
+    if (this.hnswIndexEnsured) {
+      return;
+    }
     try {
       await this.query(`
-        CREATE INDEX IF NOT EXISTS idx_memory_embeddings_hnsw
+        CREATE INDEX CONCURRENTLY IF NOT EXISTS idx_memory_embeddings_hnsw
         ON memory_embeddings USING hnsw (embedding vector_cosine_ops)
-        WITH (m = 16, ef_construction = 64)
+        WITH (m = 16, ef_construction = 32)
       `);
       this.hnswIndexEnsured = true;
       this.hnswCreateFailures = 0;
-      if (!this.iterativeScanEnabled) {
-        try {
-          await this.query(`SET hnsw.iterative_scan = relaxed_order`);
-          this.iterativeScanEnabled = true;
-        } catch {
-        }
-      }
     } catch (error) {
+      const idx = await this.query(
+        `SELECT 1 FROM pg_indexes WHERE indexname = 'idx_memory_embeddings_hnsw' LIMIT 1`
+      ).catch(() => ({ rows: [] }));
+      if (idx.rows.length > 0) {
+        this.hnswIndexEnsured = true;
+        this.hnswCreateFailures = 0;
+        return;
+      }
       this.hnswCreateFailures += 1;
       if (this.hnswCreateFailures >= 3) {
         throw new DatabaseError(
@@ -2454,48 +4149,50 @@ var PostgresStorageProvider = class {
   }
   async insertMemory(input) {
     this.requireVectorReady();
-    if (!this.insertFlushInFlight && this.insertQueue.length === 0) {
-      this.insertFlushInFlight = true;
-      try {
-        return await this.insertMemoryImmediate(input);
-      } finally {
-        this.insertFlushInFlight = false;
-        if (this.insertQueue.length > 0) {
-          this.insertFlushScheduled = true;
-          queueMicrotask(() => {
-            void this.flushInsertQueue();
-          });
-        }
-      }
-    }
     return new Promise((resolve, reject) => {
       this.insertQueue.push({ input, resolve, reject });
-      if (this.insertQueue.length >= 16) {
-        if (this.insertFlushScheduled) {
-          this.insertFlushScheduled = false;
-        }
+      if (this.insertQueue.length >= COALESCE_FLUSH_THRESHOLD) {
+        this.clearInsertFlushTimer();
         void this.flushInsertQueue();
         return;
       }
-      if (!this.insertFlushScheduled) {
-        this.insertFlushScheduled = true;
-        queueMicrotask(() => {
-          void this.flushInsertQueue();
-        });
-      }
+      this.scheduleInsertFlush();
+    });
+  }
+  clearInsertFlushTimer() {
+    if (this.insertFlushTimer) {
+      clearImmediate(this.insertFlushTimer);
+      clearTimeout(this.insertFlushTimer);
+      this.insertFlushTimer = null;
+    }
+    this.insertFlushScheduled = false;
+  }
+  /** Flush coalesced inserts after a turn so concurrent remember() can join. */
+  scheduleInsertFlush() {
+    if (this.insertFlushScheduled) {
+      return;
+    }
+    this.insertFlushScheduled = true;
+    this.insertFlushTimer = setImmediate(() => {
+      this.insertFlushTimer = null;
+      this.insertFlushScheduled = false;
+      void this.flushInsertQueue();
     });
   }
   async flushInsertQueue() {
-    if (this.insertFlushInFlight) {
+    if (this.insertFlushInFlight >= COALESCE_MAX_PARALLEL) {
+      this.scheduleInsertFlush();
       return;
     }
-    const batch = this.insertQueue;
-    this.insertQueue = [];
-    this.insertFlushScheduled = false;
+    const batch = this.insertQueue.splice(0, COALESCE_FLUSH_MAX);
+    this.clearInsertFlushTimer();
     if (batch.length === 0) {
       return;
     }
-    this.insertFlushInFlight = true;
+    this.insertFlushInFlight += 1;
+    if (this.insertQueue.length > 0 && this.insertFlushInFlight < COALESCE_MAX_PARALLEL) {
+      void this.flushInsertQueue();
+    }
     try {
       if (batch.length === 1) {
         const row = await this.insertMemoryImmediate(batch[0].input);
@@ -2511,20 +4208,16 @@ var PostgresStorageProvider = class {
         item.reject(error);
       }
     } finally {
-      this.insertFlushInFlight = false;
+      this.insertFlushInFlight -= 1;
       if (this.insertQueue.length > 0) {
-        this.insertFlushScheduled = true;
-        queueMicrotask(() => {
-          void this.flushInsertQueue();
-        });
-      } else {
-        this.insertFlushScheduled = false;
+        void this.flushInsertQueue();
       }
     }
   }
   /** Single-row insert without coalescing (used by flush + batch of 1). */
   async insertMemoryImmediate(input) {
     if (this.hasPgvector) {
+      const contentHash = input.contentHash !== void 0 ? input.contentHash : hashMemoryContent(input.contentText);
       const inserted = await this.queryNamed(STMT.insertOne, INSERT_ONE_SQL, [
         input.id,
         input.organization,
@@ -2533,8 +4226,8 @@ var PostgresStorageProvider = class {
         serializeMetadata(input.metadata),
         input.createdAt,
         input.updatedAt,
-        crypto.randomUUID(),
-        toVectorLiteral(input.embedding)
+        toFloat4Param(input.embedding),
+        contentHash
       ]);
       return this.mapRow(inserted.rows[0]);
     }
@@ -2570,7 +4263,6 @@ var PostgresStorageProvider = class {
     const metas = new Array(inputs.length);
     const created = new Array(inputs.length);
     const updated = new Array(inputs.length);
-    const histIds = new Array(inputs.length);
     const vectors = new Array(inputs.length);
     for (let i = 0; i < inputs.length; i += 1) {
       const input = inputs[i];
@@ -2581,10 +4273,9 @@ var PostgresStorageProvider = class {
       metas[i] = serializeMetadata(input.metadata);
       created[i] = input.createdAt;
       updated[i] = input.updatedAt;
-      histIds[i] = crypto.randomUUID();
       vectors[i] = toVectorLiteral(input.embedding);
     }
-    const inserted = await this.queryNamed(STMT.insertBatch, INSERT_BATCH_SQL, [
+    await this.queryNamed(STMT.insertBatch, INSERT_BATCH_SQL, [
       ids,
       orgs,
       agents,
@@ -2592,17 +4283,24 @@ var PostgresStorageProvider = class {
       metas,
       created,
       updated,
-      histIds,
       vectors
     ]);
-    const byId = new Map(
-      inserted.rows.map((r) => [String(r.id), this.mapRow(r)])
-    );
-    return ids.map((id) => byId.get(id));
+    return inputs.map((input, i) => ({
+      id: ids[i],
+      organization: orgs[i],
+      agent: agents[i],
+      content_text: texts[i],
+      metadata_json: metas[i],
+      archived: 0,
+      compressed_into: null,
+      content_hash: input.contentHash !== void 0 ? input.contentHash : null,
+      created_at: created[i],
+      updated_at: updated[i]
+    }));
   }
-  /** Split large ingest batches into parallel unnest chunks (pool pipelining). */
+  /** Parallel unnest when HNSW is absent; sequential when index must stay consistent. */
   async insertBatchChunked(inputs) {
-    const chunkSize = 128;
+    const chunkSize = this.hnswIndexEnsured ? BULK_CHUNK_WITH_HNSW : BULK_CHUNK_NO_HNSW;
     if (inputs.length <= chunkSize) {
       return this.insertBatchPgvector(inputs);
     }
@@ -2610,14 +4308,26 @@ var PostgresStorageProvider = class {
     for (let i = 0; i < inputs.length; i += chunkSize) {
       chunks.push(inputs.slice(i, i + chunkSize));
     }
-    const results = await Promise.all(
-      chunks.map((chunk) => this.insertBatchPgvector(chunk))
-    );
+    if (!this.hnswIndexEnsured) {
+      const parts = await Promise.all(
+        chunks.map((chunk) => this.insertBatchPgvector(chunk))
+      );
+      const out2 = new Array(inputs.length);
+      let offset2 = 0;
+      for (const part of parts) {
+        for (let j = 0; j < part.length; j += 1) {
+          out2[offset2 + j] = part[j];
+        }
+        offset2 += part.length;
+      }
+      return out2;
+    }
     const out = new Array(inputs.length);
     let offset = 0;
-    for (const part of results) {
-      for (let i = 0; i < part.length; i += 1) {
-        out[offset + i] = part[i];
+    for (const chunk of chunks) {
+      const part = await this.insertBatchPgvector(chunk);
+      for (let j = 0; j < part.length; j += 1) {
+        out[offset + j] = part[j];
       }
       offset += part.length;
     }
@@ -2629,13 +4339,14 @@ var PostgresStorageProvider = class {
       input.embedding.byteOffset,
       input.embedding.byteLength
     );
+    const contentHash = input.contentHash !== void 0 ? input.contentHash : hashMemoryContent(input.contentText);
     const inserted = await this.query(
       `INSERT INTO memories (
         id, organization, agent, content_text, metadata_json,
-        archived, compressed_into, created_at, updated_at
-      ) VALUES ($1,$2,$3,$4,$5::jsonb,false,NULL,$6,$7)
+        archived, compressed_into, content_hash, created_at, updated_at
+      ) VALUES ($1,$2,$3,$4,$5::jsonb,false,NULL,$8,$6,$7)
       RETURNING id, organization, agent, content_text, metadata_json,
-                archived::int AS archived, compressed_into, created_at, updated_at`,
+                archived::int AS archived, compressed_into, content_hash, created_at, updated_at`,
       [
         input.id,
         input.organization,
@@ -2643,7 +4354,8 @@ var PostgresStorageProvider = class {
         input.contentText,
         serializeMetadata(input.metadata),
         input.createdAt,
-        input.updatedAt
+        input.updatedAt,
+        contentHash
       ]
     );
     const row = this.mapRow(inserted.rows[0]);
@@ -2669,15 +4381,18 @@ var PostgresStorageProvider = class {
     if (!existing) {
       return null;
     }
+    const contentHash = input.contentHash !== void 0 ? input.contentHash : input.contentText !== void 0 ? hashMemoryContent(input.contentText) : existing.content_hash ?? null;
     await this.query(
       `UPDATE memories SET
         content_text = COALESCE($1, content_text),
         metadata_json = COALESCE($2::jsonb, metadata_json),
-        updated_at = $3
-       WHERE id = $4 AND organization = $5`,
+        content_hash = COALESCE($3, content_hash),
+        updated_at = $4
+       WHERE id = $5 AND organization = $6`,
       [
         input.contentText ?? null,
         input.metadata !== void 0 ? serializeMetadata(input.metadata) : null,
+        contentHash,
         input.updatedAt,
         input.id,
         input.organization
@@ -2687,12 +4402,29 @@ var PostgresStorageProvider = class {
       await this.deleteEmbedding(input.id);
       await this.insertEmbedding(input.id, input.embedding);
     }
+    await this.query(
+      `INSERT INTO memory_history (id, memory_id, event_type, related_memory_id, created_at)
+       VALUES ($1,$2,'updated',NULL,$3)`,
+      [crypto.randomUUID(), input.id, input.updatedAt]
+    );
     return this.getMemoryById(input.id, input.organization);
   }
+  async findActiveByContentHash(organization, agent, contentHash) {
+    const result = await this.query(
+      `SELECT id, organization, agent, content_text, metadata_json,
+              archived::int AS archived, compressed_into, content_hash, created_at, updated_at
+       FROM memories
+       WHERE organization = $1 AND agent = $2 AND content_hash = $3 AND archived = false
+       LIMIT 1`,
+      [organization, agent, contentHash]
+    );
+    const row = result.rows[0];
+    return row ? this.mapRow(row) : null;
+  }
   async getMemoryById(id, organization) {
     const result = await this.query(
       `SELECT id, organization, agent, content_text, metadata_json,
-              archived::int AS archived, compressed_into, created_at, updated_at
+              archived::int AS archived, compressed_into, content_hash, created_at, updated_at
        FROM memories WHERE id = $1 AND organization = $2`,
       [id, organization]
     );
@@ -2735,6 +4467,33 @@ var PostgresStorageProvider = class {
     return out;
   }
   async listMemories(filter, limit) {
+    const want = limit !== void 0 ? limit : filter.metadata ? 1e4 : void 0;
+    const compiled = filter.metadata ? compileMetadataFilterToPostgres(filter.metadata, 2) : null;
+    if (compiled) {
+      const clauses2 = [`organization = $1`, `(${compiled.expression})`];
+      const params2 = [filter.organization, ...compiled.params];
+      let idx2 = params2.length + 1;
+      if (filter.agent) {
+        clauses2.push(`agent = $${idx2++}`);
+        params2.push(filter.agent);
+      }
+      if (!filter.includeArchived) {
+        clauses2.push(`archived = false`);
+      }
+      let sql2 = `
+        SELECT id, organization, agent, content_text, metadata_json,
+               archived::int AS archived, compressed_into, created_at, updated_at
+        FROM memories
+        WHERE ${clauses2.join(" AND ")}
+        ORDER BY created_at ASC
+      `;
+      if (want !== void 0) {
+        sql2 += ` LIMIT $${idx2}`;
+        params2.push(want);
+      }
+      const result2 = await this.query(sql2, params2);
+      return result2.rows.map((r) => this.mapRow(r));
+    }
     const clauses = [`organization = $1`];
     const params = [filter.organization];
     let idx = 2;
@@ -2805,27 +4564,30 @@ var PostgresStorageProvider = class {
     this.requireVectorReady();
     if (this.hasPgvector) {
       await this.ensureHnswIndex();
-      const result2 = await this.query(
-        `SELECT r.row_num AS memory_rowid, ann.distance
-         FROM (
-           SELECT e.memory_id, (e.embedding <=> $1::vector) AS distance
-           FROM memory_embeddings e
-           ORDER BY e.embedding <=> $1::vector
-           LIMIT $2
-         ) ann
-         JOIN memory_row_map r ON r.memory_id = ann.memory_id
-         ORDER BY ann.distance`,
-        [toVectorLiteral(embedding), topK]
-      );
-      const hits = new Array(result2.rows.length);
-      for (let i = 0; i < result2.rows.length; i += 1) {
-        const row = result2.rows[i];
-        hits[i] = {
-          memoryRowid: Number(row.memory_rowid),
-          distance: Number(row.distance)
-        };
-      }
-      return hits;
+      return this.withSearchSession(async (client) => {
+        const result2 = await client.query(
+          `SELECT r.row_num AS memory_rowid, ann.distance
+           FROM (
+             SELECT e.memory_id, (e.embedding <=> $1::float4[]::vector) AS distance
+             FROM memory_embeddings e
+             WHERE e.archived = false
+             ORDER BY e.embedding <=> $1::float4[]::vector
+             LIMIT $2
+           ) ann
+           JOIN memory_row_map r ON r.memory_id = ann.memory_id
+           ORDER BY ann.distance`,
+          [toFloat4Param(embedding), topK]
+        );
+        const hits = new Array(result2.rows.length);
+        for (let i = 0; i < result2.rows.length; i += 1) {
+          const row = result2.rows[i];
+          hits[i] = {
+            memoryRowid: Number(row.memory_rowid),
+            distance: Number(row.distance)
+          };
+        }
+        return hits;
+      });
     }
     const result = await this.query(
       `SELECT r.row_num AS memory_rowid, e.embedding
@@ -2850,65 +4612,66 @@ var PostgresStorageProvider = class {
   async searchVectorsWithMemories(embedding, topK, organization, options) {
     this.requireVectorReady();
     if (!this.hasPgvector) {
-      const hits = await this.searchVectors(embedding, topK);
-      const map = await this.getMemoriesByRowids(
-        hits.map((h) => h.memoryRowid),
-        organization
-      );
-      const out = [];
-      for (const hit of hits) {
-        const row = map.get(hit.memoryRowid);
-        if (!row) continue;
-        if (options?.agent && row.agent !== options.agent) continue;
-        if (!options?.includeArchived && row.archived === 1) continue;
-        out.push({ row, distance: hit.distance });
+      const clauses = [`m.organization = $1`];
+      const params2 = [organization];
+      if (options?.agent) {
+        clauses.push(`m.agent = $2`);
+        params2.push(options.agent);
       }
-      return out;
+      if (!options?.includeArchived) {
+        clauses.push(`m.archived = false`);
+      }
+      const result2 = await this.query(
+        `SELECT m.id, m.organization, m.agent, m.content_text, m.metadata_json,
+                m.archived::int AS archived, m.compressed_into, m.created_at, m.updated_at,
+                r.row_num AS rowid, e.embedding
+         FROM memory_embeddings_blob e
+         JOIN memory_row_map r ON r.memory_id = e.memory_id
+         JOIN memories m ON m.id = e.memory_id
+         WHERE ${clauses.join(" AND ")}`,
+        params2
+      );
+      const scored = result2.rows.map((row) => {
+        const buf = row.embedding;
+        const vec2 = new Float32Array(
+          buf.buffer,
+          buf.byteOffset,
+          buf.byteLength / Float32Array.BYTES_PER_ELEMENT
+        );
+        return {
+          row: this.mapRow(row),
+          distance: cosineDistance(embedding, vec2)
+        };
+      });
+      scored.sort((a, b) => a.distance - b.distance);
+      return scored.slice(0, topK);
     }
     await this.ensureHnswIndex();
-    const vec = toVectorLiteral(embedding);
+    const vec = toFloat4Param(embedding);
     const mapHits = (rows) => rows.map((row) => ({
       row: this.mapRow(row),
       distance: Number(row.distance)
     }));
-    let overfetch = Math.min(Math.max(topK * 8, topK), 512);
-    const maxFetch = Math.min(Math.max(topK * 64, 512), 8192);
-    for (; ; ) {
-      const agentClause = options?.agent ? "AND m.agent = $5" : "";
-      const archivedClause = options?.includeArchived ? "" : "AND m.archived = false";
-      const params = options?.agent ? [vec, overfetch, organization, topK, options.agent] : [vec, overfetch, organization, topK];
-      const ann = await this.query(
-        `WITH ann AS (
-           SELECT e.memory_id, (e.embedding <=> $1::vector) AS distance
-           FROM memory_embeddings e
-           ORDER BY e.embedding <=> $1::vector
-           LIMIT $2
-         )
-         SELECT m.id, m.organization, m.agent, m.content_text, m.metadata_json,
-                m.archived::int AS archived, m.compressed_into, m.created_at, m.updated_at,
-                r.row_num AS rowid,
-                ann.distance,
-                (SELECT COUNT(*)::int FROM ann) AS ann_fetched
-         FROM ann
-         JOIN memory_row_map r ON r.memory_id = ann.memory_id
-         JOIN memories m ON m.id = ann.memory_id
-         WHERE m.organization = $3
-           ${agentClause}
-           ${archivedClause}
-         ORDER BY ann.distance
-         LIMIT $4`,
-        params
-      );
-      const annFetched = Number(ann.rows[0]?.ann_fetched ?? ann.rows.length);
-      if (ann.rows.length >= topK || annFetched < overfetch || overfetch >= maxFetch) {
-        return mapHits(ann.rows.slice(0, topK));
-      }
-      const next = Math.min(overfetch * 4, maxFetch);
-      if (next === overfetch) {
-        return mapHits(ann.rows.slice(0, topK));
-      }
-      overfetch = next;
-    }
+    const agentClause = options?.agent ? "AND e.agent = $4" : "";
+    const archivedClause = options?.includeArchived ? "" : "AND e.archived = false";
+    const params = options?.agent ? [vec, topK, organization, options.agent] : [vec, topK, organization];
+    const result = await this.query(
+      `SELECT m.id, m.organization, m.agent, m.content_text, m.metadata_json,
+              m.archived::int AS archived, m.compressed_into, m.created_at, m.updated_at,
+              r.row_num AS rowid,
+              (e.embedding <=> $1::float4[]::vector) AS distance
+       FROM memory_embeddings e
+       JOIN memory_row_map r ON r.memory_id = e.memory_id
+       JOIN memories m ON m.id = e.memory_id
+       WHERE e.organization = $3
+         ${agentClause}
+         ${archivedClause}
+         AND m.organization = $3
+       ORDER BY e.embedding <=> $1::float4[]::vector
+       LIMIT $2`,
+      params
+    );
+    return mapHits(result.rows);
   }
   async archiveMemories(ids, organization, compressedIntoId, archivedAt) {
     if (ids.length === 0) {
@@ -2925,6 +4688,12 @@ var PostgresStorageProvider = class {
     if (archived.length === 0) {
       return [];
     }
+    await this.query(
+      `UPDATE memory_embeddings
+       SET archived = true
+       WHERE memory_id = ANY($1::text[])`,
+      [archived]
+    ).catch(() => void 0);
     const histIds = [];
     const memIds = [];
     const types = [];
@@ -3048,6 +4817,20 @@ var PostgresStorageProvider = class {
         value TEXT NOT NULL
       )
     `);
+    const versionRow = await this.query(
+      `SELECT value FROM Wolbarg_meta WHERE key = $1`,
+      [META_KEYS.schemaVersion]
+    ).catch(() => ({ rows: [] }));
+    const current = versionRow.rows[0]?.value !== void 0 ? Number(versionRow.rows[0].value) : null;
+    if (current === SCHEMA_VERSION) {
+      const tsvProbe2 = await this.query(
+        `SELECT 1 FROM information_schema.columns
+         WHERE table_name = 'memories' AND column_name = 'content_tsv'
+         LIMIT 1`
+      ).catch(() => ({ rows: [] }));
+      this.hasContentTsv = tsvProbe2.rows.length > 0;
+      return;
+    }
     await this.query(`
       CREATE TABLE IF NOT EXISTS memories (
         id TEXT PRIMARY KEY NOT NULL,
@@ -3065,7 +4848,7 @@ var PostgresStorageProvider = class {
       CREATE TABLE IF NOT EXISTS memory_history (
         id TEXT PRIMARY KEY NOT NULL,
         memory_id TEXT NOT NULL REFERENCES memories(id) ON DELETE CASCADE,
-        event_type TEXT NOT NULL CHECK (event_type IN ('created', 'archived', 'compressed')),
+        event_type TEXT NOT NULL CHECK (event_type IN ('created', 'archived', 'compressed', 'updated')),
         related_memory_id TEXT NULL,
         created_at TIMESTAMPTZ NOT NULL
       )
@@ -3080,8 +4863,8 @@ var PostgresStorageProvider = class {
       `CREATE INDEX IF NOT EXISTS idx_memories_org_agent ON memories(organization, agent)`
     );
     await this.query(
-      `CREATE INDEX IF NOT EXISTS idx_memories_org_archived ON memories(organization, archived)`
-    );
+      `DROP INDEX IF EXISTS idx_memories_org_archived`
+    ).catch(() => void 0);
     await this.query(
       `CREATE INDEX IF NOT EXISTS idx_memories_org_active_created
        ON memories(organization, created_at) WHERE archived = false`
@@ -3089,53 +4872,132 @@ var PostgresStorageProvider = class {
     await this.query(
       `CREATE INDEX IF NOT EXISTS idx_memories_metadata ON memories USING GIN (metadata_json)`
     );
-    try {
-      await this.query(`
-        ALTER TABLE memories
-        ADD COLUMN IF NOT EXISTS content_tsv tsvector
-        GENERATED ALWAYS AS (to_tsvector('english', content_text)) STORED
-      `);
-      await this.query(
-        `CREATE INDEX IF NOT EXISTS idx_memories_content_tsv ON memories USING GIN (content_tsv)`
-      );
-      this.hasContentTsv = true;
-    } catch {
-      await this.query(
-        `CREATE INDEX IF NOT EXISTS idx_memories_fts
-         ON memories USING GIN (to_tsvector('english', content_text))`
-      ).catch(() => void 0);
-      this.hasContentTsv = false;
-    }
-    const versionRow = await this.query(
+    await this.query(
+      `ALTER TABLE memories ADD COLUMN IF NOT EXISTS content_hash TEXT`
+    ).catch(() => void 0);
+    await this.query(
+      `CREATE UNIQUE INDEX IF NOT EXISTS idx_memories_org_agent_hash_active
+       ON memories(organization, agent, content_hash)
+       WHERE archived = false AND content_hash IS NOT NULL`
+    ).catch(() => void 0);
+    await this.query(`
+      CREATE TABLE IF NOT EXISTS embedding_cache (
+        cache_key TEXT PRIMARY KEY NOT NULL,
+        model TEXT NOT NULL,
+        vector BYTEA NOT NULL,
+        created_at TIMESTAMPTZ NOT NULL,
+        last_used_at TIMESTAMPTZ NOT NULL
+      )
+    `).catch(() => void 0);
+    await this.query(`
+      DO $$
+      BEGIN
+        ALTER TABLE memory_history DROP CONSTRAINT IF EXISTS memory_history_event_type_check;
+        ALTER TABLE memory_history ADD CONSTRAINT memory_history_event_type_check
+          CHECK (event_type IN ('created', 'archived', 'compressed', 'updated'));
+      EXCEPTION WHEN others THEN
+        NULL;
+      END $$;
+    `).catch(() => void 0);
+    const priorVersion = await this.query(
       `SELECT value FROM Wolbarg_meta WHERE key = $1`,
       [META_KEYS.schemaVersion]
-    );
-    if (!versionRow.rows[0]) {
-      await this.query(
-        `INSERT INTO Wolbarg_meta (key, value) VALUES ($1, $2)`,
-        [META_KEYS.schemaVersion, String(SCHEMA_VERSION)]
-      );
+    ).catch(() => ({ rows: [] }));
+    const prior = priorVersion.rows[0]?.value !== void 0 ? Number(priorVersion.rows[0].value) : null;
+    const needsHashBackfill = prior === null || !Number.isFinite(prior) || prior < 3;
+    if (needsHashBackfill) {
+      const active = await this.query(
+        `SELECT id, organization, agent, content_text, updated_at
+         FROM memories WHERE archived = false AND content_hash IS NULL
+         ORDER BY updated_at DESC`
+      ).catch(() => ({ rows: [] }));
+      const seen = /* @__PURE__ */ new Set();
+      for (const row of active.rows) {
+        const hash = hashMemoryContent(String(row.content_text));
+        const key = `${row.organization}\0${row.agent}\0${hash}`;
+        if (seen.has(key)) {
+          await this.query(
+            `UPDATE memories SET content_hash = NULL WHERE id = $1`,
+            [row.id]
+          ).catch(() => void 0);
+        } else {
+          seen.add(key);
+          await this.query(
+            `UPDATE memories SET content_hash = $1 WHERE id = $2`,
+            [hash, row.id]
+          ).catch(() => void 0);
+        }
+      }
+    }
+    await this.query(
+      `INSERT INTO Wolbarg_meta (key, value) VALUES ($1, $2)
+       ON CONFLICT (key) DO UPDATE SET value = EXCLUDED.value`,
+      [META_KEYS.schemaVersion, String(SCHEMA_VERSION)]
+    ).catch(() => void 0);
+    const tsvProbe = await this.query(
+      `SELECT 1 FROM information_schema.columns
+       WHERE table_name = 'memories' AND column_name = 'content_tsv'
+       LIMIT 1`
+    ).catch(() => ({ rows: [] }));
+    if (tsvProbe.rows.length > 0) {
+      this.hasContentTsv = true;
+    } else {
+      try {
+        await this.query(`
+          ALTER TABLE memories
+          ADD COLUMN IF NOT EXISTS content_tsv tsvector
+          GENERATED ALWAYS AS (to_tsvector('english', content_text)) STORED
+        `);
+        await this.query(
+          `CREATE INDEX IF NOT EXISTS idx_memories_content_tsv ON memories USING GIN (content_tsv)`
+        );
+        this.hasContentTsv = true;
+      } catch {
+        await this.query(
+          `CREATE INDEX IF NOT EXISTS idx_memories_fts
+           ON memories USING GIN (to_tsvector('english', content_text))`
+        ).catch(() => void 0);
+        this.hasContentTsv = false;
+      }
     }
   }
   async tryEnablePgvector() {
+    const cached = _PostgresStorageProvider.pgvectorByConn.get(
+      this.connectionString
+    );
+    if (cached !== void 0) {
+      return cached;
+    }
     try {
       await this.query(`CREATE EXTENSION IF NOT EXISTS vector`);
+      _PostgresStorageProvider.pgvectorByConn.set(this.connectionString, true);
       return true;
     } catch {
+      _PostgresStorageProvider.pgvectorByConn.set(this.connectionString, false);
       return false;
     }
   }
+  static pgvectorByConn = /* @__PURE__ */ new Map();
+  static vectorSchemaReady = /* @__PURE__ */ new Set();
   async insertEmbedding(memoryId, embedding) {
     if (this.hasPgvector) {
       await this.query(
         `WITH mapped AS (
            INSERT INTO memory_row_map (memory_id) VALUES ($1)
            ON CONFLICT (memory_id) DO NOTHING
+         ),
+         meta AS (
+           SELECT organization, agent, archived FROM memories WHERE id = $1
          )
-         INSERT INTO memory_embeddings (memory_id, embedding)
-         VALUES ($1, $2::vector)
-         ON CONFLICT (memory_id) DO UPDATE SET embedding = EXCLUDED.embedding`,
-        [memoryId, toVectorLiteral(embedding)]
+         INSERT INTO memory_embeddings (memory_id, embedding, organization, agent, archived)
+         SELECT $1, $2::float4[]::vector, meta.organization, meta.agent, meta.archived
+         FROM meta
+         ON CONFLICT (memory_id) DO UPDATE SET
+           embedding = EXCLUDED.embedding,
+           organization = EXCLUDED.organization,
+           agent = EXCLUDED.agent,
+           archived = EXCLUDED.archived`,
+        [memoryId, toFloat4Param(embedding)]
       );
       return;
     }
@@ -3190,6 +5052,7 @@ var PostgresStorageProvider = class {
       metadata_json,
       archived: Number(row.archived ?? 0),
       compressed_into: row.compressed_into === null || row.compressed_into === void 0 ? null : String(row.compressed_into),
+      content_hash: row.content_hash === null || row.content_hash === void 0 ? null : String(row.content_hash),
       created_at: created,
       updated_at: updated,
       rowid: row.rowid !== void 0 ? Number(row.rowid) : void 0
@@ -3222,7 +5085,7 @@ var PostgresStorageProvider = class {
 };
 
 // src/storage/index.ts
-function createStorageProvider(config) {
+function createStorageProvider(config, options) {
   const connectionString = resolveDatabaseUrl(config);
   if (!connectionString) {
     throw new ConfigurationError(
@@ -3231,13 +5094,15 @@ function createStorageProvider(config) {
   }
   if (config.provider === "sqlite") {
     return new SqliteStorageProvider({
-      connectionString
+      connectionString,
+      concurrency: options?.concurrency
     });
   }
   if (config.provider === "postgres") {
     return new PostgresStorageProvider({
       connectionString,
-      maxPoolSize: config.maxPoolSize
+      maxPoolSize: config.maxPoolSize,
+      durableWrites: config.durableWrites
     });
   }
   throw new ConfigurationError(
@@ -3561,7 +5426,8 @@ function normalizeDatabaseConfig(config) {
       provider: "postgres",
       connectionString,
       url: connectionString,
-      ..."maxPoolSize" in config && config.maxPoolSize !== void 0 ? { maxPoolSize: config.maxPoolSize } : {}
+      ..."maxPoolSize" in config && config.maxPoolSize !== void 0 ? { maxPoolSize: config.maxPoolSize } : {},
+      ..."durableWrites" in config && config.durableWrites !== void 0 ? { durableWrites: config.durableWrites } : {}
     };
   }
   return {
@@ -4560,6 +6426,66 @@ Ensure no exclusive lock is held and the destination directory is writable.`,
     }
   }
 }
+function matchesFilter2(filter, event) {
+  if (filter.organization !== event.organization) {
+    return false;
+  }
+  if (filter.agent !== void 0 && filter.agent !== event.agent) {
+    return false;
+  }
+  if (filter.event === void 0) {
+    return true;
+  }
+  const events = Array.isArray(filter.event) ? filter.event : [filter.event];
+  return events.some(
+    (e) => e === "*" || e === event.event
+  );
+}
+var SqliteSubscribeEmitter = class {
+  emitter = new events.EventEmitter();
+  subscriptions = /* @__PURE__ */ new Map();
+  nextId = 1;
+  closed = false;
+  constructor() {
+    this.emitter.setMaxListeners(0);
+    this.emitter.on("change", (event) => {
+      for (const sub of this.subscriptions.values()) {
+        if (!matchesFilter2(sub.filter, event)) {
+          continue;
+        }
+        try {
+          sub.callback(event);
+        } catch (error) {
+          console.error(
+            "[wolbarg] subscribe callback error:",
+            error instanceof Error ? error.message : error
+          );
+        }
+      }
+    });
+  }
+  subscribe(filter, callback) {
+    if (this.closed) {
+      throw new Error("Subscribe backend is closed");
+    }
+    const id = this.nextId++;
+    this.subscriptions.set(id, { filter, callback });
+    return () => {
+      this.subscriptions.delete(id);
+    };
+  }
+  emit(event) {
+    if (this.closed) {
+      return;
+    }
+    this.emitter.emit("change", event);
+  }
+  async close() {
+    this.closed = true;
+    this.subscriptions.clear();
+    this.emitter.removeAllListeners();
+  }
+};
 
 // src/core/wolbarg.ts
 var Wolbarg = class {
@@ -4582,6 +6508,11 @@ var Wolbarg = class {
   checkpointProvider = null;
   memoryDbPath = null;
   transfer = new SqliteMemoryTransferProvider();
+  subscribeBackend = null;
+  pgListenBackend = null;
+  memoryDedupe = resolveMemoryDedupeConfig();
+  embeddingCacheConfig = resolveEmbeddingCacheConfig();
+  rawEmbedding = null;
   constructor(options) {
     this.telemetry = new TelemetryEmitter(null, { enabled: false, level: "off" });
     if (!options) {
@@ -4589,14 +6520,22 @@ var Wolbarg = class {
     }
     const validated = validateWolbargOptions(options);
     this.organization = validated.organization;
+    this.memoryDedupe = resolveMemoryDedupeConfig(validated.memory?.dedupe);
+    this.embeddingCacheConfig = resolveEmbeddingCacheConfig(
+      validated.embeddingCache
+    );
     const storageInput = validated.storage;
-    this.storage = isStorageProvider(storageInput) ? storageInput : createStorageProvider(storageInput);
+    this.storage = isStorageProvider(storageInput) ? storageInput : createStorageProvider(storageInput, {
+      concurrency: validated.concurrency
+    });
     if (!isStorageProvider(storageInput)) {
       this.memoryDbPath = resolveDatabaseUrl(storageInput);
     } else if (storageInput instanceof SqliteStorageProvider) {
       this.memoryDbPath = storageInput.path;
     }
-    this.embedding = isEmbeddingProvider(validated.embedding) ? validated.embedding : createEmbeddingProvider(validated.embedding);
+    const embedding = isEmbeddingProvider(validated.embedding) ? validated.embedding : createEmbeddingProvider(validated.embedding);
+    this.rawEmbedding = embedding;
+    this.embedding = embedding;
     if (validated.llm) {
       this.llm = isLlmProvider(validated.llm) ? validated.llm : createLlmProvider(validated.llm);
       this.compression = validated.compression ?? createCompressionProvider(this.llm);
@@ -4609,6 +6548,7 @@ var Wolbarg = class {
     this.vision = validated.vision ?? null;
     this.chunking = validated.chunking ?? null;
     this.retrievalConfig = validated.retrieval ?? {};
+    this.subscribeBackend = new SqliteSubscribeEmitter();
     if (validated.telemetry) {
       if (isTelemetryProvider(validated.telemetry)) {
         this.telemetry = new TelemetryEmitter(validated.telemetry, {
@@ -4684,9 +6624,54 @@ var Wolbarg = class {
       await this.storage.open();
       await this.telemetry.open();
       await this.checkpointProvider?.open();
-      const probe = await this.embedding.validate();
-      await this.storage.ensureVectorSchema(probe.dimensions);
-      this.embeddingDimensions = probe.dimensions;
+      if (this.rawEmbedding && this.embeddingCacheConfig.enabled) {
+        if (this.storage instanceof SqliteStorageProvider) {
+          const sqlite2 = this.storage;
+          const store = new SqliteEmbeddingCacheStore(() => sqlite2.getDatabase(), {
+            ttlMs: this.embeddingCacheConfig.ttlMs
+          });
+          this.embedding = withEmbeddingCache(
+            this.rawEmbedding,
+            store,
+            this.embeddingCacheConfig
+          );
+        } else if (this.storage instanceof PostgresStorageProvider) {
+          this.embedding = withEmbeddingCache(
+            this.rawEmbedding,
+            new PostgresEmbeddingCacheStore(() => null, {
+              ttlMs: this.embeddingCacheConfig.ttlMs,
+              durable: false
+            }),
+            this.embeddingCacheConfig
+          );
+        } else {
+          this.embedding = withEmbeddingCache(
+            this.rawEmbedding,
+            new MemoryEmbeddingCacheStore({
+              ttlMs: this.embeddingCacheConfig.ttlMs
+            }),
+            this.embeddingCacheConfig
+          );
+        }
+      }
+      if (this.storage instanceof PostgresStorageProvider) {
+      }
+      if (this.storage instanceof SqliteStorageProvider) {
+        this.storage.setRetryLogger((msg) => {
+          if (typeof console !== "undefined" && console.debug) {
+            console.debug(`[wolbarg] ${msg}`);
+          }
+        });
+      }
+      const storedDims = await this.storage.getEmbeddingDimensions();
+      if (storedDims !== null && storedDims > 0) {
+        await this.storage.ensureVectorSchema(storedDims);
+        this.embeddingDimensions = storedDims;
+      } else {
+        const probe = await this.embedding.validate();
+        await this.storage.ensureVectorSchema(probe.dimensions);
+        this.embeddingDimensions = probe.dimensions;
+      }
       this.initialized = true;
       this.telemetry.emitStartup(this.storage.name);
     } catch (error) {
@@ -4702,64 +6687,76 @@ var Wolbarg = class {
       );
     }
   }
-  /** Store a semantic memory for an agent. */
+  /** Store a semantic memory for an agent (may upsert when dedupe is enabled). */
   async remember(options) {
     const trace = this.telemetry.start("remember");
     try {
-      const { storage, embedding, organization } = await this.requireReady();
-      assertNonEmptyString(options.agent, "agent");
-      if (!options.content || typeof options.content.text !== "string") {
-        throw new ValidationError("content.text must be a string");
-      }
-      assertNonEmptyString(options.content.text, "content.text");
-      const metadata = options.metadata ?? {};
-      if (metadata === null || typeof metadata !== "object" || Array.isArray(metadata)) {
-        throw new ValidationError("metadata must be a plain object when provided");
-      }
-      const tEmbed = performance.now();
-      const vector = await embedding.embed(options.content.text);
-      trace.mark("embeddingMs", performance.now() - tEmbed);
-      this.assertEmbeddingDimensions(vector.length);
-      const id = createId();
-      const timestamp = nowIso();
-      const record = await this.withWriteLock(async () => {
-        const tStore = performance.now();
-        const row = await storage.insertMemory({
-          id,
-          organization,
-          agent: options.agent.trim(),
-          contentText: options.content.text,
-          metadata,
-          embedding: vector,
-          createdAt: timestamp,
-          updatedAt: timestamp
-        });
-        trace.mark("databaseWriteMs", performance.now() - tStore);
-        return toMemoryRecord(row);
-      });
+      const result = await this.rememberOne(options, trace);
       trace.success({
-        provider: storage.name,
-        memoryIds: [record.id],
+        provider: this.storage?.name,
+        memoryIds: [result.id],
         returnedCount: 1,
-        embeddingProvider: embedding.model,
-        model: embedding.model,
-        metadata,
-        agentId: options.agent.trim(),
-        tags: telemetryTags(metadata)
+        embeddingProvider: this.embedding?.model,
+        model: this.embedding?.model,
+        metadata: result.metadata,
+        agentId: result.agent,
+        tags: telemetryTags(result.metadata),
+        extra: { upsertAction: result.action }
       });
-      return record;
+      return result;
     } catch (error) {
       trace.failure(error, { agentId: options.agent });
       throw wrapOperationError("remember", error);
     }
   }
-  /** Batch remember — one parent event + child traces per item. */
+  /** Batch remember — sequential when dedupe enabled; otherwise one TX batch. */
   async rememberBatch(items) {
     const parent = this.telemetry.start("rememberBatch");
     try {
       if (!Array.isArray(items) || items.length === 0) {
         throw new ValidationError("rememberBatch requires a non-empty array");
       }
+      const anyDedupe = items.some((item) => {
+        const cfg = resolveMemoryDedupeConfig(
+          item.dedupe ?? this.memoryDedupe
+        );
+        return cfg.enabled;
+      }) || this.memoryDedupe.enabled;
+      if (anyDedupe) {
+        const out = [];
+        for (const item of items) {
+          const child = parent.child("remember");
+          const result = await this.rememberOne(item, child);
+          child.success({
+            provider: this.storage?.name,
+            memoryIds: [result.id],
+            returnedCount: 1,
+            metadata: result.metadata,
+            agentId: result.agent,
+            tags: telemetryTags(result.metadata),
+            extra: { upsertAction: result.action }
+          });
+          out.push(result);
+        }
+        parent.success({
+          provider: this.storage?.name,
+          memoryIds: out.map((r) => r.id),
+          returnedCount: out.length,
+          embeddingProvider: this.embedding?.model,
+          model: this.embedding?.model,
+          agentId: commonAgent(items.map((item) => item.agent.trim()))
+        });
+        this.emitChange({
+          event: "remember",
+          organization: this.organization,
+          agent: commonAgent(items.map((i) => i.agent.trim())) ?? items[0].agent,
+          memoryId: out.map((r) => r.id),
+          timestamp: nowIso(),
+          traceId: parent.context.traceId,
+          sessionId: this.telemetry.sessionId
+        });
+        return out;
+      }
       const { storage, embedding, organization } = await this.requireReady();
       const tEmbed = performance.now();
       const texts = items.map((item, i) => {
@@ -4784,7 +6781,9 @@ var Wolbarg = class {
         metadata: item.metadata ?? {},
         embedding: vectors[i],
         createdAt: timestamp,
-        updatedAt: timestamp
+        updatedAt: timestamp,
+        contentHash: null
+        // batch path is append-only; dedupe uses sequential rememberOne
       }));
       for (let i = 0; i < inputs.length; i += 1) {
         const child = parent.child("remember");
@@ -4803,7 +6802,10 @@ var Wolbarg = class {
         parent.mark("databaseWriteMs", performance.now() - tStore);
         return result;
       });
-      const records = rows.map(toMemoryRecord);
+      const records = rows.map((row) => ({
+        ...toMemoryRecord(row),
+        action: "created"
+      }));
       parent.success({
         provider: storage.name,
         memoryIds: records.map((r) => r.id),
@@ -4812,12 +6814,379 @@ var Wolbarg = class {
         model: embedding.model,
         agentId: commonAgent(items.map((item) => item.agent.trim()))
       });
+      this.emitChange({
+        event: "remember",
+        organization,
+        agent: commonAgent(items.map((i) => i.agent.trim())) ?? items[0].agent,
+        memoryId: records.map((r) => r.id),
+        timestamp,
+        traceId: parent.context.traceId,
+        sessionId: this.telemetry.sessionId
+      });
       return records;
     } catch (error) {
       parent.failure(error);
       throw wrapOperationError("rememberBatch", error);
     }
   }
+  /**
+   * Update an existing memory by id (re-embeds when content changes).
+   */
+  async update(options) {
+    const trace = this.telemetry.start("remember");
+    try {
+      const { storage, embedding, organization } = await this.requireReady();
+      assertNonEmptyString(options.id, "id");
+      const existing = await storage.getMemoryById(options.id.trim(), organization);
+      if (!existing) {
+        throw new MemoryNotFoundError(`Memory not found: ${options.id}`);
+      }
+      const contentText = options.content?.text ?? existing.content_text;
+      if (options.content) {
+        assertNonEmptyString(options.content.text, "content.text");
+      }
+      const existingMeta = deserializeMetadata(existing.metadata_json);
+      const metadata = options.metadata !== void 0 ? mergeMemoryMetadata(existingMeta, options.metadata) : existingMeta;
+      let vector;
+      if (options.content !== void 0) {
+        const tEmbed = performance.now();
+        vector = await embedding.embed(contentText);
+        trace.mark("embeddingMs", performance.now() - tEmbed);
+        this.assertEmbeddingDimensions(vector.length);
+      }
+      const timestamp = nowIso();
+      const row = await this.withWriteLock(async () => {
+        const tStore = performance.now();
+        const updated = await storage.updateMemory({
+          id: existing.id,
+          organization,
+          contentText: options.content !== void 0 ? contentText : void 0,
+          metadata,
+          embedding: vector,
+          updatedAt: timestamp,
+          contentHash: options.content !== void 0 ? hashMemoryContent(contentText) : void 0
+        });
+        trace.mark("databaseWriteMs", performance.now() - tStore);
+        return updated;
+      });
+      if (!row) {
+        throw new MemoryNotFoundError(`Memory not found: ${options.id}`);
+      }
+      const result = {
+        ...toMemoryRecord(row),
+        action: "updated"
+      };
+      this.emitChange({
+        event: "update",
+        organization,
+        agent: result.agent,
+        memoryId: result.id,
+        timestamp,
+        traceId: trace.context.traceId,
+        sessionId: this.telemetry.sessionId,
+        upsertAction: "updated"
+      });
+      trace.success({
+        provider: storage.name,
+        memoryIds: [result.id],
+        returnedCount: 1,
+        agentId: result.agent,
+        extra: { upsertAction: "updated" }
+      });
+      return result;
+    } catch (error) {
+      trace.failure(error);
+      throw wrapOperationError("update", error);
+    }
+  }
+  /**
+   * Subscribe to memory change events.
+   *
+   * **SQLite:** delivers events only within this Node.js process.
+   * A second process writing the same `memory.db` will not notify subscribers here.
+   */
+  subscribe(filter, callback) {
+    const org = filter.organization || this.organization;
+    if (!org) {
+      throw new ValidationError(
+        "subscribe requires organization (set on Wolbarg or in filter)"
+      );
+    }
+    const normalized = {
+      ...filter,
+      organization: org
+    };
+    if (this.storage instanceof PostgresStorageProvider) {
+      if (!this.pgListenBackend) {
+        const pool = this.storage.getPool?.();
+        if (pool) {
+          this.pgListenBackend = createPostgresListenerFromPool(pool);
+        }
+      }
+      if (this.pgListenBackend) {
+        return this.pgListenBackend.subscribe(normalized, callback);
+      }
+    }
+    if (!this.subscribeBackend) {
+      this.subscribeBackend = new SqliteSubscribeEmitter();
+    }
+    return this.subscribeBackend.subscribe(normalized, callback);
+  }
+  emitChange(event) {
+    try {
+      if (this.storage instanceof PostgresStorageProvider) {
+        const listener = this.pgListenBackend;
+        if (listener?.hasSubscribers?.()) {
+          void this.storage.notifyChange(event).catch((error) => {
+            console.error(
+              "[wolbarg] NOTIFY failed:",
+              error instanceof Error ? error.message : error
+            );
+          });
+        }
+        return;
+      }
+      this.subscribeBackend?.emit(event);
+    } catch (error) {
+      console.error(
+        "[wolbarg] emitChange error:",
+        error instanceof Error ? error.message : error
+      );
+    }
+  }
+  /** Internal remember with optional upsert/dedupe. */
+  async rememberOne(options, trace) {
+    const { storage, embedding, organization } = await this.requireReady();
+    assertNonEmptyString(options.agent, "agent");
+    if (!options.content || typeof options.content.text !== "string") {
+      throw new ValidationError("content.text must be a string");
+    }
+    assertNonEmptyString(options.content.text, "content.text");
+    const metadata = options.metadata ?? {};
+    if (metadata === null || typeof metadata !== "object" || Array.isArray(metadata)) {
+      throw new ValidationError("metadata must be a plain object when provided");
+    }
+    const agent = options.agent.trim();
+    const text = options.content.text;
+    const dedupe = resolveMemoryDedupeConfig(
+      options.dedupe !== void 0 ? options.dedupe : this.memoryDedupe
+    );
+    const tEmbed = performance.now();
+    const vector = await embedding.embed(text);
+    trace.mark("embeddingMs", performance.now() - tEmbed);
+    this.assertEmbeddingDimensions(vector.length);
+    const timestamp = nowIso();
+    const contentHash = hashMemoryContent(text);
+    if (!dedupe.enabled) {
+      const id2 = createId();
+      const record = await this.withWriteLock(async () => {
+        const tStore = performance.now();
+        const row = await storage.insertMemory({
+          id: id2,
+          organization,
+          agent,
+          contentText: text,
+          metadata,
+          embedding: vector,
+          createdAt: timestamp,
+          updatedAt: timestamp,
+          // Null hash when dedupe is off — unique index allows duplicate text.
+          contentHash: null
+        });
+        trace.mark("databaseWriteMs", performance.now() - tStore);
+        return toMemoryRecord(row);
+      });
+      this.emitChange({
+        event: "remember",
+        organization,
+        agent,
+        memoryId: record.id,
+        timestamp,
+        traceId: trace.context.traceId,
+        sessionId: this.telemetry.sessionId,
+        upsertAction: "created"
+      });
+      return { ...record, action: "created" };
+    }
+    let existing = null;
+    if (dedupe.strategy === "exact" || dedupe.strategy === "exact-or-near") {
+      if (typeof storage.findActiveByContentHash === "function") {
+        existing = await storage.findActiveByContentHash(
+          organization,
+          agent,
+          contentHash
+        );
+      }
+    }
+    if (existing) {
+      const merged = mergeMemoryMetadata(
+        deserializeMetadata(existing.metadata_json),
+        metadata
+      );
+      const row = await this.withWriteLock(async () => {
+        const tStore = performance.now();
+        const updated = await storage.updateMemory({
+          id: existing.id,
+          organization,
+          metadata: merged,
+          updatedAt: timestamp,
+          contentHash
+        });
+        trace.mark("databaseWriteMs", performance.now() - tStore);
+        return updated;
+      }, { exclusive: true });
+      const record = toMemoryRecord(row);
+      this.emitChange({
+        event: "update",
+        organization,
+        agent,
+        memoryId: record.id,
+        timestamp,
+        traceId: trace.context.traceId,
+        sessionId: this.telemetry.sessionId,
+        upsertAction: "updated"
+      });
+      return { ...record, action: "updated" };
+    }
+    if (dedupe.strategy === "near" || dedupe.strategy === "exact-or-near") {
+      const near = await this.findNearDuplicate(
+        storage,
+        organization,
+        agent,
+        vector,
+        dedupe.nearThreshold,
+        dedupe.nearCandidateLimit
+      );
+      if (near) {
+        const merged = mergeMemoryMetadata(
+          deserializeMetadata(near.metadata_json),
+          metadata
+        );
+        const row = await this.withWriteLock(async () => {
+          const tStore = performance.now();
+          const updated = await storage.updateMemory({
+            id: near.id,
+            organization,
+            contentText: text,
+            metadata: merged,
+            embedding: vector,
+            updatedAt: timestamp,
+            contentHash
+          });
+          trace.mark("databaseWriteMs", performance.now() - tStore);
+          return updated;
+        }, { exclusive: true });
+        const record = toMemoryRecord(row);
+        this.emitChange({
+          event: "update",
+          organization,
+          agent,
+          memoryId: record.id,
+          timestamp,
+          traceId: trace.context.traceId,
+          sessionId: this.telemetry.sessionId,
+          upsertAction: "updated"
+        });
+        return { ...record, action: "updated" };
+      }
+    }
+    const id = createId();
+    try {
+      const record = await this.withWriteLock(async () => {
+        const tStore = performance.now();
+        const row = await storage.insertMemory({
+          id,
+          organization,
+          agent,
+          contentText: text,
+          metadata,
+          embedding: vector,
+          createdAt: timestamp,
+          updatedAt: timestamp,
+          contentHash
+        });
+        trace.mark("databaseWriteMs", performance.now() - tStore);
+        return toMemoryRecord(row);
+      }, { exclusive: true });
+      this.emitChange({
+        event: "remember",
+        organization,
+        agent,
+        memoryId: record.id,
+        timestamp,
+        traceId: trace.context.traceId,
+        sessionId: this.telemetry.sessionId,
+        upsertAction: "created"
+      });
+      return { ...record, action: "created" };
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : String(error);
+      if (msg.toLowerCase().includes("unique") && typeof storage.findActiveByContentHash === "function") {
+        const raced = await storage.findActiveByContentHash(
+          organization,
+          agent,
+          contentHash
+        );
+        if (raced) {
+          const merged = mergeMemoryMetadata(
+            deserializeMetadata(raced.metadata_json),
+            metadata
+          );
+          const row = await this.withWriteLock(
+            async () => storage.updateMemory({
+              id: raced.id,
+              organization,
+              metadata: merged,
+              updatedAt: nowIso(),
+              contentHash
+            }),
+            { exclusive: true }
+          );
+          const record = toMemoryRecord(row);
+          this.emitChange({
+            event: "update",
+            organization,
+            agent,
+            memoryId: record.id,
+            timestamp: nowIso(),
+            upsertAction: "updated"
+          });
+          return { ...record, action: "updated" };
+        }
+      }
+      throw error;
+    }
+  }
+  async findNearDuplicate(storage, organization, agent, vector, threshold, limit) {
+    if (typeof storage.searchVectorsWithMemories === "function") {
+      const hits2 = await storage.searchVectorsWithMemories(
+        vector,
+        limit,
+        organization,
+        { agent, includeArchived: false }
+      );
+      let best2 = null;
+      for (const { row, distance } of hits2) {
+        if (row.archived === 1) continue;
+        const sim = distanceToSimilarity(distance);
+        if (sim >= threshold && (!best2 || sim > best2.sim)) {
+          best2 = { row, sim };
+        }
+      }
+      return best2?.row ?? null;
+    }
+    const hits = await storage.searchVectors(vector, limit);
+    let best = null;
+    for (const hit of hits) {
+      const row = await storage.getMemoryByRowid(hit.memoryRowid, organization);
+      if (!row || row.archived === 1 || row.agent !== agent) continue;
+      const sim = distanceToSimilarity(hit.distance);
+      if (sim >= threshold && (!best || sim > best.sim)) {
+        best = { row, sim };
+      }
+    }
+    return best?.row ?? null;
+  }
   async recall(options) {
     const trace = this.telemetry.start("recall");
     const explain = options.explain === true;
@@ -5205,6 +7574,14 @@ var Wolbarg = class {
         returnedCount: 1,
         agentId: options.agent.trim()
       });
+      this.emitChange({
+        event: "compress",
+        organization,
+        agent: options.agent.trim(),
+        memoryId: [result.summary.id, ...result.archivedIds],
+        timestamp,
+        sessionId: this.telemetry.sessionId
+      });
       return result;
     } catch (error) {
       trace.failure(error, { agentId: options.agent });
@@ -5299,9 +7676,54 @@ var Wolbarg = class {
         },
         embedding: vectors[i],
         createdAt: timestamp,
-        updatedAt: timestamp
+        updatedAt: timestamp,
+        contentHash: this.memoryDedupe.enabled ? hashMemoryContent(chunk.text) : null
       }));
-      const rows = await this.withWriteLock(async () => {
+      let rows;
+      if (this.memoryDedupe.enabled) {
+        const memories = [];
+        for (let i = 0; i < chunks.length; i += 1) {
+          const result3 = await this.rememberOne(
+            {
+              agent: options.agent.trim(),
+              content: { text: chunks[i].text },
+              metadata: {
+                ...baseMeta,
+                ingest: true,
+                chunkIndex: chunks[i].index,
+                chunkCount: chunks.length,
+                sourceFilename: loaded.filename ?? null
+              }
+            },
+            trace
+          );
+          memories.push(result3);
+        }
+        const result2 = {
+          memories,
+          extractedChars: text.length,
+          chunkCount: chunks.length,
+          usedOcr,
+          usedVision
+        };
+        trace.success({
+          provider: storage.name,
+          memoryIds: result2.memories.map((m) => m.id),
+          returnedCount: result2.memories.length,
+          agentId: options.agent.trim(),
+          tags: telemetryTags(baseMeta)
+        });
+        this.emitChange({
+          event: "ingest",
+          organization,
+          agent: options.agent.trim(),
+          memoryId: result2.memories.map((m) => m.id),
+          timestamp,
+          sessionId: this.telemetry.sessionId
+        });
+        return result2;
+      }
+      rows = await this.withWriteLock(async () => {
         const tWrite = performance.now();
         const result2 = await storage.insertMemoriesBatch(inputs);
         trace.mark("databaseWriteMs", performance.now() - tWrite);
@@ -5321,6 +7743,14 @@ var Wolbarg = class {
         agentId: options.agent.trim(),
         tags: telemetryTags(baseMeta)
       });
+      this.emitChange({
+        event: "ingest",
+        organization,
+        agent: options.agent.trim(),
+        memoryId: result.memories.map((m) => m.id),
+        timestamp,
+        sessionId: this.telemetry.sessionId
+      });
       return result;
     } catch (error) {
       trace.failure(error, { agentId: options.agent });
@@ -5359,6 +7789,16 @@ var Wolbarg = class {
         filters: "filter" in options ? options.filter : null,
         agentId: "filter" in options ? options.filter?.agent?.trim() ?? null : null
       });
+      if (deleted > 0) {
+        this.emitChange({
+          event: "forget",
+          organization,
+          agent: "filter" in options && options.filter?.agent?.trim() || ("id" in options ? "*" : "*"),
+          memoryId: "id" in options && options.id ? options.id.trim() : [],
+          timestamp: nowIso(),
+          sessionId: this.telemetry.sessionId
+        });
+      }
       return deleted;
     } catch (error) {
       trace.failure(error, {
@@ -5632,8 +8072,13 @@ var Wolbarg = class {
   get sessionId() {
     return this.telemetry.sessionId;
   }
-  withWriteLock(fn) {
-    if (this.storage?.name === "sqlite") {
+  /**
+   * Optional process-wide lock for SQLite read-modify-write (dedupe upsert).
+   * Plain inserts must NOT take this lock — the provider coalesces concurrent
+   * insertMemory calls under a single BEGIN IMMEDIATE for multi-writer throughput.
+   */
+  withWriteLock(fn, options) {
+    if (options?.exclusive && this.storage?.name === "sqlite") {
       return this.writeMutex.runExclusive(fn);
     }
     return fn();
@@ -5642,6 +8087,10 @@ var Wolbarg = class {
     if (this.storage) {
       this.telemetry.emitShutdown(this.storage.name);
     }
+    await this.subscribeBackend?.close().catch(() => void 0);
+    await this.pgListenBackend?.close().catch(() => void 0);
+    this.subscribeBackend = null;
+    this.pgListenBackend = null;
     await this.telemetry.close().catch(() => void 0);
     await this.checkpointProvider?.close().catch(() => void 0);
     if (this.storage) {
@@ -5649,6 +8098,7 @@ var Wolbarg = class {
     }
     this.storage = null;
     this.embedding = null;
+    this.rawEmbedding = null;
     this.llm = null;
     this.compression = null;
     this.organization = null;
@@ -6273,6 +8723,7 @@ exports.SqliteDatabaseProvider = SqliteDatabaseProvider;
 exports.SqliteEventDatabase = SqliteEventDatabase;
 exports.SqliteStorageProvider = SqliteStorageProvider;
 exports.SqliteTelemetryProvider = SqliteTelemetryProvider;
+exports.StorageLockedError = StorageLockedError;
 exports.TelemetryEmitter = TelemetryEmitter;
 exports.ValidationError = ValidationError;
 exports.Wolbarg = Wolbarg;