@smyslenny/agent-memory 2.2.0 → 3.1.0

package/dist/mcp/server.js

@@ -14366,261 +14366,6 @@ 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, 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 (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, 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, 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 = [
-    { id: startId, hop: 0, relation: "self" }
-  ];
-  while (queue.length > 0) {
-    const current = queue.shift();
-    if (visited.has(current.id)) continue;
-    visited.add(current.id);
-    if (current.hop > 0) {
-      results.push(current);
-    }
-    if (current.hop < maxHops) {
-      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({
-            id: link.target_id,
-            hop: current.hop + 1,
-            relation: link.relation
-          });
-        }
-      }
-      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({
-            id: link.source_id,
-            hop: current.hop + 1,
-            relation: link.relation
-          });
-        }
-      }
-    }
-  }
-  return results;
-}
-
-// 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}`);
-  const id = newId();
-  db.prepare(
-    `INSERT INTO snapshots (id, memory_id, content, changed_by, action, created_at)
-     VALUES (?, ?, ?, ?, ?, ?)`
-  ).run(id, memoryId, memory.content, changedBy ?? null, action, now());
-  return { id, memory_id: memoryId, content: memory.content, changed_by: changedBy ?? null, action, created_at: now() };
-}
-function getSnapshots(db, memoryId) {
-  return db.prepare("SELECT * FROM snapshots WHERE memory_id = ? ORDER BY created_at DESC").all(memoryId);
-}
-function getSnapshot(db, id) {
-  return db.prepare("SELECT * FROM snapshots WHERE id = ?").get(id) ?? null;
-}
-function rollback(db, snapshotId) {
-  const snapshot = getSnapshot(db, snapshotId);
-  if (!snapshot) return false;
-  createSnapshot(db, snapshot.memory_id, "update", "rollback");
-  db.prepare("UPDATE memories SET content = ?, updated_at = ? WHERE id = ?").run(
-    snapshot.content,
-    now(),
-    snapshot.memory_id
-  );
-  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,
-    tokenizeForIndex(snapshot.content)
-  );
-  return true;
-}
-
-// src/search/intent.ts
-init_tokenizer();
-var INTENT_PATTERNS = {
-  factual: [
-    // 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: [
-    // 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
-    /什么时候/,
-    /(昨天|今天|明天|上周|下周|最近|以前|之前|之后|刚才|刚刚)/,
-    /(几月|几号|几点|多久|多长时间)/,
-    /(上次|下次|第一次|最后一次|那天|那时)/,
-    // Date patterns
-    /\d{4}[-/.]\d{1,2}/,
-    /\d{1,2}月\d{1,2}[日号]/,
-    // Chinese - temporal context
-    /(历史|记录|日志|以来|至今|期间)/
-  ],
-  causal: [
-    // 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: [
-    // 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,
-    exploratory: 0,
-    temporal: 0,
-    causal: 0
-  };
-  for (const [intent, patterns] of Object.entries(INTENT_PATTERNS)) {
-    for (const pattern of patterns) {
-      if (pattern.test(query)) {
-        scores[intent] += 1;
-      }
-    }
-  }
-  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)) {
-    if (score > maxScore) {
-      maxScore = score;
-      maxIntent = intent;
-    }
-  }
-  const totalScore = Object.values(scores).reduce((a, b) => a + b, 0);
-  const confidence = totalScore > 0 ? Math.min(0.95, maxScore / totalScore) : 0.5;
-  return { intent: maxIntent, confidence };
-}
-function getStrategy(intent) {
-  switch (intent) {
-    case "factual":
-      return { boostRecent: false, boostPriority: true, limit: 5 };
-    case "temporal":
-      return { boostRecent: true, boostPriority: false, limit: 10 };
-    case "causal":
-      return { boostRecent: false, boostPriority: false, limit: 10 };
-    case "exploratory":
-      return { boostRecent: false, boostPriority: false, limit: 15 };
-  }
-}
-
-// 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) => {
-    let finalScore = r.score;
-    if (opts.boostPriority) {
-      const priorityMultiplier = [4, 3, 2, 1][r.memory.priority] ?? 1;
-      finalScore *= priorityMultiplier;
-    }
-    if (opts.boostRecent && r.memory.updated_at) {
-      const age = now2 - new Date(r.memory.updated_at).getTime();
-      const daysSinceUpdate = age / (1e3 * 60 * 60 * 24);
-      const recencyBoost = Math.max(0.1, 1 / (1 + daysSinceUpdate * 0.1));
-      finalScore *= recencyBoost;
-    }
-    finalScore *= Math.max(0.1, r.memory.vitality);
-    return { ...r, score: finalScore };
-  });
-  scored.sort((a, b) => b.score - a.score);
-  return scored.slice(0, opts.limit);
-}
-
 // src/search/bm25.ts
 init_tokenizer();
 function searchBM25(db, query, opts) {
@@ -14673,321 +14418,6 @@ function buildFtsQuery(text) {
   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();
 
@@ -15121,7 +14551,6 @@ function syncOne(db, input) {
     }
     case "update": {
       if (!guardResult.existingId) return { action: "skipped", reason: "No existing ID for update" };
-      createSnapshot(db, guardResult.existingId, "update", "sync");
       updateMemory(db, guardResult.existingId, { content: input.content });
       return { action: "updated", memoryId: guardResult.existingId, reason: guardResult.reason };
     }
@@ -15129,7 +14558,6 @@ function syncOne(db, input) {
       if (!guardResult.existingId || !guardResult.mergedContent) {
         return { action: "skipped", reason: "Missing merge data" };
       }
-      createSnapshot(db, guardResult.existingId, "merge", "sync");
       updateMemory(db, guardResult.existingId, { content: guardResult.mergedContent });
       return { action: "merged", memoryId: guardResult.existingId, reason: guardResult.reason };
     }
@@ -15201,18 +14629,12 @@ function getDecayedMemories(db, threshold = 0.05, opts) {
 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, agentId ? { agent_id: agentId } : void 0);
     for (const mem of decayed) {
-      try {
-        createSnapshot(db, mem.id, "delete", "tidy");
-      } catch {
-      }
       deleteMemory(db, mem.id);
       archived++;
     }
@@ -15224,35 +14646,15 @@ function runTidy(db, opts) {
       "DELETE FROM paths WHERE memory_id NOT IN (SELECT id FROM memories)"
     ).run();
     orphansCleaned = orphans.changes;
-    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 > ?`
-    ).all(maxSnapshots);
-    for (const { memory_id } of memoriesWithSnapshots) {
-      const pruned = db.prepare(
-        `DELETE FROM snapshots WHERE id NOT IN (
-            SELECT id FROM snapshots WHERE memory_id = ?
-            ORDER BY created_at DESC LIMIT ?
-          ) AND memory_id = ?`
-      ).run(memory_id, maxSnapshots, memory_id);
-      snapshotsPruned += pruned.changes;
-    }
   });
   transaction();
-  return { archived, orphansCleaned, snapshotsPruned };
+  return { archived, orphansCleaned };
 }
 
 // src/sleep/govern.ts
 function runGovern(db, opts) {
   const agentId = opts?.agent_id;
   let orphanPaths = 0;
-  let orphanLinks = 0;
   let emptyMemories = 0;
   const transaction = db.transaction(() => {
     const pathResult = agentId ? db.prepare(
@@ -15261,23 +14663,11 @@ function runGovern(db, opts) {
            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 = 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 = 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();
-  return { orphanPaths, orphanLinks, emptyMemories };
+  return { orphanPaths, emptyMemories };
 }
 
 // src/sleep/boot.ts
@@ -15333,17 +14723,400 @@ function boot(db, opts) {
   };
 }
 
+// src/ingest/ingest.ts
+function slugify2(input) {
+  return input.toLowerCase().replace(/[^a-z0-9\u4e00-\u9fff\s-]/g, " ").trim().replace(/\s+/g, "-").slice(0, 64) || "item";
+}
+function classifyIngestType(text) {
+  const lower = text.toLowerCase();
+  if (/##\s*身份|\bidentity\b|\b我是\b|我是/.test(text)) {
+    return "identity";
+  }
+  if (/##\s*情感|❤️|💕|爱你|感动|难过|开心|害怕|想念|表白/.test(text)) {
+    return "emotion";
+  }
+  if (/##\s*决策|##\s*技术|选型|教训|\bknowledge\b|⚠️|复盘|经验/.test(text)) {
+    return "knowledge";
+  }
+  if (/\d{4}-\d{2}-\d{2}|发生了|完成了|今天|昨日|刚刚|部署|上线/.test(text)) {
+    return "event";
+  }
+  if (lower.length <= 12) return "event";
+  return "knowledge";
+}
+function splitIngestBlocks(text) {
+  const headingRegex = /^##\s+(.+)$/gm;
+  const matches = [...text.matchAll(headingRegex)];
+  const blocks = [];
+  if (matches.length > 0) {
+    for (let i = 0; i < matches.length; i++) {
+      const match = matches[i];
+      const start = match.index ?? 0;
+      const end = i + 1 < matches.length ? matches[i + 1].index ?? text.length : text.length;
+      const raw = text.slice(start, end).trim();
+      const lines = raw.split("\n");
+      const title = lines[0].replace(/^##\s+/, "").trim();
+      const content = lines.slice(1).join("\n").trim();
+      if (content) blocks.push({ title, content });
+    }
+    return blocks;
+  }
+  const bullets = text.split("\n").map((line) => line.trim()).filter((line) => /^[-*]\s+/.test(line)).map((line) => line.replace(/^[-*]\s+/, "").trim()).filter(Boolean);
+  if (bullets.length > 0) {
+    return bullets.map((content, i) => ({ title: `bullet-${i + 1}`, content }));
+  }
+  const plain = text.trim();
+  if (!plain) return [];
+  return [{ title: "ingest", content: plain }];
+}
+function extractIngestItems(text, source) {
+  const blocks = splitIngestBlocks(text);
+  return blocks.map((block, index) => {
+    const merged = `${block.title}
+${block.content}`;
+    const type = classifyIngestType(merged);
+    const domain2 = type === "identity" ? "core" : type;
+    const sourcePart = slugify2(source ?? "ingest");
+    const uri = `${domain2}://ingest/${sourcePart}/${index + 1}-${slugify2(block.title)}`;
+    return {
+      index,
+      title: block.title,
+      content: block.content,
+      type,
+      uri
+    };
+  });
+}
+function ingestText(db, options) {
+  const extracted = extractIngestItems(options.text, options.source);
+  const dryRun = options.dryRun ?? false;
+  const agentId = options.agentId ?? "default";
+  if (dryRun) {
+    return {
+      extracted: extracted.length,
+      written: 0,
+      skipped: extracted.length,
+      dry_run: true,
+      details: extracted.map((item) => ({
+        index: item.index,
+        type: item.type,
+        uri: item.uri,
+        preview: item.content.slice(0, 80)
+      }))
+    };
+  }
+  let written = 0;
+  let skipped = 0;
+  const details = [];
+  for (const item of extracted) {
+    const result = syncOne(db, {
+      content: item.content,
+      type: item.type,
+      uri: item.uri,
+      source: `auto:${options.source ?? "ingest"}`,
+      agent_id: agentId
+    });
+    if (result.action === "added" || result.action === "updated" || result.action === "merged") {
+      written++;
+    } else {
+      skipped++;
+    }
+    details.push({
+      index: item.index,
+      type: item.type,
+      uri: item.uri,
+      action: result.action,
+      reason: result.reason,
+      memoryId: result.memoryId
+    });
+  }
+  return {
+    extracted: extracted.length,
+    written,
+    skipped,
+    dry_run: false,
+    details
+  };
+}
+
+// src/ingest/watcher.ts
+import { existsSync, readFileSync as readFileSync2, readdirSync, statSync, watch } from "fs";
+import { join, relative, resolve } from "path";
+function runAutoIngestWatcher(options) {
+  const workspaceDir = resolve(options.workspaceDir);
+  const memoryDir = join(workspaceDir, "memory");
+  const memoryMdPath = join(workspaceDir, "MEMORY.md");
+  const debounceMs = options.debounceMs ?? 1200;
+  const initialScan = options.initialScan ?? true;
+  const logger = options.logger ?? console;
+  const timers = /* @__PURE__ */ new Map();
+  const watchers = [];
+  const stats = {
+    triggers: 0,
+    filesProcessed: 0,
+    extracted: 0,
+    written: 0,
+    skipped: 0,
+    errors: 0
+  };
+  let stopped = false;
+  let queue = Promise.resolve();
+  const toSource = (absPath) => {
+    const rel = relative(workspaceDir, absPath).replace(/\\/g, "/");
+    return rel || absPath;
+  };
+  const isTrackedMarkdownFile = (absPath) => {
+    if (!absPath.endsWith(".md")) return false;
+    if (resolve(absPath) === memoryMdPath) return true;
+    const rel = relative(memoryDir, absPath).replace(/\\/g, "/");
+    if (rel.startsWith("..") || rel === "") return false;
+    return !rel.includes("/");
+  };
+  const ingestFile = (absPath, reason) => {
+    if (stopped) return;
+    if (!existsSync(absPath)) {
+      logger.log(`[auto-ingest] skip missing file: ${toSource(absPath)} (reason=${reason})`);
+      return;
+    }
+    let isFile = false;
+    try {
+      isFile = statSync(absPath).isFile();
+    } catch (err) {
+      stats.errors += 1;
+      logger.warn(`[auto-ingest] stat failed for ${toSource(absPath)}: ${String(err)}`);
+      return;
+    }
+    if (!isFile) return;
+    try {
+      const text = readFileSync2(absPath, "utf-8");
+      const source = toSource(absPath);
+      const result = ingestText(options.db, {
+        text,
+        source,
+        agentId: options.agentId
+      });
+      stats.filesProcessed += 1;
+      stats.extracted += result.extracted;
+      stats.written += result.written;
+      stats.skipped += result.skipped;
+      logger.log(
+        `[auto-ingest] file=${source} reason=${reason} extracted=${result.extracted} written=${result.written} skipped=${result.skipped}`
+      );
+    } catch (err) {
+      stats.errors += 1;
+      logger.error(`[auto-ingest] ingest failed for ${toSource(absPath)}: ${String(err)}`);
+    }
+  };
+  const scheduleIngest = (absPath, reason) => {
+    if (stopped) return;
+    if (!isTrackedMarkdownFile(absPath)) return;
+    stats.triggers += 1;
+    const previous = timers.get(absPath);
+    if (previous) clearTimeout(previous);
+    const timer = setTimeout(() => {
+      timers.delete(absPath);
+      queue = queue.then(() => {
+        ingestFile(absPath, reason);
+      }).catch((err) => {
+        stats.errors += 1;
+        logger.error(`[auto-ingest] queue error: ${String(err)}`);
+      });
+    }, debounceMs);
+    timers.set(absPath, timer);
+  };
+  const safeWatch = (dir, onEvent) => {
+    if (!existsSync(dir)) {
+      logger.warn(`[auto-ingest] watch path does not exist, skipping: ${dir}`);
+      return;
+    }
+    try {
+      const watcher = watch(dir, { persistent: true }, (eventType, filename) => {
+        if (!filename) return;
+        onEvent(eventType, filename.toString());
+      });
+      watchers.push(watcher);
+      logger.log(`[auto-ingest] watching ${dir}`);
+    } catch (err) {
+      stats.errors += 1;
+      logger.error(`[auto-ingest] failed to watch ${dir}: ${String(err)}`);
+    }
+  };
+  safeWatch(workspaceDir, (eventType, filename) => {
+    if (filename === "MEMORY.md") {
+      scheduleIngest(join(workspaceDir, filename), `workspace:${eventType}`);
+    }
+  });
+  safeWatch(memoryDir, (eventType, filename) => {
+    if (filename.endsWith(".md")) {
+      scheduleIngest(join(memoryDir, filename), `memory:${eventType}`);
+    }
+  });
+  if (initialScan) {
+    scheduleIngest(memoryMdPath, "initial");
+    if (existsSync(memoryDir)) {
+      for (const file2 of readdirSync(memoryDir)) {
+        if (file2.endsWith(".md")) {
+          scheduleIngest(join(memoryDir, file2), "initial");
+        }
+      }
+    }
+  }
+  return {
+    close: () => {
+      if (stopped) return;
+      stopped = true;
+      for (const timer of timers.values()) {
+        clearTimeout(timer);
+      }
+      timers.clear();
+      for (const watcher of watchers) {
+        try {
+          watcher.close();
+        } catch {
+        }
+      }
+      logger.log(
+        `[auto-ingest] stopped triggers=${stats.triggers} files=${stats.filesProcessed} extracted=${stats.extracted} written=${stats.written} skipped=${stats.skipped} errors=${stats.errors}`
+      );
+    }
+  };
+}
+
 // src/mcp/server.ts
 var DB_PATH = process.env.AGENT_MEMORY_DB ?? "./agent-memory.db";
 var AGENT_ID = process.env.AGENT_MEMORY_AGENT_ID ?? "default";
