wolbarg 0.3.2 → 0.4.0

package/dist/index.js

@@ -1,9 +1,11 @@
 import path5 from "node:path";
+import { createHash } from 'crypto';
 import fs from 'fs/promises';
 import fs5 from "node:fs";
 import { DatabaseSync } from "node:sqlite";
 import * as sqliteVec from 'sqlite-vec';
 import { AsyncLocalStorage } from 'async_hooks';
+import { EventEmitter } from 'events';
 
 // src/core/wolbarg.ts
 
@@ -47,6 +49,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);
@@ -84,11 +92,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")) {
@@ -548,6 +556,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 = 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 {
@@ -902,8 +1308,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",
@@ -924,6 +1426,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
@@ -933,7 +1436,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
@@ -954,14 +1457,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) {
@@ -985,35 +1507,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 (?, ?)
   `,
@@ -1096,6 +1625,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 = ?
   `,
@@ -1105,6 +1635,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 = ?
   `
 };
 
@@ -1310,10 +1886,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 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;
@@ -1324,13 +2030,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);
@@ -1344,17 +2074,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) {
@@ -1386,10 +2115,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)}`, {
@@ -1399,6 +2136,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) {
@@ -1431,16 +2174,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) {
@@ -1467,38 +2258,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;
     });
@@ -1515,9 +2281,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
@@ -1534,9 +2302,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) {
@@ -1582,13 +2366,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);
@@ -1598,41 +2380,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
@@ -1647,26 +2399,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;
   }
@@ -1675,6 +2445,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,
@@ -1683,6 +2454,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(),
@@ -1723,17 +2497,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
@@ -1744,13 +2509,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);
     });
@@ -1771,15 +2531,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() {
@@ -1812,59 +2569,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.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.
@@ -1896,13 +2753,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),
@@ -1910,6 +2787,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,
@@ -1922,10 +2800,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),
@@ -1934,11 +2809,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) {
@@ -1948,13 +2828,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) {
@@ -2038,6 +3221,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);
@@ -2046,6 +3236,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();
@@ -2054,7 +3251,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();
@@ -2125,58 +3327,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.isAbsolute(connectionString) ? connectionString : path5.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.isAbsolute(connectionString) ? connectionString : path5.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 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 = "[";
@@ -2186,17 +3748,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)
@@ -2204,9 +3794,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 (
@@ -2219,13 +3808,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)
@@ -2233,31 +3821,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;
@@ -2268,6 +3867,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 {
@@ -2283,6 +3886,7 @@ var PostgresStorageProvider = class {
         connectionString: this.connectionString,
         max: this.maxPoolSize,
         idleTimeoutMillis: 3e4,
+        connectionTimeoutMillis: 1e4,
         allowExitOnIdle: true,
         keepAlive: true
       });
@@ -2291,7 +3895,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);
@@ -2306,12 +3920,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) {
@@ -2334,6 +3981,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`
       );
@@ -2347,6 +4022,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.
@@ -2380,22 +4059,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(
@@ -2427,48 +4122,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);
@@ -2484,20 +4181,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,
@@ -2506,8 +4199,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]);
     }
@@ -2543,7 +4236,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];
@@ -2554,10 +4246,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,
@@ -2565,17 +4256,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);
     }
@@ -2583,14 +4281,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;
     }
@@ -2602,13 +4312,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,
@@ -2616,7 +4327,8 @@ var PostgresStorageProvider = class {
         input.contentText,
         serializeMetadata(input.metadata),
         input.createdAt,
-        input.updatedAt
+        input.updatedAt,
+        contentHash
       ]
     );
     const row = this.mapRow(inserted.rows[0]);
@@ -2642,15 +4354,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
@@ -2660,12 +4375,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]
     );
@@ -2708,6 +4440,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;
@@ -2778,27 +4537,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
@@ -2823,65 +4585,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) {
@@ -2898,6 +4661,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 = [];
@@ -3021,6 +4790,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,
@@ -3038,7 +4821,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
       )
@@ -3053,8 +4836,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`
@@ -3062,53 +4845,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;
     }
@@ -3163,6 +5025,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
@@ -3195,7 +5058,7 @@ var PostgresStorageProvider = class {
 };
 
 // src/storage/index.ts
