@smyslenny/agent-memory 2.0.0 → 2.2.0

package/dist/index.js

@@ -3,7 +3,7 @@
 // src/core/db.ts
 import Database from "better-sqlite3";
 import { randomUUID } from "crypto";
-var SCHEMA_VERSION = 1;
+var SCHEMA_VERSION = 3;
 var SCHEMA_SQL = `
 -- Memory entries
 CREATE TABLE IF NOT EXISTS memories (
@@ -28,20 +28,23 @@ CREATE TABLE IF NOT EXISTS memories (
 CREATE TABLE IF NOT EXISTS paths (
   id          TEXT PRIMARY KEY,
   memory_id   TEXT NOT NULL REFERENCES memories(id) ON DELETE CASCADE,
-  uri         TEXT NOT NULL UNIQUE,
+  agent_id    TEXT NOT NULL DEFAULT 'default',
+  uri         TEXT NOT NULL,
   alias       TEXT,
   domain      TEXT NOT NULL,
-  created_at  TEXT NOT NULL
+  created_at  TEXT NOT NULL,
+  UNIQUE(agent_id, uri)
 );
 
 -- Association network (knowledge graph)
 CREATE TABLE IF NOT EXISTS links (
+  agent_id    TEXT NOT NULL DEFAULT 'default',
   source_id   TEXT NOT NULL REFERENCES memories(id) ON DELETE CASCADE,
   target_id   TEXT NOT NULL REFERENCES memories(id) ON DELETE CASCADE,
   relation    TEXT NOT NULL,
   weight      REAL NOT NULL DEFAULT 1.0,
   created_at  TEXT NOT NULL,
-  PRIMARY KEY (source_id, target_id)
+  PRIMARY KEY (agent_id, source_id, target_id)
 );
 
 -- Snapshots (version control, from nocturne + Memory Palace)
@@ -61,6 +64,18 @@ CREATE VIRTUAL TABLE IF NOT EXISTS memories_fts USING fts5(
   tokenize='unicode61'
 );
 
+-- Embeddings (optional semantic layer)
+CREATE TABLE IF NOT EXISTS embeddings (
+  agent_id    TEXT NOT NULL DEFAULT 'default',
+  memory_id   TEXT NOT NULL REFERENCES memories(id) ON DELETE CASCADE,
+  model       TEXT NOT NULL,
+  dim         INTEGER NOT NULL,
+  vector      BLOB NOT NULL,
+  created_at  TEXT NOT NULL,
+  updated_at  TEXT NOT NULL,
+  PRIMARY KEY (agent_id, memory_id, model)
+);
+
 -- Schema version tracking
 CREATE TABLE IF NOT EXISTS schema_meta (
   key   TEXT PRIMARY KEY,
@@ -75,9 +90,10 @@ CREATE INDEX IF NOT EXISTS idx_memories_vitality ON memories(vitality);
 CREATE INDEX IF NOT EXISTS idx_memories_hash ON memories(hash);
 CREATE INDEX IF NOT EXISTS idx_paths_memory ON paths(memory_id);
 CREATE INDEX IF NOT EXISTS idx_paths_domain ON paths(domain);
-CREATE INDEX IF NOT EXISTS idx_links_source ON links(source_id);
-CREATE INDEX IF NOT EXISTS idx_links_target ON links(target_id);
 `;
