@modusensus/dsh-mneme 0.11.0 → 0.13.0

package/test/config.test.js

@@ -3,6 +3,7 @@ import assert from "node:assert/strict";
 import { readFileSync } from "node:fs";
 import { fileURLToPath } from "node:url";
 import { Config } from "../src/config.js";
+import { isCodingTask } from "../src/service.js";
 
 test("session incognito is opt-in, with a default-on subordinate selector", () => {
   const cfg = Config({});
@@ -72,3 +73,81 @@ test("startup probe: the reranker module never statically imports transformers/o
     "loader 不得静态导入 transformers，否则惰性加载就失效了"
   );
 });
+
+// ---------------------------------------------------------------- codingKeywords 工程协作词（2026-11-06）
+// 生产日志里「合并 / 开 PR / 看 CI / 发版 / 验收 / 冲突 / 分支 / issue」这类
+// 工程协作话在原 56 项词表里一个都不命中，被判成非编码任务，于是
+// rejected_solution / pitfall / constraint 三类编码记忆被 codingGate 整类滤掉。
+// 实测这类 query 占非编码调用的 17.1~17.8%。本组用例锁住补词后的词表与行为。
+
+test("codingKeywords 覆盖工程协作动作，且不含歧义词", () => {
+  const { codingKeywords } = Config({});
+
+  // 这 34 项就是补进去的工程协作词，一个都不能少（少了就等于白改）。
+  // 不另加「长度必须是 90」的断言：那是把「逐词覆盖」和「不多不少」两个语义
+  // 绑在一处，删一个词会同时触发两条断言，看报告的人会误以为两条用例各自
+  // 独立兜底。逐词断言已经足够——多出来的词由下面的「不得含」三条反向兜住。
+  //
+  // 「审评」必须与「评审」并列：她真实说的是「等审评」「看CI和审评」（8 条 /
+  // 779 次），「评审」只有 4 条 / 420 次。同义不同形，子串匹配两套都得分开放。
+  const engineering = [
+    "提交", "合并", "分支", "冲突", "验收", "审查", "评审", "审评", "发版",
+    "仓库", "回滚", "推送", "拉取", "变基", "上线", "打包", "迁移",
+    "字段", "鉴权", "超时", "并发", "闪退", "白屏", "端口", "进程",
+    "守护", "定时任务", "索引", "缓存", "死锁", "内存泄漏", "日志",
+    "版本号", "环境变量"
+  ];
+  for (const kw of engineering) {
+    assert.ok(codingKeywords.includes(kw), `缺少工程协作词「${kw}」`);
+  }
+
+  // 刻意不加的两个：
+  // 「事务」唯一命中是政治学简答「公共事务委托给企业和社会组织」，加进去
+  // 会把考研答题场景判成编码任务，方向正好相反。
+  // 「依赖包」纯冗余——「依赖」已在表内，它永远不会单独生效。
+  assert.ok(!codingKeywords.includes("事务"), "不得加「事务」：会把政治学简答判成编码任务");
+  assert.ok(!codingKeywords.includes("依赖包"), "不得加「依赖包」：「依赖」已在表内，纯冗余");
+
+  // 无重复
+  assert.equal(new Set(codingKeywords).size, codingKeywords.length, "词表不得有重复项");
+
+  // 英文词一律不加：isCodingTask 是纯子串匹配，无词边界的短英文词会误命中。
+  // 实测 pr 命中 69 条/6002 次，其中无词边界 30 条/3477 次（57.9%）是
+  // C:/Program File/GitHub CLI、pnpm 路径、prompt 这类文本。
+  for (const kw of ["pr", "ci", "push", "pull", "rebase", "revert", "diff"]) {
+    assert.ok(!codingKeywords.includes(kw), `不得加英文短词「${kw}」：无词边界会误命中`);
+  }
+});
+
+test("工程协作话被判成编码任务，考研答题话仍判成非编码", () => {
+  // 走生产的 isCodingTask，不在这里另写一份判断逻辑。
+  // 此前这条用例自己写 const isCoding = (t) => codingKeywords.some(...)，
+  // 测的是「词表内容对不对」，不是「生产函数怎么用它」——实测把
+  // src/service.js 的 isCodingTask 改成永远 return false（整个编码门废掉），
+  // 全仓 177 个相关用例仍然全绿。所以这里必须 import 真函数。
+  const { codingKeywords } = Config({});
+
+  // 这些是她真实说过的工程协作话，补词前全部被判成非编码
+  for (const q of [
+    "提交这个issue然后你在主分支的基础上开分支修",
+    "先回帖再开分支。",
+    "合并",
+    "看看#536，解决冲突",
+    "看看ci和评审",
+    "A+B，今天就能发版",
+    "等审评。你看看#35那个pr。",
+    "按照你说的，先合并完前面的再开#493"
+  ]) {
+    assert.equal(isCodingTask(q, codingKeywords), true, `「${q}」应判成编码任务`);
+  }
+
+  // 考研答题话：补词后仍然不能被判成编码任务，否则她的答题场景会注入编码踩坑
+  for (const q of [
+    "1.B,2.这个就是……政府职能转变，公共事务委托给企业和社会组织",
+    "背95单词",
+    "英语阅读 1 篇（2016 起正序）",
+    "631 专业课块 · 15:30–17:00"
+  ]) {
+    assert.equal(isCodingTask(q, codingKeywords), false, `「${q}」应判成非编码任务`);
+  }
+});

