@modusensus/dsh-mneme 0.10.1 → 0.12.0

package/test/config-keys-routes.test.js

@@ -0,0 +1,233 @@
+// issue #386 第 6 条（面板 bootstrap 入口）与第 7 条（配置键覆盖面）的服务端契约。
+//
+// 这一层要钉住的不是「路由存在」，而是三件容易在改动里悄悄走样的事：
+//   1. /bootstrap 的 policy 是 token（写库），且先判 body 形状、再判能力接线——
+//      顺序反了会把「你没给目录」报成「能力没接线」，把人引去查错的排查方向。
+//   2. /config-keys 只回键名与计数，一个值都不回。apiToken 的名字必须出现（那正是
+//      用户想知道它存在的原因），值必须不出现（那会是一处新泄漏面）。
+//   3. 三份清单是真算出来的：panelEditable = 有默认值的白名单键，
+//      fileOnly = schema 声明 − 白名单，undefaulted = 白名单 − 有默认值。
+import test from "node:test";
+import assert from "node:assert/strict";
+import { EventEmitter } from "node:events";
+import { createStore } from "../src/store.js";
+import { createService } from "../src/service.js";
+import { createApi } from "../src/api.js";
+import { createSettings } from "../src/settings.js";
+import { Config } from "../src/config.js";
+import { describeConfigKeys, schemaLeafKeys, defaultedLeafKeys, flagKeysFromSpec } from "../src/config-keys.js";
+import { bootstrapReply } from "../src/bootstrap-http.js";
+
+class FakeRes extends EventEmitter {
+  constructor() { super(); this.statusCode = 200; this.body = ""; }
+  writeHead(code, headers) { this.statusCode = code; this.headers = headers; return this; }
+  end(text) { this.body = text ?? ""; this.emit("end"); return this; }
+}
+
+function req(path, { method = "GET", body = null } = {}) {
+  const r = new EventEmitter();
+  r.url = path;
+  r.method = method;
+  r.headers = {};
+  // readBody 是事件式的（data/end），不是 async iterable：必须真的把事件发出去，
+  // 否则 handler 会永远挂在那个 Promise 上（第一版测试就是这么挂死的）。
+  setImmediate(() => {
+    if (body !== null) r.emit("data", Buffer.from(body, "utf8"));
+    r.emit("end");
+  });
+  return r;
+}
+
+function setup({ config = {}, apiToken = "" } = {}) {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config });
+  const settings = createSettings(store.db);
+  const commands = { add: () => {}, remove: () => {}, list: () => [] };
+  const routes = [];
+  const ctx = { webServer: { register(route) { routes.push(route); return () => {}; } } };
+  createApi(ctx, service, settings, commands, null, undefined, apiToken, config);
+  return { store, service, settings, routes };
+}
+
+const BOOTSTRAP = "/api/dsh-mneme/bootstrap";
+const CONFIG_KEYS = "/api/dsh-mneme/config-keys";
+
+async function call(routes, path, opts) {
+  const route = routes.find((r) => r.path === path);
+  assert.ok(route, `route ${path} must be registered`);
+  const res = new FakeRes();
+  await route.handler(req(path, opts), res);
+  return { route, res, json: res.body ? JSON.parse(res.body) : null };
+}
+
+// --- /bootstrap -------------------------------------------------------------
+
+test("bootstrap route is registered with the token policy", () => {
+  const { routes } = setup({ apiToken: "secret-token" });
+  const route = routes.find((r) => r.path === BOOTSTRAP);
+  assert.ok(route, "route must be registered");
+  // 它写库（虽然幂等），所以不能是 open；也不该借 token-write 的读写双义——这条
+  // 路由没有 GET 分支，声明 token-write 只会让 SECURITY.md 的开放读清单多一条假的。
+  assert.equal(route.policy, "token");
+});
+
+test("bootstrap demands a token when one is configured", async () => {
+  const { routes } = setup({ apiToken: "secret-token" });
+  const { res } = await call(routes, BOOTSTRAP, { method: "POST", body: JSON.stringify({ dir: "/tmp" }) });
+  assert.equal(res.statusCode, 401);
+  assert.equal(JSON.parse(res.body).error, "unauthorized");
+});
+
+test("bootstrap rejects GET with 404 (no read branch exists)", async () => {
+  const { routes } = setup();
+  const { res } = await call(routes, BOOTSTRAP, { method: "GET" });
+  assert.equal(res.statusCode, 404);
+  assert.equal(JSON.parse(res.body).error, "not-found");
+});
+
+test("bootstrap separates malformed JSON from a non-object body", async () => {
+  const { routes } = setup();
+  const bad = await call(routes, BOOTSTRAP, { method: "POST", body: "{not json" });
+  assert.equal(bad.res.statusCode, 400);
+  assert.equal(bad.json.error, "invalid-json");
+  // 数组是合法 JSON 但不是「对象」：两个码分开，调用方才知道该改哪里。
+  const arr = await call(routes, BOOTSTRAP, { method: "POST", body: "[]" });
+  assert.equal(arr.res.statusCode, 400);
+  assert.equal(arr.json.error, "invalid-body");
+});
+
+test("bootstrap validates dir before it decides whether the capability is wired", async () => {
+  // 这条是顺序锁：给一个没有 saveWithDedupe 的装配 + 缺 dir 的 body。若先判能力，
+  // 用户会看到「能力没接线」——而真正的问题是他没填目录。
+  const store = createStore(":memory:");
+  const settings = createSettings(store.db);
+  const routes = [];
+  const ctx = { webServer: { register(route) { routes.push(route); return () => {}; } } };
+  createApi(ctx, {}, settings, { add: () => {}, remove: () => {}, list: () => [] }, null, undefined, "", {});
+  const { res, json } = await call(routes, BOOTSTRAP, { method: "POST", body: JSON.stringify({}) });
+  assert.equal(res.statusCode, 400);
+  assert.equal(json.error, "missing-dir", "缺 dir 必须报 missing-dir，不能报 bootstrap-unavailable");
+});
+
+test("bootstrap reports the coded error when the directory does not exist", async () => {
+  const { routes, service } = setup();
+  const { res, json } = await call(routes, BOOTSTRAP, {
+    method: "POST",
+    body: JSON.stringify({ dir: "/definitely/not/here/386-bootstrap" })
+  });
+  assert.equal(res.statusCode, 400);
+  assert.equal(json.error, "dir-not-found");
+  // 失败路径不能留下半截记忆：目录都没读到，一条都不该落库。
+  assert.equal(service.count({}), 0);
+});
+
+test("bootstrapReply survives a logger that throws (the layer never throws)", async () => {
+  // 这一层的契约是「从不抛」：warn 裸调时，宿主 logger 自己坏掉会从 catch 块里再抛出去，
+  // 而两侧 handler 的外层 try 在 .then 回调里早已退栈——现场就是「一个字节都没回」
+  // （#410，share-http.js 的 warnSafely 注释记着同一件事）。守卫必须住在层里。
+  const reply = await bootstrapReply({
+    bootstrapper: () => Promise.reject(new Error("disk on fire")),
+    dir: "/tmp",
+    warn: () => { throw new Error("logger is broken too"); }
+  });
+  assert.equal(reply.status, 500);
+  assert.deepEqual(reply.body, { error: "internal" });
+});
+
+test("bootstrap imports deterministic artifacts from a real directory", async () => {
+  const { routes, service } = setup();
+  const os = await import("node:os");
+  const fs = await import("node:fs");
+  const path = await import("node:path");
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), "mneme-386-"));
+  try {
+    fs.writeFileSync(path.join(dir, "README.md"), "# sample project\n\nA tiny fixture.\n", "utf8");
+    fs.writeFileSync(path.join(dir, "package.json"), JSON.stringify({ name: "sample", scripts: { build: "tsc -p ." } }), "utf8");
+    const { res, json } = await call(routes, BOOTSTRAP, { method: "POST", body: JSON.stringify({ dir }) });
+    assert.equal(res.statusCode, 200);
+    assert.ok(json.created >= 2, `expected at least 2 imported rows, got ${JSON.stringify(json)}`);
+    assert.equal(json.dir, fs.realpathSync(dir));
+    // 「返回成功不等于生效」：去看库里到底有没有那几行。
+    const rows = service.list({ limit: 20, includeArchived: false });
+    assert.ok(rows.length >= 2, "the response must correspond to rows that actually exist");
+    assert.ok(rows.every((m) => (m.tags || []).includes("bootstrap")), "every imported row carries the bootstrap tag");
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+// --- /config-keys -----------------------------------------------------------
+
+test("config-keys route is open and read-only", async () => {
+  const { routes } = setup({ apiToken: "secret-token" });
+  const { route, res } = await call(routes, CONFIG_KEYS, { method: "GET" });
+  assert.equal(route.policy, "open");
+  assert.equal(res.statusCode, 200, "read-only route must not demand a token");
+});
+
+test("config-keys rejects non-GET", async () => {
+  const { routes } = setup();
+  const { res } = await call(routes, CONFIG_KEYS, { method: "POST", body: "{}" });
+  assert.equal(res.statusCode, 404);
+});
+
+test("config-keys returns key names but never the apiToken value", async () => {
+  const { routes } = setup({ config: { apiToken: "super-secret-value" }, apiToken: "super-secret-value" });
+  const { res } = await call(routes, CONFIG_KEYS, { method: "GET" });
+  assert.equal(res.statusCode, 200);
+  // 名字必须在：用户正是要靠这份清单知道「apiToken 只能改配置文件」。
+  assert.ok(res.body.includes("apiToken"), "the key name must be listed");
+  // 值必须不在：这条断言是这整条路由存在的安全边界。
+  assert.ok(!res.body.includes("super-secret-value"), "the value must never leave the server");
+});
+
+test("config-keys only reads the schema — it never echoes a configured value", async () => {
+  // 上一条锁的是「没漏出去」，这条锁的是「不是靠脱敏才没漏」：即便装了一个
+  // 非敏感键的值，响应里也不该出现它——这份清单只谈键名与计数。
+  const { routes } = setup({ config: { memoryDir: "/unique/marker/path/386" } });
+  const { res } = await call(routes, CONFIG_KEYS, { method: "GET" });
+  assert.ok(!res.body.includes("/unique/marker/path/386"), "no configured value may appear in this response");
+});
+
+test("config-keys partitions the two source lists without losing anything", async () => {
+  const d = describeConfigKeys();
+  const declared = schemaLeafKeys();
+  const defaulted = defaultedLeafKeys();
+  const flags = flagKeysFromSpec();
+  assert.equal(d.counts.schemaLeaf, declared.length);
+  assert.equal(d.counts.flag, flags.length);
+  // 并集必须正好铺满「schema 声明 ∪ 白名单」，一个键都不许漏在三个桶之外。
+  const union = new Set([...d.panelEditable, ...d.fileOnly, ...d.undefaulted]);
+  const expected = new Set([...declared, ...flags]);
+  assert.deepEqual([...union].sort(), [...expected].sort());
+  // 两个等式同时成立，才说明三个桶互不相交且覆盖完整。注意第一个等式要把
+  // undefaulted 也加进去：dreamProvider / dreamModel 既是 schema 声明的键、又挂在
+  // 白名单上，它既不属于 panelEditable（没默认值）也不属于 fileOnly（白名单有它），
+  // 只落在 undefaulted 这一个桶里。
+  assert.equal(d.panelEditable.length + d.fileOnly.length + d.undefaulted.length, declared.length);
+  assert.equal(d.panelEditable.length + d.undefaulted.length, flags.length);
+  // 白名单里每个键都必须在 schema 里声明过——否则那是登记了一个不存在的键。
+  for (const key of flags) assert.ok(expected.has(key), `flag ${key} is not declared in the schema`);
+  // 有默认值的键必须都被 schema 声明覆盖（反向包含，防 schema 漏声明）。
+  for (const key of defaulted) assert.ok(declared.includes(key), `defaulted key ${key} is missing from the schema declaration`);
+});
+
+test("config-keys flags keys that the whitelist registers without a schema default", async () => {
+  const d = describeConfigKeys();
+  // dreamProvider / dreamModel 在 settings.js 白名单里，但 config.js 只有
+  // z.string().description(...) 没有 .default()。面板因此有个永远不进 effective 的
+  // 输入框——这正是 #386 第 7 条说的「不对称」，必须被告知而不是被悄悄抹平。
+  assert.deepEqual(d.undefaulted.sort(), ["dreamModel", "dreamProvider"]);
+});
+
+test("config-keys lists file-only keys that users actually hit (apiToken, memoryDir, maxInjectedItems)", async () => {
+  const d = describeConfigKeys();
+  // apiToken 是最要紧的一个：它没有默认值，所以「拿解析结果当 schema」的写法会把它
+  // 整个漏掉——第一版正是这么错的，这条用例是那个错的回归锁。
+  assert.ok(d.fileOnly.includes("apiToken"), "apiToken must be visible as file-only");
+  // 另外两个是 issue 原文点名的键：用户能理解、却在面板上找不到。
+  assert.ok(d.fileOnly.includes("memoryDir"));
+  assert.ok(d.fileOnly.includes("maxInjectedItems"));
+  // 反向：一个面板确实能改的键，绝不能被列进 fileOnly。
+  assert.ok(!d.fileOnly.includes("autoInject"));
+});

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/contrast.test.js

@@ -233,13 +233,16 @@ test("面板引用的宿主 token 必须真实存在（幻影 token 回归锁）
   assert.deepEqual(unknown, [], "面板引用了宿主快照里没有的 token（幻影名或快照过期）：" + unknown.join(", "));
 });
 
