@smyslenny/agent-memory 2.1.0 → 3.1.0

package/dist/index.js

@@ -565,108 +565,6 @@ function deletePath(db, id) {
   return result.changes > 0;
 }
 
-// src/core/link.ts
-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 getOutgoingLinks(db, sourceId, agent_id) {
-  const agentId = agent_id ?? db.prepare("SELECT agent_id FROM memories WHERE id = ?").get(sourceId)?.agent_id ?? "default";
-  return db.prepare("SELECT * FROM links WHERE agent_id = ? AND source_id = ?").all(agentId, sourceId);
-}
-function traverse(db, startId, maxHops = 2, 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;
-}
-function deleteLink(db, sourceId, targetId, agent_id) {
-  const agentId = agent_id ?? db.prepare("SELECT agent_id FROM memories WHERE id = ?").get(sourceId)?.agent_id ?? "default";
-  const result = db.prepare("DELETE FROM links WHERE agent_id = ? AND source_id = ? AND target_id = ?").run(agentId, sourceId, targetId);
-  return result.changes > 0;
-}
-
-// src/core/snapshot.ts
-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/core/guard.ts
 function guard(db, input) {
   const hash = contentHash(input.content);
@@ -880,389 +778,314 @@ function buildFtsQuery(text) {
   return tokens.map((w) => `"${w}"`).join(" OR ");
 }
 
-// src/search/intent.ts
-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
+// src/sleep/sync.ts
+function syncOne(db, input) {
+  const memInput = {
+    content: input.content,
+    type: input.type ?? "event",
+    priority: input.priority,
+    emotion_val: input.emotion_val,
+    source: input.source,
+    agent_id: input.agent_id,
+    uri: input.uri
   };
-  for (const [intent, patterns] of Object.entries(INTENT_PATTERNS)) {
-    for (const pattern of patterns) {
-      if (pattern.test(query)) {
-        scores[intent] += 1;
+  const guardResult = guard(db, memInput);
+  switch (guardResult.action) {
+    case "skip":
+      return { action: "skipped", reason: guardResult.reason, memoryId: guardResult.existingId };
+    case "add": {
+      const mem = createMemory(db, memInput);
+      if (!mem) return { action: "skipped", reason: "createMemory returned null" };
+      if (input.uri) {
+        try {
+          createPath(db, mem.id, input.uri);
+        } catch {
+        }
       }
+      return { action: "added", memoryId: mem.id, reason: guardResult.reason };
     }
-  }
-  for (const [intent, patterns] of Object.entries(CN_STRUCTURE_BOOSTS)) {
-    for (const pattern of patterns) {
-      if (pattern.test(query)) {
-        scores[intent] += 0.5;
-      }
+    case "update": {
+      if (!guardResult.existingId) return { action: "skipped", reason: "No existing ID for update" };
+      updateMemory(db, guardResult.existingId, { content: input.content });
+      return { action: "updated", memoryId: guardResult.existingId, reason: guardResult.reason };
     }
-  }
-  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;
+    case "merge": {
+      if (!guardResult.existingId || !guardResult.mergedContent) {
+        return { action: "skipped", reason: "Missing merge data" };
+      }
+      updateMemory(db, guardResult.existingId, { content: guardResult.mergedContent });
+      return { action: "merged", memoryId: guardResult.existingId, reason: guardResult.reason };
     }
   }
-  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
-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;
+function syncBatch(db, inputs) {
+  const results = [];
+  const transaction = db.transaction(() => {
+    for (const input of inputs) {
+      results.push(syncOne(db, input));
     }
-    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/embeddings.ts
-function encodeEmbedding(vector) {
-  const arr = vector instanceof Float32Array ? vector : Float32Array.from(vector);
-  return Buffer.from(arr.buffer, arr.byteOffset, arr.byteLength);
-}
-function decodeEmbedding(buf) {
-  const copy = Buffer.from(buf);
-  return new Float32Array(copy.buffer, copy.byteOffset, Math.floor(copy.byteLength / 4));
-}
-function upsertEmbedding(db, input) {
-  const ts = now();
-  const vec = input.vector instanceof Float32Array ? input.vector : Float32Array.from(input.vector);
-  const blob = encodeEmbedding(vec);
-  db.prepare(
-    `INSERT INTO embeddings (agent_id, memory_id, model, dim, vector, created_at, updated_at)
-     VALUES (?, ?, ?, ?, ?, ?, ?)
-     ON CONFLICT(agent_id, memory_id, model) DO UPDATE SET
-       dim = excluded.dim,
-       vector = excluded.vector,
-       updated_at = excluded.updated_at`
-  ).run(input.agent_id, input.memory_id, input.model, vec.length, blob, ts, ts);
-}
-function getEmbedding(db, agent_id, memory_id, model) {
-  const row = db.prepare(
-    "SELECT agent_id, memory_id, model, dim, vector, created_at, updated_at FROM embeddings WHERE agent_id = ? AND memory_id = ? AND model = ?"
-  ).get(agent_id, memory_id, model);
-  if (!row) return null;
-  return { ...row, vector: decodeEmbedding(row.vector) };
-}
-function listEmbeddings(db, agent_id, model) {
-  const rows = db.prepare(
-    "SELECT memory_id, vector FROM embeddings WHERE agent_id = ? AND model = ?"
-  ).all(agent_id, model);
-  return rows.map((r) => ({ memory_id: r.memory_id, vector: decodeEmbedding(r.vector) }));
+  transaction();
+  return results;
 }
 
-// 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;
+// src/ingest/ingest.ts
+function slugify(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 (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);
+  if (/##\s*情感|❤️|💕|爱你|感动|难过|开心|害怕|想念|表白/.test(text)) {
+    return "emotion";
   }
-  const qVec = Float32Array.from(await provider.embed(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) });
+  if (/##\s*决策|##\s*技术|选型|教训|\bknowledge\b|⚠️|复盘|经验/.test(text)) {
+    return "knowledge";
   }
-  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("+")
-    });
+  if (/\d{4}-\d{2}-\d{2}|发生了|完成了|今天|昨日|刚刚|部署|上线/.test(text)) {
+    return "event";
   }
-  out.sort((a, b) => b.score - a.score);
-  return out.slice(0, limit);
-}
-
-// src/search/providers.ts
-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;
-    return createOpenAIProvider({ apiKey, model, baseUrl });
+  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;
   }
-  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;
-    return createDashScopeProvider({ apiKey, model, baseUrl });
+  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 }));
   }
