@modusensus/dsh-mneme 0.12.0 → 0.14.0-beta.1

package/test/conflict-ledger.test.js

@@ -0,0 +1,242 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { createStore } from "../src/store.js";
+import { Config } from "../src/config.js";
+import { triagePair, recordLedgerTriage, LEDGER_TIERS } from "../src/dream/triage.js";
+
+// Issue #641（beta 第一阶段）：冲突分诊账本。锁三件事，防的回归是：
+//   ① 分诊判据漂移：四档的时间/相似度边界被「顺手调一下」而没有任何记录——
+//      shadow 期分布与真实库 46/20/5/27 的可比性全靠判据稳定，边界一动，
+//      shadow 周就白跑（每条边界用例的注释都写明它锚的真实库依据）；
+//   ② 账本不幂等/首见时刻被刷新：同一对每轮重写 first_seen_at，挂账时长与
+//      同召率统计全部失真；
+//   ③ 记账反噬相位或误入人工队列：shadow 档的写入是纯测量，抛错必须只计
+//      failed、绝不打断巩固，也绝不涨 countConflictPending 的面板徽标。
+
+const mem = (id, over = {}) => ({
+  id,
+  title: `t-${id}`,
+  content: `c-${id}`,
+  created_at: "2026-11-01T00:00:00.000Z",
+  agent_scope: undefined,
+  workspace_scope: undefined,
+  ...over
+});
+
+const HOUR = 3_600_000;
+const DAY = 86_400_000;
+
+// ---- triagePair：四档判据与边界 ----
+
+test("issue#641 跨作用域对判 cross-scope-dup（任一维键不同即算，#170 口径）", () => {
+  const r1 = triagePair(mem("a", { agent_scope: "x" }), mem("b", { agent_scope: "y" }), 0.9);
+  assert.equal(r1.tier, "cross-scope-dup");
+  assert.equal(r1.signals.crossScope, true);
+  // workspace 单维不同也算——与 sleep.js isCrossScopePair 同一判据
+  const r2 = triagePair(mem("a", { workspace_scope: "w1" }), mem("b", { workspace_scope: "w2" }), 0.86);
+  assert.equal(r2.tier, "cross-scope-dup");
+});
+
+test("issue#641 两侧都未标注不算跨作用域，但 annotated=false 显式落账（#616 的洞在测量层可见）", () => {
+  const r = triagePair(mem("a"), mem("b"), 0.91, { now: Date.UTC(2026, 10, 1, 2) });
+  assert.equal(r.tier, "dup");
+  assert.equal(r.signals.crossScope, false);
+  assert.equal(r.signals.annotated, false);
+  // 一侧标注一侧未标注：scopeKeyOf(null) !== scopeKeyOf("x") → 跨作用域
+  const r2 = triagePair(mem("a", { agent_scope: "x" }), mem("b"), 0.86);
+  assert.equal(r2.tier, "cross-scope-dup");
+  assert.equal(r2.signals.annotated, false);
+});
+
+test("issue#641 同日双录（<24h）+ sim≥dupMin 判 dup；真实库 76% 的对落这一档的依据", () => {
+  const a = mem("a", { created_at: "2026-11-01T00:00:00.000Z" });
+  const b = mem("b", { created_at: "2026-11-01T02:00:00.000Z" });
+  const r = triagePair(a, b, 0.91, { now: Date.UTC(2026, 10, 1) });
+  assert.equal(r.tier, "dup");
+  assert.equal(r.signals.gapDays, 0.083, "gapDays 落账时四舍五入到 3 位（audit JSON 保持干净）");
+});
+
+test("issue#641 dup 边界：sim 恰在 dupMin 判 dup（>=），低一分保守归 conflict", () => {
+  const a = mem("a", { created_at: "2026-11-01T00:00:00.000Z" });
+  const b = mem("b", { created_at: "2026-11-01T01:00:00.000Z" });
+  assert.equal(triagePair(a, b, 0.9, { now: Date.UTC(2026, 10, 1) }).tier, "dup");
+  assert.equal(triagePair(a, b, 0.899, { now: Date.UTC(2026, 10, 1) }).tier, "conflict");
+});
+
+test("issue#641 时间边界：差恰好 24h 不算 dup（1-7 天的模糊带宁保守归 conflict）；≥7 天判 evolution", () => {
+  const a = mem("a", { created_at: "2026-11-01T00:00:00.000Z" });
+  const day1 = mem("b", { created_at: "2026-11-02T00:00:00.000Z" });
+  assert.equal(triagePair(a, day1, 0.95, { now: Date.UTC(2026, 10, 1) }).tier, "conflict");
+  const day30 = mem("b", { created_at: "2026-12-01T00:00:00.000Z" });
+  // evolution 的判据只有时间——sim 再高也先走取代链候选（enforce 阶段接线）
+  const r = triagePair(a, day30, 0.99, { now: Date.UTC(2026, 10, 1) });
+  assert.equal(r.tier, "evolution");
+});
+
+test("issue#641 created_at 缺失不下结论：归 conflict、gapDays=null，不编造时间信号", () => {
+  const r = triagePair(mem("a", { created_at: undefined }), mem("b"), 0.91);
+  assert.equal(r.tier, "conflict");
+  assert.equal(r.signals.gapDays, null);
+});
+
+test("issue#641 dupMin 可经 opts 覆盖（配置键 conflictLedgerDupMinSimilarity 的直通口）", () => {
+  const a = mem("a", { created_at: "2026-11-01T00:00:00.000Z" });
+  const b = mem("b", { created_at: "2026-11-01T01:00:00.000Z" });
+  assert.equal(triagePair(a, b, 0.87, { now: Date.UTC(2026, 10, 1), dupMinSimilarity: 0.86 }).tier, "dup");
+});
+
+// ---- recordLedgerTriage：best-effort 记账 ----
+
+test("issue#641 分诊记账：逐对落账、tally 与档位计数一致", async () => {
+  const saved = [];
+  const service = { saveConflictLedgerEntry: (r) => saved.push(r) };
+  const pairs = [
+    { a: mem("a", { created_at: "2026-11-01T00:00:00.000Z" }), b: mem("b", { created_at: "2026-11-01T01:00:00.000Z" }), similarity: 0.91 },
+    { a: mem("c", { agent_scope: "x" }), b: mem("d", { agent_scope: "y" }), similarity: 0.86 },
+    { a: mem("e", { created_at: "2026-10-01T00:00:00.000Z" }), b: mem("f", { created_at: "2026-11-01T00:00:00.000Z" }), similarity: 0.8 },
+    { a: mem("g", { created_at: "2026-11-02T00:00:00.000Z" }), b: mem("h", { created_at: "2026-11-01T00:00:00.000Z" }), similarity: 0.86 }
+  ];
+  const tally = await recordLedgerTriage(service, "run-1", pairs, { now: Date.UTC(2026, 10, 1) });
+  assert.deepEqual(tally, { dup: 1, "cross-scope-dup": 1, evolution: 1, conflict: 1, recorded: 4, failed: 0, truncatedAt: null });
+  assert.equal(saved.length, 4);
+  assert.equal(saved[0].tier, "dup");
+  assert.equal(saved[0].run_id, "run-1");
+});
+
+test("issue#641 记账失败只计 failed 不打断：纯测量绝不反噬巩固相位", async () => {
+  let calls = 0;
+  const service = {
+    saveConflictLedgerEntry: () => {
+      calls++;
+      if (calls === 2) throw new Error("db busy");
+    }
+  };
+  const pairs = [1, 2, 3].map((i) => ({ a: mem(`a${i}`), b: mem(`b${i}`), similarity: 0.91 }));
+  const warns = [];
+  const tally = await recordLedgerTriage(service, "run-1", pairs, {
+    now: Date.UTC(2026, 10, 1),
+    logger: { warn: (m) => warns.push(m) }
+  });
+  assert.equal(tally.recorded, 2);
+  assert.equal(tally.failed, 1);
+  assert.equal(warns.length, 1, "失败要留下 warn，不是静默吞");
+});
+
+test("issue#641 记账分块：大池逐块落账不丢样本（shadow 分母必须完整）", async () => {
+  const saved = [];
+  const service = { saveConflictLedgerEntry: (r) => saved.push(r) };
+  const pairs = Array.from({ length: 120 }, (_, i) => ({
+    a: mem(`a${i}`, { created_at: "2026-11-01T00:00:00.000Z" }),
+    b: mem(`b${i}`, { created_at: "2026-11-01T01:00:00.000Z" }),
+    similarity: 0.91
+  }));
+  const tally = await recordLedgerTriage(service, "run-1", pairs, { now: Date.UTC(2026, 10, 1) });
+  assert.equal(tally.recorded, 120, "跨三块全部落账，无截断");
+  assert.equal(tally.dup, 120);
+  assert.equal(tally.truncatedAt, null);
+  assert.equal(saved.length, 120);
+});
+
+test("issue#641 记账分块：取消即停、truncatedAt 可见，绝不静默截断观察样本", async () => {
+  const service = { saveConflictLedgerEntry: () => {} };
+  const pairs = Array.from({ length: 120 }, (_, i) => ({
+    a: mem(`a${i}`, { created_at: "2026-11-01T00:00:00.000Z" }),
+    b: mem(`b${i}`, { created_at: "2026-11-01T01:00:00.000Z" }),
+    similarity: 0.91
+  }));
+  // 首块前取消：零写入，truncatedAt=0
+  const stopAtStart = await recordLedgerTriage(service, "run-1", pairs, { now: Date.UTC(2026, 10, 1), signal: { aborted: true } });
+  assert.equal(stopAtStart.recorded, 0, "取消在首块前生效");
+  assert.equal(stopAtStart.truncatedAt, 0);
+  // 中途取消：getter 在首块（50 条）落完后翻转 → 第二块前停，块内不弃样本
+  const saved = [];
+  let flipped = false;
+  const midService = {
+    saveConflictLedgerEntry: (r) => {
+      saved.push(r);
+      if (saved.length >= 10) flipped = true;
+    }
+  };
+  const mid = await recordLedgerTriage(midService, "run-2", pairs, {
+    now: Date.UTC(2026, 10, 1),
+    signal: { get aborted() { return flipped; } }
+  });
+  assert.equal(mid.recorded, 50, "第一块完整落账（块内不检查取消）");
+  assert.equal(mid.truncatedAt, 50, "取消点对可见，余下的对下一轮重见");
+});
+
+// ---- conflict_ledger 存储契约 ----
+
+test("issue#641 conflict_ledger：键归一化 + 读回 + 人工队列零污染", () => {
+  const store = createStore(":memory:");
+  store.saveConflictLedgerEntry({
+    run_id: "run-1", memory_a: "b-id", memory_b: "a-id", tier: "dup",
+    similarity: 0.91, signals: { crossScope: false, annotated: false, gapDays: 0.5, dupMin: 0.9, similarity: 0.91 }
+  });
+  const rows = store.listConflictLedger();
+  assert.equal(rows.length, 1);
+  assert.equal(rows[0].memory_a, "a-id", "键按字典序归一化——反着传也是同一行");
+  assert.equal(rows[0].tier, "dup");
+  assert.equal(rows[0].status, "open");
+  assert.deepEqual(JSON.parse(rows[0].signals), { crossScope: false, annotated: false, gapDays: 0.5, dupMin: 0.9, similarity: 0.91 });
+  assert.equal(store.countConflictPending(), 0, "分诊账本是测量记录，绝不涨人工队列徽标");
+  assert.equal(store.countConflictLedger(), 1);
+  store.close();
+});
+
+test("issue#641 conflict_ledger：重复观察是刷新不是新行，first_* 保留首次检出", () => {
+  const store = createStore(":memory:");
+  store.saveConflictLedgerEntry({ run_id: "run-1", memory_a: "a", memory_b: "b", tier: "conflict", similarity: 0.86 });
+  const first = store.listConflictLedger()[0];
+  // 同一对后来判成 dup（两侧内容变了 tier 就该变——tier 是观察结论，不是身份）
+  store.saveConflictLedgerEntry({ run_id: "run-2", memory_a: "b", memory_b: "a", tier: "dup", similarity: 0.92 });
+  const rows = store.listConflictLedger();
+  assert.equal(rows.length, 1, "同一对只留一行");
+  assert.equal(rows[0].tier, "dup");
+  assert.equal(rows[0].first_run_id, "run-1", "首见 run 保留——挂账时长锚在首次检出");
+  assert.equal(rows[0].last_run_id, "run-2");
+  assert.ok(rows[0].first_seen_at < rows[0].last_seen_at, "单调时钟下两次观察严格递增");
+  assert.equal(typeof first.first_seen_at, "string");
+  store.close();
+});
+
+test("issue#641 conflict_ledger：状态迁移合法值校验 + 未知对返回 false", () => {
+  const store = createStore(":memory:");
+  store.saveConflictLedgerEntry({ run_id: "run-1", memory_a: "a", memory_b: "b", tier: "conflict" });
+  assert.equal(store.setConflictLedgerStatus("b", "a", "zombied"), true, "反着传也能命中（归一化）");
+  assert.equal(store.listConflictLedger({ status: "zombied" }).length, 1);
+  assert.throws(() => store.setConflictLedgerStatus("a", "b", "not-a-status"), /unknown status/, "非法状态是编程错误，抛错不落库");
+  assert.equal(store.setConflictLedgerStatus("x", "y", "open"), false, "未知对返回 false 不抛");
+  assert.throws(() => store.saveConflictLedgerEntry({ memory_a: "a", memory_b: "b", tier: "weird" }), /unknown tier/);
+  store.close();
+});
+
+test("issue#641 conflict_ledger：tier/status 过滤口径（shadow 周分析的查询面）", () => {
+  const store = createStore(":memory:");
+  store.saveConflictLedgerEntry({ memory_a: "a", memory_b: "b", tier: "dup" });
+  store.saveConflictLedgerEntry({ memory_a: "c", memory_b: "d", tier: "conflict" });
+  store.saveConflictLedgerEntry({ memory_a: "e", memory_b: "f", tier: "conflict" });
+  assert.equal(store.countConflictLedger({ tier: "conflict" }), 2);
+  assert.equal(store.countConflictLedger({ tier: "dup" }), 1);
+  assert.equal(store.listConflictLedger({ tier: "dup" })[0].memory_a, "a");
+  store.close();
+});
+
+// ---- 配置面 ----
+
+test("issue#641 conflictLedgerMode 默认 off、枚举拒绝未定义档位（不存在设了没行为的档位）", () => {
+  const cfg = Config({});
+  assert.equal(cfg.conflictLedgerMode, "off");
+  assert.equal(cfg.conflictLedgerDupMinSimilarity, 0.9);
+  // enforce 在 beta 第二阶段进枚举（处置接线），但清单之外的值仍然要被拒
+  assert.throws(() => Config({ conflictLedgerMode: "yolo" }), /conflictLedgerMode/);
+});
+
+test("issue#641 LEDGER_TIERS 与 store 侧白名单一致（两处清单不许漂移）", () => {
+  const store = createStore(":memory:");
+  for (const tier of LEDGER_TIERS) {
+    store.saveConflictLedgerEntry({ memory_a: `a-${tier}`, memory_b: `b-${tier}`, tier });
+  }
+  assert.equal(store.countConflictLedger(), LEDGER_TIERS.length, "triage.js 的每一档都能落账");
+  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/contrast.test.js

@@ -48,8 +48,15 @@ const HOST_TOKENS = {
   "--dsw-alias-interactive-bg-active": { light: "#2631481a", dark: "#ffffff24" },
   "--dsw-alias-scrollbar-bg-l2": { light: "#e5e5e5", dark: "#545557" },
   "--dsw-alias-scrollbar-hover-l2": { light: "#d4d4d4", dark: "#65676b" },
+  // static-* 在两个主题下同值（宿主定义在 :root），图表色盘就是靠它们做色相来源，
+  // 再由 label 混色让深浅两套色阶自动成立。
+  "--dsw-static-amber-500": { light: "#f59e0b", dark: "#f59e0b" },
   "--dsw-static-amber-600": { light: "#dd8629", dark: "#dd8629" },
+  "--dsw-static-blue-500": { light: "#3b82f6", dark: "#3b82f6" },
   "--dsw-static-green-500": { light: "#22c55e", dark: "#22c55e" },
+  "--dsw-static-neutral-500": { light: "#7f8287", dark: "#7f8287" },
+  "--dsw-static-red-500": { light: "#ef4444", dark: "#ef4444" },
+  "--dsw-static-violet-400": { light: "#a78bfa", dark: "#a78bfa" },
   // 真实存在但**不是颜色**的宿主 token：只参与上面的「名字必须存在」检查。
   "--dsw-radius-md": { light: null, dark: null },
   "--dsw-focus-ring-width": { light: null, dark: null },
@@ -139,22 +146,38 @@ function resolveValue(raw, theme) {
   }
   return v.includes("\u00acMISSING\u00ac") ? null : v.trim();
 }
+// 按顶层逗号切。color-mix 会嵌套（图表色盘先跟中性灰压彩度、再跟 label 适配主题），
+// 早期用非贪婪正则会从内层那个「62%,」处劈开，两层都解析失败 → 图形锁报「解析不出颜色」，
+// 看着像色值坏了，其实是解析器不会数括号。
+function splitTop(s) {
+  const out = [];
+  let depth = 0;
+  let cur = "";
+  for (const ch of s) {
+    if (ch === "(") depth++;
+    else if (ch === ")") depth--;
+    if (ch === "," && depth === 0) { out.push(cur); cur = ""; continue; }
+    cur += ch;
+  }
+  out.push(cur);
+  return out.map((x) => x.trim());
+}
 function colorOf(raw, theme) {
   const v = resolveValue(raw, theme);
   if (v === null) return null;
-  let m = /^color-mix\(\s*in\s+srgb\s*,\s*(.+?)\s+([\d.]+)%\s*,\s*transparent\s*\)$/.exec(v);
-  if (m) {
-    const base = colorOf(m[1], theme);
+  const head = /^color-mix\(\s*in\s+srgb\s*,/i.exec(v);
+  if (head && v.endsWith(")")) {
+    const args = splitTop(v.slice(head[0].length, -1));
+    if (args.length !== 2) return null;
+    const pct = /^(.*?)\s+([\d.]+)%$/.exec(args[0]);
+    if (!pct) return null;
+    const base = colorOf(pct[1], theme);
     if (!base) return null;
-    return [...base.slice(0, 3), base[3] * (parseFloat(m[2]) / 100)];
-  }
-  m = /^color-mix\(\s*in\s+srgb\s*,\s*(.+?)\s+([\d.]+)%\s*,\s*(.+?)\s*\)$/.exec(v);
-  if (m) {
-    const a = colorOf(m[1], theme);
-    const b = colorOf(m[3], theme);
-    if (!a || !b) return null;
-    const p = parseFloat(m[2]) / 100;
-    return [...a.slice(0, 3).map((x, i) => x * p + b[i] * (1 - p)), a[3] * p + b[3] * (1 - p)];
+    const p = parseFloat(pct[2]) / 100;
+    if (/^transparent$/i.test(args[1])) return [...base.slice(0, 3), base[3] * p];
+    const other = colorOf(args[1], theme);
+    if (!other) return null;
+    return [...base.slice(0, 3).map((x, i) => x * p + other[i] * (1 - p)), base[3] * p + other[3] * (1 - p)];
   }
   return parseColor(v);
 }
@@ -308,6 +331,95 @@ test("图形色（热度/打卡/连线）在浅深两主题下都达到 3:1", ()
   assert.deepEqual(problems, [], "图形色对比度不足：\n" + problems.join("\n"));
 });
 
+// 色槽的归属是全局的：--mneme-chart-* 只服侍 donut（弧 + 图例点），--mneme-heat-* 只服侍
+// 热力格，--mneme-sink-* 只服侍沉淀图那两根柱。三种回退都在这条锁上：
+//   ① 沉淀图借 donut 的 chart-3 / chart-2——同一页里一根琥珀柱在 donut 是「实体抽取」、
+//      在沉淀图是「新增」，用户会把两个无关的量读成同一类；
+//   ② 上一版把第 6 个色槽内联成了三份（令牌 + 弧 + 图例点），改一处漏两处，死令牌还
+//      没人发现——所以要求每一格都真的由令牌供给，不许内联字面量；
+//   ③ 令牌之间互相继承（`--mneme-sink-added:var(--mneme-chart-3)`）——看着解耦了，实际
+//      一动 donut 的色盘就跟着改，语义层里出现别的图的 var() 一律拦。
+// 它不锁色值：调色是设计决定，该靠截图给人看。与上面 GRAPHICS 的分工是「值 vs 名字」——
+// 那条按值算 3:1、不看名字，所以换语义名也放宽不了对比度，新令牌照样被它咬住。
+test("色槽各有其主：只被自己的图引用，且每格都由令牌供给", () => {
+  const FAMILIES = [
+    { name: "chart", re: /var\(\s*--mneme-chart-/, owns: /^\.mneme-(seg|dot)--[1-6]$/ },
+    { name: "heat", re: /var\(\s*--mneme-heat-/, owns: /^\.mneme-heatcell\.l[1-4]$/ },
+    { name: "sink", re: /var\(\s*--mneme-sink-/, owns: /^\.mneme-sinkbar--(added|merged)$/ }
+  ];
+  const problems = [];
+  // 语义层自己的声明也要查：`--mneme-sink-added:var(--mneme-chart-3)` 这种「继承式解耦」
+  // 看着分了家，实际上 donut 一动色盘它就跟着变。注意语义层那条规则是字符串拼出来的，
+  // **不在 rules 里**（rules 只收能整条匹配单个字面量的规则），所以必须单独扫 layer.body
+  // ——第一版写成了 `if (r.sel === layer.sel)`，那条分支永远进不去，等于没锁。
+  for (const f of FAMILIES) {
+    if (f.re.test(layer.body)) problems.push(`语义层里出现 ${f.name} 色槽的 var() 引用：色值要写成独立一份，不能继承别的图`);
+  }
+  for (const r of rules) {
+    for (const f of FAMILIES) {
+      if (f.re.test(r.body) && !f.owns.test(r.sel)) problems.push(`${r.sel} 借用了 ${f.name} 的色槽`);
+    }
+  }
+  const bySel = new Map(rules.map((r) => [r.sel, r]));
+  for (let i = 1; i <= 6; i++) {
+    for (const kind of ["seg", "dot"]) {
+      const sel = `.mneme-${kind}--${i}`;
+      const r = bySel.get(sel);
+      if (!r) { problems.push(`${sel} 规则没了`); continue; }
+      if (!r.body.includes(`var(--mneme-chart-${i})`)) problems.push(`${sel} 没按 --mneme-chart-${i} 取色（内联颜色会变成第二份源）`);
+    }
+  }
+  for (const [sel, tok] of [
+    ...Array.from({ length: 4 }, (_, i) => [`.mneme-heatcell.l${i + 1}`, null]),
+    [".mneme-sinkbar--added", "--mneme-sink-added"],
+    [".mneme-sinkbar--merged", "--mneme-sink-merged"]
+  ]) {
+    const r = bySel.get(sel);
+    if (!r) { problems.push(`${sel} 规则没了`); continue; }
+    if (tok ? !r.body.includes(`var(${tok})`) : !/var\(\s*--mneme-heat-/.test(r.body)) {
+      problems.push(`${sel} 的填充色不是从语义层的令牌取的`);
+    }
+  }
+  assert.deepEqual(problems, [], "色槽归属或取色来源不对：\n" + problems.join("\n"));
+});
+
+// 图表调色盘（2026-11，代号 E）：五个色相 + 一套共同配方。上面那条明说了「不锁色值」——
+// 色号该靠截图给人看。这条锁的是**配方**，因为配方一散就会退回旧口径：
+//   ① 五个槽各自挑色器与配比：chart-2 与 chart-5 又都变绿（深色下 H 只差 4）、红槽彩度
+//      翻到 0.172（别人的两倍）、amber-600 再压黑读成土褐；
+//   ② 少掉「先跟中性灰混」那一步：彩度与明度带一起散，深浅两套色阶就没法自动成立；
+//   ③ 拿 --dsw-alias-state-* 当色源：那是宿主状态的语义别名，宿主调一次状态色就顺手
+//      换掉了整张图——图表色盘是设计决定，不该被别人的开关牵走。
+// 五个色相必须互不相同（这就是「两块绿」那条的直接回归锁），灰槽留给 chart-6。
+test("图表五色：五个不同色相、同一套两步混色配方", () => {
+  const problems = [];
+  const hues = new Set();
+  for (let i = 1; i <= 5; i++) {
+    const m = new RegExp("--mneme-chart-" + i + ":([^;]+);").exec(layer.body);
+    if (!m) { problems.push("--mneme-chart-" + i + " 没了"); continue; }
+    const v = m[1].trim();
+    if (/--dsw-alias-state-/.test(v)) problems.push("--mneme-chart-" + i + " 用了宿主状态别名当色源：" + v);
+    const shape = /^color-mix\(in srgb,color-mix\(in srgb,var\((--dsw-static-[a-z]+-\d{3}),#[0-9a-f]{6}\) \d+%,var\(--dsw-static-neutral-500,#7f8287\)\) \d+%,var\(--dsw-alias-label-primary\)\)$/.exec(v);
+    if (!shape) { problems.push("--mneme-chart-" + i + " 不是「静态色 → 中性灰 → label」两步式：" + v); continue; }
+    hues.add(shape[1]);
+  }
+  if (hues.size !== 5) problems.push("五个槽只用了 " + hues.size + " 个色相（" + [...hues].join(" / ") + "）：相邻两块又会分不出");
+  const g = /--mneme-chart-6:([^;]+);/.exec(layer.body);
+  if (!g) problems.push("--mneme-chart-6 没了");
+  else if (!/^color-mix\(in srgb,var\(--dsw-alias-label-primary\) \d+%,transparent\)$/.test(g[1].trim())) {
+    problems.push("--mneme-chart-6 是「其他」类，该保持半透明灰：" + g[1].trim());
+  }
+  // 沉淀图两根柱跟着同一套配方走（同页一半柔和一半艳最难解释），但归属仍是自己的
+  for (const tok of ["--mneme-sink-added", "--mneme-sink-merged"]) {
+    const m = new RegExp(tok + ":([^;]+);").exec(layer.body);
+    if (!m) { problems.push(tok + " 没了"); continue; }
+    if (!/color-mix\(in srgb,color-mix\(in srgb,var\(--dsw-static-/.test(m[1])) {
+      problems.push(tok + " 没跟着图表的配方走（单层混色会和 donut 并排时突兀）");
+    }
+  }
+  assert.deepEqual(problems, [], "图表调色盘的配方不统一：\n" + problems.join("\n"));
+});
+
 // 虚线关系边曾经在 .mneme-gedge-dashed 上再叠一层 opacity:.7，把已经只有 50% 的
 // 描边压到浅色 2.28（低于图形 3:1）。上面那条图形锁只读单条规则自己的 stroke，
 // 看不到「同一条边同时命中两条规则、其中一条在降透明度」这种叠加，所以单独锁一层：

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)");
+});