@modusensus/dsh-mneme 0.8.15 → 0.9.0

package/lib/reclaim-http.js

@@ -0,0 +1,150 @@
+// 存储回收（maintenance/reclaim）的 HTTP 口径 —— 唯一实现。
+//
+// 为什么要单独一个模块：这张脸有两个入口——宿主内的面板路由（src/api.js 的
+// /api/dsh-mneme/maintenance/reclaim）与 Bearer 数据面（src/api-standalone.js 的
+// /maintenance/reclaim）。两者底下是**同一份** src/maintenance.js，差别只在鉴权与
+// 路径。历史上它们是整段复制的，于是 #410 修好面板侧的上界与兜错之后，数据面还停在
+// 旧形态（#411）——复制粘贴漂移不是设计，是缺陷。
+//
+// 口径（错误码字符串、默认值、报告形状）现在只写在这里，两个入口都调它。这样
+// 「改一边忘一边」在结构上就不可能发生；真要再写第二份，test/reclaim-http.test.js
+// 的静态锁会直接转红。
+//
+// 这里只做协议层的事：解析、校验、把 maintenance.reclaim 的结果包成答复。一行数据
+// 都不改——真正的丢弃逻辑在 src/maintenance.js。
+
+/**
+ * 回收窗口上界。整数校验挡不住量级：1e20 也是整数，而 maintenance 会拿它算
+ * `now() - days * 86400000` 再 toISOString()，抛 RangeError；GET 侧 400 位十进制
+ * 字面量还会化成 Infinity，被当成畸形输入静默落回默认窗口 7——调用方要一个巨大
+ * 窗口，实际只清了 7 天外的东西，而报告上写着 7 看不出异样。
+ *
+ * 取值与 config.js 的 llmAudit.retentionDays / recallRetentionDays 同一条线
+ * （3650 天 = 10 年）：回收窗口比审计保留期还长没有意义，那之后的东西本来也不在。
+ */
+export const MAX_RECLAIM_WINDOW_DAYS = 3650;
+
+/** 拒执行时的提示。两个入口必须逐字一致——它是给调用方看的下一步动作。 */
+export const RECLAIM_CONFIRM_HINT = "先看 dry-run 报告，确认后带 {\"dryRun\":false,\"confirm\":true} 再发";
+
+/**
+ * 「维护能力没接线」的错误码。两个入口各有一次**顺序敏感**的显式检查（503 要赢过
+ * 400：端点整个没接线时，报「窗口不合法」是误导），所以这条不能只藏在 reclaimReply
+ * 里；但也必须是同一份字符串，否则两张皮又能各写各的。
+ */
+export const RECLAIM_UNAVAILABLE = "maintenance-unavailable";
+
+/** 回收失败的 warn 文案。两条路径共用，日志里不会出现两种拼法。 */
+export function reclaimWarnMessage(error) {
+  return `[dsh-mneme] storage reclaim failed: ${String(error)}`;
+}
+
+/**
+ * 解析 GET 的 ?olderThanDays（searchParams.get 的原始字符串）。
+ *
+ * query 是字符串域：只收十进制整数字面量，缺省才落默认窗口。**不能用 Number()**
+ * ——它把 ""/[]/" " 都化成 0，而 0 在这里是「清掉全部快照」，最坏解释绝不能从一个
+ * 畸形输入静默拿到（POST 侧收 JSON 数字，口径不同，见 readReclaimFields）。
+ *
+ * @returns {{ok: true, olderThanDays: number|undefined} | {ok: false, error: string}}
+ */
+export function parseReclaimQuery(raw) {
+  if (raw === null) return { ok: true, olderThanDays: undefined };
+  if (!/^\d+$/.test(raw)) return { ok: false, error: "invalid-older-than-days" };
+  const olderThanDays = Number(raw);
+  // 十进制字面量不保证是个能算日期的数：400 位数字会化成 Infinity。
+  if (!Number.isFinite(olderThanDays) || olderThanDays > MAX_RECLAIM_WINDOW_DAYS) {
+    return { ok: false, error: "invalid-older-than-days" };
+  }
+  return { ok: true, olderThanDays };
+}
+
+/**
+ * 解析 POST body（已读成文本）的结构。只判 JSON 与顶层形状，字段在
+ * readReclaimFields 里读——两步分开是为了让调用方保住「invalid-json → invalid-body
+ * → maintenance 是否接线 → 字段」这个顺序，这个顺序是既有的对外行为。
+ *
+ * 不用 parseBody：它把坏 JSON 吞成 {}，而 invalid-json 与 invalid-body 是两个不同
+ * 的错（前者是调用方发坏了，后者是发成了数组/null）。
+ *
+ * @returns {{ok: true, body: object} | {ok: false, error: string}}
+ */
+export function parseReclaimJson(text) {
+  let body;
+  try {
+    body = JSON.parse(text || "{}");
+  } catch {
+    return { ok: false, error: "invalid-json" };
+  }
+  if (body === null || typeof body !== "object" || Array.isArray(body)) {
+    return { ok: false, error: "invalid-body" };
+  }
+  return { ok: true, body };
+}
+
+/**
+ * 读 POST 的字段并归一化。
+ *
+ * @returns {{ok: true, dryRun: boolean, olderThanDays: number|undefined, vacuum: boolean,
+ *            confirm: boolean} | {ok: false, error: string}}
+ */
+export function readReclaimFields(body) {
+  const dryRun = body.dryRun !== false;
+  // 只收 JSON 数字：Number() 会把 ""/[]/false 都化成 0，而 0 在这里是「清掉全部
+  // 快照」——最坏解释绝不能让一个畸形输入静默拿到。
+  const olderThanDays = body.olderThanDays === undefined || body.olderThanDays === null
+    ? undefined
+    : body.olderThanDays;
+  if (olderThanDays !== undefined
+    && (!Number.isInteger(olderThanDays) || olderThanDays < 0 || olderThanDays > MAX_RECLAIM_WINDOW_DAYS)) {
+    return { ok: false, error: "invalid-older-than-days" };
+  }
+  if (body.vacuum !== undefined && typeof body.vacuum !== "boolean") {
+    return { ok: false, error: "invalid-vacuum" };
+  }
+  return {
+    ok: true,
+    dryRun,
+    olderThanDays,
+    vacuum: body.vacuum === true,
+    confirm: body.confirm === true
+  };
+}
+
+/**
+ * 把一次回收请求变成 { status, body }。调用方只管 sendJson，不自己拼答复。
+ *
+ * 报告一律不加包装层（就是 maintenance.reclaim 的原样返回）：面板与数据面都直接读
+ * planned/cleared/vacuum 这几格。
+ *
+ * confirm-required 分支里那份 dry-run 报告是**在这里**算的。它曾经写在 readBody 的
+ * 回调里，而外层 try 那时已经退栈——抛出去就是一个没人接的 rejection，客户端拿到的
+ * 不是 500 而是「一个字节都没回」（#410 实测）。所以本地兜住，与执行路径给出同一个
+ * 500 internal。
+ *
+ * @param {{maintenance: object|null, dryRun: boolean, olderThanDays?: number,
+ *          vacuum?: boolean, confirm?: boolean, warn?: ((msg: string) => void)|null}} input
+ * @returns {{status: number, body: object}}
+ */
+export function reclaimReply({ maintenance, dryRun, olderThanDays, vacuum = false, confirm = false, warn = null }) {
+  if (!maintenance) return { status: 503, body: { error: RECLAIM_UNAVAILABLE } };
+  if (!dryRun && confirm !== true) {
+    // 拒执行，但把 dry-run 报告一并回给调用方：确认的依据就是这份数字。报告必须描述
+    // **将要执行的那个动作**，所以 vacuum 原样带上——否则调用方看到的是「不 VACUUM」
+    // 的数字，却带着 vacuum 去执行。
+    let report;
+    try {
+      report = maintenance.reclaim({ olderThanDays, vacuum, dryRun: true });
+    } catch (error) {
+      warn?.(reclaimWarnMessage(error));
+      return { status: 500, body: { error: "internal" } };
+    }
+    return { status: 400, body: { error: "confirm-required", hint: RECLAIM_CONFIRM_HINT, report } };
+  }
+  try {
+    return { status: 200, body: maintenance.reclaim({ olderThanDays, vacuum, dryRun }) };
+  } catch (error) {
+    warn?.(reclaimWarnMessage(error));
+    return { status: 500, body: { error: "internal" } };
+  }
+}