-  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;
+  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 domain = type === "identity" ? "core" : type;
+    const sourcePart = slugify(source ?? "ingest");
+    const uri = `${domain}://ingest/${sourcePart}/${index + 1}-${slugify(block.title)}`;
+    return {
+      index,
+      title: block.title,
+      content: block.content,
+      type,
+      uri
+    };
   });
 }
-function createOpenAIProvider(opts) {
-  const baseUrl = opts.baseUrl ?? "https://api.openai.com/v1";
+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 {
-    id: "openai",
-    model: opts.model,
-    async embed(text) {
-      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: text })
+    extracted: extracted.length,
+    written,
+    skipped,
+    dry_run: false,
+    details
+  };
+}
+
+// src/ingest/watcher.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2, readdirSync, statSync, watch } from "fs";
+import { join as join2, relative, resolve } from "path";
+function runAutoIngestWatcher(options) {
+  const workspaceDir = resolve(options.workspaceDir);
+  const memoryDir = join2(workspaceDir, "memory");
+  const memoryMdPath = join2(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 (!existsSync2(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
       });
-      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();
-      const emb = data.data?.[0]?.embedding;
-      return normalizeEmbedding(emb);
+      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)}`);
     }
   };
-}
-function createDashScopeProvider(opts) {
-  const baseUrl = opts.baseUrl ?? "https://dashscope.aliyuncs.com";
-  return {
-    id: "dashscope",
-    model: opts.model,
-    async embed(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] }
-        })
+  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)}`);
       });
