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

package/test/dependency-overrides.test.js

@@ -1,78 +1,78 @@
-// 两个 overrides 存在的唯一理由是 osv-scanner 的红灯，而红灯的判据是**已提交的
-// lockfile**——所以这里锁的是 lockfile 的解析结果，不是 node_modules 里装了什么。
-// 2026-10-31 的现场：同一条 lockfile 在 08:36 是绿的，04:42 那次 push 却是红的，
-// 中间没有任何依赖变更——上游在 23:09 发了两条新公告（glob 超时后仍继续遍历、
-// minimatch globparts 放大 DoS）。换句话说，这个文件里的断言会**因为上游多一条公告
-// 而变红**，那是它应该做的事：红在本地，比红在 main 上便宜。
-//
-// 依赖链只有一条，且全部是 devDependency：
-//   c8@12 → test-exclude@8 → glob + minimatch
-// 两个上游包都已经是 npm 上的最新版、其 deps 仍写旧范围，所以只能在本仓库抬 pin。
-// 一旦上游跟上、这条链不再解析到旧版本，下面的 overrides 断言就会失败——那时应当
-// 删掉这两条 overrides，而不是把断言删掉。
-import test from "node:test";
-import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
-import { dirname, join } from "node:path";
-import { fileURLToPath } from "node:url";
-
-const PKG_ROOT = join(dirname(fileURLToPath(import.meta.url)), "..");
-const pkg = JSON.parse(readFileSync(join(PKG_ROOT, "package.json"), "utf8"));
-const lock = JSON.parse(readFileSync(join(PKG_ROOT, "package-lock.json"), "utf8"));
-
-// 公告给出的修复下限。低于它 = osv-scanner 会在 main 上红，这里先红。
-const FLOORS = {
-  glob: { fixed: [14, 0, 2], cve: "CVE-2026-118773 / GHSA-3g3m-2fjr-6pw4" },
-  minimatch: { fixed: [11, 0, 1], cve: "CVE-2026-118764 / GHSA-g3hv-75wg-m249" },
-};
-
-function parseVersion(v) {
-  return String(v).split(/[.+-]/).slice(0, 3).map((n) => Number.parseInt(n, 10) || 0);
-}
-
-function gte(a, b) {
-  for (let i = 0; i < 3; i++) {
-    if (a[i] !== b[i]) return a[i] > b[i];
-  }
-  return true;
-}
-
-test("glob 与 minimatch 在 lockfile 里都解析到公告的修复下限之上", () => {
-  for (const [name, { fixed, cve }] of Object.entries(FLOORS)) {
-    const entry = lock.packages[`node_modules/${name}`];
-    assert.ok(entry, `lockfile 里应当有 node_modules/${name}`);
-    const actual = parseVersion(entry.version);
-    assert.ok(
-      gte(actual, fixed),
-      `${name} 解析成 ${entry.version}，低于 ${cve} 的修复下限 ${fixed.join(".")}——osv-scanner 会在 main 上红`,
-    );
-  }
-});
-
-// overrides 必须是**精确版本**，不能是 ^ / ~ 范围。
-// 范围等于把选择权交回解析器：下一次上游发版，lockfile 会在某个「只更新 lockfile」
-// 的 PR 里悄悄漂走，而红绿灯本该由人决定。brace-expansion 那次（PR #345）就是精确号。
-test("overrides 是精确版本号，不是范围", () => {
-  for (const name of Object.keys(FLOORS)) {
-    const pin = pkg.overrides?.[name];
-    assert.equal(typeof pin, "string", `package.json overrides 里应当钉住 ${name}`);
-    assert.ok(
-      /^\d+\.\d+\.\d+$/.test(pin),
-      `${name} 的 override 应写精确版本（如 14.0.3），实际是 ${JSON.stringify(pin)}`,
-    );
-  }
-});
-
-// 钉版本是权宜之计，不是永久配置：这条链还在（c8 → test-exclude → glob）就说明
-// 上游仍会解析到旧范围，overrides 必须留着。上游哪天收了，这条会红，提示来删 pin。
-test("devDependency 链仍在：c8 → test-exclude → glob", () => {
-  const c8 = lock.packages["node_modules/c8"];
-  assert.ok(c8, "lockfile 里应当有 c8");
-  assert.ok(c8.dependencies?.["test-exclude"], "c8 仍应依赖 test-exclude");
-  const testExclude = lock.packages["node_modules/test-exclude"];
-  assert.ok(testExclude, "lockfile 里应当有 test-exclude");
-  assert.ok(
-    testExclude.dependencies?.glob,
-    "test-exclude 仍应依赖 glob——它一旦不再依赖，glob/minimatch 两条 overrides 就可以删了",
-  );
-});
+// 两个 overrides 存在的唯一理由是 osv-scanner 的红灯，而红灯的判据是**已提交的
+// lockfile**——所以这里锁的是 lockfile 的解析结果，不是 node_modules 里装了什么。
+// 2026-10-31 的现场：同一条 lockfile 在 08:36 是绿的，04:42 那次 push 却是红的，
+// 中间没有任何依赖变更——上游在 23:09 发了两条新公告（glob 超时后仍继续遍历、
+// minimatch globparts 放大 DoS）。换句话说，这个文件里的断言会**因为上游多一条公告
+// 而变红**，那是它应该做的事：红在本地，比红在 main 上便宜。
+//
+// 依赖链只有一条，且全部是 devDependency：
+//   c8@12 → test-exclude@8 → glob + minimatch
+// 两个上游包都已经是 npm 上的最新版、其 deps 仍写旧范围，所以只能在本仓库抬 pin。
+// 一旦上游跟上、这条链不再解析到旧版本，下面的 overrides 断言就会失败——那时应当
+// 删掉这两条 overrides，而不是把断言删掉。
+import test from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const PKG_ROOT = join(dirname(fileURLToPath(import.meta.url)), "..");
+const pkg = JSON.parse(readFileSync(join(PKG_ROOT, "package.json"), "utf8"));
+const lock = JSON.parse(readFileSync(join(PKG_ROOT, "package-lock.json"), "utf8"));
+
+// 公告给出的修复下限。低于它 = osv-scanner 会在 main 上红，这里先红。
+const FLOORS = {
+  glob: { fixed: [14, 0, 2], cve: "CVE-2026-118773 / GHSA-3g3m-2fjr-6pw4" },
+  minimatch: { fixed: [11, 0, 1], cve: "CVE-2026-118764 / GHSA-g3hv-75wg-m249" },
+};
+
+function parseVersion(v) {
+  return String(v).split(/[.+-]/).slice(0, 3).map((n) => Number.parseInt(n, 10) || 0);
+}
+
+function gte(a, b) {
+  for (let i = 0; i < 3; i++) {
+    if (a[i] !== b[i]) return a[i] > b[i];
+  }
+  return true;
+}
+
+test("glob 与 minimatch 在 lockfile 里都解析到公告的修复下限之上", () => {
+  for (const [name, { fixed, cve }] of Object.entries(FLOORS)) {
+    const entry = lock.packages[`node_modules/${name}`];
+    assert.ok(entry, `lockfile 里应当有 node_modules/${name}`);
+    const actual = parseVersion(entry.version);
+    assert.ok(
+      gte(actual, fixed),
+      `${name} 解析成 ${entry.version}，低于 ${cve} 的修复下限 ${fixed.join(".")}——osv-scanner 会在 main 上红`,
+    );
+  }
+});
+
+// overrides 必须是**精确版本**，不能是 ^ / ~ 范围。
+// 范围等于把选择权交回解析器：下一次上游发版，lockfile 会在某个「只更新 lockfile」
+// 的 PR 里悄悄漂走，而红绿灯本该由人决定。brace-expansion 那次（PR #345）就是精确号。
+test("overrides 是精确版本号，不是范围", () => {
+  for (const name of Object.keys(FLOORS)) {
+    const pin = pkg.overrides?.[name];
+    assert.equal(typeof pin, "string", `package.json overrides 里应当钉住 ${name}`);
+    assert.ok(
+      /^\d+\.\d+\.\d+$/.test(pin),
+      `${name} 的 override 应写精确版本（如 14.0.3），实际是 ${JSON.stringify(pin)}`,
+    );
+  }
+});
+
+// 钉版本是权宜之计，不是永久配置：这条链还在（c8 → test-exclude → glob）就说明
+// 上游仍会解析到旧范围，overrides 必须留着。上游哪天收了，这条会红，提示来删 pin。
+test("devDependency 链仍在：c8 → test-exclude → glob", () => {
+  const c8 = lock.packages["node_modules/c8"];
+  assert.ok(c8, "lockfile 里应当有 c8");
+  assert.ok(c8.dependencies?.["test-exclude"], "c8 仍应依赖 test-exclude");
+  const testExclude = lock.packages["node_modules/test-exclude"];
+  assert.ok(testExclude, "lockfile 里应当有 test-exclude");
+  assert.ok(
+    testExclude.dependencies?.glob,
+    "test-exclude 仍应依赖 glob——它一旦不再依赖，glob/minimatch 两条 overrides 就可以删了",
+  );
+});

package/test/diary-library.test.js

@@ -1,187 +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)");
-});
+// 左侧「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)");
+});