@smyslenny/agent-memory 2.0.0 → 2.2.0

package/dist/mcp/server.js

@@ -20,13 +20,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() {
@@ -35,11 +39,177 @@ 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;
+  }
+}
 var SCHEMA_VERSION, SCHEMA_SQL;
 var init_db = __esm({
   "src/core/db.ts"() {
     "use strict";
-    SCHEMA_VERSION = 1;
+    SCHEMA_VERSION = 3;
     SCHEMA_SQL = `
 -- Memory entries
 CREATE TABLE IF NOT EXISTS memories (
@@ -64,20 +234,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)
@@ -97,6 +270,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,
@@ -111,12 +296,94 @@ 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);
 `;
   }
 });
 
+// src/search/tokenizer.ts
+import { readFileSync } from "fs";
+import { createRequire } from "module";
+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;
+}
+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(" ");
+}
+var _jieba, STOPWORDS;
+var init_tokenizer = __esm({
+  "src/search/tokenizer.ts"() {
+    "use strict";
+    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"
+    ]);
+  }
+});
+
 // src/core/memory.ts
 var memory_exports = {};
 __export(memory_exports, {
@@ -161,7 +428,7 @@ function createMemory(db, input) {
     agentId,
     hash2
   );
-  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) {
@@ -206,7 +473,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);
 }