+var PRIORITY_WEIGHT = {
+  0: 4,
+  1: 3,
+  2: 2,
+  3: 1
+};
+function formatMemory(memory, score) {
+  return {
+    id: memory.id,
+    uri: null,
+    content: memory.content,
+    type: memory.type,
+    priority: memory.priority,
+    vitality: memory.vitality,
+    score,
+    updated_at: memory.updated_at
+  };
+}
+function formatWarmBootNarrative(identities, emotions, knowledges, events, totalStats) {
+  const now2 = Date.now();
+  const sevenDaysAgo = now2 - 7 * 24 * 60 * 60 * 1e3;
+  const recentEvents = events.filter((e) => new Date(e.updated_at).getTime() >= sevenDaysAgo);
+  const olderEventCount = Math.max(0, events.length - recentEvents.length);
+  const avgVitalitySource = [...identities, ...emotions, ...knowledges, ...events];
+  const avgVitality = avgVitalitySource.length ? avgVitalitySource.reduce((s, m) => s + m.vitality, 0) / avgVitalitySource.length : 0;
+  const lines = [];
+  lines.push("## \u{1FAAA} \u6211\u662F\u8C01");
+  if (identities.length === 0) {
+    lines.push("\u6682\u65E0\u8EAB\u4EFD\u8BB0\u5FC6\u3002");
+  } else {
+    for (const m of identities.slice(0, 6)) {
+      lines.push(`- ${m.content.slice(0, 140)}`);
+    }
+  }
+  lines.push("", "## \u{1F495} \u6700\u8FD1\u7684\u60C5\u611F");
+  if (emotions.length === 0) {
+    lines.push("\u6682\u65E0\u60C5\u611F\u8BB0\u5FC6\u3002");
+  } else {
+    for (const m of emotions.slice(0, 6)) {
+      lines.push(`- ${m.content.slice(0, 140)}\uFF08vitality: ${m.vitality.toFixed(2)}\uFF09`);
+    }
+  }
+  lines.push("", "## \u{1F9E0} \u5173\u952E\u77E5\u8BC6");
+  if (knowledges.length === 0) {
+    lines.push("\u6682\u65E0\u77E5\u8BC6\u8BB0\u5FC6\u3002");
+  } else {
+    lines.push(`\u5171 ${knowledges.length} \u6761\u6D3B\u8DC3\u77E5\u8BC6\u8BB0\u5FC6`);
+    for (const m of knowledges.slice(0, 8)) {
+      lines.push(`- ${m.content.slice(0, 140)}\uFF08vitality: ${m.vitality.toFixed(2)}\uFF09`);
+    }
+  }
+  lines.push("", "## \u{1F4C5} \u8FD1\u671F\u4E8B\u4EF6");
+  if (recentEvents.length === 0) {
+    lines.push("\u6700\u8FD1 7 \u5929\u65E0\u4E8B\u4EF6\u8BB0\u5FC6\u3002");
+  } else {
+    lines.push("\u6700\u8FD1 7 \u5929\u5185\u7684\u4E8B\u4EF6\uFF1A");
+    for (const m of recentEvents.slice(0, 8)) {
+      const dateLabel = m.updated_at.slice(5, 10);
+      lines.push(`- [${dateLabel}] ${m.content.slice(0, 120)}`);
+    }
+  }
+  if (olderEventCount > 0) {
+    lines.push(`- ... \u53CA ${olderEventCount} \u6761\u66F4\u65E9\u4E8B\u4EF6`);
+  }
+  lines.push("", "## \u{1F4CA} \u8BB0\u5FC6\u6982\u51B5");
+  lines.push(
+    `\u603B\u8BA1 ${totalStats.total} \u6761 | identity: ${totalStats.by_type.identity ?? 0} | emotion: ${totalStats.by_type.emotion ?? 0} | knowledge: ${totalStats.by_type.knowledge ?? 0} | event: ${totalStats.by_type.event ?? 0}`
+  );
+  lines.push(`\u5E73\u5747 vitality: ${avgVitality.toFixed(2)}`);
+  return lines.join("\n");
+}
+function getSummaryStats(db, agentId) {
+  const row = db.prepare("SELECT COUNT(*) as total, COALESCE(AVG(vitality), 0) as avg FROM memories WHERE agent_id = ?").get(agentId);
+  return { total: row.total, avgVitality: row.avg };
+}
+function getMemoryUri(db, memoryId, agentId) {
+  const row = db.prepare("SELECT uri FROM paths WHERE memory_id = ? AND agent_id = ? ORDER BY created_at DESC LIMIT 1").get(memoryId, agentId);
+  return row?.uri ?? "(no-uri)";
+}
+function formatReflectReport(input) {
+  const lines = [];
+  lines.push("## \u{1F319} Sleep Cycle \u62A5\u544A", "");
+  if (input.phase === "decay" || input.phase === "all") {
+    const decay = input.decaySummary ?? { updated: 0, decayed: 0, belowThreshold: 0 };
+    lines.push("### Decay\uFF08\u8870\u51CF\uFF09");
+    lines.push(`\u5904\u7406 ${decay.updated} \u6761\u8BB0\u5FC6\uFF0C\u5176\u4E2D ${decay.decayed} \u6761 vitality \u4E0B\u964D\u3002`);
+    const details = (input.decayDetails ?? []).slice(0, 8);
+    if (details.length > 0) {
+      for (const d of details) {
+        lines.push(`- ${d.uri} | ${d.type} P${d.priority} | ${d.oldVitality.toFixed(2)} \u2192 ${d.newVitality.toFixed(2)} | ${d.content.slice(0, 64)}`);
+      }
+      if ((input.decayDetails?.length ?? 0) > details.length) {
+        lines.push(`- ... \u53CA ${(input.decayDetails?.length ?? 0) - details.length} \u6761\u66F4\u591A\u8870\u51CF\u8BB0\u5F55`);
+      }
+    }
+    lines.push("");
+  }
+  if (input.phase === "tidy" || input.phase === "all") {
+    const tidy = input.tidySummary ?? { archived: 0, orphansCleaned: 0 };
+    lines.push("### Tidy\uFF08\u6574\u7406\uFF09");
+    lines.push(`\u5F52\u6863 ${tidy.archived} \u6761\u4F4E\u6D3B\u529B\u8BB0\u5FC6\uFF0C\u6E05\u7406\u5B64\u513F\u8DEF\u5F84 ${tidy.orphansCleaned} \u6761\u3002`);
+    const archived = (input.archivedDetails ?? []).slice(0, 8);
+    if (archived.length > 0) {
+      for (const a of archived) {
+        lines.push(`- \u5F52\u6863 ${a.uri} | P${a.priority} vitality=${a.vitality.toFixed(2)} | ${a.content.slice(0, 64)}`);
+      }
+      if ((input.archivedDetails?.length ?? 0) > archived.length) {
+        lines.push(`- ... \u53CA ${(input.archivedDetails?.length ?? 0) - archived.length} \u6761\u66F4\u591A\u5F52\u6863\u8BB0\u5F55`);
+      }
+    }
+    lines.push("");
+  }
+  if (input.phase === "govern" || input.phase === "all") {
+    const govern = input.governSummary ?? { orphanPaths: 0, emptyMemories: 0 };
+    lines.push("### Govern\uFF08\u6CBB\u7406\uFF09");
+    lines.push(`\u5B64\u513F\u8DEF\u5F84\uFF1A${govern.orphanPaths} \u6761`);
+    lines.push(`\u7A7A\u8BB0\u5FC6\uFF1A${govern.emptyMemories} \u6761`);
+    lines.push("");
+  }
+  lines.push("### \u{1F4CA} \u603B\u7ED3");
+  const delta = input.after.total - input.before.total;
+  const deltaLabel = delta > 0 ? `+${delta}` : `${delta}`;
+  lines.push(`\u8BB0\u5FC6\u603B\u6570\uFF1A${input.before.total} \u2192 ${input.after.total}\uFF08${deltaLabel}\uFF09`);
+  lines.push(`\u5E73\u5747 vitality\uFF1A${input.before.avgVitality.toFixed(2)} \u2192 ${input.after.avgVitality.toFixed(2)}`);
+  return lines.join("\n");
+}
 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.1.0"
