@modusensus/dsh-mneme 0.8.1 → 0.8.3

package/src/runtime/model-fetch.js

@@ -0,0 +1,361 @@
+// 模型文件取件（issue #194）
+//
+// transformers.js 下载模型文件（如 model.onnx，约 1GB）走它自己的 env.fetch；undici
+// socket 中途被重置（TypeError: terminated）时整份下载作废重来。4.2.0 的 env.fetch 是
+// 官方文档化的可替换面（env.js: `fetch: DEFAULT_FETCH`），所以韧性做在这一层：对
+// transformers.js 而言这仍然是一个普通的 fetch，成功路径的语义一点没变；变化只发生在
+// 失败路径 —— 已收的字节落在磁盘 .part 里，重试（包括换一次进程）从断点继续。
+//
+// 硬规矩（与 runtime/download.js 的取件层同一套直觉）：
+//   1. 交给下游的响应永远是规范的 200 + 完整 content-length。hub.js 把非 200 一律当
+//      失败处理，206 直接透传反而会破坏下游；断点拼接是我们内部的事，不能漏出去。
+//   2. 续传前带 If-Range：断点对应的内容若在服务端被换过，服务器会回 200（全量）。
+//      旧断点拼新内容是一份静默损坏的模型 —— 宁可整份重来，不可拼错。
+//   3. 同一 URL 的 .part 同一时刻只允许一个写者。两个进程并发追加同一份字节是写损坏；
+//      抢不到锁就按现状直接转发（裸 fetch），让持锁的那份去落盘。
+//
+// @module dsh-mneme/runtime/model-fetch
+import { createHash } from "node:crypto";
+import { closeSync, createReadStream, existsSync, futimesSync, mkdirSync, openSync, readFileSync, rmSync, statSync, writeFileSync, writeSync } from "node:fs";
+import { Readable } from "node:stream";
+import { join } from "node:path";
+import { defaultModelCacheDir } from "./layout.js";
+
+const DEFAULT_ATTEMPTS = 3;
+const DEFAULT_RETRY_DELAY_MS = 1000;
+const DEFAULT_MAX_RETRY_DELAY_MS = 15000;
+// 看门狗是「连续无字节」上限而不是总时长上限：几百 MB～1GB 的文件在慢网下合法地要下
+// 几十分钟，总时长上限会掐死健康但慢的下载；连续这么久一个字节都没有才是 socket 僵死。
+const DEFAULT_IDLE_TIMEOUT_MS = 120000;
+// 锁的 mtime 超过这么久没刷新 = 持锁方已死（活着的话每个进度节拍都会刷新），可以抢。
+const STALE_LOCK_MS = 30 * 60 * 1000;
+// 进度事件节流：1GB 按 64KB 一块是一万多个事件，逐个发出去日志没法看。
+const PROGRESS_EMIT_INTERVAL_MS = 500;
+
+/** URL → 稳定文件名。断点文件要跨进程、跨重启可复用，所以用内容寻址而不是 pid。 */
+function partName(url) {
+  return createHash("sha256").update(url).digest("hex");
+}
+
+function readMeta(metaPath) {
+  try {
+    return readFileSync(metaPath, "utf8").trim();
+  } catch {
+    return "";
+  }
+}
+
+function writeMeta(metaPath, etag) {
+  writeFileSync(metaPath, `${etag}\n`, "utf8");
+}
+
+/** 断点不可信（比源文件还大 / 内容对不上）时整体作废，而不是试着修剪。 */
+function resetPart(partPath, metaPath) {
+  rmSync(partPath, { force: true });
+  rmSync(metaPath, { force: true });
+}
+
+/**
+ * 拿 .part 的写锁。返回 fd（持有着，供流式期间刷新 mtime）或 null（别人在写）。
+ * 只尝试偷一次过期锁：再抢不到就放弃，调用方按现状裸转发。
+ */
+function acquireLock(lockPath, staleLockMs) {
+  for (let i = 0; i < 2; i++) {
+    try {
+      const fd = openSync(lockPath, "wx");
+      writeSync(fd, String(process.pid));
+      return fd;
+    } catch {
+      let age = Infinity;
+      try {
+        age = Date.now() - statSync(lockPath).mtimeMs;
+      } catch {}
+      if (age > staleLockMs) {
+        rmSync(lockPath, { force: true });
+        continue;
+      }
+      return null;
+    }
+  }
+  return null;
+}
+
+function releaseLock(lockPath, lockFd) {
+  if (lockFd === null) return;
+  try {
+    closeSync(lockFd);
+  } catch {}
+  rmSync(lockPath, { force: true });
+}
+
+/** 进度事件的百分数。total 未知时给 null，让日志退化为「已收字节数」。 */
+function percentOf(received, total) {
+  return Number.isFinite(total) && total > 0 ? Math.floor((received / total) * 100) : null;
+}
+
+/**
+ * 造一个「带断点续传的 fetch」。
+ * @param {object} opts - 选项。
+ * @param {Function} [opts.fetchImpl] - 底层 fetch，测试注入。
+ * @param {string} opts.partDir - 断点文件目录（应与模型缓存同盘）。
+ * @param {number} [opts.attempts] - 含首次在内的总尝试次数。
+ * @param {number} [opts.retryDelayMs] - 退避基数：1s → 2s → 4s，封顶 maxRetryDelayMs。
+ * @param {number} [opts.idleTimeoutMs] - 连续无字节的看门狗上限。
+ * @param {Function} [opts.onEvent] - resume / progress / restart / fail 事件回调。
+ * @param {Function} [opts.hash] - URL → 断点文件名，测试注入。
+ * @returns {Function} 与全局 fetch 同签名的函数。
+ */
+export function createResilientFetch({
+  fetchImpl = fetch,
+  partDir,
+  attempts = DEFAULT_ATTEMPTS,
+  retryDelayMs = DEFAULT_RETRY_DELAY_MS,
+  maxRetryDelayMs = DEFAULT_MAX_RETRY_DELAY_MS,
+  idleTimeoutMs = DEFAULT_IDLE_TIMEOUT_MS,
+  onEvent = null,
+  hash = partName
+} = {}) {
+  if (typeof partDir !== "string" || partDir === "") {
+    throw new TypeError("createResilientFetch：partDir 是必填的（.part 断点文件落在这里）");
+  }
+  mkdirSync(partDir, { recursive: true });
+  const emit = (event) => {
+    try {
+      onEvent?.(event);
+    } catch {
+      // 进度回调的异常不该打断下载本身。
+    }
+  };
+
+  return async function resilientFetch(input, init = undefined) {
+    const url = typeof input === "string" ? input : String(input?.url ?? input);
+    const method = String(init?.method ?? "GET").toUpperCase();
+    // 非 GET（HEAD 元数据预检等）与带 body 的请求不落盘：原样转发，语义与裸 fetch 一致。
+    if (method !== "GET" || init?.body != null) return fetchImpl(input, init);
+
+    const partPath = join(partDir, hash(url));
+    const metaPath = `${partPath}.meta`;
+    const lockPath = `${partPath}.lock`;
+    const lockFd = acquireLock(lockPath, STALE_LOCK_MS);
+    if (lockFd === null) {
+      // 另一个进程正在下同一个文件。并发追加同一份 .part 是写损坏，所以这边不参与落盘，
+      // 按改动前的行为裸转发一次 —— 持锁方会正常下完，之后的加载会命中缓存。
+      return fetchImpl(input, init);
+    }
+
+    try {
+      return await downloadWithResume(url, init, {
+        fetchImpl,
+        partPath,
+        metaPath,
+        lockPath,
+        lockFd,
+        attempts,
+        retryDelayMs,
+        maxRetryDelayMs,
+        idleTimeoutMs,
+        emit
+      });
+    } catch (error) {
+      // 失败路径锁在这里释放；成功路径的锁随断点文件一起在响应体流关闭后清理 ——
+      // 若在返回响应时就放锁，另一个进程会在「.part 仍被下游流读着」的窗口里动它。
+      releaseLock(lockPath, lockFd);
+      throw error;
+    }
+  };
+}
+
+async function downloadWithResume(url, init, ctx) {
+  const { fetchImpl, partPath, metaPath, lockPath, lockFd, attempts, retryDelayMs, maxRetryDelayMs, idleTimeoutMs, emit } = ctx;
+  let lastError = null;
+  let lastPercent = null;
+  let lastReceived = 0;
+
+  for (let attempt = 1; attempt <= attempts; attempt++) {
+    let offset = 0;
+    if (existsSync(partPath)) {
+      offset = statSync(partPath).size;
+      if (offset > 0) {
+        emit({ type: "resume", url, offset, attempt });
+      }
+    }
+
+    const headers = new Headers(init?.headers);
+    if (offset > 0) {
+      headers.set("Range", `bytes=${offset}-`);
+      // If-Range：断点对应的内容在服务端被换过时，服务器回 200（全量）而不是 206 ——
+      // 那就整份重来。没有它，旧断点 + 新内容会拼出一份静默损坏的模型。
+      const storedEtag = readMeta(metaPath);
+      if (storedEtag) headers.set("If-Range", storedEtag);
+    }
+
+    const controller = new AbortController();
+    const onCallerAbort = () => controller.abort(init?.signal?.reason);
+    init?.signal?.addEventListener("abort", onCallerAbort, { once: true });
+    let idleTimer = null;
+    const armIdle = () => {
+      if (!(idleTimeoutMs > 0)) return;
+      if (idleTimer !== null) clearTimeout(idleTimer);
+      idleTimer = setTimeout(
+        () => controller.abort(new Error(`连接空闲超过 ${Math.round(idleTimeoutMs / 1000)}s 无数据`)),
+        idleTimeoutMs
+      );
+    };
+    armIdle();
+
+    let fd = -1;
+    let received = 0;
+    let total = null;
+    let lastEmitAt = 0;
+    const reportProgress = (force = false) => {
+      const now = Date.now();
+      if (!force && now - lastEmitAt < PROGRESS_EMIT_INTERVAL_MS) return;
+      lastEmitAt = now;
+      lastReceived = offset + received;
+      lastPercent = percentOf(lastReceived, total);
+      futimesSync(lockFd, new Date(), new Date()); // 锁的活着证明与进度同节拍刷新。
+      emit({ type: "progress", url, received: lastReceived, total, percent: lastPercent, attempt });
+    };
+
+    try {
+      const res = await fetchImpl(url, { ...init, headers, signal: controller.signal });
+
+      // Range 起点越过源文件末尾（断点比源还大，通常断点来自被替换前的旧文件）：
+      // 断点不可信 —— 清掉，这次尝试作废，下一次从 0 开始。不处理的话会在 416 上
+      // 把重试次数全部烧完，报一条用户看不懂的错。
+      if (res.status === 416) {
+        emit({ type: "restart", url, offset, attempt, reason: "range-not-satisfiable" });
+        resetPart(partPath, metaPath);
+        lastError = new Error("HTTP 416（断点已重置）");
+        continue;
+      }
+      if (!res.ok) throw new Error(`HTTP ${res.status}`);
+
+      if (offset > 0 && res.status === 200) {
+        // 服务器无视了 Range，或 If-Range 判定内容已变：整份重来。
+        emit({ type: "restart", url, offset, attempt, reason: "range-rejected" });
+        resetPart(partPath, metaPath);
+        offset = 0;
+      }
+      if (res.status === 206) {
+        const cr = /bytes (\d+)-(\d+)\/(\d+)/.exec(res.headers.get("content-range") ?? "");
+        if (cr === null) throw new Error("206 响应缺少 Content-Range");
+        total = Number(cr[3]);
+        if (Number(cr[1]) !== offset) {
+          // 服务器续的位置和断点对不上：不猜（拼错的字节比下载失败更糟），清掉重来。
+          emit({ type: "restart", url, offset, attempt, reason: "offset-mismatch" });
+          resetPart(partPath, metaPath);
+          throw new Error(`断点偏移不一致（本地 ${offset}，服务器 ${cr[1]}），断点已重置`);
+        }
+      } else {
+        total = Number(res.headers.get("content-length")) || null;
+      }
+      const etag = res.headers.get("etag");
+      if (etag) writeMeta(metaPath, etag);
+
+      fd = openSync(partPath, "a");
+      if (res.body !== null) {
+        const reader = res.body.getReader();
+        for (;;) {
+          const { done, value } = await reader.read();
+          if (done) break;
+          writeSync(fd, value);
+          received += value.length;
+          armIdle();
+          reportProgress();
+        }
+      }
+      // 服务端"干净地"提前关流（不抛错、但字节没给够）也是断流的一种，必须查出来。
+      if (total !== null && offset + received !== total) {
+        throw new Error(`下载不完整：收到 ${offset + received}/${total} 字节`);
+      }
+      clearTimeout(idleTimer);
+      idleTimer = null;
+      reportProgress(true);
+      return partResponse(partPath, metaPath, lockPath, lockFd, offset + received, etag);
+    } catch (error) {
+      lastError = error;
+      lastReceived = offset + received;
+      lastPercent = percentOf(lastReceived, total);
+      emit({ type: "fail", url, received: lastReceived, total, percent: lastPercent, attempt, error: String(error?.message ?? error) });
+    } finally {
+      if (fd >= 0) closeSync(fd);
+      if (idleTimer !== null) clearTimeout(idleTimer);
+      init?.signal?.removeEventListener("abort", onCallerAbort);
+    }
+
+    if (attempt < attempts) {
+      // 退避：1s → 2s → 4s，封顶 maxRetryDelayMs。
+      await new Promise((resolve) => setTimeout(resolve, Math.min(retryDelayMs * 2 ** (attempt - 1), maxRetryDelayMs)));
+    }
+  }
+
+  // 最终失败的错误必须带中断位置（issue #194 的第 3 项）：用户要能区分是网络断了
+  // 还是磁盘满了，而不是看到一句干巴巴的 TypeError: terminated。
+  const where = lastPercent !== null ? `中断于 ${lastPercent}%（${lastReceived} 字节）` : `已收 ${lastReceived} 字节`;
+  throw new Error(`模型文件下载失败（试了 ${attempts} 次，${where}）：${lastError?.message ?? lastError}`);
+}
+
+/**
+ * 把完成的断点文件包装成给下游的响应：规范的 200 + 完整 content-length，body 从磁盘
+ * 流式读出（1GB 不进内存）。流关闭即清理断点文件 —— 它给下游（FileCache.put /
+ * arrayBuffer）供字节的使命结束了，不清的话一个 1GB 的副本会一直躺在缓存旁边。
+ */
+function partResponse(partPath, metaPath, lockPath, lockFd, size, etag) {
+  const nodeStream = createReadStream(partPath);
+  const cleanup = () => {
+    try {
+      rmSync(partPath, { force: true });
+      rmSync(metaPath, { force: true });
+      releaseLock(lockPath, lockFd);
+    } catch {}
+  };
+  nodeStream.on("close", cleanup);
+  nodeStream.on("error", cleanup);
+  return new Response(Readable.toWeb(nodeStream), {
+    status: 200,
+    headers: {
+      "content-type": "application/octet-stream",
+      "content-length": String(size),
+      ...(etag ? { etag } : {})
+    }
+  });
+}
+
+/** 把事件映射成日志。只发人该看的行：续传、重来、每次失败的位置 —— 不刷进度条。 */
+export function logModelFetchEvent(logger, event) {
+  const kb = (n) => (n >= 1048576 ? `${(n / 1048576).toFixed(1)}MB` : `${Math.round(n / 1024)}KB`);
+  const where = (e) => (e.percent !== null && e.percent !== undefined ? `${e.percent}%（${kb(e.received)}${e.total ? `/${kb(e.total)}` : ""}）` : kb(e.received ?? 0));
+  switch (event.type) {
+    case "resume":
+      logger?.info?.(`[dsh-mneme] 模型下载带断点续传：已有 ${kb(event.offset)}，第 ${event.attempt} 次尝试`);
+      break;
+    case "restart":
+      logger?.warn?.(`[dsh-mneme] 断点不可用（${event.reason}），模型下载从头再来`);
+      break;
+    case "fail":
+      logger?.warn?.(`[dsh-mneme] 模型下载中断于 ${where(event)}，第 ${event.attempt} 次尝试失败：${event.error}`);
+      break;
+    default:
+      break;
+  }
+}
+
+/**
+ * 把弹性 fetch 装到 transformers.js 的 env 上（embedder / reranker 共用这一个入口）。
+ * @param {object} env - transformers.js 的 env（至少支持赋值 fetch）。
+ * @param {object} opts - 选项。
+ * @param {boolean} [opts.enabled] - 开关；关 = 完全不动 env（默认保持现状的出口）。
+ * @param {string} [opts.cacheDir] - 模型缓存目录，断点文件落在它的 .mneme-partial 下。
+ * @param {object} [opts.logger] - 接收下载进度日志的 logger。
+ * @param {object} [opts.rest] - 透传给 createResilientFetch 的其余选项（测试注入）。
+ * @returns {boolean} 是否实际安装。
+ */
+export function installResilientFetch(env, { enabled = true, cacheDir = "", logger = null, ...rest } = {}) {
+  if (!enabled || !env) return false;
+  const root = String(cacheDir ?? "").trim() || defaultModelCacheDir();
+  const partDir = join(root, ".mneme-partial");
+  mkdirSync(partDir, { recursive: true });
+  env.fetch = createResilientFetch({ partDir, onEvent: (event) => logModelFetchEvent(logger, event), ...rest });
+  return true;
+}