package/test/conflict-freeze.test.js

@@ -82,6 +82,50 @@ test("store: 不同对不去重", () => {
   store.close();
 });
 
+// Issue #603 第 2 层：排序键从 created_at 换成相似度。原键在同一次 sleep 轮次里
+// 全同（实测 60 条落在 60ms 内），队列在面板上等于随机——而「先看哪对」的唯一
+// 客观信号就是相似度。这组用例锁三件事：相似度真的落库、排序真的按它、以及
+// NULL（没记过）排在最后而不是被当成 0。
+test("#603 store: similarity is persisted and read back", () => {
+  const store = openStore();
+  const row = store.saveConflictPending({ memory_a: "a", memory_b: "b", reason: "r", similarity: 0.87 });
+  assert.equal(row.similarity, 0.87, "fresh row carries the similarity it was parked with");
+  const [read] = store.listConflictPending();
+  assert.equal(read.similarity, 0.87, "listConflictPending reads the column back");
+  store.close();
+});
+
+test("#603 store: the queue is ordered by similarity, newest only as a tiebreak", () => {
+  const store = openStore();
+  // 写入顺序与相似度顺序相反：如果仍按 created_at 排，结果会是 low → high。
+  const low = store.saveConflictPending({ memory_a: "a", memory_b: "b", reason: "low", similarity: 0.61 });
+  const high = store.saveConflictPending({ memory_a: "c", memory_b: "d", reason: "high", similarity: 0.94 });
+  const mid = store.saveConflictPending({ memory_a: "e", memory_b: "f", reason: "mid", similarity: 0.78 });
+  const order = store.listConflictPending().map((r) => r.id);
+  assert.deepEqual(order, [high.id, mid.id, low.id], "most similar first, regardless of insertion order");
+  store.close();
+});
+
+test("#603 store: rows without a similarity sort last, they are not 'zero similar'", () => {
+  const store = openStore();
+  // 存量行（加列之前入队的）与 LLM 裁决路径（只有理由文本）都没有相似度。
+  const unknown = store.saveConflictPending({ memory_a: "a", memory_b: "b", reason: "no number" });
+  const known = store.saveConflictPending({ memory_a: "c", memory_b: "d", reason: "r", similarity: 0.7 });
+  assert.equal(unknown.similarity, undefined, "an unmeasured row must not report a number");
+  const order = store.listConflictPending().map((r) => r.id);
+  assert.deepEqual(order, [known.id, unknown.id], "unknown similarity goes after every measured row");
+  store.close();
+});
+
+test("#603 store: an out-of-range or non-numeric similarity is stored as unknown", () => {
+  const store = openStore();
+  for (const bad of [1.5, -0.2, Number.NaN, "0.9", null]) {
+    const row = store.saveConflictPending({ memory_a: `a${String(bad)}`, memory_b: `b${String(bad)}`, reason: "r", similarity: bad });
+    assert.equal(row.similarity, undefined, `similarity ${String(bad)} must not be stored as a number`);
+  }
+  store.close();
+});
+
 test("store: resolveConflictPending 标 resolved + winner，默认列表不再返回", () => {
   const store = openStore();
   const pending = store.saveConflictPending({ memory_a: "a", memory_b: "b", reason: "r" });
@@ -294,7 +338,7 @@ test("dream: freeze=true 同一对跨 run 去重 —— 只保留一条 pending"
   const ctx2 = freezeCtx({ conflicts: [{ action: "conflict", winner: w.id, loser: l.id, reason: "日期矛盾" }] });
   const r2 = await dream.runDream(ctx2, service, { ...BASE_CONFIG, conflictFreezeEnabled: true });
   assert.equal(r1.frozen, 1);
-  assert.equal(r2.frozen, 1, "每次 run 都检出并上报该对");
+  assert.equal(r2.frozen, 0, "第二次检出的是已在队列里的对，不算新停车（#603 第 1 层）");
   assert.equal(store.countConflictPending(), 1, "但队列只有一条 pending");
   store.close();
 });

package/test/continuity.test.js

@@ -267,8 +267,15 @@ test("#249 N3：队列满的丢弃必须留痕（§8 触发率口径）", async
 test("#249 N3：门控不调模型（静态锁）与挂载点的父开关在前", () => {
   // §11「门控不调 LLM」：本模块只 import 消息工厂。静态锁而不是运行时断言——真去调模型的
   // 回归不会从返回值露出来，只会让这一步变慢、变贵。
+  //
+  // #611 起多了 src/attachment-text.js：它同样**不调模型**（纯字符串函数、自己不
+  // import 任何东西），只是把图片块读成占位文本。所以锁的口径从「恰好一行 import」
+  // 改成「import 清单恰是这两项」——新增一行仍然转红，仍然要人来看一眼它是不是纯的。
   const src = readFileSync(new URL("../src/continuity.js", import.meta.url), "utf8");
-  assert.deepEqual(src.match(/^import .*$/gm), ['import { createUserMessage } from "@deepseek-ai/dsh-llm";']);
+  assert.deepEqual(src.match(/^import .*$/gm), [
+    'import { createUserMessage } from "@deepseek-ai/dsh-llm";',
+    'import { contentToText } from "./attachment-text.js";'
+  ]);
   // 挂载点（`src/index.js`）是本功能唯一的生产入口：父开关必须在前、子项在后，否则「默认关」
   // 只剩 Config 里的默认值撑着，接线漏一次没人发现。
   const index = readFileSync(new URL("../src/index.js", import.meta.url), "utf8");

package/test/diary-library.test.js

@@ -0,0 +1,187 @@
+// 左侧「ta 的日记」面板读的是**跨桶**清单——它长在 `main` 座位上，宿主不给它
+// sessionId，所以算不出「当前会话的项目根」。这套用例锁的就是那条路径：
+// 谁被算成一个桶、谁被跳过、谁的名字从 frontmatter 来而不是从目录名猜。
+//
+// 反面教材是 #613 的双桶：同一个项目因为历史原因落了两个目录键
+// （`QQ对话-4f061790` 与 `QQ---4f061790`），面板若按目录名认人就会把同一本日记
+// 挂成两个人。所以这里有一条用例专门断言「名字取自 frontmatter 的 persona」。
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { listDiaryLibrary, readLibraryEntry, isBucketName } from "../src/diary/index.js";
+
+/** 造一个临时 memoryDir，里面的 diaries/ 按给定的桶与日期铺开。 */
+function fixture(buckets) {
+  const memoryDir = mkdtempSync(join(tmpdir(), "mneme-diary-lib-"));
+  const root = join(memoryDir, "diaries");
+  mkdirSync(root, { recursive: true });
+  for (const [bucket, files] of Object.entries(buckets)) {
+    const dir = join(root, bucket);
+    mkdirSync(dir, { recursive: true });
+    for (const [date, text] of Object.entries(files)) {
+      writeFileSync(join(dir, `${date}.md`), text, "utf8");
+    }
+  }
+  return { memoryDir, root };
+}
+
+function entry({ persona = "", project = "p", body = "正文" } = {}) {
+  const lines = ["---", "date: 2026-11-08"];
+  if (project) lines.push(`project: ${project}`);
+  if (persona) lines.push(`persona: ${persona}`);
+  lines.push("---", "", body, "");
+  return lines.join("\n");
+}
+
+test("按桶列出日记，名字取自 frontmatter 的 persona 而不是目录名", (t) => {
+  // 两个桶是同一个项目（#613 的双桶现场）：目录名一个保留中文、一个被洗成 -。
+  // 面板要显示的是「amarre」与「ptc」，不是那两个目录键。
+  const { memoryDir } = fixture({
+    "QQ对话-4f061790": { "2026-11-07": entry({ persona: "settings (amarre)", project: "QQ对话-4f061790" }) },
+    "QQ---4f061790": { "2026-11-08": entry({ persona: "default (ptc)", project: "QQ---4f061790" }) }
+  });
+  t.after(() => rmSync(memoryDir, { recursive: true, force: true }));
+
+  const { buckets } = listDiaryLibrary({ memoryDir });
+  assert.equal(buckets.length, 2);
+  const byKey = Object.fromEntries(buckets.map((b) => [b.key, b]));
+  assert.equal(byKey["QQ对话-4f061790"].persona, "settings (amarre)");
+  assert.equal(byKey["QQ---4f061790"].persona, "default (ptc)");
+  // 桶键原样保留（面板要用它拼路由），没被改写。
+  assert.ok(byKey["QQ---4f061790"]);
+});
+
+test("新的在前；每桶带 latest / count / entries", (t) => {
+  const { memoryDir } = fixture({
+    a: {
+      "2026-11-05": entry({ persona: "default (x)" }),
+      "2026-11-08": entry({ persona: "default (x)" }),
+      "2026-11-06": entry({ persona: "default (x)" })
+    },
+    b: { "2026-11-01": entry({ persona: "default (y)" }) }
+  });
+  t.after(() => rmSync(memoryDir, { recursive: true, force: true }));
+
+  const { buckets } = listDiaryLibrary({ memoryDir });
+  assert.deepEqual(buckets.map((x) => x.key), ["a", "b"], "按 latest 倒序");
+  assert.equal(buckets[0].latest, "2026-11-08");
+  assert.equal(buckets[0].count, 3);
+  assert.deepEqual(buckets[0].entries.map((e) => e.date), ["2026-11-08", "2026-11-06", "2026-11-05"]);
+  assert.equal(buckets[1].latest, "2026-11-01");
+});
+
+test("空桶、回收站、非日记文件都不算一本", (t) => {
+  const { memoryDir, root } = fixture({
+    real: { "2026-11-08": entry({ persona: "default (x)" }) }
+  });
+  t.after(() => rmSync(memoryDir, { recursive: true, force: true }));
+  // 只有 runs.jsonl 的桶：文件被删光之后的样子。
+  mkdirSync(join(root, "hollow"), { recursive: true });
+  writeFileSync(join(root, "hollow", "runs.jsonl"), "{}\n", "utf8");
+  // 回收站：以点开头。
+  mkdirSync(join(root, ".deleted"), { recursive: true });
+  writeFileSync(join(root, ".deleted", "2026-11-08.md"), entry(), "utf8");
+  // 根目录下的散落文件不是桶。
+  writeFileSync(join(root, "stray.md"), "x", "utf8");
+
+  const { buckets } = listDiaryLibrary({ memoryDir });
+  assert.deepEqual(buckets.map((b) => b.key), ["real"],
+    "只有 runs.jsonl 的桶、.deleted 回收站、根下的散文件都不该出现在导航栏里");
+});
+
+test("读不到 diaries 根目录时返回空清单，不抛", () => {
+  const { buckets } = listDiaryLibrary({ memoryDir: join(tmpdir(), "mneme-no-such-dir-xyz") });
+  assert.deepEqual(buckets, []);
+});
+
+test("第一篇没 persona 时往下找：同一桶里先后住过两个人才是 #613 要拆的形状", (t) => {
+  const { memoryDir } = fixture({
+    shared: {
+      "2026-11-06": entry({ persona: "" }),            // 手工写的，没有 frontmatter persona
+      "2026-11-07": entry({ persona: "settings (amarre)" })
+    }
+  });
+  t.after(() => rmSync(memoryDir, { recursive: true, force: true }));
+
+  const { buckets } = listDiaryLibrary({ memoryDir });
+  assert.equal(buckets[0].persona, "settings (amarre)", "跳过没 persona 的那篇，取第一篇带它的");
+});
+
+test("读一篇：桶名与日期都是路径成分，越界一律读不到", (t) => {
+  const { memoryDir, root } = fixture({ ok: { "2026-11-08": entry({ body: "今天很好" }) } });
+  t.after(() => rmSync(memoryDir, { recursive: true, force: true }));
+  // **诱饵**：root 外面放一个真能被读到的文件。只断言「返回 null」是不够的
+  // ——桶名那一层挡不住时，`join` 会真的读到它；没有这个诱饵，校验坏了用例也绿。
+  const leak = join(memoryDir, "leak");
+  mkdirSync(leak, { recursive: true });
+  writeFileSync(join(leak, "2026-11-08.md"), "根外面的东西", "utf8");
+  mkdirSync(join(root, "ok"), { recursive: true });
+
+  assert.match(readLibraryEntry({ memoryDir, bucket: "ok", date: "2026-11-08" }), /今天很好/);
+  // 这三种都是「不能让它们拼进路径」的形状；命中诱饵就说明校验漏了。
+  assert.equal(readLibraryEntry({ memoryDir, bucket: "..", date: "2026-11-08" }), null);
+  assert.equal(readLibraryEntry({ memoryDir, bucket: "../leak", date: "2026-11-08" }), null);
+  assert.equal(readLibraryEntry({ memoryDir, bucket: "ok/../../leak", date: "2026-11-08" }), null);
+  // 合法但不存在 → null（面板据此显示「读不出」而不是空框）。
+  assert.equal(readLibraryEntry({ memoryDir, bucket: "ok", date: "2026-01-01" }), null);
+});
+
+test("桶名判据挡的是路径语义，不是字符集", () => {
+  // 挡：分隔符、上跳、控制字符、首尾空白、`.` 与 `..`。
+  for (const bad of ["..", "../x", "a/b", "a\\b", "", ".", " a", "a ", "a\u0000b"]) {
+    assert.equal(isBucketName(bad), false, `不该接受桶名 ${JSON.stringify(bad)}`);
+  }
+  // 不挡：合法的单层目录名。**中文不在这道判据里**——历史上真有一个保留中文的
+  // 桶（`QQ对话-4f061790`），按字符集白名单会把它列出来却读不到。
+  for (const ok of ["QQ---4f061790", "amarre-c836db6a", "QQ对话-4f061790", "a b"]) {
+    assert.equal(isBucketName(ok), true, `该接受桶名 ${JSON.stringify(ok)}`);
+  }
+});
+
+test("历史桶名带中文也要能读（#613 的双桶就有一个是那样）", (t) => {
+  // 上一版 `projectKey` 只留 ASCII，但现场确实存在一个保留中文的桶
+  // （用户那次让另一个会话手工写的）。清单与读取必须用同一道判据，否则就是
+  // 「列得出来、点进去读不到」——用户看到的是点了没反应。
+  const { memoryDir } = fixture({ "QQ对话-4f061790": { "2026-11-07": entry({ body: "旧的那篇" }) } });
+  t.after(() => rmSync(memoryDir, { recursive: true, force: true }));
+
+  const { buckets } = listDiaryLibrary({ memoryDir });
+  assert.deepEqual(buckets.map((b) => b.key), ["QQ对话-4f061790"],
+    "带中文的桶名必须出现在清单里——它是真实存在的历史桶，跳过它等于把用户写过的日记藏起来");
+  assert.match(readLibraryEntry({ memoryDir, bucket: "QQ对话-4f061790", date: "2026-11-07" }), /旧的那篇/,
+    "清单里列得出来就必须读得到，不能只做一半");
+});
+
+test("清单带上桶的 projectRoot / agentId，面板靠它决定能不能写", (t) => {
+  // 桶名（目录名 + 8 位哈希）反推不回绝对路径，而「写今天」必须给 project。
+  // 所以 listDiaryLibrary 从 diaries/state.json 里取账本；账本里没有就留空，
+  // 面板据此禁用按钮——绝不猜路径，猜错就把日记写到别的项目去了。
+  const { memoryDir, root } = fixture({
+    "amarre-c836db6a": { "2026-11-08": entry({ persona: "default (ptc)" }) },
+    "lone-11111111": { "2026-11-08": entry({ persona: "default (ptc)" }) }
+  });
+  t.after(() => rmSync(memoryDir, { recursive: true, force: true }));
+  writeFileSync(join(root, "state.json"), JSON.stringify({
+    "amarre-c836db6a": { projectRoot: "D:\\amarre", lastDate: "2026-11-08", chatId: "c1", agentId: "ptc" }
+  }), "utf8");
+
+  const byKey = Object.fromEntries(listDiaryLibrary({ memoryDir }).buckets.map((b) => [b.key, b]));
+  assert.equal(byKey["amarre-c836db6a"].projectRoot, "D:\\amarre", "有账本的桶要带出绝对路径");
+  assert.equal(byKey["amarre-c836db6a"].agentId, "ptc");
+  assert.equal(byKey["lone-11111111"].projectRoot, "", "没账本就留空，绝不猜");
+  assert.equal(byKey["lone-11111111"].agentId, "");
+});
+
+test("state.json 坏掉时清单照常出，不因账本读不出就整页空白", (t) => {
+  // 账本只是附加信息。它坏了最坏是「不知道该写哪」，不该连日记都看不到。
+  const { memoryDir, root } = fixture({ "amarre-c836db6a": { "2026-11-08": entry({ persona: "default (ptc)" }) } });
+  t.after(() => rmSync(memoryDir, { recursive: true, force: true }));
+  writeFileSync(join(root, "state.json"), "{ not json", "utf8");
+
+  const { buckets } = listDiaryLibrary({ memoryDir });
+  assert.equal(buckets.length, 1);
+  assert.equal(buckets[0].projectRoot, "");
+  assert.equal(buckets[0].persona, "default (ptc)");
+});