-function createStorageProvider(config) {
+function createStorageProvider(config, options) {
   const connectionString = resolveDatabaseUrl(config);
   if (!connectionString) {
     throw new ConfigurationError(
@@ -3204,13 +5067,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(
@@ -3534,7 +5399,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 {
@@ -4533,6 +6399,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 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 {
@@ -4555,6 +6481,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) {
@@ -4562,14 +6493,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);
@@ -4582,6 +6521,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, {
@@ -4657,9 +6597,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) {
@@ -4675,64 +6660,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) => {
@@ -4757,7 +6754,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");
@@ -4776,7 +6775,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),
@@ -4785,12 +6787,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;
@@ -5178,6 +7547,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 });
@@ -5272,9 +7649,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);
@@ -5294,6 +7716,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 });
@@ -5332,6 +7762,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, {
@@ -5605,8 +8045,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();
@@ -5615,6 +8060,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) {
@@ -5622,6 +8071,7 @@ var Wolbarg = class {
     }
     this.storage = null;
     this.embedding = null;
+    this.rawEmbedding = null;
     this.llm = null;
     this.compression = null;
     this.organization = null;
@@ -6226,6 +8676,6 @@ function percentile(sorted, p) {
   return sorted[idx];
 }
 
-export { CompressionError, ConfigurationError, DatabaseError, EmbeddingError, FixedChunkingStrategy, HeadingChunkingStrategy, InitializationError, LlmCompressionProvider, MarkdownChunkingStrategy, MemoryNotFoundError, NoopTelemetryProvider, ParagraphChunkingStrategy, PostgresStorageProvider, ProviderNotConfiguredError, SentenceChunkingStrategy, SqliteCheckpointProvider, SqliteDatabaseProvider, SqliteEventDatabase, SqliteStorageProvider, SqliteTelemetryProvider, TelemetryEmitter, ValidationError, Wolbarg, WolbargError, WolbargLogger, bgeReranker, bm25, cohereReranker, createChunkingStrategy, createCompressionProvider, createDatabaseProvider, createEmbeddingProvider, createLlmProvider, createStorageProvider, createTelemetryProvider, wolbarg2 as createWolbarg, crossEncoder, geminiEmbedding, geminiVision, jinaReranker, lmStudioEmbedding, meta, ollamaEmbedding, ollamaLlm, openRouterEmbedding, openRouterLlm, openaiCompatibleEmbedding, openaiCompatibleLlm, openaiEmbedding, openaiLlm, openaiReranker, openaiVision, postgres, postgresConfig, runBenchmark, sqlite, sqliteCheckpoint, sqliteConfig, sqliteTelemetry, summarizeBenchmark, tesseract, togetherEmbedding, vllmEmbedding, wolbarg, wrapOperationError };
+export { CompressionError, ConfigurationError, DatabaseError, EmbeddingError, FixedChunkingStrategy, HeadingChunkingStrategy, InitializationError, LlmCompressionProvider, MarkdownChunkingStrategy, MemoryNotFoundError, NoopTelemetryProvider, ParagraphChunkingStrategy, PostgresStorageProvider, ProviderNotConfiguredError, SentenceChunkingStrategy, SqliteCheckpointProvider, SqliteDatabaseProvider, SqliteEventDatabase, SqliteStorageProvider, SqliteTelemetryProvider, StorageLockedError, TelemetryEmitter, ValidationError, Wolbarg, WolbargError, WolbargLogger, bgeReranker, bm25, cohereReranker, createChunkingStrategy, createCompressionProvider, createDatabaseProvider, createEmbeddingProvider, createLlmProvider, createStorageProvider, createTelemetryProvider, wolbarg2 as createWolbarg, crossEncoder, geminiEmbedding, geminiVision, jinaReranker, lmStudioEmbedding, meta, ollamaEmbedding, ollamaLlm, openRouterEmbedding, openRouterLlm, openaiCompatibleEmbedding, openaiCompatibleLlm, openaiEmbedding, openaiLlm, openaiReranker, openaiVision, postgres, postgresConfig, runBenchmark, sqlite, sqliteCheckpoint, sqliteConfig, sqliteTelemetry, summarizeBenchmark, tesseract, togetherEmbedding, vllmEmbedding, wolbarg, wrapOperationError };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map