package/src/service.js

@@ -1235,7 +1235,7 @@ export function createService({ store, mirror, config, onWrite, logger }) {
    * fills + dedupes the remaining slots. Empty query / no cached recall /
    * hybridInject off → pure legacy rule-based selection.
    */
-  function injectCandidates({ query = "", maxItems = 5, threshold = 3, queryVector, scope = null } = {}) {
+  function injectCandidates({ query = "", maxItems = 5, threshold = 3, queryVector, scope = null, rotate = null, rotateWindow = 0 } = {}) {
     const q = String(query ?? "").trim();
     // codingRetrospect 读取侧门控：编码记忆（rejected_solution / pitfall /
     // constraint）只在编码任务时注入，防噪声污染其他业务；编码任务时按
@@ -1246,7 +1246,15 @@ export function createService({ store, mirror, config, onWrite, logger }) {
     // (quality_score null) count as 100 (weight 1), so legacy stores keep their
     // exact summary>preference>importance ordering.
     const qualityWeight = (m) => (m.quality_score != null ? m.quality_score / 100 : 1);
-    const items = store.list({ limit: 200, includeForgotten: false })
+    // Issue #205 补测：候选池必须比轮换窗口大——窗口 N 需要 maxItems×(N+1) 张
+    // 不同的牌，池子只有 maxItems×2 时窗口一开就被吃光、只剩回填（重复率的
+    // 结构性下限由池子大小决定）。无轮换时保持既有 maxItems×2 不变；规则路
+    // 的 200 条上限同样给轮换让路（上限翻倍也只是多读一次 SQL LIMIT）。
+    const rotateWindowN = Number.isInteger(rotateWindow) && rotateWindow > 0 ? rotateWindow : 0;
+    const poolSize = rotateWindowN > 0
+      ? Math.max(maxItems * 2, maxItems * (rotateWindowN + 1))
+      : maxItems * 2;
+    const items = store.list({ limit: Math.max(200, poolSize), includeForgotten: false })
       .filter((m) => !m.archived && INJECT_TYPES.has(m.type) && !m.forgotten &&
         codingGate(m) &&
         (m.type === "summary" || m.type === "preference" || m.importance >= threshold))
@@ -1277,7 +1285,7 @@ export function createService({ store, mirror, config, onWrite, logger }) {
       const semanticItems = [];
       if (Array.isArray(queryVector) && queryVector.length && vectorIndex) {
         try {
-          const hits = vectorIndex.search(queryVector, { limit: maxItems * 2, threshold: 0 });
+          const hits = vectorIndex.search(queryVector, { limit: poolSize, threshold: 0 });
           for (const m of hits) {
             if (m && !m.archived && INJECT_TYPES.has(m.type) && !m.forgotten &&
               codingGate(m) &&
@@ -1292,6 +1300,22 @@ export function createService({ store, mirror, config, onWrite, logger }) {
           if (m && !m.archived && INJECT_TYPES.has(m.type) && !m.forgotten && codingGate(m)) semanticItems.push(m);
         }
       }
+      // Issue #198：首轮（无向量、无缓存召回）的同步兜底——BM25 词法召回领位。
+      // 注入渲染是同步的（宿主 systemPrompt 的 contexts 不支持异步 text），
+      // 查询向量只能异步 prefetch 给下一轮，首轮必 miss；此时纯静态排序会让
+      // 老的高重要性 summary/preference 占满槽位，当前话题的 decision/project
+      // 进不来。查询文本本身就在手上，BM25 是纯进程内同步计算，词法相关性
+      // 足以把当前话题顶到前排；门控与向量路径一致（含 importance 阈值）。
+      // 语义向量命中时本分支不参与，行为不变。
+      if (!semanticItems.length) {
+        for (const hit of bm25Recall(q, poolSize)) {
+          if (hit && !hit.archived && INJECT_TYPES.has(hit.type) && !hit.forgotten &&
+            codingGate(hit) &&
+            (hit.type === "summary" || hit.type === "preference" || hit.importance >= threshold)) {
+            semanticItems.push(hit);
+          }
+        }
+      }
       if (semanticItems.length) {
         const seen = new Set();
         const merged = [];
@@ -1302,10 +1326,10 @@ export function createService({ store, mirror, config, onWrite, logger }) {
         };
         for (const m of semanticItems) {
           push(m);
-          if (merged.length >= maxItems * 2) break;
+          if (merged.length >= poolSize) break;
         }
         for (const m of items) {
-          if (merged.length >= maxItems * 2) break;
+          if (merged.length >= poolSize) break;
           push(m);
         }
         candidates = merged;
@@ -1330,6 +1354,14 @@ export function createService({ store, mirror, config, onWrite, logger }) {
     if (config?.strictScope === true && scope) {
       candidates = candidates.filter((m) => isVisibleInScope(m, scope));
     }
+    // Issue #205：注入位跨轮轮换。rotate = 最近 N 轮注入过的 id 集合（由注入层
+    // 按会话维护并传入）：这些条目本轮不再优先——新鲜者前置（各自内部相对次序
+    // 保持），不足时按原序回填，槽位数与 touchRecall 语义均不变。rotate 为空时
+    // 行为与既有排序完全一致。
+    if (rotate && rotate.size > 0 && candidates.length > 0) {
+      const fresh = candidates.filter((m) => !rotate.has(m.id));
+      if (fresh.length > 0) candidates = [...fresh, ...candidates.filter((m) => rotate.has(m.id))];
+    }
     const selected = candidates.slice(0, maxItems);
     touchRecalled(selected);
     return selected;

package/src/settings.js

@@ -52,6 +52,7 @@ const FEATURE_FLAG_BOOLEANS = [
   "selectiveInjectEnabled",
   "searchSemanticDedup",
   "rerankEnabled",
+  "resilientModelDownload",
   "adaptiveThresholdEnabled",
   "reflectionUpdateEnabled",
   "reflectionFailureTracking",

package/src/store.js

@@ -22,6 +22,9 @@ CREATE TABLE IF NOT EXISTS memories (
 );
 CREATE INDEX IF NOT EXISTS idx_memories_type ON memories(type);
 CREATE INDEX IF NOT EXISTS idx_memories_importance ON memories(importance);
+-- Issue #202：all()/list() 按 updated_at 排序，无索引时走临时 B 树全表排序
+-- （5k 行实测 all() 231ms → 135ms）。IF NOT EXISTS 幂等，存量库启动即建。
+CREATE INDEX IF NOT EXISTS idx_memories_updated ON memories(updated_at);
 
 -- autoDream audit trail: one row per consolidation run, capturing the exact
 -- input snapshot digest + the LLM decision list + per-id outcome + a compact
@@ -717,11 +720,51 @@ export function createStore(path) {
     }
   }
 
+  // Issue #202：embedding 解析缓存。检索路径此前每次调用都对全部带向量行
+  // JSON.parse（993 × 512 维 ≈ 48 ms/次，且 SQL 拖着 10 MB 的 TEXT），余弦本身
+  // 只占 3%。向量只经 setEmbedding 写入（单一失效点），把解析结果按 id 缓存，
+  // 命中即零解析；上限 FIFO 驱逐防大库内存无界（4000 × 512 维 double ≈ 16 MB）。
+  const embeddingCache = new Map();
+  const EMBEDDING_CACHE_MAX = 4000;
+
+  function cacheEmbedding(id, vector) {
+    if (embeddingCache.size >= EMBEDDING_CACHE_MAX && !embeddingCache.has(id)) {
+      const oldest = embeddingCache.keys().next().value;
+      embeddingCache.delete(oldest);
+    }
+    embeddingCache.set(id, vector);
+  }
+
+  /** Parsed embedding for one id (cache-first); undefined when none/parse
+   *  failure. Single read path shared by searchVector / getEmbedding(s). */
+  function getParsedEmbedding(id) {
+    const cached = embeddingCache.get(id);
+    if (cached) return cached;
+    const row = db.prepare("SELECT embedding FROM memories WHERE id = ?").get(id);
+    if (!row?.embedding) return undefined;
+    try {
+      const v = JSON.parse(row.embedding);
+      if (Array.isArray(v) && v.length) {
+        cacheEmbedding(id, v);
+        return v;
+      }
+    } catch { /* corrupt embedding text: treated as absent */ }
+    return undefined;
+  }
+
+  // all()/list() 的显式列清单：从实际 schema 派生（迁移后），只排除 embedding
+  // 列——consolidation/sleep/inject 的消费方都不读向量，而它是全表里最重的一列
+  // （5k 行库 ≈ 9.4 MB TEXT），每次全表调用都白搬。经 PRAGMA 派生而非硬编码，
+  // schema 演进时自动跟随。
+  const memoryColumns = db.prepare("PRAGMA table_info(memories)").all()
+    .map((c) => c.name)
+    .filter((n) => n !== "embedding");
+  const memoryColumnList = memoryColumns.join(", ");
+
   // Per-instance monotonic timestamp guard: consecutive writes within the same
   // millisecond must still produce strictly increasing timestamps (test asserts
   // updated_at != created_at). State lives in the store closure, not module scope.
-  let lastTs = "";
-  function nowIso() {
+  let lastTs = "";  function nowIso() {
     let ts = new Date().toISOString();
     if (lastTs && ts <= lastTs) {
       const d = new Date(lastTs);
@@ -925,6 +968,10 @@ export function createStore(path) {
         now,
         id
       );
+      // Issue #202：update 可直写 embedding（patch.embedding），缓存条目失效，
+      // 下次读取按库值重解析。宁滥勿缺——即便本 patch 未含 embedding，丢一条
+      // 缓存只多一次点查重解析。
+      embeddingCache.delete(id);
       // Desired generation bumped in the same transaction as the update (peer
       // blocker 1: crash between write and sync must still be recoverable).
       incrementGeneration();
@@ -995,6 +1042,8 @@ export function createStore(path) {
         expectedUpdatedAt
       );
       if (result.changes === 0) return; // CAS miss: a concurrent write won
+      // Issue #202：同 update——CAS 命中即可能改写 embedding，失效缓存条目。
+      embeddingCache.delete(id);
       // Only bump desired generation on a successful CAS — a miss writes nothing.
       incrementGeneration();
       applied = true;
@@ -1177,7 +1226,9 @@ export function createStore(path) {
   }
 
   function all() {
-    const rows = db.prepare("SELECT * FROM memories ORDER BY updated_at DESC").all();
+    // Issue #202：显式列清单排除 embedding——toRow 本就不输出向量，SELECT *
+    // 纯属把全表最重的列（9.4 MB TEXT/5k 行）拖进内存再丢弃。
+    const rows = db.prepare(`SELECT ${memoryColumnList} FROM memories ORDER BY updated_at DESC`).all();
     return rows.map(toRow);
   }
 
@@ -1185,6 +1236,17 @@ export function createStore(path) {
   function setEmbedding(id, vector) {
     const json = Array.isArray(vector) && vector.length ? JSON.stringify(vector) : null;
     db.prepare("UPDATE memories SET embedding = ? WHERE id = ?").run(json, id);
+    // Issue #202：单一写入口即单一失效点——重写缓存条目（向量在手上不必重解析），
+    // 清空则移除，删除过的 id 不会被下一次 searchVector 的 id 集合选中。
+    if (json) {
+      try {
+        const parsed = JSON.parse(json);
+        if (Array.isArray(parsed) && parsed.length) cacheEmbedding(id, parsed);
+        else embeddingCache.delete(id);
+      } catch { embeddingCache.delete(id); }
+    } else {
+      embeddingCache.delete(id);
+    }
   }
 
   /** Batch fetch stored embeddings by id (v0.5.0 search-time semantic dedup).
@@ -1193,19 +1255,10 @@ export function createStore(path) {
   function getEmbeddings(ids) {
     const out = new Map();
     const list = (Array.isArray(ids) ? ids : []).filter(Boolean);
-    for (let i = 0; i < list.length; i += 100) {
-      const chunk = list.slice(i, i + 100);
-      const rows = db.prepare(
-        `SELECT id, embedding FROM memories
-         WHERE embedding IS NOT NULL AND embedding != ''
-           AND id IN (${chunk.map(() => "?").join(",")})`
-      ).all(...chunk);
-      for (const row of rows) {
-        try {
-          const vec = JSON.parse(row.embedding);
-          if (Array.isArray(vec) && vec.length) out.set(row.id, vec);
-        } catch { /* corrupt row: skip */ }
-      }
+    for (const id of list) {
+      // Issue #202：走同一解析缓存（语义去重的批量读也免重复 parse）。
+      const vec = getParsedEmbedding(id);
+      if (vec) out.set(id, vec);
     }
     return out;
   }
@@ -1280,24 +1333,30 @@ export function createStore(path) {
   function searchVector(vector, { limit = 20, includeArchived = false, threshold = 0 } = {}) {
     if (!Array.isArray(vector) || !vector.length) return [];
     const archivedFilter = includeArchived ? "" : "archived = 0 AND ";
+    // Issue #202：只取 id 列（~40 KB）而非 SELECT *（~11 MB）——向量从缓存取，
+    // 缓存未命中时按 id 点查 embedding 再解析回填。SQL 里保留 embedding 的
+    // IS NOT NULL 过滤，保证「有向量的行」集合始终以库为准（删除/清空即时生效）。
     const rows = db.prepare(
-      `SELECT * FROM memories
+      `SELECT id FROM memories
        WHERE ${archivedFilter}forgotten = 0 AND embedding IS NOT NULL AND embedding != ''`
     ).all();
     const scored = [];
     for (const row of rows) {
-      let v;
-      try {
-        v = JSON.parse(row.embedding);
-      } catch {
-        continue;
-      }
+      const v = getParsedEmbedding(row.id);
+      if (!v) continue;
       const score = cosine(vector, v);
-      if (score >= threshold) scored.push({ row, score });
+      if (score >= threshold) scored.push({ row: { id: row.id }, score });
     }
     scored.sort((a, b) => b.score - a.score);
     const { limit: lim } = sanitizePage(limit, 0, 20);
-    return scored.slice(0, lim).map(({ row, score }) => ({ ...toRow(row), score }));
+    // Top-N 回表：只对入选行取完整字段（主键点查 ≤ lim 行），评分别拖着正文走。
+    const getFull = db.prepare("SELECT * FROM memories WHERE id = ?");
+    const out = [];
+    for (const { row, score } of scored.slice(0, lim)) {
+      const full = getFull.get(row.id);
+      if (full) out.push({ ...toRow(full), score });
+    }
+    return out;
   }
 
   // --- autoDream audit trail ----------------------------------------------
@@ -2245,6 +2304,7 @@ export function createStore(path) {
     search,
     setEmbedding,
     getEmbeddings,
+    getParsedEmbedding,
     embeddedCount,
     needsEmbedding,
     searchVector,

package/src/summarize.js

@@ -144,7 +144,7 @@ function collectMessages(session, maxChars = 8000, language = "zh") {
         break;
     }
   }
-  return lines.length ? [createUserMessage({ content: [{ type: "text", text: trim(lines.join("\n"), maxChars) }] })] : [];
+  return lines.length ? [createUserMessage({ content: [{ type: "text", text: trim(lines.join("\n"), maxChars) }], source: { kind: "plugin", plugin: "dsh-mneme" } })] : [];
 }
 
 // ── 智能调速器（429 保护）─────────────────────────────────────────────
@@ -265,7 +265,7 @@ export function createSummarizer(ctx, service, config) {
         model: route.model,
         purpose: "summarization",
         messages: [
-          { role: "system", content: [{ type: "text", text: config.codingRetrospect ? STR.prompts.codingSummary[langOf(config)] : STR.prompts.summary[langOf(config)] }] },
+          { role: "system", content: [{ type: "text", text: config.codingRetrospect ? STR.prompts.codingSummary[langOf(config)] : STR.prompts.summary[langOf(config)] }], source: { kind: "plugin", plugin: "dsh-mneme" } },
           ...messages
         ],
         signal: controller.signal