package/lib/safe-slice.js

@@ -0,0 +1,18 @@
+// Issue #334：UTF-16 截断切开 emoji 代理对会留下孤立代理项（如 🔴 = D83D DD34
+// 在 800 处切，D83D 留下、DD34 被切走）。DSH 把它序列化成非法 UTF-8，DeepSeek
+// API 对每个请求回 400 INVALID_REQUEST——而且畸形文本随注入消息被永久写进会话
+// 历史，此后**每一轮**都带着它，表现为会话从某一轮起连续 400、换话题/重启都不
+// 恢复（会话级不可逆损坏）。防法是「少一个字符都行，绝不留半个」：尾字符是
+// 高位代理（0xD800–0xDBFF）说明它的低位搭档被切走了，把这个高位代理整个丢掉。
+// （反过来尾字符是低位代理不可能孤立——它的搭档必然紧邻在前、同在切点之内。）
+// ASCII-only 的文本零开销（length 相等直接短路）。
+// （原为 inject.js 模块私有；热记忆的轮次抽取同样要做正文截断，收拢成共享模块
+// 以免两份实现漂移。）
+export function safeSlice(text, limit) {
+  const s = String(text);
+  if (s.length <= limit) return s;
+  let cut = s.slice(0, limit);
+  const tail = cut.charCodeAt(cut.length - 1);
+  if (tail >= 0xd800 && tail <= 0xdbff) cut = cut.slice(0, -1);
+  return cut;
+}