-      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);
+    }, debounceMs);
+    timers.set(absPath, timer);
+  };
+  const safeWatch = (dir, onEvent) => {
+    if (!existsSync2(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)}`);
     }
   };
-}
-
-// 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
+  safeWatch(workspaceDir, (eventType, filename) => {
+    if (filename === "MEMORY.md") {
+      scheduleIngest(join2(workspaceDir, filename), `workspace:${eventType}`);
+    }
   });
-  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++;
+  safeWatch(memoryDir, (eventType, filename) => {
+    if (filename.endsWith(".md")) {
+      scheduleIngest(join2(memoryDir, filename), `memory:${eventType}`);
+    }
+  });
+  if (initialScan) {
+    scheduleIngest(memoryMdPath, "initial");
+    if (existsSync2(memoryDir)) {
+      for (const file of readdirSync(memoryDir)) {
+        if (file.endsWith(".md")) {
+          scheduleIngest(join2(memoryDir, file), "initial");
+        }
+      }
+    }
   }
-  return { embedded, scanned: rows.length };
+  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/sleep/decay.ts
@@ -1325,74 +1148,15 @@ function getDecayedMemories(db, threshold = 0.05, opts) {
   ).all(...agentId ? [threshold, agentId] : [threshold]);
 }
 
-// src/sleep/sync.ts
-function syncOne(db, input) {
-  const memInput = {
-    content: input.content,
-    type: input.type ?? "event",
-    priority: input.priority,
-    emotion_val: input.emotion_val,
-    source: input.source,
-    agent_id: input.agent_id,
-    uri: input.uri
-  };
-  const guardResult = guard(db, memInput);
-  switch (guardResult.action) {
-    case "skip":
-      return { action: "skipped", reason: guardResult.reason, memoryId: guardResult.existingId };
-    case "add": {
-      const mem = createMemory(db, memInput);
-      if (!mem) return { action: "skipped", reason: "createMemory returned null" };
-      if (input.uri) {
-        try {
-          createPath(db, mem.id, input.uri);
-        } catch {
-        }
-      }
-      return { action: "added", memoryId: mem.id, reason: guardResult.reason };
-    }
-    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 };
-    }
-    case "merge": {
-      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 };
-    }
-  }
-}
-function syncBatch(db, inputs) {
-  const results = [];
-  const transaction = db.transaction(() => {
-    for (const input of inputs) {
-      results.push(syncOne(db, input));
-    }
-  });
-  transaction();
-  return results;
-}
-
 // src/sleep/tidy.ts
 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++;
     }
@@ -1404,35 +1168,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(
@@ -1441,23 +1185,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
@@ -1514,56 +1246,39 @@ function boot(db, opts) {
 export {
   boot,
   calculateVitality,
-  classifyIntent,
+  classifyIngestType,
   contentHash,
   countMemories,
-  createDashScopeProvider,
-  createLink,
   createMemory,
-  createOpenAIProvider,
   createPath,
-  createSnapshot,
-  decodeEmbedding,
-  deleteLink,
   deleteMemory,
   deletePath,
-  embedMemory,
-  embedMissingForAgent,
-  encodeEmbedding,
   exportMemories,
+  extractIngestItems,
   getDecayedMemories,
-  getEmbedding,
-  getEmbeddingProviderFromEnv,
-  getLinks,
   getMemory,
-  getOutgoingLinks,
   getPath,
   getPathByUri,
   getPathsByDomain,
   getPathsByMemory,
   getPathsByPrefix,
-  getSnapshot,
-  getSnapshots,
-  getStrategy,
   guard,
+  ingestText,
   isCountRow,
-  listEmbeddings,
   listMemories,
   openDatabase,
   parseUri,
   recordAccess,
-  rerank,
-  rollback,
+  runAutoIngestWatcher,
   runDecay,
   runGovern,
   runTidy,
   searchBM25,
-  searchHybrid,
+  slugify,
+  splitIngestBlocks,
   syncBatch,
   syncOne,
   tokenize,
-  traverse,
-  updateMemory,
-  upsertEmbedding
+  updateMemory
 };
 //# sourceMappingURL=index.js.map