+    version: "3.0.0"
   });
   server.tool(
     "remember",
@@ -15357,12 +15130,6 @@ 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) }]
       };
@@ -15370,65 +15137,49 @@ function createMcpServer(dbPath, agentId) {
   );
   server.tool(
     "recall",
-    "Search memories using intent-aware BM25 search with priority weighting. Automatically classifies query intent (factual/temporal/causal/exploratory).",
+    "Search memories using BM25 full-text retrieval with inline priority\xD7vitality weighting.",
     {
       query: external_exports.string().describe("Search query (natural language)"),
       limit: external_exports.number().default(10).describe("Max results to return")
     },
     async ({ query, limit }) => {
-      const { intent, confidence } = classifyIntent(query);
-      const strategy = getStrategy(intent);
-      let raw = await searchHybrid(db, query, { agent_id: aid, embeddingProvider, limit: limit * 2 });
-      if (rerankerProvider) {
-        raw = await rerankWithProvider(raw, query, rerankerProvider);
+      const expandedLimit = Math.max(limit * 2, limit);
+      const raw = searchBM25(db, query, { agent_id: aid, limit: expandedLimit });
+      const scored = raw.map((r) => {
+        const weight = PRIORITY_WEIGHT[r.memory.priority] ?? 1;
+        const vitality = Math.max(0.1, r.memory.vitality);
+        return {
+          memory: r.memory,
+          score: r.score * weight * vitality
+        };
+      }).sort((a, b) => b.score - a.score).slice(0, limit);
+      for (const r of scored) {
+        recordAccess(db, r.memory.id);
       }
-      const results = rerank(raw, { ...strategy, limit });
       const output = {
-        intent,
-        confidence,
-        count: results.length,
-        memories: results.map((r) => ({
-          id: r.memory.id,
-          content: r.memory.content,
-          type: r.memory.type,
-          priority: r.memory.priority,
-          vitality: r.memory.vitality,
-          score: r.score,
-          updated_at: r.memory.updated_at
-        }))
+        count: scored.length,
+        memories: scored.map((r) => formatMemory(r.memory, r.score))
       };
-      for (const r of results) {
-        recordAccess(db, r.memory.id);
-      }
       return { content: [{ type: "text", text: JSON.stringify(output, null, 2) }] };
     }
   );
   server.tool(
     "recall_path",
-    "Read memory at a specific URI path, or list memories under a URI prefix. Supports multi-hop traversal.",
+    "Read memory at a specific URI path, or list memories under a URI prefix.",
     {
       uri: external_exports.string().describe("URI path (e.g. core://user/name) or prefix (e.g. core://user/)"),
-      traverse_hops: external_exports.number().default(0).describe("Multi-hop graph traversal depth (0 = direct only)")
+      traverse_hops: external_exports.number().default(0).describe("Traversal depth (deprecated, reserved for compatibility)")
     },
-    async ({ uri, traverse_hops }) => {
+    async ({ uri }) => {
       const path = getPathByUri(db, uri, aid);
       if (path) {
         const mem = getMemory(db, path.memory_id);
         if (mem && mem.agent_id === aid) {
           recordAccess(db, mem.id);
-          let related = [];
-          if (traverse_hops > 0) {
-            const hops = traverse(db, mem.id, traverse_hops, aid);
-            related = hops.map((h) => {
-              const m = getMemory(db, h.id);
-              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 {
             content: [{
               type: "text",
-              text: JSON.stringify({ found: true, memory: mem, related }, null, 2)
+              text: JSON.stringify({ found: true, memory: mem }, null, 2)
             }]
           };
         }
@@ -15438,7 +15189,7 @@ function createMcpServer(dbPath, agentId) {
         const memories = paths.map((p) => {
           const m = getMemory(db, p.memory_id);
           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 { uri: p.uri, content: m.content, type: m.type, priority: m.priority, vitality: m.vitality };
         });
         return {
           content: [{
@@ -15452,21 +15203,33 @@ function createMcpServer(dbPath, agentId) {
   );
   server.tool(
     "boot",
-    "Load core identity memories (P0) and system://boot entries. Call this when starting a new session.",
-    {},
-    async () => {
-      const result = boot(db, { agent_id: aid });
-      const output = {
-        count: result.identityMemories.length,
-        bootPaths: result.bootPaths,
-        memories: result.identityMemories.map((m) => ({
-          id: m.id,
-          content: m.content,
-          type: m.type,
-          priority: m.priority
-        }))
-      };
-      return { content: [{ type: "text", text: JSON.stringify(output, null, 2) }] };
+    "Load startup memories. Default output is narrative markdown; pass format=json for legacy output.",
+    {
+      format: external_exports.enum(["narrative", "json"]).default("narrative").optional()
+    },
+    async ({ format }) => {
+      const outputFormat = format ?? "narrative";
+      const base = boot(db, { agent_id: aid });
+      if (outputFormat === "json") {
+        const jsonOutput = {
+          count: base.identityMemories.length,
+          bootPaths: base.bootPaths,
+          memories: base.identityMemories.map((m) => ({
+            id: m.id,
+            content: m.content,
+            type: m.type,
+            priority: m.priority
+          }))
+        };
+        return { content: [{ type: "text", text: JSON.stringify(jsonOutput, null, 2) }] };
+      }
+      const identity = listMemories(db, { agent_id: aid, type: "identity", limit: 12 });
+      const emotion = listMemories(db, { agent_id: aid, type: "emotion", min_vitality: 0.1, limit: 12 }).sort((a, b) => b.vitality - a.vitality);
+      const knowledge = listMemories(db, { agent_id: aid, type: "knowledge", min_vitality: 0.1, limit: 16 }).sort((a, b) => b.vitality - a.vitality);
+      const event = listMemories(db, { agent_id: aid, type: "event", min_vitality: 0, limit: 24 }).sort((a, b) => b.vitality - a.vitality);
+      const stats = countMemories(db, aid);
+      const narrative = formatWarmBootNarrative(identity.length > 0 ? identity : base.identityMemories, emotion, knowledge, event, stats);
+      return { content: [{ type: "text", text: narrative }] };
     }
   );
   server.tool(
@@ -15480,7 +15243,6 @@ function createMcpServer(dbPath, agentId) {
       const mem = getMemory(db, id);
       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));
         deleteMemory2(db, id);
         return { content: [{ type: "text", text: JSON.stringify({ action: "deleted", id }) }] };
@@ -15494,97 +15256,80 @@ function createMcpServer(dbPath, agentId) {
       };
     }
   );
-  server.tool(
-    "link",
-    "Create or query associations between memories (knowledge graph).",
-    {
-      action: external_exports.enum(["create", "query", "traverse"]).describe("Action to perform"),
-      source_id: external_exports.string().optional().describe("Source memory ID"),
-      target_id: external_exports.string().optional().describe("Target memory ID (for create)"),
-      relation: external_exports.enum(["related", "caused", "reminds", "evolved", "contradicts"]).optional().describe("Relation type"),
-      max_hops: external_exports.number().default(2).describe("Max traversal depth (for traverse action)")
-    },
-    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, 1, aid);
-        return { content: [{ type: "text", text: JSON.stringify({ created: link }) }] };
-      }
-      if (action === "query" && 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, aid);
-        const detailed = nodes.map((n) => {
-          const m = getMemory(db, n.id);
-          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 }) }] };
-      }
-      return { content: [{ type: "text", text: '{"error": "Invalid action or missing params"}' }] };
-    }
-  );
-  server.tool(
-    "snapshot",
-    "View or rollback memory snapshots (version history).",
-    {
-      action: external_exports.enum(["list", "rollback"]).describe("list snapshots or rollback to one"),
-      memory_id: external_exports.string().optional().describe("Memory ID (for list)"),
-      snapshot_id: external_exports.string().optional().describe("Snapshot ID (for rollback)")
-    },
-    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 }) }] };
-      }
-      return { content: [{ type: "text", text: '{"error": "Invalid action or missing params"}' }] };
-    }
-  );
   server.tool(
     "reflect",
-    "Trigger sleep cycle phases: decay (Ebbinghaus), tidy (archive + cleanup), or govern (orphan removal).",
+    "Trigger sleep cycle phases and return a human-readable markdown report.",
     {
       phase: external_exports.enum(["decay", "tidy", "govern", "all"]).describe("Which sleep phase to run")
     },
     async ({ phase }) => {
-      const results = {};
+      const before = getSummaryStats(db, aid);
+      let decaySummary;
+      let tidySummary;
+      let governSummary;
+      const decayDetails = [];
+      const archivedDetails = [];
       if (phase === "decay" || phase === "all") {
-        results.decay = runDecay(db, { agent_id: aid });
+        const beforeRows = db.prepare("SELECT id, type, priority, vitality, content FROM memories WHERE agent_id = ?").all(aid);
+        const beforeMap = new Map(beforeRows.map((r) => [r.id, r]));
+        decaySummary = runDecay(db, { agent_id: aid });
+        const afterRows = db.prepare("SELECT id, vitality FROM memories WHERE agent_id = ?").all(aid);
+        for (const row of afterRows) {
+          const prev = beforeMap.get(row.id);
+          if (!prev) continue;
+          if (row.vitality < prev.vitality - 1e-3) {
+            decayDetails.push({
+              uri: getMemoryUri(db, row.id, aid),
+              type: prev.type,
+              priority: prev.priority,
+              oldVitality: prev.vitality,
+              newVitality: row.vitality,
+              content: prev.content
+            });
+          }
+        }
+        decayDetails.sort((a, b) => b.oldVitality - b.newVitality - (a.oldVitality - a.newVitality));
       }
       if (phase === "tidy" || phase === "all") {
-        results.tidy = runTidy(db, { agent_id: aid });
+        const candidates = db.prepare("SELECT id, content, vitality, priority FROM memories WHERE agent_id = ? AND vitality < 0.05 AND priority >= 3").all(aid);
+        tidySummary = runTidy(db, { agent_id: aid });
+        for (const c of candidates) {
+          const uriBeforeDelete = getMemoryUri(db, c.id, aid);
+          const exists = db.prepare("SELECT id FROM memories WHERE id = ?").get(c.id);
+          if (!exists) {
+            archivedDetails.push({
+              uri: uriBeforeDelete,
+              content: c.content,
+              vitality: c.vitality,
+              priority: c.priority
+            });
+          }
+        }
       }
       if (phase === "govern" || phase === "all") {
-        results.govern = runGovern(db, { agent_id: aid });
-      }
-      return { content: [{ type: "text", text: JSON.stringify(results, null, 2) }] };
+        governSummary = runGovern(db, { agent_id: aid });
+      }
+      const after = getSummaryStats(db, aid);
+      const report = formatReflectReport({
+        phase,
+        decaySummary,
+        decayDetails,
+        tidySummary,
+        archivedDetails,
+        governSummary,
+        before,
+        after
+      });
+      return { content: [{ type: "text", text: report }] };
     }
   );
   server.tool(
     "status",
-    "Get memory system statistics: counts by type/priority, health metrics.",
+    "Get memory system statistics: counts by type/priority and health metrics.",
     {},
     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 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: [{
@@ -15592,8 +15337,6 @@ function createMcpServer(dbPath, agentId) {
           text: JSON.stringify({
             ...stats,
             paths: totalPaths.c,
-            links: totalLinks.c,
-            snapshots: totalSnapshots.c,
             low_vitality: lowVitality.c,
             agent_id: aid
           }, null, 2)
@@ -15601,11 +15344,104 @@ function createMcpServer(dbPath, agentId) {
       };
     }
   );
+  server.tool(
+    "ingest",
+    "Extract structured memories from markdown text and write via syncOne().",
+    {
+      text: external_exports.string().describe("Markdown/plain text to ingest"),
+      source: external_exports.string().optional().describe("Source annotation, e.g. memory/2026-02-23.md"),
+      dry_run: external_exports.boolean().default(false).optional().describe("Preview extraction without writing")
+    },
+    async ({ text, source, dry_run }) => {
+      const result = ingestText(db, {
+        text,
+        source,
+        dryRun: dry_run,
+        agentId: aid
+      });
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify(result, null, 2)
+        }]
+      };
+    }
+  );
+  server.tool(
+    "surface",
+    "Lightweight readonly memory surfacing: keyword OR search + priority\xD7vitality\xD7hitRatio ranking (no access recording).",
+    {
+      keywords: external_exports.array(external_exports.string()).min(1).describe("Keywords to surface related memories"),
+      limit: external_exports.number().min(1).max(20).default(5).optional().describe("Max results (default 5, max 20)"),
+      types: external_exports.array(external_exports.enum(["identity", "emotion", "knowledge", "event"])).optional().describe("Optional type filter"),
+      min_vitality: external_exports.number().min(0).max(1).default(0.1).optional().describe("Minimum vitality filter")
+    },
+    async ({ keywords, limit, types, min_vitality }) => {
+      const maxResults = limit ?? 5;
+      const minVitality = min_vitality ?? 0.1;
+      const normalizedKeywords = keywords.map((k) => k.trim()).filter(Boolean);
+      const candidates = /* @__PURE__ */ new Map();
+      for (const kw of normalizedKeywords) {
+        const results = searchBM25(db, kw, { agent_id: aid, limit: 50, min_vitality: minVitality });
+        for (const r of results) {
+          const existing = candidates.get(r.memory.id);
+          if (existing) {
+            existing.hits += 1;
+          } else {
+            candidates.set(r.memory.id, { memory: r.memory, hits: 1 });
+          }
+        }
+      }
+      const scored = [...candidates.values()].filter((c) => c.memory.vitality >= minVitality).filter((c) => types?.length ? types.includes(c.memory.type) : true).map((c) => {
+        const weight = PRIORITY_WEIGHT[c.memory.priority] ?? 1;
+        const hitRatio = normalizedKeywords.length > 0 ? c.hits / normalizedKeywords.length : 0;
+        const score = weight * c.memory.vitality * hitRatio;
+        return {
+          memory: c.memory,
+          hits: c.hits,
+          score,
+          hitRatio
+        };
+      }).sort((a, b) => b.score - a.score).slice(0, maxResults);
+      const output = {
+        count: scored.length,
+        results: scored.map((s) => ({
+          id: s.memory.id,
+          uri: getMemoryUri(db, s.memory.id, aid),
+          type: s.memory.type,
+          priority: s.memory.priority,
+          vitality: s.memory.vitality,
+          content: s.memory.content,
+          score: s.score,
+          keyword_hits: s.hits,
+          updated_at: s.memory.updated_at
+        }))
+      };
+      return { content: [{ type: "text", text: JSON.stringify(output, null, 2) }] };
+    }
+  );
   return { server, db };
 }
 async function main() {
-  const { server } = createMcpServer();
+  const { server, db } = createMcpServer();
   const transport = new StdioServerTransport();
+  const autoIngestEnabled = process.env.AGENT_MEMORY_AUTO_INGEST !== "0";
+  const workspaceDir = process.env.AGENT_MEMORY_WORKSPACE ?? `${process.env.HOME ?? "."}/.openclaw/workspace`;
+  const agentId = process.env.AGENT_MEMORY_AGENT_ID ?? "default";
+  const watcher = autoIngestEnabled ? runAutoIngestWatcher({
+    db,
+    workspaceDir,
+    agentId
+  }) : null;
+  const shutdown = () => {
+    try {
+      watcher?.close();
+    } catch {
+    }
+  };
+  process.once("SIGINT", shutdown);
+  process.once("SIGTERM", shutdown);
+  process.once("exit", shutdown);
   await server.connect(transport);
 }
 var isMain = process.argv[1]?.includes("server");