@smyslenny/agent-memory 2.0.0 → 2.2.0

package/dist/bin/agent-memory.js

@@ -4,7 +4,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 (
@@ -29,20 +29,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)
@@ -62,6 +65,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,
@@ -76,8 +91,6 @@ 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 openDatabase(opts) {
   const db = new Database(opts.path);
@@ -87,13 +100,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() {
@@ -102,9 +119,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);
 }
@@ -152,7 +416,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) {
@@ -197,7 +461,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);
 }
@@ -250,95 +514,134 @@ function countMemories(db, agent_id = "default") {
   };
 }
 
-// src/search/bm25.ts
-function searchBM25(db, query, opts) {
-  const limit = opts?.limit ?? 20;
+// 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";
-  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);
+  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);
   }
-}
-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 ");
+  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/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,
@@ -353,6 +656,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)) {
@@ -362,7 +677,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) {
@@ -400,6 +715,346 @@ function rerank(results, opts) {
   return scored.slice(0, opts.limit);
 }
 
+// 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) => {
+      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
+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, 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/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/core/path.ts
 var DEFAULT_DOMAINS = /* @__PURE__ */ new Set(["core", "emotion", "knowledge", "event", "system"]);
 function parseUri(uri) {
@@ -407,27 +1062,33 @@ 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;
 }
 
 // src/sleep/boot.ts
@@ -447,7 +1108,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)) {
@@ -459,13 +1120,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) {
@@ -493,25 +1154,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);
@@ -528,12 +1192,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/core/snapshot.ts
@@ -552,11 +1219,12 @@ function createSnapshot(db, memoryId, action, changedBy) {
 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");
@@ -565,13 +1233,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(
@@ -588,20 +1266,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();
@@ -617,7 +1306,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",
@@ -626,40 +1315,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
@@ -706,13 +1440,16 @@ function syncOne(db, input) {
 }
 
 // src/bin/agent-memory.ts
-import { existsSync, readFileSync, readdirSync } from "fs";
+import { existsSync as existsSync2, readFileSync as readFileSync2, readdirSync } from "fs";
 import { resolve, basename } from "path";
 var args = process.argv.slice(2);
 var command = args[0];
 function getDbPath() {
   return process.env.AGENT_MEMORY_DB ?? "./agent-memory.db";
 }
+function getAgentId() {
+  return process.env.AGENT_MEMORY_AGENT_ID ?? "default";
+}
 function printHelp() {
   console.log(`
 \u{1F9E0} AgentMemory v2 \u2014 Sleep-cycle memory for AI agents
@@ -721,12 +1458,16 @@ Usage: agent-memory <command> [options]
 
 Commands:
   init                          Create database
+  db:migrate                    Run schema migrations (no-op if up-to-date)
+  embed [--limit N]             Embed missing memories (requires provider)
   remember <content> [--uri X] [--type T]  Store a memory
   recall <query> [--limit N]    Search memories
   boot                          Load identity memories
   status                        Show statistics
   reflect [decay|tidy|govern|all]  Run sleep cycle
+  reindex                         Rebuild FTS index with jieba tokenizer
   migrate <dir>                 Import from Markdown files
+  export <dir>                  Export memories to Markdown files
   help                          Show this help
 
 Environment:
@@ -739,178 +1480,254 @@ function getFlag(flag) {
   if (idx >= 0 && idx + 1 < args.length) return args[idx + 1];
   return void 0;
 }
-try {
-  switch (command) {
-    case "init": {
-      const dbPath = getDbPath();
-      openDatabase({ path: dbPath });
-      console.log(`\u2705 Database created at ${dbPath}`);
-      break;
-    }
-    case "remember": {
-      const content = args.slice(1).filter((a) => !a.startsWith("--")).join(" ");
-      if (!content) {
-        console.error("Usage: agent-memory remember <content>");
-        process.exit(1);
-      }
-      const db = openDatabase({ path: getDbPath() });
-      const uri = getFlag("--uri");
-      const type = getFlag("--type") ?? "knowledge";
-      const result = syncOne(db, { content, type, uri });
-      console.log(`${result.action}: ${result.reason}${result.memoryId ? ` (${result.memoryId.slice(0, 8)})` : ""}`);
-      db.close();
-      break;
-    }
-    case "recall": {
-      const query = args.slice(1).filter((a) => !a.startsWith("--")).join(" ");
-      if (!query) {
-        console.error("Usage: agent-memory recall <query>");
-        process.exit(1);
+async function main() {
+  try {
+    switch (command) {
+      case "init": {
+        const dbPath = getDbPath();
+        openDatabase({ path: dbPath });
+        console.log(`\u2705 Database created at ${dbPath}`);
+        break;
       }
-      const db = openDatabase({ path: getDbPath() });
-      const limit = parseInt(getFlag("--limit") ?? "10");
-      const { intent } = classifyIntent(query);
-      const strategy = getStrategy(intent);
-      const raw = searchBM25(db, query, { limit: limit * 2 });
-      const results = rerank(raw, { ...strategy, limit });
-      console.log(`\u{1F50D} Intent: ${intent} | Results: ${results.length}
-`);
-      for (const r of results) {
-        const p = ["\u{1F534}", "\u{1F7E0}", "\u{1F7E1}", "\u26AA"][r.memory.priority];
-        const v = (r.memory.vitality * 100).toFixed(0);
-        console.log(`${p} P${r.memory.priority} [${v}%] ${r.memory.content.slice(0, 80)}`);
+      case "db:migrate": {
+        const dbPath = getDbPath();
+        const db = openDatabase({ path: dbPath });
+        const version = db.prepare("SELECT value FROM schema_meta WHERE key = 'version'").get()?.value;
+        console.log(`\u2705 Schema version: ${version ?? "unknown"} (${dbPath})`);
+        db.close();
+        break;
       }
-      db.close();
-      break;
-    }
-    case "boot": {
-      const db = openDatabase({ path: getDbPath() });
-      const result = boot(db);
-      console.log(`\u{1F9E0} Boot: ${result.identityMemories.length} identity memories loaded
-`);
-      for (const m of result.identityMemories) {
-        console.log(`  \u{1F534} ${m.content.slice(0, 100)}`);
+      case "embed": {
+        const provider = getEmbeddingProviderFromEnv();
+        if (!provider) {
+          console.error("Embedding provider not configured. Set AGENT_MEMORY_EMBEDDINGS_PROVIDER=openai|qwen and the corresponding API key.");
+          process.exit(1);
+        }
+        const db = openDatabase({ path: getDbPath() });
+        const agentId = getAgentId();
+        const limit = parseInt(getFlag("--limit") ?? "200");
+        const r = await embedMissingForAgent(db, provider, { agent_id: agentId, limit });
+        console.log(`\u2705 Embedded: ${r.embedded}/${r.scanned} (agent_id=${agentId}, model=${provider.model})`);
+        db.close();
+        break;
       }
-      if (result.bootPaths.length) {
-        console.log(`
-\u{1F4CD} Boot paths: ${result.bootPaths.join(", ")}`);
+      case "remember": {
+        const content = args.slice(1).filter((a) => !a.startsWith("--")).join(" ");
+        if (!content) {
+          console.error("Usage: agent-memory remember <content>");
+          process.exit(1);
+        }
+        const db = openDatabase({ path: getDbPath() });
+        const uri = getFlag("--uri");
+        const type = getFlag("--type") ?? "knowledge";
+        const agentId = getAgentId();
+        const provider = getEmbeddingProviderFromEnv();
+        const result = syncOne(db, { content, type, uri, agent_id: agentId });
+        if (provider && result.memoryId && (result.action === "added" || result.action === "updated" || result.action === "merged")) {
+          try {
+            await embedMemory(db, result.memoryId, provider, { agent_id: agentId });
+          } catch {
+          }
+        }
+        console.log(`${result.action}: ${result.reason}${result.memoryId ? ` (${result.memoryId.slice(0, 8)})` : ""}`);
+        db.close();
+        break;
       }
-      db.close();
-      break;
-    }
-    case "status": {
-      const db = openDatabase({ path: getDbPath() });
-      const stats = countMemories(db);
-      const lowVit = db.prepare("SELECT COUNT(*) as c FROM memories WHERE vitality < 0.1").get().c;
-      const paths = db.prepare("SELECT COUNT(*) as c FROM paths").get().c;
-      const links = db.prepare("SELECT COUNT(*) as c FROM links").get().c;
-      const snaps = db.prepare("SELECT COUNT(*) as c FROM snapshots").get().c;
-      console.log("\u{1F9E0} AgentMemory Status\n");
-      console.log(`  Total memories: ${stats.total}`);
-      console.log(`  By type: ${Object.entries(stats.by_type).map(([k, v]) => `${k}=${v}`).join(", ")}`);
-      console.log(`  By priority: ${Object.entries(stats.by_priority).map(([k, v]) => `${k}=${v}`).join(", ")}`);
-      console.log(`  Paths: ${paths} | Links: ${links} | Snapshots: ${snaps}`);
-      console.log(`  Low vitality (<10%): ${lowVit}`);
-      db.close();
-      break;
-    }
-    case "reflect": {
-      const phase = args[1] ?? "all";
-      const db = openDatabase({ path: getDbPath() });
-      console.log(`\u{1F319} Running ${phase} phase...
+      case "recall": {
+        const query = args.slice(1).filter((a) => !a.startsWith("--")).join(" ");
+        if (!query) {
+          console.error("Usage: agent-memory recall <query>");
+          process.exit(1);
+        }
+        const db = openDatabase({ path: getDbPath() });
+        const limit = parseInt(getFlag("--limit") ?? "10");
+        const { intent } = classifyIntent(query);
+        const strategy = getStrategy(intent);
+        const agentId = getAgentId();
+        const provider = getEmbeddingProviderFromEnv();
+        const raw = await searchHybrid(db, query, { agent_id: agentId, embeddingProvider: provider, limit: limit * 2 });
+        const results = rerank(raw, { ...strategy, limit });
+        console.log(`\u{1F50D} Intent: ${intent} | Results: ${results.length}
 `);
-      if (phase === "decay" || phase === "all") {
-        const r = runDecay(db);
-        console.log(`  Decay: ${r.updated} updated, ${r.decayed} decayed, ${r.belowThreshold} below threshold`);
-      }
-      if (phase === "tidy" || phase === "all") {
-        const r = runTidy(db);
-        console.log(`  Tidy: ${r.archived} archived, ${r.orphansCleaned} orphans, ${r.snapshotsPruned} snapshots pruned`);
-      }
-      if (phase === "govern" || phase === "all") {
-        const r = runGovern(db);
-        console.log(`  Govern: ${r.orphanPaths} paths, ${r.orphanLinks} links, ${r.emptyMemories} empty cleaned`);
+        for (const r of results) {
+          const p = ["\u{1F534}", "\u{1F7E0}", "\u{1F7E1}", "\u26AA"][r.memory.priority];
+          const v = (r.memory.vitality * 100).toFixed(0);
+          console.log(`${p} P${r.memory.priority} [${v}%] ${r.memory.content.slice(0, 80)}`);
+        }
+        db.close();
+        break;
       }
-      db.close();
-      break;
-    }
-    case "migrate": {
-      const dir = args[1];
-      if (!dir) {
-        console.error("Usage: agent-memory migrate <directory>");
-        process.exit(1);
+      case "boot": {
+        const db = openDatabase({ path: getDbPath() });
+        const result = boot(db, { agent_id: getAgentId() });
+        console.log(`\u{1F9E0} Boot: ${result.identityMemories.length} identity memories loaded
+`);
+        for (const m of result.identityMemories) {
+          console.log(`  \u{1F534} ${m.content.slice(0, 100)}`);
+        }
+        if (result.bootPaths.length) {
+          console.log(`
+\u{1F4CD} Boot paths: ${result.bootPaths.join(", ")}`);
+        }
+        db.close();
+        break;
       }
-      const dirPath = resolve(dir);
-      if (!existsSync(dirPath)) {
-        console.error(`Directory not found: ${dirPath}`);
-        process.exit(1);
+      case "status": {
+        const db = openDatabase({ path: getDbPath() });
+        const agentId = getAgentId();
+        const stats = countMemories(db, agentId);
+        const lowVit = db.prepare("SELECT COUNT(*) as c FROM memories WHERE vitality < 0.1 AND agent_id = ?").get(agentId).c;
+        const paths = db.prepare("SELECT COUNT(*) as c FROM paths WHERE agent_id = ?").get(agentId).c;
+        const links = db.prepare("SELECT COUNT(*) as c FROM links WHERE agent_id = ?").get(agentId).c;
+        const snaps = db.prepare(
+          `SELECT COUNT(*) as c FROM snapshots s
+         JOIN memories m ON m.id = s.memory_id
+         WHERE m.agent_id = ?`
+        ).get(agentId).c;
+        console.log("\u{1F9E0} AgentMemory Status\n");
+        console.log(`  Total memories: ${stats.total}`);
+        console.log(`  By type: ${Object.entries(stats.by_type).map(([k, v]) => `${k}=${v}`).join(", ")}`);
+        console.log(`  By priority: ${Object.entries(stats.by_priority).map(([k, v]) => `${k}=${v}`).join(", ")}`);
+        console.log(`  Paths: ${paths} | Links: ${links} | Snapshots: ${snaps}`);
+        console.log(`  Low vitality (<10%): ${lowVit}`);
+        db.close();
+        break;
       }
-      const db = openDatabase({ path: getDbPath() });
-      let imported = 0;
-      const memoryMd = resolve(dirPath, "MEMORY.md");
-      if (existsSync(memoryMd)) {
-        const content = readFileSync(memoryMd, "utf-8");
-        const sections = content.split(/^## /m).filter((s) => s.trim());
-        for (const section of sections) {
-          const lines = section.split("\n");
-          const title = lines[0]?.trim();
-          const body = lines.slice(1).join("\n").trim();
-          if (!body) continue;
-          const type = title?.toLowerCase().includes("\u5173\u4E8E") || title?.toLowerCase().includes("about") ? "identity" : "knowledge";
-          const uri = `knowledge://memory-md/${title?.replace(/[^a-z0-9\u4e00-\u9fff]/gi, "-").toLowerCase()}`;
-          syncOne(db, { content: `## ${title}
-${body}`, type, uri, source: "migrate:MEMORY.md" });
-          imported++;
+      case "reflect": {
+        const phase = args[1] ?? "all";
+        const db = openDatabase({ path: getDbPath() });
+        const agentId = getAgentId();
+        console.log(`\u{1F319} Running ${phase} phase...
+`);
+        if (phase === "decay" || phase === "all") {
+          const r = runDecay(db, { agent_id: agentId });
+          console.log(`  Decay: ${r.updated} updated, ${r.decayed} decayed, ${r.belowThreshold} below threshold`);
+        }
+        if (phase === "tidy" || phase === "all") {
+          const r = runTidy(db, { agent_id: agentId });
+          console.log(`  Tidy: ${r.archived} archived, ${r.orphansCleaned} orphans, ${r.snapshotsPruned} snapshots pruned`);
         }
-        console.log(`\u{1F4C4} MEMORY.md: ${sections.length} sections imported`);
+        if (phase === "govern" || phase === "all") {
+          const r = runGovern(db, { agent_id: agentId });
+          console.log(`  Govern: ${r.orphanPaths} paths, ${r.orphanLinks} links, ${r.emptyMemories} empty cleaned`);
+        }
+        db.close();
+        break;
       }
-      const mdFiles = readdirSync(dirPath).filter((f) => /^\d{4}-\d{2}-\d{2}\.md$/.test(f)).sort();
-      for (const file of mdFiles) {
-        const content = readFileSync(resolve(dirPath, file), "utf-8");
-        const date = basename(file, ".md");
-        syncOne(db, {
-          content,
-          type: "event",
-          uri: `event://journal/${date}`,
-          source: `migrate:${file}`
+      case "reindex": {
+        const db = openDatabase({ path: getDbPath() });
+        const memories = db.prepare("SELECT id, content FROM memories").all();
+        db.exec("DELETE FROM memories_fts");
+        const insert = db.prepare("INSERT INTO memories_fts (id, content) VALUES (?, ?)");
+        let count = 0;
+        const txn = db.transaction(() => {
+          for (const mem of memories) {
+            insert.run(mem.id, tokenizeForIndex(mem.content));
+            count++;
+          }
         });
-        imported++;
+        txn();
+        console.log(`\u{1F504} Reindexed ${count} memories with jieba tokenizer`);
+        db.close();
+        break;
+      }
+      case "export": {
+        const dir = args[1];
+        if (!dir) {
+          console.error("Usage: agent-memory export <directory>");
+          process.exit(1);
+        }
+        const dirPath = resolve(dir);
+        const db = openDatabase({ path: getDbPath() });
+        const agentId = getAgentId();
+        const result = exportMemories(db, dirPath, { agent_id: agentId });
+        console.log(`\u2705 Export complete: ${result.exported} items to ${dirPath} (${result.files.length} files)`);
+        db.close();
+        break;
       }
-      if (mdFiles.length) console.log(`\u{1F4DD} Journals: ${mdFiles.length} files imported`);
-      const weeklyDir = resolve(dirPath, "weekly");
-      if (existsSync(weeklyDir)) {
-        const weeklyFiles = readdirSync(weeklyDir).filter((f) => f.endsWith(".md"));
-        for (const file of weeklyFiles) {
-          const content = readFileSync(resolve(weeklyDir, file), "utf-8");
-          const week = basename(file, ".md");
+      case "migrate": {
+        const dir = args[1];
+        if (!dir) {
+          console.error("Usage: agent-memory migrate <directory>");
+          process.exit(1);
+        }
+        const dirPath = resolve(dir);
+        if (!existsSync2(dirPath)) {
+          console.error(`Directory not found: ${dirPath}`);
+          process.exit(1);
+        }
+        const db = openDatabase({ path: getDbPath() });
+        const agentId = getAgentId();
+        let imported = 0;
+        const memoryFile = ["MEMORY.md", "MEMORY.qmd"].map((f) => resolve(dirPath, f)).find((p) => existsSync2(p));
+        if (memoryFile) {
+          const content = readFileSync2(memoryFile, "utf-8");
+          const sections = content.split(/^## /m).filter((s) => s.trim());
+          for (const section of sections) {
+            const lines = section.split("\n");
+            const title = lines[0]?.trim();
+            const body = lines.slice(1).join("\n").trim();
+            if (!body) continue;
+            const type = title?.toLowerCase().includes("\u5173\u4E8E") || title?.toLowerCase().includes("about") ? "identity" : "knowledge";
+            const uri = `knowledge://memory-md/${title?.replace(/[^a-z0-9\u4e00-\u9fff]/gi, "-").toLowerCase()}`;
+            syncOne(db, { content: `## ${title}
+${body}`, type, uri, source: `migrate:${basename(memoryFile)}`, agent_id: agentId });
+            imported++;
+          }
+          console.log(`\u{1F4C4} ${basename(memoryFile)}: ${sections.length} sections imported`);
+        }
+        const mdFiles = readdirSync(dirPath).filter((f) => /^\d{4}-\d{2}-\d{2}\.(md|qmd)$/.test(f)).sort();
+        for (const file of mdFiles) {
+          const content = readFileSync2(resolve(dirPath, file), "utf-8");
+          const date = file.replace(/\.(md|qmd)$/i, "");
           syncOne(db, {
             content,
-            type: "knowledge",
-            uri: `knowledge://weekly/${week}`,
-            source: `migrate:weekly/${file}`
+            type: "event",
+            uri: `event://journal/${date}`,
+            source: `migrate:${file}`,
+            agent_id: agentId
           });
           imported++;
         }
-        if (weeklyFiles.length) console.log(`\u{1F4E6} Weekly: ${weeklyFiles.length} files imported`);
-      }
-      console.log(`
+        if (mdFiles.length) console.log(`\u{1F4DD} Journals: ${mdFiles.length} files imported`);
+        const weeklyDir = resolve(dirPath, "weekly");
+        if (existsSync2(weeklyDir)) {
+          const weeklyFiles = readdirSync(weeklyDir).filter((f) => f.endsWith(".md") || f.endsWith(".qmd"));
+          for (const file of weeklyFiles) {
+            const content = readFileSync2(resolve(weeklyDir, file), "utf-8");
+            const week = file.replace(/\.(md|qmd)$/i, "");
+            syncOne(db, {
+              content,
+              type: "knowledge",
+              uri: `knowledge://weekly/${week}`,
+              source: `migrate:weekly/${file}`,
+              agent_id: agentId
+            });
+            imported++;
+          }
+          if (weeklyFiles.length) console.log(`\u{1F4E6} Weekly: ${weeklyFiles.length} files imported`);
+        }
+        console.log(`
 \u2705 Migration complete: ${imported} items imported`);
-      db.close();
-      break;
-    }
-    case "help":
-    case "--help":
-    case "-h":
-    case void 0:
-      printHelp();
-      break;
-    default:
-      console.error(`Unknown command: ${command}`);
-      printHelp();
-      process.exit(1);
-  }
-} catch (err) {
-  console.error("Error:", err.message);
-  process.exit(1);
+        db.close();
+        break;
+      }
+      case "help":
+      case "--help":
+      case "-h":
+      case void 0:
+        printHelp();
+        break;
+      default:
+        console.error(`Unknown command: ${command}`);
+        printHelp();
+        process.exit(1);
+    }
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    console.error("Error:", message);
+    process.exit(1);
+  }
 }
+main();
 //# sourceMappingURL=agent-memory.js.map