package/lib/scope.js

@@ -48,9 +48,17 @@ export function createScopeResolver({ ctx, config, logger } = {}) {
       header = null;
     }
 
+    // header 字段的读取要各自护住：session.header 本身取得回来，不代表它的字段
+    // 取得回来——宿主可以给出会抛错的 accessor（sessionOf / sessionKeyOf 就是为
+    // 同一类宿主写的）。漏在这里的异常会穿出解析器，把调用方的整段写入拖挂：
+    // 蒸馏路径上是一个窗口的记忆与游标一起丢，工具路径上是一次 memory_save 直接失败。
     let agentScope = null;
-    const preset = header?.agentPreset;
-    if (typeof preset === "string" && preset.trim()) agentScope = preset.trim();
+    try {
+      const preset = header?.agentPreset;
+      if (typeof preset === "string" && preset.trim()) agentScope = preset.trim();
+    } catch (e) {
+      warnOnce(`[dsh-mneme] session header agentPreset lookup failed: ${String(e)}`);
+    }
 
     // workspace：registry 反查优先（成员资格 = id 命中 + header canonical cwd
     // 校验过，path 已 realpath 归一），失败回退 header.cwd，再失败留 NULL。
@@ -70,8 +78,12 @@ export function createScopeResolver({ ctx, config, logger } = {}) {
       );
     }
     if (!workspaceScope) {
-      const cwd = header?.cwd;
-      if (typeof cwd === "string" && cwd.trim()) workspaceScope = cwd.trim();
+      try {
+        const cwd = header?.cwd;
+        if (typeof cwd === "string" && cwd.trim()) workspaceScope = cwd.trim();
+      } catch (e) {
+        warnOnce(`[dsh-mneme] session header cwd lookup failed: ${String(e)}`);
+      }
     }
 
     return { agent_scope: agentScope, workspace_scope: workspaceScope };

package/lib/serve.js

@@ -112,7 +112,7 @@ export async function createServeRuntime({
     }
   }
 