-// 变量层必须挂满四个渲染根：面板不只长在 .mneme-x 下——记忆库 sheet portal 到
-// body（.mneme-overlay）、侧边栏入口在宿主插槽（.mneme-triggerwrap）、顶部入口
-// portal 到宿主侧边栏（.mneme-topentry）。少挂一个，那个根下的文字就退回宿主的
-// 低对比度 token，而且上面的主锁**照样全绿**（主锁只算颜色，不知道变量有没有继承到）。
-test("面板语义色层覆盖四个渲染根", () => {
+// 变量层必须挂满五个渲染根：面板不只长在 .mneme-x 下——老宿主上记忆库 sheet
+// portal 到 body（.mneme-overlay）、侧边栏入口在宿主插槽（.mneme-triggerwrap）、
+// 顶部入口 portal 到宿主侧边栏（.mneme-topentry）；新宿主的侧栏图标长在宿主
+// panelGlyph 里、不在 .mneme-x 子树内（.mneme-paneliglyph），它挂着冲突红点，
+// 必须吃到 --mneme-danger。
+// 少挂一个，那个根下的文字/图形就退回宿主的低对比度 token，而且上面的主锁
+// **照样全绿**（主锁只算颜色，不知道变量有没有继承到）。
+test("面板语义色层覆盖五个渲染根", () => {
   const sel = layer.sel;
-  assert.equal(sel, ".mneme-x,.mneme-overlay,.mneme-triggerwrap,.mneme-topentry");
+  assert.equal(sel, ".mneme-x,.mneme-overlay,.mneme-triggerwrap,.mneme-topentry,.mneme-paneliglyph");
 });
 
 // 图形色的对比度（WCAG 1.4.11，非文字 3:1）。上面那条主锁只看 `color:`，
@@ -275,7 +278,11 @@ const GRAPHICS = [
   { sel: ".mneme-heatcell.l1", prop: "background" },
   { sel: ".mneme-heatcell.l2", prop: "background" },
   { sel: ".mneme-heatcell.l3", prop: "background" },
-  { sel: ".mneme-heatcell.l4", prop: "background" }
+  { sel: ".mneme-heatcell.l4", prop: "background" },
+  // 8 周沉淀的两根柱：高度差就是「进来的 vs 稳住的」这层信息本身（新增高、
+  // 巩固矮＝库在膨胀），柱子掉回浅灰等于把结论擦掉，所以按图形色 3:1 锁。
+  { sel: ".mneme-sinkbar--added", prop: "background" },
+  { sel: ".mneme-sinkbar--merged", prop: "background" }
 ];
 test("图形色（热度/打卡/连线）在浅深两主题下都达到 3:1", () => {
   const bySel = new Map(rules.map((r) => [r.sel, r]));

package/test/document.test.js

@@ -227,6 +227,38 @@ test("re-registering a document whose evidence was absorbed keeps the references
   }
 });
 
+// #593 遗留缺口（#593 把 pin 从「按类型推断」改成显式存储后新出现的旁路）：
+// 上一版只问 pinnedTypes.has(row.type)，于是被显式钉住的 pattern / decision 在升格
+// 吸收时仍被 setArchived —— 用户钉过的行被文档悄悄收走，pin 语义（「这条我要长期
+// 带着」）当场失效。这条锁住「显式 pin 表是第二判据」，且用 pattern 类型（它不在
+// PINNED_MEMORY_TYPES 里），否则用例会被类型口径顺手护住、测不到缺口。
+test("explicitly pinned evidence rows survive absorption even when their type is not in the pinned pool", async () => {
+  const { store, service, close } = makeService({ documentMemoryEnabled: true });
+  const { writeDoc, cleanup } = await makeDocDir();
+  try {
+    const pinnedPattern = service.saveWithDedupe({ type: "pattern", title: "P", content: "用户反复这样操作" }).memory;
+    const plainPattern = service.saveWithDedupe({ type: "pattern", title: "P2", content: "另一条没钉的模式" }).memory;
+    store.pinMemory(pinnedPattern.id, { note: "显式钉住" });
+    const p = await writeDoc("pin-survives.md");
+
+    const res = await service.registerDocument({
+      path: p, title: "PinSurvives", summary: "s", evidence: [pinnedPattern.id, plainPattern.id]
+    });
+
+    assert.equal(res.evidence_kept, 2);
+    assert.equal(res.evidence_archived, 1, "只收走没被钉的那条");
+    assert.equal(
+      service.getById(pinnedPattern.id).archived,
+      false,
+      "被显式 pin 的行不能被升格吸收静默归档（pin 表是第二判据，不能只按类型猜）"
+    );
+    assert.equal(service.getById(plainPattern.id).archived, true, "没钉的同类型行照旧被吸收（补丁不放宽口径）");
+  } finally {
+    cleanup();
+    close();
+  }
+});
+
 test("registrar without the pinned pool wiring archives nothing (fail-safe)", async () => {
   // 拿不到 pinned 集合就不做这一步：宁可少做，也不能把保真池当普通行收走。
   const store = createStore(":memory:");