+function isCountRow(row) {
+  return row !== null && typeof row === "object" && "c" in row && typeof row.c === "number";
+}
 function openDatabase(opts) {
   const db = new Database(opts.path);
   if (opts.walMode !== false) {
@@ -86,13 +102,17 @@ function openDatabase(opts) {
   db.pragma("foreign_keys = ON");
   db.pragma("busy_timeout = 5000");
   db.exec(SCHEMA_SQL);
-  const getVersion = db.prepare("SELECT value FROM schema_meta WHERE key = 'version'");
-  const row = getVersion.get();
-  if (!row) {
-    db.prepare("INSERT INTO schema_meta (key, value) VALUES ('version', ?)").run(
-      String(SCHEMA_VERSION)
-    );
+  const currentVersion = getSchemaVersion(db);
+  if (currentVersion === null) {
+    const inferred = inferSchemaVersion(db);
+    if (inferred < SCHEMA_VERSION) {
+      migrateDatabase(db, inferred, SCHEMA_VERSION);
+    }
+    db.prepare("INSERT OR REPLACE INTO schema_meta (key, value) VALUES ('version', ?)").run(String(SCHEMA_VERSION));
+  } else if (currentVersion < SCHEMA_VERSION) {
+    migrateDatabase(db, currentVersion, SCHEMA_VERSION);
   }
+  ensureIndexes(db);
   return db;
 }
 function now() {
@@ -101,9 +121,256 @@ function now() {
 function newId() {
   return randomUUID();
 }
+function getSchemaVersion(db) {
+  try {
+    const row = db.prepare("SELECT value FROM schema_meta WHERE key = 'version'").get();
+    if (!row) return null;
+    const n = Number.parseInt(row.value, 10);
+    return Number.isFinite(n) ? n : null;
+  } catch {
+    return null;
+  }
+}
+function tableHasColumn(db, table, column) {
+  try {
+    const cols = db.prepare(`PRAGMA table_info(${table})`).all();
+    return cols.some((c) => c.name === column);
+  } catch {
+    return false;
+  }
+}
+function migrateDatabase(db, from, to) {
+  let v = from;
+  while (v < to) {
+    if (v === 1) {
+      migrateV1ToV2(db);
+      v = 2;
+      continue;
+    }
+    if (v === 2) {
+      migrateV2ToV3(db);
+      v = 3;
+      continue;
+    }
+    throw new Error(`Unsupported schema migration path: v${from} \u2192 v${to} (stuck at v${v})`);
+  }
+}
+function migrateV1ToV2(db) {
+  const pathsMigrated = tableHasColumn(db, "paths", "agent_id");
+  const linksMigrated = tableHasColumn(db, "links", "agent_id");
+  const alreadyMigrated = pathsMigrated && linksMigrated;
+  if (alreadyMigrated) {
+    db.prepare("UPDATE schema_meta SET value = ? WHERE key = 'version'").run(String(2));
+    return;
+  }
+  db.pragma("foreign_keys = OFF");
+  try {
+    db.exec("BEGIN");
+    if (!pathsMigrated) {
+      db.exec(`
+        CREATE TABLE IF NOT EXISTS paths_v2 (
+          id          TEXT PRIMARY KEY,
+          memory_id   TEXT NOT NULL REFERENCES memories(id) ON DELETE CASCADE,
+          agent_id    TEXT NOT NULL DEFAULT 'default',
+          uri         TEXT NOT NULL,
+          alias       TEXT,
+          domain      TEXT NOT NULL,
+          created_at  TEXT NOT NULL,
+          UNIQUE(agent_id, uri)
+        );
+      `);
+      db.exec(`
+        INSERT INTO paths_v2 (id, memory_id, agent_id, uri, alias, domain, created_at)
+        SELECT p.id, p.memory_id, COALESCE(m.agent_id, 'default'), p.uri, p.alias, p.domain, p.created_at
+        FROM paths p
+        LEFT JOIN memories m ON m.id = p.memory_id;
+      `);
+      db.exec("DROP TABLE paths;");
+      db.exec("ALTER TABLE paths_v2 RENAME TO paths;");
+    }
+    if (!linksMigrated) {
+      db.exec(`
+        CREATE TABLE IF NOT EXISTS links_v2 (
+          agent_id    TEXT NOT NULL DEFAULT 'default',
+          source_id   TEXT NOT NULL REFERENCES memories(id) ON DELETE CASCADE,
+          target_id   TEXT NOT NULL REFERENCES memories(id) ON DELETE CASCADE,
+          relation    TEXT NOT NULL,
+          weight      REAL NOT NULL DEFAULT 1.0,
+          created_at  TEXT NOT NULL,
+          PRIMARY KEY (agent_id, source_id, target_id)
+        );
+      `);
+      db.exec(`
+        INSERT INTO links_v2 (agent_id, source_id, target_id, relation, weight, created_at)
+        SELECT COALESCE(ms.agent_id, 'default'), l.source_id, l.target_id, l.relation, l.weight, l.created_at
+        FROM links l
+        LEFT JOIN memories ms ON ms.id = l.source_id;
+      `);
+      db.exec(`
+        DELETE FROM links_v2
+        WHERE EXISTS (SELECT 1 FROM memories s WHERE s.id = links_v2.source_id AND s.agent_id != links_v2.agent_id)
+           OR EXISTS (SELECT 1 FROM memories t WHERE t.id = links_v2.target_id AND t.agent_id != links_v2.agent_id);
+      `);
+      db.exec("DROP TABLE links;");
+      db.exec("ALTER TABLE links_v2 RENAME TO links;");
+    }
+    db.exec(`
+      CREATE INDEX IF NOT EXISTS idx_paths_memory ON paths(memory_id);
+      CREATE INDEX IF NOT EXISTS idx_paths_domain ON paths(domain);
+    `);
+    db.prepare("UPDATE schema_meta SET value = ? WHERE key = 'version'").run(String(2));
+    db.exec("COMMIT");
+  } catch (e) {
+    try {
+      db.exec("ROLLBACK");
+    } catch {
+    }
+    throw e;
+  } finally {
+    db.pragma("foreign_keys = ON");
+  }
+}
+function inferSchemaVersion(db) {
+  const hasAgentScopedPaths = tableHasColumn(db, "paths", "agent_id");
+  const hasAgentScopedLinks = tableHasColumn(db, "links", "agent_id");
+  const hasEmbeddings = (() => {
+    try {
+      const row = db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='embeddings'").get();
+      return Boolean(row);
+    } catch {
+      return false;
+    }
+  })();
+  if (hasAgentScopedPaths && hasAgentScopedLinks && hasEmbeddings) return 3;
+  if (hasAgentScopedPaths && hasAgentScopedLinks) return 2;
+  return 1;
+}
+function ensureIndexes(db) {
+  if (tableHasColumn(db, "paths", "agent_id")) {
+    db.exec("CREATE INDEX IF NOT EXISTS idx_paths_agent_uri ON paths(agent_id, uri);");
+  }
+  if (tableHasColumn(db, "links", "agent_id")) {
+    db.exec("CREATE INDEX IF NOT EXISTS idx_links_agent_source ON links(agent_id, source_id);");
+    db.exec("CREATE INDEX IF NOT EXISTS idx_links_agent_target ON links(agent_id, target_id);");
+  }
+  try {
+    const row = db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='embeddings'").get();
+    if (row) {
+      db.exec("CREATE INDEX IF NOT EXISTS idx_embeddings_agent_model ON embeddings(agent_id, model);");
+      db.exec("CREATE INDEX IF NOT EXISTS idx_embeddings_memory ON embeddings(memory_id);");
+    }
+  } catch {
+  }
+}
+function migrateV2ToV3(db) {
+  try {
+    db.exec("BEGIN");
+    db.exec(`
+      CREATE TABLE IF NOT EXISTS embeddings (
+        agent_id    TEXT NOT NULL DEFAULT 'default',
+        memory_id   TEXT NOT NULL REFERENCES memories(id) ON DELETE CASCADE,
+        model       TEXT NOT NULL,
+        dim         INTEGER NOT NULL,
+        vector      BLOB NOT NULL,
+        created_at  TEXT NOT NULL,
+        updated_at  TEXT NOT NULL,
+        PRIMARY KEY (agent_id, memory_id, model)
+      );
+    `);
+    db.prepare("UPDATE schema_meta SET value = ? WHERE key = 'version'").run(String(3));
+    db.exec("COMMIT");
+  } catch (e) {
+    try {
+      db.exec("ROLLBACK");
+    } catch {
+    }
+    throw e;
+  }
+}
 
 // src/core/memory.ts
 import { createHash } from "crypto";
+
+// src/search/tokenizer.ts
+import { readFileSync } from "fs";
+import { createRequire } from "module";
+var _jieba;
+function getJieba() {
+  if (_jieba !== void 0) return _jieba;
+  try {
+    const req = createRequire(import.meta.url);
+    const { Jieba } = req("@node-rs/jieba");
+    const dictPath = req.resolve("@node-rs/jieba/dict.txt");
+    const dictBuf = readFileSync(dictPath);
+    _jieba = Jieba.withDict(dictBuf);
+  } catch {
+    _jieba = null;
+  }
+  return _jieba;
+}
+var STOPWORDS = /* @__PURE__ */ new Set([
+  "\u7684",
+  "\u4E86",
+  "\u5728",
+  "\u662F",
+  "\u6211",
+  "\u6709",
+  "\u548C",
+  "\u5C31",
+  "\u4E0D",
+  "\u4EBA",
+  "\u90FD",
+  "\u4E00",
+  "\u4E2A",
+  "\u4E0A",
+  "\u4E5F",
+  "\u5230",
+  "\u4ED6",
+  "\u6CA1",
+  "\u8FD9",
+  "\u8981",
+  "\u4F1A",
+  "\u5BF9",
+  "\u8BF4",
+  "\u800C",
+  "\u53BB",
+  "\u4E4B",
+  "\u88AB",
+  "\u5979",
+  "\u628A",
+  "\u90A3"
+]);
+function tokenize(text) {
+  const cleaned = text.replace(/[^\w\u4e00-\u9fff\u3040-\u30ff\uac00-\ud7af\s]/g, " ");
+  const tokens = [];
+  const latinWords = cleaned.replace(/[\u4e00-\u9fff\u3040-\u30ff\uac00-\ud7af]/g, " ").split(/\s+/).filter((w) => w.length > 1);
+  tokens.push(...latinWords);
+  const cjkChunks = cleaned.match(/[\u4e00-\u9fff\u3040-\u30ff\uac00-\ud7af]+/g);
+  if (cjkChunks && cjkChunks.length > 0) {
+    const jieba = getJieba();
+    for (const chunk of cjkChunks) {
+      if (jieba) {
+        const words = jieba.cutForSearch(chunk).filter((w) => w.length >= 1);
+        tokens.push(...words);
+      } else {
+        for (const ch of chunk) {
+          tokens.push(ch);
+        }
+        for (let i = 0; i < chunk.length - 1; i++) {
+          tokens.push(chunk[i] + chunk[i + 1]);
+        }
+      }
+    }
+  }
+  const unique = [...new Set(tokens)].filter((t) => t.length > 0 && !STOPWORDS.has(t)).slice(0, 30);
+  return unique;
+}
+function tokenizeForIndex(text) {
+  const tokens = tokenize(text);
+  return tokens.join(" ");
+}
+
+// src/core/memory.ts
 function contentHash(content) {
   return createHash("sha256").update(content.trim()).digest("hex").slice(0, 16);
 }
@@ -151,7 +418,7 @@ function createMemory(db, input) {
     agentId,
     hash
   );
-  db.prepare("INSERT INTO memories_fts (id, content) VALUES (?, ?)").run(id, input.content);
+  db.prepare("INSERT INTO memories_fts (id, content) VALUES (?, ?)").run(id, tokenizeForIndex(input.content));
   return getMemory(db, id);
 }
 function getMemory(db, id) {
@@ -196,7 +463,7 @@ function updateMemory(db, id, input) {
   db.prepare(`UPDATE memories SET ${fields.join(", ")} WHERE id = ?`).run(...values);
   if (input.content !== void 0) {
     db.prepare("DELETE FROM memories_fts WHERE id = ?").run(id);
-    db.prepare("INSERT INTO memories_fts (id, content) VALUES (?, ?)").run(id, input.content);
+    db.prepare("INSERT INTO memories_fts (id, content) VALUES (?, ?)").run(id, tokenizeForIndex(input.content));
   }
   return getMemory(db, id);
 }
@@ -256,36 +523,42 @@ function parseUri(uri) {
   if (!match) throw new Error(`Invalid URI: ${uri}. Expected format: domain://path`);
   return { domain: match[1], path: match[2] };
 }
-function createPath(db, memoryId, uri, alias, validDomains) {
+function createPath(db, memoryId, uri, alias, validDomains, agent_id) {
   const { domain } = parseUri(uri);
   const domains = validDomains ?? DEFAULT_DOMAINS;
   if (!domains.has(domain)) {
     throw new Error(`Invalid domain "${domain}". Valid: ${[...domains].join(", ")}`);
   }
-  const existing = db.prepare("SELECT id FROM paths WHERE uri = ?").get(uri);
+  const memoryAgent = db.prepare("SELECT agent_id FROM memories WHERE id = ?").get(memoryId)?.agent_id;
+  if (!memoryAgent) throw new Error(`Memory not found: ${memoryId}`);
+  if (agent_id && agent_id !== memoryAgent) {
+    throw new Error(`Agent mismatch for path: memory agent_id=${memoryAgent}, requested agent_id=${agent_id}`);
+  }
+  const agentId = agent_id ?? memoryAgent;
+  const existing = db.prepare("SELECT id FROM paths WHERE agent_id = ? AND uri = ?").get(agentId, uri);
   if (existing) {
     throw new Error(`URI already exists: ${uri}`);
   }
   const id = newId();
   db.prepare(
-    "INSERT INTO paths (id, memory_id, uri, alias, domain, created_at) VALUES (?, ?, ?, ?, ?, ?)"
-  ).run(id, memoryId, uri, alias ?? null, domain, now());
+    "INSERT INTO paths (id, memory_id, agent_id, uri, alias, domain, created_at) VALUES (?, ?, ?, ?, ?, ?, ?)"
+  ).run(id, memoryId, agentId, uri, alias ?? null, domain, now());
   return getPath(db, id);
 }
 function getPath(db, id) {
   return db.prepare("SELECT * FROM paths WHERE id = ?").get(id) ?? null;
 }
-function getPathByUri(db, uri) {
-  return db.prepare("SELECT * FROM paths WHERE uri = ?").get(uri) ?? null;
+function getPathByUri(db, uri, agent_id = "default") {
+  return db.prepare("SELECT * FROM paths WHERE agent_id = ? AND uri = ?").get(agent_id, uri) ?? null;
 }
 function getPathsByMemory(db, memoryId) {
   return db.prepare("SELECT * FROM paths WHERE memory_id = ?").all(memoryId);
 }
-function getPathsByDomain(db, domain) {
-  return db.prepare("SELECT * FROM paths WHERE domain = ? ORDER BY uri").all(domain);
+function getPathsByDomain(db, domain, agent_id = "default") {
+  return db.prepare("SELECT * FROM paths WHERE agent_id = ? AND domain = ? ORDER BY uri").all(agent_id, domain);
 }
-function getPathsByPrefix(db, prefix) {
-  return db.prepare("SELECT * FROM paths WHERE uri LIKE ? ORDER BY uri").all(`${prefix}%`);
+function getPathsByPrefix(db, prefix, agent_id = "default") {
+  return db.prepare("SELECT * FROM paths WHERE agent_id = ? AND uri LIKE ? ORDER BY uri").all(agent_id, `${prefix}%`);
 }
 function deletePath(db, id) {
   const result = db.prepare("DELETE FROM paths WHERE id = ?").run(id);
@@ -293,20 +566,30 @@ function deletePath(db, id) {
 }
 
 // src/core/link.ts
-function createLink(db, sourceId, targetId, relation, weight = 1) {
+function createLink(db, sourceId, targetId, relation, weight = 1, agent_id) {
+  const sourceAgent = db.prepare("SELECT agent_id FROM memories WHERE id = ?").get(sourceId)?.agent_id;
+  const targetAgent = db.prepare("SELECT agent_id FROM memories WHERE id = ?").get(targetId)?.agent_id;
+  if (!sourceAgent) throw new Error(`Source memory not found: ${sourceId}`);
+  if (!targetAgent) throw new Error(`Target memory not found: ${targetId}`);
+  if (sourceAgent !== targetAgent) throw new Error("Cross-agent links are not allowed");
+  if (agent_id && agent_id !== sourceAgent) throw new Error("Agent mismatch for link");
+  const agentId = agent_id ?? sourceAgent;
   db.prepare(
-    `INSERT OR REPLACE INTO links (source_id, target_id, relation, weight, created_at)
-     VALUES (?, ?, ?, ?, ?)`
-  ).run(sourceId, targetId, relation, weight, now());
-  return { source_id: sourceId, target_id: targetId, relation, weight, created_at: now() };
+    `INSERT OR REPLACE INTO links (agent_id, source_id, target_id, relation, weight, created_at)
+     VALUES (?, ?, ?, ?, ?, ?)`
+  ).run(agentId, sourceId, targetId, relation, weight, now());
+  return { agent_id: agentId, source_id: sourceId, target_id: targetId, relation, weight, created_at: now() };
 }
-function getLinks(db, memoryId) {
-  return db.prepare("SELECT * FROM links WHERE source_id = ? OR target_id = ?").all(memoryId, memoryId);
+function getLinks(db, memoryId, agent_id) {
+  const agentId = agent_id ?? db.prepare("SELECT agent_id FROM memories WHERE id = ?").get(memoryId)?.agent_id ?? "default";
+  return db.prepare("SELECT * FROM links WHERE agent_id = ? AND (source_id = ? OR target_id = ?)").all(agentId, memoryId, memoryId);
 }
-function getOutgoingLinks(db, sourceId) {
-  return db.prepare("SELECT * FROM links WHERE source_id = ?").all(sourceId);
+function getOutgoingLinks(db, sourceId, agent_id) {
+  const agentId = agent_id ?? db.prepare("SELECT agent_id FROM memories WHERE id = ?").get(sourceId)?.agent_id ?? "default";
+  return db.prepare("SELECT * FROM links WHERE agent_id = ? AND source_id = ?").all(agentId, sourceId);
 }
-function traverse(db, startId, maxHops = 2) {
+function traverse(db, startId, maxHops = 2, agent_id) {
+  const agentId = agent_id ?? db.prepare("SELECT agent_id FROM memories WHERE id = ?").get(startId)?.agent_id ?? "default";
   const visited = /* @__PURE__ */ new Set();
   const results = [];
   const queue = [
@@ -320,7 +603,7 @@ function traverse(db, startId, maxHops = 2) {
       results.push(current);
     }
     if (current.hop < maxHops) {
-      const links = db.prepare("SELECT target_id, relation FROM links WHERE source_id = ?").all(current.id);
+      const links = db.prepare("SELECT target_id, relation FROM links WHERE agent_id = ? AND source_id = ?").all(agentId, current.id);
       for (const link of links) {
         if (!visited.has(link.target_id)) {
           queue.push({
@@ -330,7 +613,7 @@ function traverse(db, startId, maxHops = 2) {
           });
         }
       }
-      const reverseLinks = db.prepare("SELECT source_id, relation FROM links WHERE target_id = ?").all(current.id);
+      const reverseLinks = db.prepare("SELECT source_id, relation FROM links WHERE agent_id = ? AND target_id = ?").all(agentId, current.id);
       for (const link of reverseLinks) {
         if (!visited.has(link.source_id)) {
           queue.push({
@@ -344,8 +627,9 @@ function traverse(db, startId, maxHops = 2) {
   }
   return results;
 }
-function deleteLink(db, sourceId, targetId) {
-  const result = db.prepare("DELETE FROM links WHERE source_id = ? AND target_id = ?").run(sourceId, targetId);
+function deleteLink(db, sourceId, targetId, agent_id) {
+  const agentId = agent_id ?? db.prepare("SELECT agent_id FROM memories WHERE id = ?").get(sourceId)?.agent_id ?? "default";
+  const result = db.prepare("DELETE FROM links WHERE agent_id = ? AND source_id = ? AND target_id = ?").run(agentId, sourceId, targetId);
   return result.changes > 0;
 }
 
@@ -378,7 +662,7 @@ function rollback(db, snapshotId) {
   db.prepare("DELETE FROM memories_fts WHERE id = ?").run(snapshot.memory_id);
   db.prepare("INSERT INTO memories_fts (id, content) VALUES (?, ?)").run(
     snapshot.memory_id,
-    snapshot.content
+    tokenizeForIndex(snapshot.content)
   );
   return true;
 }
@@ -392,7 +676,7 @@ function guard(db, input) {
     return { action: "skip", reason: "Exact duplicate (hash match)", existingId: exactMatch.id };
   }
   if (input.uri) {
-    const existingPath = getPathByUri(db, input.uri);
+    const existingPath = getPathByUri(db, input.uri, agentId);
     if (existingPath) {
       return {
         action: "update",
@@ -401,40 +685,148 @@ function guard(db, input) {
       };
     }
   }
-  const similar = db.prepare(
-    `SELECT m.id, m.content, m.type, rank
-       FROM memories_fts f
-       JOIN memories m ON m.id = f.id
-       WHERE memories_fts MATCH ? AND m.agent_id = ?
-       ORDER BY rank
-       LIMIT 3`
-  ).all(escapeFts(input.content), agentId);
-  if (similar.length > 0 && similar[0].rank < -10) {
-    const existing = similar[0];
-    if (existing.type === input.type) {
-      const merged = `${existing.content}
+  const ftsTokens = tokenize(input.content.slice(0, 200));
+  const ftsQuery = ftsTokens.length > 0 ? ftsTokens.slice(0, 8).map((w) => `"${w}"`).join(" OR ") : null;
+  if (ftsQuery) {
+    try {
+      const similar = db.prepare(
+        `SELECT m.id, m.content, m.type, rank
+           FROM memories_fts f
+           JOIN memories m ON m.id = f.id
+           WHERE memories_fts MATCH ? AND m.agent_id = ?
+           ORDER BY rank
+           LIMIT 3`
+      ).all(ftsQuery, agentId);
+      if (similar.length > 0) {
+        const topRank = Math.abs(similar[0].rank);
+        const tokenCount = ftsTokens.length;
+        const dynamicThreshold = tokenCount * 1.5;
+        if (topRank > dynamicThreshold) {
+          const existing = similar[0];
+          if (existing.type === input.type) {
+            const merged = `${existing.content}
 
 [Updated] ${input.content}`;
-      return {
-        action: "merge",
-        reason: "Similar content found, merging",
-        existingId: existing.id,
-        mergedContent: merged
-      };
+            return {
+              action: "merge",
+              reason: `Similar content found (score=${topRank.toFixed(1)}, threshold=${dynamicThreshold.toFixed(1)}), merging`,
+              existingId: existing.id,
+              mergedContent: merged
+            };
+          }
+        }
+      }
+    } catch {
     }
   }
-  const priority = input.priority ?? (input.type === "identity" ? 0 : input.type === "emotion" ? 1 : 2);
-  if (priority <= 1) {
-    if (!input.content.trim()) {
-      return { action: "skip", reason: "Empty content rejected by gate" };
-    }
+  const gateResult = fourCriterionGate(input);
+  if (!gateResult.pass) {
+    return { action: "skip", reason: `Gate rejected: ${gateResult.failedCriteria.join(", ")}` };
   }
   return { action: "add", reason: "Passed all guard checks" };
 }
-function escapeFts(text) {
-  const words = text.slice(0, 100).replace(/[^\w\u4e00-\u9fff\s]/g, " ").split(/\s+/).filter((w) => w.length > 1).slice(0, 5);
-  if (words.length === 0) return '""';
-  return words.map((w) => `"${w}"`).join(" OR ");
+function fourCriterionGate(input) {
+  const content = input.content.trim();
+  const failed = [];
+  const priority = input.priority ?? (input.type === "identity" ? 0 : input.type === "emotion" ? 1 : input.type === "knowledge" ? 2 : 3);
+  const minLength = priority <= 1 ? 4 : 8;
+  const specificity = content.length >= minLength ? Math.min(1, content.length / 50) : 0;
+  if (specificity === 0) failed.push(`specificity (too short: ${content.length} < ${minLength} chars)`);
+  const tokens = tokenize(content);
+  const novelty = tokens.length >= 1 ? Math.min(1, tokens.length / 5) : 0;
+  if (novelty === 0) failed.push("novelty (no meaningful tokens after filtering)");
+  const hasCJK = /[\u4e00-\u9fff]/.test(content);
+  const hasCapitalized = /[A-Z][a-z]+/.test(content);
+  const hasNumbers = /\d+/.test(content);
+  const hasURI = /\w+:\/\//.test(content);
+  const hasEntityMarkers = /[@#]/.test(content);
+  const hasMeaningfulLength = content.length >= 15;
+  const topicSignals = [hasCJK, hasCapitalized, hasNumbers, hasURI, hasEntityMarkers, hasMeaningfulLength].filter(Boolean).length;
+  const relevance = topicSignals >= 1 ? Math.min(1, topicSignals / 3) : 0;
+  if (relevance === 0) failed.push("relevance (no identifiable topics/entities)");
+  const allCaps = content === content.toUpperCase() && content.length > 20 && /^[A-Z\s]+$/.test(content);
+  const hasWhitespaceOrPunctuation = /[\s，。！？,.!?；;：:]/.test(content) || content.length < 30;
+  const excessiveRepetition = /(.)\1{9,}/.test(content);
+  let coherence = 1;
+  if (allCaps) {
+    coherence -= 0.5;
+  }
+  if (!hasWhitespaceOrPunctuation) {
+    coherence -= 0.3;
+  }
+  if (excessiveRepetition) {
+    coherence -= 0.5;
+  }
+  coherence = Math.max(0, coherence);
+  if (coherence < 0.3) failed.push("coherence (garbled or malformed content)");
+  return {
+    pass: failed.length === 0,
+    scores: { specificity, novelty, relevance, coherence },
+    failedCriteria: failed
+  };
+}
+
+// src/core/export.ts
+import { writeFileSync, mkdirSync, existsSync } from "fs";
+import { join } from "path";
+function exportMemories(db, dirPath, opts) {
+  const agentId = opts?.agent_id ?? "default";
+  if (!existsSync(dirPath)) mkdirSync(dirPath, { recursive: true });
+  let exported = 0;
+  const files = [];
+  const identities = listMemories(db, { agent_id: agentId, type: "identity" });
+  const knowledge = listMemories(db, { agent_id: agentId, type: "knowledge" });
+  const emotions = listMemories(db, { agent_id: agentId, type: "emotion" });
+  if (identities.length || knowledge.length || emotions.length) {
+    const sections = ["# Agent Memory Export\n"];
+    if (identities.length) {
+      sections.push("## Identity\n");
+      for (const m of identities) {
+        sections.push(`- ${m.content}
+`);
+        exported++;
+      }
+    }
+    if (emotions.length) {
+      sections.push("\n## Emotions\n");
+      for (const m of emotions) {
+        sections.push(`- ${m.content}
+`);
+        exported++;
+      }
+    }
+    if (knowledge.length) {
+      sections.push("\n## Knowledge\n");
+      for (const m of knowledge) {
+        sections.push(`- ${m.content}
+`);
+        exported++;
+      }
+    }
+    const memoryPath = join(dirPath, "MEMORY.md");
+    writeFileSync(memoryPath, sections.join("\n"));
+    files.push(memoryPath);
+  }
+  const events = listMemories(db, { agent_id: agentId, type: "event", limit: 1e4 });
+  const byDate = /* @__PURE__ */ new Map();
+  for (const ev of events) {
+    const date = ev.created_at.slice(0, 10);
+    if (!byDate.has(date)) byDate.set(date, []);
+    byDate.get(date).push(ev);
+  }
+  for (const [date, mems] of byDate) {
+    const lines = [`# ${date}
+`];
+    for (const m of mems) {
+      lines.push(`- ${m.content}
+`);
+      exported++;
+    }
+    const filePath = join(dirPath, `${date}.md`);
+    writeFileSync(filePath, lines.join("\n"));
+    files.push(filePath);
+  }
+  return { exported, files };
 }
 
 // src/search/bm25.ts
@@ -455,12 +847,15 @@ function searchBM25(db, query, opts) {
          ORDER BY rank
          LIMIT ?`
     ).all(ftsQuery, agentId, minVitality, limit);
-    return rows.map((row) => ({
-      memory: { ...row, score: void 0 },
-      score: Math.abs(row.score),
-      // FTS5 rank is negative (lower = better)
-      matchReason: "bm25"
-    }));
+    return rows.map((row) => {
+      const { score: _score, ...memoryFields } = row;
+      return {
+        memory: memoryFields,
+        score: Math.abs(row.score),
+        // FTS5 rank is negative (lower = better)
+        matchReason: "bm25"
+      };
+    });
   } catch {
     return searchSimple(db, query, agentId, minVitality, limit);
   }
@@ -480,52 +875,76 @@ function searchSimple(db, query, agentId, minVitality, limit) {
   }));
 }
 function buildFtsQuery(text) {
-  const words = text.replace(/[^\w\u4e00-\u9fff\u3040-\u30ff\s]/g, " ").split(/\s+/).filter((w) => w.length > 1).slice(0, 10);
-  if (words.length === 0) return null;
-  return words.map((w) => `"${w}"`).join(" OR ");
+  const tokens = tokenize(text);
+  if (tokens.length === 0) return null;
+  return tokens.map((w) => `"${w}"`).join(" OR ");
 }
 
 // src/search/intent.ts
 var INTENT_PATTERNS = {
   factual: [
-    /^(what|who|where|which|how much|how many)/i,
-    /是(什么|谁|哪)/,
-    /叫什么/,
-    /名字/,
-    /地址/,
-    /号码/,
-    /密码/,
-    /配置/,
-    /设置/
+    // English
+    /^(what|who|where|which|how much|how many)\b/i,
+    /\b(name|address|number|password|config|setting)\b/i,
+    // Chinese - questions about facts
+    /是(什么|谁|哪|啥)/,
+    /叫(什么|啥)/,
+    /(名字|地址|号码|密码|配置|设置|账号|邮箱|链接|版本)/,
+    /(多少|几个|哪个|哪些|哪里)/,
+    // Chinese - lookup patterns
+    /(查一下|找一下|看看|搜一下)/,
+    /(.+)是什么$/
   ],
   temporal: [
-    /^(when|what time|how long)/i,
-    /(yesterday|today|last week|recently|ago|before|after)/i,
+    // English
+    /^(when|what time|how long)\b/i,
+    /\b(yesterday|today|tomorrow|last week|recently|ago|before|after)\b/i,
+    /\b(first|latest|newest|oldest|previous|next)\b/i,
+    // Chinese - time expressions
     /什么时候/,
-    /(昨天|今天|上周|最近|以前|之前|之后)/,
-    /\d{4}[-/]\d{1,2}/,
-    /(几月|几号|几点)/
+    /(昨天|今天|明天|上周|下周|最近|以前|之前|之后|刚才|刚刚)/,
+    /(几月|几号|几点|多久|多长时间)/,
+    /(上次|下次|第一次|最后一次|那天|那时)/,
+    // Date patterns
+    /\d{4}[-/.]\d{1,2}/,
+    /\d{1,2}月\d{1,2}[日号]/,
+    // Chinese - temporal context
+    /(历史|记录|日志|以来|至今|期间)/
   ],
   causal: [
-    /^(why|how come|what caused)/i,
-    /^(because|due to|reason)/i,
-    /为什么/,
-    /原因/,
-    /导致/,
-    /怎么回事/,
-    /为啥/
+    // English
+    /^(why|how come|what caused)\b/i,
+    /\b(because|due to|reason|cause|result)\b/i,
+    // Chinese - causal questions
+    /为(什么|啥|何)/,
+    /(原因|导致|造成|引起|因为|所以|结果)/,
+    /(怎么回事|怎么了|咋回事|咋了)/,
+    /(为啥|凭啥|凭什么)/,
+    // Chinese - problem/diagnosis
+    /(出(了|了什么)?问题|报错|失败|出错|bug)/
   ],
   exploratory: [
-    /^(how|tell me about|explain|describe)/i,
-    /^(what do you think|what about)/i,
-    /怎么样/,
-    /介绍/,
-    /说说/,
-    /讲讲/,
-    /有哪些/,
-    /关于/
+    // English
+    /^(how|tell me about|explain|describe|show me)\b/i,
+    /^(what do you think|what about|any)\b/i,
+    /\b(overview|summary|list|compare)\b/i,
+    // Chinese - exploratory
+    /(怎么样|怎样|如何)/,
+    /(介绍|说说|讲讲|聊聊|谈谈)/,
+    /(有哪些|有什么|有没有)/,
+    /(关于|对于|至于|关联)/,
+    /(总结|概括|梳理|回顾|盘点)/,
+    // Chinese - opinion/analysis
+    /(看法|想法|意见|建议|评价|感觉|觉得)/,
+    /(对比|比较|区别|差异|优缺点)/
   ]
 };
+var CN_STRUCTURE_BOOSTS = {
+  factual: [/^.{1,6}(是什么|叫什么|在哪)/, /^(谁|哪)/],
+  temporal: [/^(什么时候|上次|最近)/, /(时间|日期)$/],
+  causal: [/^(为什么|为啥)/, /(为什么|怎么回事)$/],
+  exploratory: [/^(怎么|如何|说说)/, /(哪些|什么样)$/]
+};
 function classifyIntent(query) {
   const scores = {
     factual: 0,
@@ -540,6 +959,18 @@ function classifyIntent(query) {
       }
     }
   }
+  for (const [intent, patterns] of Object.entries(CN_STRUCTURE_BOOSTS)) {
+    for (const pattern of patterns) {
+      if (pattern.test(query)) {
+        scores[intent] += 0.5;
+      }
+    }
+  }
+  const tokens = tokenize(query);
+  const totalPatternScore = Object.values(scores).reduce((a, b) => a + b, 0);
+  if (totalPatternScore === 0 && tokens.length <= 3) {
+    scores.factual += 1;
+  }
   let maxIntent = "factual";
   let maxScore = 0;
   for (const [intent, score] of Object.entries(scores)) {
@@ -549,7 +980,7 @@ function classifyIntent(query) {
     }
   }
   const totalScore = Object.values(scores).reduce((a, b) => a + b, 0);
-  const confidence = totalScore > 0 ? maxScore / totalScore : 0.5;
+  const confidence = totalScore > 0 ? Math.min(0.95, maxScore / totalScore) : 0.5;
   return { intent: maxIntent, confidence };
 }
 function getStrategy(intent) {
@@ -566,6 +997,26 @@ function getStrategy(intent) {
 }
 
 // src/search/rerank.ts
+async function rerankWithProvider(results, query, provider) {
+  if (results.length === 0) return results;
+  const documents = results.map((r) => r.memory.content);
+  try {
+    const apiResults = await provider.rerank(query, documents);
+    const scoreMap = new Map(apiResults.map((r) => [r.index, r.relevance_score]));
+    return results.map((r, i) => {
+      const score = scoreMap.get(i);
+      if (score === void 0) return r;
+      return {
+        ...r,
+        score,
+        matchReason: `${r.matchReason}+rerank`
+      };
+    });
+  } catch (err) {
+    console.warn("[agent-memory] External rerank failed, falling back:", err);
+    return results;
+  }
+}
 function rerank(results, opts) {
   const now2 = Date.now();
   const scored = results.map((r) => {
@@ -587,6 +1038,347 @@ function rerank(results, opts) {
   return scored.slice(0, opts.limit);
 }
 
+// src/search/embeddings.ts
+function encodeEmbedding(vector) {
+  const arr = vector instanceof Float32Array ? vector : Float32Array.from(vector);
+  return Buffer.from(arr.buffer, arr.byteOffset, arr.byteLength);
+}
+function decodeEmbedding(buf) {
+  const copy = Buffer.from(buf);
+  return new Float32Array(copy.buffer, copy.byteOffset, Math.floor(copy.byteLength / 4));
+}
+function upsertEmbedding(db, input) {
+  const ts = now();
+  const vec = input.vector instanceof Float32Array ? input.vector : Float32Array.from(input.vector);
+  const blob = encodeEmbedding(vec);
+  db.prepare(
+    `INSERT INTO embeddings (agent_id, memory_id, model, dim, vector, created_at, updated_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?)
+     ON CONFLICT(agent_id, memory_id, model) DO UPDATE SET
+       dim = excluded.dim,
+       vector = excluded.vector,
+       updated_at = excluded.updated_at`
+  ).run(input.agent_id, input.memory_id, input.model, vec.length, blob, ts, ts);
+}
+function getEmbedding(db, agent_id, memory_id, model) {
+  const row = db.prepare(
+    "SELECT agent_id, memory_id, model, dim, vector, created_at, updated_at FROM embeddings WHERE agent_id = ? AND memory_id = ? AND model = ?"
+  ).get(agent_id, memory_id, model);
+  if (!row) return null;
+  return { ...row, vector: decodeEmbedding(row.vector) };
+}
+function listEmbeddings(db, agent_id, model) {
+  const rows = db.prepare(
+    "SELECT memory_id, vector FROM embeddings WHERE agent_id = ? AND model = ?"
+  ).all(agent_id, model);
+  return rows.map((r) => ({ memory_id: r.memory_id, vector: decodeEmbedding(r.vector) }));
+}
+
+// src/search/hybrid.ts
+function cosine(a, b) {
+  const n = Math.min(a.length, b.length);
+  let dot = 0;
+  let na = 0;
+  let nb = 0;
+  for (let i = 0; i < n; i++) {
+    const x = a[i];
+    const y = b[i];
+    dot += x * y;
+    na += x * x;
+    nb += y * y;
+  }
+  if (na === 0 || nb === 0) return 0;
+  return dot / (Math.sqrt(na) * Math.sqrt(nb));
+}
+function rrfScore(rank, k) {
+  return 1 / (k + rank);
+}
+function fuseRrf(lists, k) {
+  const out = /* @__PURE__ */ new Map();
+  for (const list of lists) {
+    for (let i = 0; i < list.items.length; i++) {
+      const it = list.items[i];
+      const rank = i + 1;
+      const add = rrfScore(rank, k);
+      const prev = out.get(it.id);
+      if (!prev) out.set(it.id, { score: add, sources: [list.name] });
+      else {
+        prev.score += add;
+        if (!prev.sources.includes(list.name)) prev.sources.push(list.name);
+      }
+    }
+  }
+  return out;
+}
+function fetchMemories(db, ids, agentId) {
+  if (ids.length === 0) return [];
+  const placeholders = ids.map(() => "?").join(", ");
+  const sql = agentId ? `SELECT * FROM memories WHERE id IN (${placeholders}) AND agent_id = ?` : `SELECT * FROM memories WHERE id IN (${placeholders})`;
+  const rows = db.prepare(sql).all(...agentId ? [...ids, agentId] : ids);
+  return rows;
+}
+async function searchHybrid(db, query, opts) {
+  const agentId = opts?.agent_id ?? "default";
+  const limit = opts?.limit ?? 10;
+  const bm25Mult = opts?.bm25CandidateMultiplier ?? 3;
+  const semanticCandidates = opts?.semanticCandidates ?? 50;
+  const rrfK = opts?.rrfK ?? 60;
+  const bm25 = searchBM25(db, query, {
+    agent_id: agentId,
+    limit: limit * bm25Mult
+  });
+  const provider = opts?.embeddingProvider ?? null;
+  const model = opts?.embeddingModel ?? provider?.model;
+  if (!provider || !model) {
+    return bm25.slice(0, limit);
+  }
+  const embedFn = provider.embedQuery ?? provider.embed;
+  const qVec = Float32Array.from(await embedFn.call(provider, query));
+  const embeddings = listEmbeddings(db, agentId, model);
+  const scored = [];
+  for (const e of embeddings) {
+    scored.push({ id: e.memory_id, score: cosine(qVec, e.vector) });
+  }
+  scored.sort((a, b) => b.score - a.score);
+  const semanticTop = scored.slice(0, semanticCandidates);
+  const fused = fuseRrf(
+    [
+      { name: "bm25", items: bm25.map((r) => ({ id: r.memory.id, score: r.score })) },
+      { name: "semantic", items: semanticTop }
+    ],
+    rrfK
+  );
+  const ids = [...fused.keys()];
+  const memories = fetchMemories(db, ids, agentId);
+  const byId = new Map(memories.map((m) => [m.id, m]));
+  const out = [];
+  for (const [id, meta] of fused) {
+    const mem = byId.get(id);
+    if (!mem) continue;
+    out.push({
+      memory: mem,
+      score: meta.score,
+      matchReason: meta.sources.sort().join("+")
+    });
+  }
+  out.sort((a, b) => b.score - a.score);
+  return out.slice(0, limit);
+}
+
+// src/search/providers.ts
+var QWEN_DEFAULT_INSTRUCTION = "Given a query, retrieve the most semantically relevant document";
+function getDefaultInstruction(model) {
+  const m = model.toLowerCase();
+  if (m.includes("qwen")) return QWEN_DEFAULT_INSTRUCTION;
+  if (m.includes("gemini")) return null;
+  return null;
+}
+function resolveInstruction(model) {
+  const override = process.env.AGENT_MEMORY_EMBEDDINGS_INSTRUCTION;
+  if (override !== void 0) {
+    const normalized = override.trim();
+    if (!normalized) return null;
+    const lowered = normalized.toLowerCase();
+    if (lowered === "none" || lowered === "off" || lowered === "false" || lowered === "null") return null;
+    return normalized;
+  }
+  return getDefaultInstruction(model);
+}
+function buildQueryInput(query, instructionPrefix) {
+  if (!instructionPrefix) return query;
+  return `Instruct: ${instructionPrefix}
+Query: ${query}`;
+}
+function getEmbeddingProviderFromEnv() {
+  const provider = (process.env.AGENT_MEMORY_EMBEDDINGS_PROVIDER ?? "none").toLowerCase();
+  if (provider === "none" || provider === "off" || provider === "false") return null;
+  if (provider === "openai") {
+    const apiKey = process.env.OPENAI_API_KEY;
+    const model = process.env.AGENT_MEMORY_EMBEDDINGS_MODEL ?? "text-embedding-3-small";
+    const baseUrl = process.env.OPENAI_BASE_URL ?? "https://api.openai.com/v1";
+    if (!apiKey) return null;
+    const instruction = resolveInstruction(model);
+    return createOpenAIProvider({ apiKey, model, baseUrl, instruction });
+  }
+  if (provider === "gemini" || provider === "google") {
+    const apiKey = process.env.GEMINI_API_KEY ?? process.env.OPENAI_API_KEY;
+    const model = process.env.AGENT_MEMORY_EMBEDDINGS_MODEL ?? "gemini-embedding-001";
+    const baseUrl = process.env.GEMINI_BASE_URL ?? process.env.OPENAI_BASE_URL ?? "https://generativelanguage.googleapis.com/v1beta";
+    if (!apiKey) return null;
+    const instruction = resolveInstruction(model);
+    return createOpenAIProvider({ id: "gemini", apiKey, model, baseUrl, instruction });
+  }
+  if (provider === "qwen" || provider === "dashscope" || provider === "tongyi") {
+    const apiKey = process.env.DASHSCOPE_API_KEY;
+    const model = process.env.AGENT_MEMORY_EMBEDDINGS_MODEL ?? "text-embedding-v3";
+    const baseUrl = process.env.DASHSCOPE_BASE_URL ?? "https://dashscope.aliyuncs.com";
+    if (!apiKey) return null;
+    const instruction = resolveInstruction(model);
+    return createDashScopeProvider({ apiKey, model, baseUrl, instruction });
+  }
+  return null;
+}
+function authHeader(apiKey) {
+  return apiKey.startsWith("Bearer ") ? apiKey : `Bearer ${apiKey}`;
+}
+function normalizeEmbedding(e) {
+  if (!Array.isArray(e)) throw new Error("Invalid embedding: not an array");
+  if (e.length === 0) throw new Error("Invalid embedding: empty");
+  return e.map((x) => {
+    if (typeof x !== "number" || !Number.isFinite(x)) throw new Error("Invalid embedding: non-numeric value");
+    return x;
+  });
+}
+function createOpenAIProvider(opts) {
+  const baseUrl = opts.baseUrl ?? "https://api.openai.com/v1";
+  const instructionPrefix = opts.instruction ?? null;
+  async function requestEmbedding(input) {
+    const resp = await fetch(`${baseUrl.replace(/\/$/, "")}/embeddings`, {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        authorization: authHeader(opts.apiKey)
+      },
+      body: JSON.stringify({ model: opts.model, input })
+    });
+    if (!resp.ok) {
+      const body = await resp.text().catch(() => "");
+      throw new Error(`OpenAI embeddings failed: ${resp.status} ${resp.statusText} ${body}`.trim());
+    }
+    const data = await resp.json();
+    return normalizeEmbedding(data.data?.[0]?.embedding);
+  }
+  return {
+    id: opts.id ?? "openai",
+    model: opts.model,
+    instructionPrefix,
+    async embed(text) {
+      return requestEmbedding(text);
+    },
+    async embedQuery(query) {
+      return requestEmbedding(buildQueryInput(query, instructionPrefix));
+    }
+  };
+}
+function createDashScopeProvider(opts) {
+  const baseUrl = opts.baseUrl ?? "https://dashscope.aliyuncs.com";
+  const instructionPrefix = opts.instruction ?? null;
+  async function requestEmbedding(text) {
+    const resp = await fetch(`${baseUrl.replace(/\/$/, "")}/api/v1/services/embeddings/text-embedding/text-embedding`, {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        authorization: authHeader(opts.apiKey)
+      },
+      body: JSON.stringify({
+        model: opts.model,
+        input: { texts: [text] }
+      })
+    });
+    if (!resp.ok) {
+      const body = await resp.text().catch(() => "");
+      throw new Error(`DashScope embeddings failed: ${resp.status} ${resp.statusText} ${body}`.trim());
+    }
+    const data = await resp.json();
+    const emb = data.output?.embeddings?.[0]?.embedding ?? data.output?.embeddings?.[0]?.vector ?? data.output?.embedding ?? data.data?.[0]?.embedding;
+    return normalizeEmbedding(emb);
+  }
+  return {
+    id: "dashscope",
+    model: opts.model,
+    instructionPrefix,
+    async embed(text) {
+      return requestEmbedding(text);
+    },
+    async embedQuery(query) {
+      return requestEmbedding(buildQueryInput(query, instructionPrefix));
+    }
+  };
+}
+
+// src/search/rerank-provider.ts
+function authHeader2(apiKey) {
+  return apiKey.startsWith("Bearer ") ? apiKey : `Bearer ${apiKey}`;
+}
+function getRerankerProviderFromEnv() {
+  const provider = (process.env.AGENT_MEMORY_RERANK_PROVIDER ?? "none").toLowerCase();
+  if (provider === "none" || provider === "off") return null;
+  if (provider === "openai" || provider === "jina" || provider === "cohere") {
+    const apiKey = process.env.AGENT_MEMORY_RERANK_API_KEY ?? process.env.OPENAI_API_KEY;
+    const model = process.env.AGENT_MEMORY_RERANK_MODEL ?? "Qwen/Qwen3-Reranker-8B";
+    const baseUrl = process.env.AGENT_MEMORY_RERANK_BASE_URL ?? process.env.OPENAI_BASE_URL ?? "https://api.openai.com/v1";
+    if (!apiKey) return null;
+    return createOpenAIRerankProvider({ apiKey, model, baseUrl });
+  }
+  return null;
+}
+function createOpenAIRerankProvider(opts) {
+  const baseUrl = opts.baseUrl ?? "https://api.openai.com/v1";
+  return {
+    id: "openai-rerank",
+    model: opts.model,
+    async rerank(query, documents) {
+      const resp = await fetch(`${baseUrl.replace(/\/$/, "")}/rerank`, {
+        method: "POST",
+        headers: {
+          "content-type": "application/json",
+          authorization: authHeader2(opts.apiKey)
+        },
+        body: JSON.stringify({ model: opts.model, query, documents })
+      });
+      if (!resp.ok) {
+        const body = await resp.text().catch(() => "");
+        throw new Error(`Rerank API failed: ${resp.status} ${resp.statusText} ${body}`.trim());
+      }
+      const data = await resp.json();
+      const results = data.results ?? [];
+      return results.map((r) => {
+        const index = typeof r.index === "number" ? r.index : Number.NaN;
+        const relevance = typeof r.relevance_score === "number" ? r.relevance_score : Number.NaN;
+        return { index, relevance_score: relevance };
+      }).filter((r) => Number.isInteger(r.index) && Number.isFinite(r.relevance_score));
+    }
+  };
+}
+
+// src/search/embed.ts
+async function embedMemory(db, memoryId, provider, opts) {
+  const row = db.prepare("SELECT id, agent_id, content FROM memories WHERE id = ?").get(memoryId);
+  if (!row) return false;
+  if (opts?.agent_id && row.agent_id !== opts.agent_id) return false;
+  const model = opts?.model ?? provider.model;
+  const maxChars = opts?.maxChars ?? 2e3;
+  const text = row.content.length > maxChars ? row.content.slice(0, maxChars) : row.content;
+  const vector = await provider.embed(text);
+  upsertEmbedding(db, {
+    agent_id: row.agent_id,
+    memory_id: row.id,
+    model,
+    vector
+  });
+  return true;
+}
+async function embedMissingForAgent(db, provider, opts) {
+  const agentId = opts?.agent_id ?? "default";
+  const model = opts?.model ?? provider.model;
+  const limit = opts?.limit ?? 1e3;
+  const rows = db.prepare(
+    `SELECT m.id
+     FROM memories m
+     LEFT JOIN embeddings e
+       ON e.memory_id = m.id AND e.agent_id = m.agent_id AND e.model = ?
+     WHERE m.agent_id = ? AND e.memory_id IS NULL
+     ORDER BY m.updated_at DESC
+     LIMIT ?`
+  ).all(model, agentId, limit);
+  let embedded = 0;
+  for (const r of rows) {
+    const ok = await embedMemory(db, r.id, provider, { agent_id: agentId, model, maxChars: opts?.maxChars });
+    if (ok) embedded++;
+  }
+  return { embedded, scanned: rows.length };
+}
+
 // src/sleep/decay.ts
 var MIN_VITALITY = {
   0: 1,
@@ -598,25 +1390,28 @@ var MIN_VITALITY = {
   3: 0
   // P3: event — full decay
 };
-function calculateVitality(stability, daysSinceCreation, priority) {
+function calculateVitality(stability, daysSinceLastAccess, priority) {
   if (priority === 0) return 1;
   const S = Math.max(0.01, stability);
-  const retention = Math.exp(-daysSinceCreation / S);
+  const retention = Math.exp(-daysSinceLastAccess / S);
   const minVit = MIN_VITALITY[priority] ?? 0;
   return Math.max(minVit, retention);
 }
-function runDecay(db) {
+function runDecay(db, opts) {
   const currentTime = now();
   const currentMs = new Date(currentTime).getTime();
-  const memories = db.prepare("SELECT id, priority, stability, created_at, vitality FROM memories WHERE priority > 0").all();
+  const agentId = opts?.agent_id;
+  const query = agentId ? "SELECT id, priority, stability, created_at, last_accessed, vitality FROM memories WHERE priority > 0 AND agent_id = ?" : "SELECT id, priority, stability, created_at, last_accessed, vitality FROM memories WHERE priority > 0";
+  const memories = db.prepare(query).all(...agentId ? [agentId] : []);
   let updated = 0;
   let decayed = 0;
   let belowThreshold = 0;
   const updateStmt = db.prepare("UPDATE memories SET vitality = ?, updated_at = ? WHERE id = ?");
   const transaction = db.transaction(() => {
     for (const mem of memories) {
-      const createdMs = new Date(mem.created_at).getTime();
-      const daysSince = (currentMs - createdMs) / (1e3 * 60 * 60 * 24);
+      const referenceTime = mem.last_accessed ?? mem.created_at;
+      const referenceMs = new Date(referenceTime).getTime();
+      const daysSince = (currentMs - referenceMs) / (1e3 * 60 * 60 * 24);
       const newVitality = calculateVitality(mem.stability, daysSince, mem.priority);
       if (Math.abs(newVitality - mem.vitality) > 1e-3) {
         updateStmt.run(newVitality, currentTime, mem.id);
@@ -633,12 +1428,15 @@ function runDecay(db) {
   transaction();
   return { updated, decayed, belowThreshold };
 }
-function getDecayedMemories(db, threshold = 0.05) {
+function getDecayedMemories(db, threshold = 0.05, opts) {
+  const agentId = opts?.agent_id;
   return db.prepare(
-    `SELECT id, content, vitality, priority FROM memories
-       WHERE vitality < ? AND priority >= 3
-       ORDER BY vitality ASC`
-  ).all(threshold);
+    agentId ? `SELECT id, content, vitality, priority FROM memories
+           WHERE vitality < ? AND priority >= 3 AND agent_id = ?
+           ORDER BY vitality ASC` : `SELECT id, content, vitality, priority FROM memories
+           WHERE vitality < ? AND priority >= 3
+           ORDER BY vitality ASC`
+  ).all(...agentId ? [threshold, agentId] : [threshold]);
 }
 
 // src/sleep/sync.ts
@@ -698,11 +1496,12 @@ function syncBatch(db, inputs) {
 function runTidy(db, opts) {
   const threshold = opts?.vitalityThreshold ?? 0.05;
   const maxSnapshots = opts?.maxSnapshotsPerMemory ?? 10;
+  const agentId = opts?.agent_id;
   let archived = 0;
   let orphansCleaned = 0;
   let snapshotsPruned = 0;
   const transaction = db.transaction(() => {
-    const decayed = getDecayedMemories(db, threshold);
+    const decayed = getDecayedMemories(db, threshold, agentId ? { agent_id: agentId } : void 0);
     for (const mem of decayed) {
       try {
         createSnapshot(db, mem.id, "delete", "tidy");
@@ -711,13 +1510,23 @@ function runTidy(db, opts) {
       deleteMemory(db, mem.id);
       archived++;
     }
-    const orphans = db.prepare(
-      `DELETE FROM paths WHERE memory_id NOT IN (SELECT id FROM memories)`
+    const orphans = agentId ? db.prepare(
+      `DELETE FROM paths
+         WHERE agent_id = ?
+           AND memory_id NOT IN (SELECT id FROM memories WHERE agent_id = ?)`
+    ).run(agentId, agentId) : db.prepare(
+      "DELETE FROM paths WHERE memory_id NOT IN (SELECT id FROM memories)"
     ).run();
     orphansCleaned = orphans.changes;
-    const memoriesWithSnapshots = db.prepare(
+    const memoriesWithSnapshots = agentId ? db.prepare(
+      `SELECT s.memory_id, COUNT(*) as cnt
+           FROM snapshots s
+           JOIN memories m ON m.id = s.memory_id
+           WHERE m.agent_id = ?
+           GROUP BY s.memory_id HAVING cnt > ?`
+    ).all(agentId, maxSnapshots) : db.prepare(
       `SELECT memory_id, COUNT(*) as cnt FROM snapshots
-         GROUP BY memory_id HAVING cnt > ?`
+           GROUP BY memory_id HAVING cnt > ?`
     ).all(maxSnapshots);
     for (const { memory_id } of memoriesWithSnapshots) {
       const pruned = db.prepare(
@@ -734,20 +1543,31 @@ function runTidy(db, opts) {
 }
 
 // src/sleep/govern.ts
-function runGovern(db) {
+function runGovern(db, opts) {
+  const agentId = opts?.agent_id;
   let orphanPaths = 0;
   let orphanLinks = 0;
   let emptyMemories = 0;
   const transaction = db.transaction(() => {
-    const pathResult = db.prepare("DELETE FROM paths WHERE memory_id NOT IN (SELECT id FROM memories)").run();
+    const pathResult = agentId ? db.prepare(
+      `DELETE FROM paths
+         WHERE agent_id = ?
+           AND memory_id NOT IN (SELECT id FROM memories WHERE agent_id = ?)`
+    ).run(agentId, agentId) : db.prepare("DELETE FROM paths WHERE memory_id NOT IN (SELECT id FROM memories)").run();
     orphanPaths = pathResult.changes;
-    const linkResult = db.prepare(
+    const linkResult = agentId ? db.prepare(
+      `DELETE FROM links WHERE
+         agent_id = ? AND (
+           source_id NOT IN (SELECT id FROM memories WHERE agent_id = ?) OR
+           target_id NOT IN (SELECT id FROM memories WHERE agent_id = ?)
+         )`
+    ).run(agentId, agentId, agentId) : db.prepare(
       `DELETE FROM links WHERE
          source_id NOT IN (SELECT id FROM memories) OR
          target_id NOT IN (SELECT id FROM memories)`
     ).run();
     orphanLinks = linkResult.changes;
-    const emptyResult = db.prepare("DELETE FROM memories WHERE TRIM(content) = ''").run();
+    const emptyResult = agentId ? db.prepare("DELETE FROM memories WHERE agent_id = ? AND TRIM(content) = ''").run(agentId) : db.prepare("DELETE FROM memories WHERE TRIM(content) = ''").run();
     emptyMemories = emptyResult.changes;
   });
   transaction();
@@ -771,7 +1591,7 @@ function boot(db, opts) {
   }
   const bootPaths = [];
   for (const uri of corePaths) {
-    const path = getPathByUri(db, uri);
+    const path = getPathByUri(db, uri, agentId);
     if (path) {
       bootPaths.push(uri);
       if (!memories.has(path.memory_id)) {
@@ -783,13 +1603,13 @@ function boot(db, opts) {
       }
     }
   }
-  const bootEntry = getPathByUri(db, "system://boot");
+  const bootEntry = getPathByUri(db, "system://boot", agentId);
   if (bootEntry) {
     const bootMem = getMemory(db, bootEntry.memory_id);
     if (bootMem) {
       const additionalUris = bootMem.content.split("\n").map((l) => l.trim()).filter((l) => l.match(/^[a-z]+:\/\//));
       for (const uri of additionalUris) {
-        const path = getPathByUri(db, uri);
+        const path = getPathByUri(db, uri, agentId);
         if (path && !memories.has(path.memory_id)) {
           const mem = getMemory(db, path.memory_id);
           if (mem) {
@@ -811,14 +1631,25 @@ export {
   classifyIntent,
   contentHash,
   countMemories,
+  createDashScopeProvider,
   createLink,
   createMemory,
+  createOpenAIProvider,
+  createOpenAIRerankProvider,
   createPath,
   createSnapshot,
+  decodeEmbedding,
   deleteLink,
   deleteMemory,
   deletePath,
+  embedMemory,
+  embedMissingForAgent,
+  encodeEmbedding,
+  exportMemories,
   getDecayedMemories,
+  getDefaultInstruction,
+  getEmbedding,
+  getEmbeddingProviderFromEnv,
   getLinks,
   getMemory,
   getOutgoingLinks,
@@ -827,23 +1658,30 @@ export {
   getPathsByDomain,
   getPathsByMemory,
   getPathsByPrefix,
+  getRerankerProviderFromEnv,
   getSnapshot,
   getSnapshots,
   getStrategy,
   guard,
+  isCountRow,
+  listEmbeddings,
   listMemories,
   openDatabase,
   parseUri,
   recordAccess,
   rerank,
+  rerankWithProvider,
   rollback,
   runDecay,
   runGovern,
   runTidy,
   searchBM25,
+  searchHybrid,
   syncBatch,
   syncOne,
+  tokenize,
   traverse,
-  updateMemory
+  updateMemory,
+  upsertEmbedding
 };
 //# sourceMappingURL=index.js.map