-  // index.js:294-309:检索回执落 recall_runs(searchMemories 的 recordRecall 默认开,
+  // index.js 的 setRecallRecorder（2026-10-14 在 :339-350）：检索回执落 recall_runs(searchMemories 的 recordRecall 默认开,
   // 第三方检索统计因此不缺数)。best-effort:回执写失败绝不影响检索本身。
   service.setRecallRecorder((recall) => {
     try {

package/lib/service.js

@@ -13,7 +13,20 @@ import { createBM25Index } from "./search/bm25.js";
 import { adaptiveThreshold } from "./search/adaptive.js";
 import { anchorSeeds, normalizePath, cascadeDepths, HOP_QUOTA } from "./graph/anchoring.js";
 
-const INJECT_TYPES = new Set(["preference", "project", "decision", "summary", "rejected_solution", "pitfall", "constraint"]);
+// Issue #369：蒸馏白名单（src/summarize.js 的 VALID）产得出 history，注入白名单
+// 原先不收——本机活跃库实测 378/1820（20.8%）因此永不可自动注入，而它们在同一库
+// 的 recall_runs `auto` 模式里被按需检索过 328 次：不是垃圾数据，只是进不了注入池。
+// 收编后候选池 1362 → 1713（+25.8%），按 top_k=5 粗算约多占 1 席；重要度闸门对
+// history 一视同仁（见 injectCandidates 的 importance >= threshold），低于闸门照旧出局。
+// pattern 一并收编：它一度被当成「只由手工写入（实测 40 条全 source=manual）」——那个
+// 判据是错的。机器一直在 mint：2026-10-14 按 dream_runs 的 patterns.applied 逐轮求和，
+// 得 144，与表内 pattern 行数 144 相等（72 轮 sleep 里 48 轮 ok，auto 轮 0），来源是
+// src/dream/sleep.js 的 phasePatterns；当时的 source=manual 只是 saveWithDedupe 没拿到
+// source 时的兜底值，不是「人写的」的意思（现在 mint 会带 source=sleep/dream）。
+// 但它确实已被 dreamMergeGuard 列为长保留受保护类型（docs/CONFIGURATION.md）——巩固层
+// 当资产护住、注入面一次不给看，是同一条口径的两头不一致。这一点与作者是谁无关，
+// 收编的结论不变，错的只是当初用来支持它的那句前提。
+const INJECT_TYPES = new Set(["preference", "project", "decision", "summary", "rejected_solution", "pitfall", "constraint", "history", "pattern"]);
 
 // document 摘要行（#230）：仅 documentMemoryEnabled 开启时进注入候选。独立
 // 集合而非常改共享 Set——INJECT_TYPES 本身是「类型可注入」的静态事实，flag
@@ -1285,7 +1298,10 @@ export function createService({ store, mirror, config, onWrite, logger, document
     let quality = null;
     if (qf?.enabled === true) {
       try {
-        const recentContents = store.all().slice(0, 20).map((m) => m.content ?? "");
+        // #430：近重复判定只要最近 20 条正文，别再为了 slice(0,20) 先物化整库
+        // （all() + 逐行 toRow，5k 行实测 100ms 级；本查询 0.06ms 级）。口径与
+        // all().slice(0, 20) 一致：不加 WHERE、updated_at DESC、同刻顺序未定义。
+        const recentContents = store.recentContents(20);
         quality = evaluateMemoryQuality(memory, {
           minContentLength: qf.minContentLength ?? 10,
           recentContents
@@ -1634,9 +1650,14 @@ export function createService({ store, mirror, config, onWrite, logger, document
         } catch { /* vector unavailable: fall through to the recall cache */ }
       }
       if (!semanticItems.length && lastSemanticRecall?.query === q && lastSemanticRecall.items?.length) {
+        // CodeRabbit on #404：这条回填分支此前独漏重要度门槛——向量路（上方）与
+        // BM25 路（下方 :1655 注释「门控与向量路径一致（含 importance 阈值）」）
+        // 都带着它。#369 收编 history 后缺口会被放大：库里低于闸门的行（实测
+        // history 378 条中有 27 条 i<=2）走一次检索进缓存就能绕开门槛占注入位。
         for (const m of lastSemanticRecall.items) {
           if (m && !m.archived && injectTypes.has(m.type) && !m.forgotten &&
-            (m.source !== "narrative" || allowNarrative) && codingGate(m)) semanticItems.push(m);
+            (m.source !== "narrative" || allowNarrative) && codingGate(m) &&
+            (m.type === "summary" || m.type === "preference" || m.importance >= threshold)) semanticItems.push(m);
         }
       }
       // Issue #198：首轮（无向量、无缓存召回）的同步兜底——BM25 词法召回领位。
@@ -1824,9 +1845,15 @@ export function createService({ store, mirror, config, onWrite, logger, document
     if ((config?.recallRecordDefault ?? true) && recallRecorder && injected.length > 0) {
       try {
         recallRecorder({
-          // recall_runs.query 是 NOT NULL（store.js:61）：注入是主动曝光、
-          // 没有查询词，用空串而非 null——SQLite 改列约束需重建表，不值得。
-          query: "",
+          // recall_runs.query 是 NOT NULL（store.js 的 recall_runs 建表语句，
+          // 2026-10-14 在 :75）—— 注入是主动曝光，
+          // 没有查询词时用空串而非 null——SQLite 改列约束需重建表，不值得。
+          // v0.9.0：调用方（inject.js 的 lastUserQuery，2026-10-14 在 :343）本来就带着本轮的
+          // 用户原话传进来，这里丢掉等于把「当时想干什么」从审计里抹掉
+          // （2026-10-13 快照：18,231/18,231 注入行 query 全空，全空比例
+          // 100%——这个比率才是要记的，绝对行数随表长，引用要带时刻）。
+          // 有就记，真没有才空串。
+          query: q,
           mode: "inject",
           topK: maxItems,
           threshold: null,
@@ -1931,6 +1958,9 @@ export function createService({ store, mirror, config, onWrite, logger, document
         setArchived: (mid, v) => archiveMemory(mid, v),
         transaction: (fn) => transaction(fn)
       };
+      // 不传 mintSource——本路径由人在面板上点确认，即便日后有人在这里加
+      // create，落 saveWithDedupe 的 manual 兜底恰好就是对的语义（人触发的写入）。
+      // 这是刻意的，不是漏传。
       const { committed, failures } = applyDecisions(
         [{ action: "conflict", winner: winnerId, loser: loserId, reason: row.reason ?? "" }],
         applyService,
@@ -1970,6 +2000,11 @@ export function createService({ store, mirror, config, onWrite, logger, document
         type: m.type,
         importance: m.importance,
         content: m.content,
+        // 裁决依据：两侧的新旧与重要度是「该留哪条」的客观信号。此前 side() 不带
+        // 时间戳，面板只能显示 A 方/B 方两个标签，用户没有依据就整对删掉或乱选
+        // （#400）。
+        created_at: m.created_at ?? null,
+        updated_at: m.updated_at ?? null,
         archived: m.archived === true,
         forgotten: m.forgotten === true
       };
@@ -2132,18 +2167,22 @@ export function createService({ store, mirror, config, onWrite, logger, document
     try {
       // 预先取本次要覆盖的全部活跃行（只读一次）。这里曾经是
       // store.list({ limit: 500 })——活跃集超过 500 时镜像会静默少掉尾部记忆，
-      // 而文件本身没有任何提示（#278 第一批）。store.list 的 limit 默认值只有
-      // 50，比原来显式传的 500 更小，所以改用 all() 并在这里做同一套过滤
-      // （forgotten/archived 都不进镜像，与 includeForgotten:false + 默认
-      // includeArchived:false 等价）。
-      // 代价是全表读，且落在每次业务写后的最热路径上（#202 自记 all() 5k 行
-      // 231ms → ~135ms）。要压这一层得换按 type 分页取，属另一批的事；
-      // 在这里退回任何截断都不行——「宣称覆盖活跃集」与静默截断不能共存。
-      const list = store.all().filter((m) => !m.forgotten && !m.archived
+      // 而文件本身没有任何提示（#278 第一批）。在这里退回任何截断都不行——
+      // 「宣称覆盖活跃集」与静默截断不能共存（这一条不变）。
+      // #430：改成 list 的无界档（limit: null）+ SQL 侧过滤，替掉 all() + 逐行
+      // filter——list 的默认 includeForgotten:false / includeArchived:false 与旧
+      // filter 的 !forgotten && !archived 完全同口径（store.js 里就是这两条
+      // clause），document 闸改由 excludeTypes 在 LIMIT 之前排除。旧写法先物化
+      // 整库（embedding 列 + 逐行 27 字段 toRow）再逐行丢弃：被丢掉的行连带它们
+      // 的物化一起省下了。要再压一层得换按 type 分页取，属另一批的事。
+      const list = store.list({
+        limit: null,
+        order: "chrono",
         // #296 第二批：镜像里的 documents.md 与 index.md 共用 documentMemoryEnabled
         // 闸。关掉时把 document 行也从渲染集里去掉——sync 对「空 type」的既有处理
         // 会把陈旧的 documents.md 删掉，不留一个「看着还在、其实已关」的视图。
-        && (m.type !== "document" || config?.documentMemoryEnabled === true));
+        excludeTypes: config?.documentMemoryEnabled === true ? null : ["document"]
+      });
       for (const memory of list) {
         if (memory?.type && TYPE_FILE[memory.type]) {
           coveredTypes.add(memory.type);
@@ -2480,6 +2519,13 @@ export function createService({ store, mirror, config, onWrite, logger, document
     transaction,
     getDistillCursor: (sessionId) => store.getDistillCursor(sessionId),
     setDistillCursor: (sessionId, lastSeq) => store.setDistillCursor(sessionId, lastSeq),
+    // #399 蒸馏原始记录与溯源：与上面两条游标一样是纯 passthrough——它们不是
+    // 记忆写入，不该触发 syncMirror / notifyWrite / 实体抽取（那些钩子挂在
+    // saveWithDedupe 上）。distill_records 的落盘由 summarize.js 在蒸馏窗口内
+    // 一次性批写，读回只给面板/CLI 的溯源视图用。
+    saveDistillRecords: (records) => store.saveDistillRecords(records),
+    saveMemoryProvenance: (link) => store.saveMemoryProvenance(link),
+    provenanceFor: (memoryId) => store.provenanceFor(memoryId),
     enqueue,
     setDreamHook(fn) { dreamHook = fn; },
     setSleepHook(fn) { sleepHook = fn; },
@@ -2499,11 +2545,31 @@ export function createService({ store, mirror, config, onWrite, logger, document
       // Async-initializing embedder: poll `ready` until it flips, then flush.
       if ("ready" in emb && embedReadyTimer === null) {
         let attempts = 0;
+        let readyReadFailed = false;
+        // 读 `ready` 必须先兜住异常再算天花板，否则天花板形同不存在：`ready` 是
+        // getter（embedding.js 的 OpenAI embedder 直接读库），getter 一抛错，整条
+        // `||` 的求值当场中断，右侧的 `attempts >= EMBED_READY_POLL_LIMIT` 永远轮
+        // 不到 —— stopEmbedReadyPolling() 不执行，定时器就活过 3s 上限，并以未捕获
+        // 异常的形式每 100ms 抛一次。实测（2026-10-14）：卸载路径 store.close() 之后
+        // 每次读 ready 都抛 "database is not open"，5s 内读 46 次，天花板 31 被直接
+        // 打穿，宿主事件循环因此永不排空。读不出来按「没就绪」处理，但上限照算。
+        const readReady = () => {
+          try {
+            return emb.ready === true;
+          } catch (err) {
+            if (!readyReadFailed) {
+              readyReadFailed = true; // 只报一次，别让 3s 上限变成 30 条刷屏
+              logger?.warn?.("embedder ready probe failed, treating it as not-ready:", err);
+            }
+            return false;
+          }
+        };
         embedReadyTimer = setInterval(() => {
           attempts++;
-          if (emb.ready === true || attempts >= EMBED_READY_POLL_LIMIT) {
+          const ready = readReady();
+          if (ready || attempts >= EMBED_READY_POLL_LIMIT) {
             stopEmbedReadyPolling();
-            if (emb.ready === true) flushEmbedPending();
+            if (ready) flushEmbedPending();
             else embedPending = []; // init never landed: drop the queue
           }
         }, EMBED_READY_POLL_MS);