@@ -263,6 +530,7 @@ var init_memory = __esm({
   "src/core/memory.ts"() {
     "use strict";
     init_db();
+    init_tokenizer();
     TYPE_PRIORITY = {
       identity: 0,
       emotion: 1,
@@ -14066,45 +14334,60 @@ 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: domain2 } = parseUri(uri);
   const domains = validDomains ?? DEFAULT_DOMAINS;
   if (!domains.has(domain2)) {
     throw new Error(`Invalid domain "${domain2}". 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, domain2, now());
+    "INSERT INTO paths (id, memory_id, agent_id, uri, alias, domain, created_at) VALUES (?, ?, ?, ?, ?, ?, ?)"
+  ).run(id, memoryId, agentId, uri, alias ?? null, domain2, 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 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}%`);
 }
 
 // src/core/link.ts
 init_db();
-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 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 = [
@@ -14118,7 +14401,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({
@@ -14128,7 +14411,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({
@@ -14145,6 +14428,7 @@ function traverse(db, startId, maxHops = 2) {
 
 // src/core/snapshot.ts
 init_db();
+init_tokenizer();
 function createSnapshot(db, memoryId, action, changedBy) {
   const memory = db.prepare("SELECT content FROM memories WHERE id = ?").get(memoryId);
   if (!memory) throw new Error(`Memory not found: ${memoryId}`);
@@ -14173,100 +14457,77 @@ 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;
 }
 
-// src/search/bm25.ts
-function searchBM25(db, query, opts) {
-  const limit = opts?.limit ?? 20;
-  const agentId = opts?.agent_id ?? "default";
-  const minVitality = opts?.min_vitality ?? 0;
-  const ftsQuery = buildFtsQuery(query);
-  if (!ftsQuery) return [];
-  try {
-    const rows = db.prepare(
-      `SELECT m.*, rank AS score
-         FROM memories_fts f
-         JOIN memories m ON m.id = f.id
-         WHERE memories_fts MATCH ?
-           AND m.agent_id = ?
-           AND m.vitality >= ?
-         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"
-    }));
-  } catch {
-    return searchSimple(db, query, agentId, minVitality, limit);
-  }
-}
-function searchSimple(db, query, agentId, minVitality, limit) {
-  const rows = db.prepare(
-    `SELECT * FROM memories
-       WHERE agent_id = ? AND vitality >= ? AND content LIKE ?
-       ORDER BY priority ASC, updated_at DESC
-       LIMIT ?`
-  ).all(agentId, minVitality, `%${query}%`, limit);
-  return rows.map((m, i) => ({
-    memory: m,
-    score: 1 / (i + 1),
-    // Simple rank by position
-    matchReason: "like"
-  }));
-}
-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 ");
-}
-
 // src/search/intent.ts
+init_tokenizer();
 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,
@@ -14281,6 +14542,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)) {
@@ -14290,7 +14563,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) {
@@ -14307,6 +14580,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) => {
@@ -14328,11 +14621,379 @@ function rerank(results, opts) {
   return scored.slice(0, opts.limit);
 }
 
+// src/search/bm25.ts
+init_tokenizer();
+function searchBM25(db, query, opts) {
+  const limit = opts?.limit ?? 20;
+  const agentId = opts?.agent_id ?? "default";
+  const minVitality = opts?.min_vitality ?? 0;
+  const ftsQuery = buildFtsQuery(query);
+  if (!ftsQuery) return [];
+  try {
+    const rows = db.prepare(
+      `SELECT m.*, rank AS score
+         FROM memories_fts f
+         JOIN memories m ON m.id = f.id
+         WHERE memories_fts MATCH ?
+           AND m.agent_id = ?
+           AND m.vitality >= ?
+         ORDER BY rank
+         LIMIT ?`
+    ).all(ftsQuery, agentId, minVitality, limit);
+    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);
+  }
+}
+function searchSimple(db, query, agentId, minVitality, limit) {
+  const rows = db.prepare(
+    `SELECT * FROM memories
+       WHERE agent_id = ? AND vitality >= ? AND content LIKE ?
+       ORDER BY priority ASC, updated_at DESC
+       LIMIT ?`
+  ).all(agentId, minVitality, `%${query}%`, limit);
+  return rows.map((m, i) => ({
+    memory: m,
+    score: 1 / (i + 1),
+    // Simple rank by position
+    matchReason: "like"
+  }));
+}
+function buildFtsQuery(text) {
+  const tokens = tokenize(text);
+  if (tokens.length === 0) return null;
+  return tokens.map((w) => `"${w}"`).join(" OR ");
+}
+
+// src/search/embeddings.ts
+init_db();
+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 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, meta3] of fused) {
+    const mem = byId.get(id);
+    if (!mem) continue;
+    out.push({
+      memory: mem,
+      score: meta3.score,
+      matchReason: meta3.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;
+}
+
 // src/sleep/sync.ts
 init_memory();
 
 // src/core/guard.ts
 init_memory();
+init_tokenizer();
 function guard(db, input) {
   const hash2 = contentHash(input.content);
   const agentId = input.agent_id ?? "default";
@@ -14341,7 +15002,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",
@@ -14350,40 +15011,85 @@ 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/sleep/sync.ts
@@ -14442,25 +15148,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);
@@ -14477,12 +15186,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/tidy.ts
@@ -14490,11 +15202,12 @@ init_memory();
 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");
@@ -14503,13 +15216,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(
@@ -14526,20 +15249,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();
@@ -14564,7 +15298,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)) {
@@ -14576,13 +15310,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) {
@@ -14605,9 +15339,11 @@ var AGENT_ID = process.env.AGENT_MEMORY_AGENT_ID ?? "default";
 function createMcpServer(dbPath, agentId) {
   const db = openDatabase({ path: dbPath ?? DB_PATH });
   const aid = agentId ?? AGENT_ID;
+  const embeddingProvider = getEmbeddingProviderFromEnv();
+  const rerankerProvider = getRerankerProviderFromEnv();
   const server = new McpServer({
     name: "agent-memory",
-    version: "2.0.0"
+    version: "2.1.0"
   });
   server.tool(
     "remember",
@@ -14621,6 +15357,12 @@ function createMcpServer(dbPath, agentId) {
     },
     async ({ content, type, uri, emotion_val, source }) => {
       const result = syncOne(db, { content, type, uri, emotion_val, source, agent_id: aid });
+      if (embeddingProvider && result.memoryId && (result.action === "added" || result.action === "updated" || result.action === "merged")) {
+        try {
+          await embedMemory(db, result.memoryId, embeddingProvider, { agent_id: aid });
+        } catch {
+        }
+      }
       return {
         content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
       };
@@ -14636,7 +15378,10 @@ function createMcpServer(dbPath, agentId) {
     async ({ query, limit }) => {
       const { intent, confidence } = classifyIntent(query);
       const strategy = getStrategy(intent);
-      const raw = searchBM25(db, query, { agent_id: aid, limit: limit * 2 });
+      let raw = await searchHybrid(db, query, { agent_id: aid, embeddingProvider, limit: limit * 2 });
+      if (rerankerProvider) {
+        raw = await rerankWithProvider(raw, query, rerankerProvider);
+      }
       const results = rerank(raw, { ...strategy, limit });
       const output = {
         intent,
@@ -14666,17 +15411,18 @@ function createMcpServer(dbPath, agentId) {
       traverse_hops: external_exports.number().default(0).describe("Multi-hop graph traversal depth (0 = direct only)")
     },
     async ({ uri, traverse_hops }) => {
-      const path = getPathByUri(db, uri);
+      const path = getPathByUri(db, uri, aid);
       if (path) {
         const mem = getMemory(db, path.memory_id);
-        if (mem) {
+        if (mem && mem.agent_id === aid) {
           recordAccess(db, mem.id);
           let related = [];
           if (traverse_hops > 0) {
-            const hops = traverse(db, mem.id, traverse_hops);
+            const hops = traverse(db, mem.id, traverse_hops, aid);
             related = hops.map((h) => {
               const m = getMemory(db, h.id);
-              return { id: h.id, content: m?.content ?? "", relation: h.relation, hop: h.hop };
+              if (!m || m.agent_id !== aid) return { id: h.id, content: "", relation: h.relation, hop: h.hop };
+              return { id: h.id, content: m.content, relation: h.relation, hop: h.hop };
             });
           }
           return {
@@ -14687,11 +15433,12 @@ function createMcpServer(dbPath, agentId) {
           };
         }
       }
-      const paths = getPathsByPrefix(db, uri);
+      const paths = getPathsByPrefix(db, uri, aid);
       if (paths.length > 0) {
         const memories = paths.map((p) => {
           const m = getMemory(db, p.memory_id);
-          return { uri: p.uri, content: m?.content, type: m?.type, priority: m?.priority };
+          if (!m || m.agent_id !== aid) return { uri: p.uri, content: void 0, type: void 0, priority: void 0 };
+          return { uri: p.uri, content: m.content, type: m.type, priority: m.priority };
         });
         return {
           content: [{
@@ -14731,7 +15478,7 @@ function createMcpServer(dbPath, agentId) {
     },
     async ({ id, hard }) => {
       const mem = getMemory(db, id);
-      if (!mem) return { content: [{ type: "text", text: '{"error": "Memory not found"}' }] };
+      if (!mem || mem.agent_id !== aid) return { content: [{ type: "text", text: '{"error": "Memory not found"}' }] };
       if (hard) {
         createSnapshot(db, id, "delete", "forget");
         const { deleteMemory: deleteMemory2 } = await Promise.resolve().then(() => (init_memory(), memory_exports));
@@ -14759,18 +15506,19 @@ function createMcpServer(dbPath, agentId) {
     },
     async ({ action, source_id, target_id, relation, max_hops }) => {
       if (action === "create" && source_id && target_id && relation) {
-        const link = createLink(db, source_id, target_id, relation);
+        const link = createLink(db, source_id, target_id, relation, 1, aid);
         return { content: [{ type: "text", text: JSON.stringify({ created: link }) }] };
       }
       if (action === "query" && source_id) {
-        const links = getLinks(db, source_id);
+        const links = getLinks(db, source_id, aid);
         return { content: [{ type: "text", text: JSON.stringify({ links }) }] };
       }
       if (action === "traverse" && source_id) {
-        const nodes = traverse(db, source_id, max_hops);
+        const nodes = traverse(db, source_id, max_hops, aid);
         const detailed = nodes.map((n) => {
           const m = getMemory(db, n.id);
-          return { ...n, content: m?.content };
+          if (!m || m.agent_id !== aid) return { ...n, content: void 0 };
+          return { ...n, content: m.content };
         });
         return { content: [{ type: "text", text: JSON.stringify({ nodes: detailed }) }] };
       }
@@ -14787,10 +15535,16 @@ function createMcpServer(dbPath, agentId) {
     },
     async ({ action, memory_id, snapshot_id }) => {
       if (action === "list" && memory_id) {
+        const mem = getMemory(db, memory_id);
+        if (!mem || mem.agent_id !== aid) return { content: [{ type: "text", text: '{"error": "Memory not found"}' }] };
         const snaps = getSnapshots(db, memory_id);
         return { content: [{ type: "text", text: JSON.stringify({ snapshots: snaps }) }] };
       }
       if (action === "rollback" && snapshot_id) {
+        const snap = getSnapshot(db, snapshot_id);
+        if (!snap) return { content: [{ type: "text", text: '{"error": "Snapshot not found"}' }] };
+        const mem = getMemory(db, snap.memory_id);
+        if (!mem || mem.agent_id !== aid) return { content: [{ type: "text", text: '{"error": "Snapshot not found"}' }] };
         const ok = rollback(db, snapshot_id);
         return { content: [{ type: "text", text: JSON.stringify({ rolled_back: ok }) }] };
       }
@@ -14806,13 +15560,13 @@ function createMcpServer(dbPath, agentId) {
     async ({ phase }) => {
       const results = {};
       if (phase === "decay" || phase === "all") {
-        results.decay = runDecay(db);
+        results.decay = runDecay(db, { agent_id: aid });
       }
       if (phase === "tidy" || phase === "all") {
-        results.tidy = runTidy(db);
+        results.tidy = runTidy(db, { agent_id: aid });
       }
       if (phase === "govern" || phase === "all") {
-        results.govern = runGovern(db);
+        results.govern = runGovern(db, { agent_id: aid });
       }
       return { content: [{ type: "text", text: JSON.stringify(results, null, 2) }] };
     }
@@ -14824,9 +15578,14 @@ function createMcpServer(dbPath, agentId) {
     async () => {
       const stats = countMemories(db, aid);
       const lowVitality = db.prepare("SELECT COUNT(*) as c FROM memories WHERE vitality < 0.1 AND agent_id = ?").get(aid);
-      const totalSnapshots = db.prepare("SELECT COUNT(*) as c FROM snapshots").get();
-      const totalLinks = db.prepare("SELECT COUNT(*) as c FROM links").get();
-      const totalPaths = db.prepare("SELECT COUNT(*) as c FROM paths").get();
+      const totalSnapshots = db.prepare(
+        `SELECT COUNT(*) as c
+           FROM snapshots s
+           JOIN memories m ON m.id = s.memory_id
+           WHERE m.agent_id = ?`
+      ).get(aid);
+      const totalLinks = db.prepare("SELECT COUNT(*) as c FROM links WHERE agent_id = ?").get(aid);
+      const totalPaths = db.prepare("SELECT COUNT(*) as c FROM paths WHERE agent_id = ?").get(aid);
       return {
         content: [{
           type: "text",