@modusensus/dsh-mneme 0.11.0 → 0.13.0

package/test/api-routes-gaps.test.js

@@ -271,6 +271,52 @@ test("external-api PUT applies valid config and echoes it", async () => {
   assert.ok(typeof cfg.token === "string");
 });
 
+// 名字过滤必须下推到 store：面板的「搜索实体」此前是自己取回 limit 条再本地
+// 过滤，排在 limit 之外的实体永远搜不到。q 走 SQL LIKE，% 与 _ 要转义，否则
+// 用户输入一个 "%" 就把整库匹配出来。
+test("entities q filters by name in the store, not after the limit", async () => {
+  const { routes, service } = setup();
+  service.createEntity({ name: "SQLite", type: "technology" });
+  service.createEntity({ name: "记忆", type: "concept" });
+  service.createEntity({ name: "postgres", type: "technology" });
+  const route = handler(routes, "/api/dsh-mneme/entities");
+
+  let res = new FakeRes();
+  await route.handler(req("/api/dsh-mneme/entities?q=lite"), res);
+  let data = JSON.parse(res.body);
+  assert.deepEqual(data.entities.map((e) => e.name), ["SQLite"], "substring match");
+
+  // q 命中排在 limit 之外的那一条：这正是本地过滤拿不到的情形
+  res = new FakeRes();
+  await route.handler(req("/api/dsh-mneme/entities?limit=1&q=postgres"), res);
+  data = JSON.parse(res.body);
+  assert.deepEqual(data.entities.map((e) => e.name), ["postgres"]);
+
+  // 通配符必须被转义，不能变成「匹配一切」
+  res = new FakeRes();
+  await route.handler(req("/api/dsh-mneme/entities?q=%25"), res);
+  assert.equal(JSON.parse(res.body).entities.length, 0, "% must not match everything");
+});
+
+// 手机面板只需要 enabled/port/host 来渲染表单，但默认的 GET 会顺手 materialize
+// 一个 Bearer 写进 user_settings —— 纯读变成写路径。?token=omit 让它只读。
+test("external-api GET with token=omit neither materializes nor returns a token", async () => {
+  const { routes, settings } = setup();
+  const route = handler(routes, "/api/dsh-mneme/external-api");
+
+  const res = new FakeRes();
+  await route.handler(req("/api/dsh-mneme/external-api?token=omit"), res);
+  assert.equal(res.statusCode, 200);
+  const cfg = JSON.parse(res.body).config;
+  assert.equal(cfg.token, "", "no plaintext token on a read-only call");
+  assert.equal(settings.getExternalApi()?.token ?? "", "", "nothing persisted either");
+
+  // 不带参数的老客户端行为不变：仍然发 token 并落库
+  const res2 = new FakeRes();
+  await route.handler(req("/api/dsh-mneme/external-api"), res2);
+  assert.ok(JSON.parse(res2.body).config.token.length >= 16);
+});
+
 // ---------------------------------------------------------------------------
 // /api/dsh-mneme/create（#386 第 5 条：面板手动新增记忆）
 // ---------------------------------------------------------------------------
@@ -944,6 +990,23 @@ test("wiring: maintenance is built before the panel createApi call and passed in
   assert.match(callText(src, standaloneAt), /maintenance/);
 });
 
+test("wiring: the panel createApi receives createSemantic's surface, not a bare literal", () => {
+  // 接线锁。#604 的诊断面（backfill / receipts）挂在 createSemantic() 的返回值上，
+  // 而面板这一处曾传字面量 { vectorIndex, reranker }，embeddingDiagnostics 挂不上去，
+  // api.js 的 typeof 守卫每次都落空 —— 真机上 data.embeddings 恒为 null，
+  // 而且没有任何用例断言过它，所以测试全绿。这里锁住传参形状。
+  const src = readFileSync(join(root, "src", "index.js"), "utf8");
+  const callAt = src.indexOf("createApi(ctx, service, settings");
+  assert.ok(callAt >= 0, "src/index.js 里找不到面板 createApi 调用");
+  const call = callText(src, callAt);
+  assert.match(
+    call, /\.\.\.semantic/,
+    "面板 createApi 必须展开 createSemantic() 的返回值，否则 embeddingDiagnostics 永远挂不上"
+  );
+  assert.match(call, /vectorIndex/, "createSemantic() 不带 vectorIndex，必须显式补上");
+  assert.match(call, /reranker/, "reranker 仍要传，/semantic 的 reranker 状态靠它");
+});
+
 
 // ---------------------------------------------------------------------------
 // /api/dsh-mneme/semantic/consolidation-stats（8 周沉淀图的数据源）

package/test/api.test.js

@@ -1,7 +1,9 @@
 import test from "node:test";
 import assert from "node:assert/strict";
 import { EventEmitter } from "node:events";
-import { readFileSync } from "node:fs";
+import { readFileSync, mkdtempSync, mkdirSync, writeFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
 import { createStore } from "../src/store.js";
 import { createService } from "../src/service.js";
 import { createApi } from "../src/api.js";
@@ -57,8 +59,12 @@ function setup(embedder, apiToken = "", config = null, semantic = undefined) {
 }
 
 function findHandler(routes, path) {
-  const route = routes.find((r) => r.path === path || (r.kind === "prefix" && path.startsWith(r.path)));
-  return route;
+  // 先找精确登记，再退回 prefix 兜底。不能只写一个 find：`/api/dsh-mneme` 那条
+  // prefix 404 兜底登记得很早，路径以它开头的任何一条都会先命中它，于是不管
+  // 断言什么都是 404。
+  const exact = routes.find((r) => r.kind === "exact" && r.path === path);
+  if (exact) return exact;
+  return routes.find((r) => r.kind === "prefix" && path.startsWith(r.path));
 }
 
 test("registers list, search, and get prefix routes", () => {
@@ -115,6 +121,56 @@ test("list total excludes forgotten entries", async () => {
   assert.equal(data.total, 1, "total matches visible items, forgotten excluded");
 });
 
+test("list carries typeCounts: the full distribution without the type filter (#597)", async () => {
+  const { routes, service } = setup();
+  service.saveWithDedupe({ type: "preference", title: "p", content: "c" });
+  service.saveWithDedupe({ type: "project", title: "j1", content: "c" });
+  service.saveWithDedupe({ type: "project", title: "j2", content: "c" });
+  const route = routes.find((r) => r.path === "/api/dsh-mneme/list");
+  const res = new FakeRes();
+  await route.handler(req("/api/dsh-mneme/list?type=project"), res);
+  assert.equal(res.statusCode, 200);
+  const data = JSON.parse(res.body);
+  assert.equal(data.total, 2, "total honors the type filter");
+  assert.deepEqual(data.typeCounts, { preference: 1, project: 2 }, "distribution ignores the type filter — other classes survive a selection");
+
+  const resAll = new FakeRes();
+  await route.handler(req("/api/dsh-mneme/list"), resAll);
+  const all = JSON.parse(resAll.body);
+  assert.equal(
+    Object.keys(all.typeCounts).reduce((n, k) => n + all.typeCounts[k], 0),
+    all.total,
+    "distribution sums to the unfiltered total"
+  );
+});
+
+test("list?id= also excludes forgotten entries", async () => {
+  // getById 是裸 SELECT，不套 list 的 forgotten 谓词；这条路由是 open 的，
+  // 漏掉过滤等于让本机任意进程按 id 读到遗忘记忆的全文（评审 #1）。
+  const { routes, service } = setup();
+  const forgotten = service.saveWithDedupe({ type: "preference", title: "遗忘", content: "隐藏" });
+  service.setForget(forgotten.memory.id, true);
+  const route = routes.find((r) => r.path === "/api/dsh-mneme/list");
+  const res = new FakeRes();
+  await route.handler(req(`/api/dsh-mneme/list?id=${forgotten.memory.id}`), res);
+  assert.equal(res.statusCode, 200);
+  const data = JSON.parse(res.body);
+  assert.deepEqual(data.items, []);
+  assert.equal(data.total, 0);
+});
+
+test("list?id= still returns archived rows (archive is not forget)", async () => {
+  const { routes, service } = setup();
+  const archived = service.saveWithDedupe({ type: "preference", title: "归档", content: "仍可比对" });
+  service.setArchived(archived.memory.id, true);
+  const route = routes.find((r) => r.path === "/api/dsh-mneme/list");
+  const res = new FakeRes();
+  await route.handler(req(`/api/dsh-mneme/list?id=${archived.memory.id}`), res);
+  const data = JSON.parse(res.body);
+  assert.equal(data.items.length, 1);
+  assert.equal(data.items[0].title, "归档");
+});
+
 test("list honors limit/offset", async () => {
   const { routes, service } = setup();
   service.saveWithDedupe({ type: "preference", title: "a", content: "1" });
@@ -595,6 +651,33 @@ test("GET /api/dsh-mneme/semantic counts stale-dimension rows as unsearchable wi
   assert.equal(data.vectors.unsearchable, 1, "yet only one is retrievable");
 });
 
+test("GET /api/dsh-mneme/semantic surfaces the #604 backfill/receipt diagnostics", async () => {
+  // #604 的诊断面在 api.js 里一直有出口，但全仓没有一条用例断言过
+  // `data.embeddings`，所以「传参形状不对 → 真机恒为 null」这件事测试看不见。
+  // 这里从 handler 一侧锁住出口本身：semantic 面有 embeddingDiagnostics 就必须透出。
+  const diag = {
+    backfill: { indexed: 12, failed: 1, finishReason: "capped", stillStale: true },
+    receipts: { recent: [{ reason: "http-503" }], totals: { ok: 12, failed: 1 } }
+  };
+  const { routes } = setup(undefined, "", null, {
+    vectorIndex: { getStats: () => ({ embeddedCount: 12, totalCount: 13 }) },
+    embeddingDiagnostics: () => diag
+  });
+  const sem = routes.find((r) => r.path === "/api/dsh-mneme/semantic");
+  const res = new FakeRes();
+  await sem.handler(req("/api/dsh-mneme/semantic"), res);
+  assert.equal(res.statusCode, 200);
+  const data = JSON.parse(res.body);
+  assert.deepEqual(data.embeddings, diag, "the diagnostics must reach the panel verbatim");
+
+  // 老 semantic 面（没有这个方法）仍报 null，不伪造空对象。
+  const { routes: plain } = setup(undefined, "", null, { vectorIndex: { getStats: () => ({ embeddedCount: 0, totalCount: 0 }) } });
+  const plainSem = plain.find((r) => r.path === "/api/dsh-mneme/semantic");
+  const plainRes = new FakeRes();
+  await plainSem.handler(req("/api/dsh-mneme/semantic"), plainRes);
+  assert.equal(JSON.parse(plainRes.body).embeddings, null);
+});
+
 // --- Bug8: llm-audit API (pagination + stats) --------------------------------
 
 test("GET /api/dsh-mneme/semantic/llm-audit returns paginated rows", async () => {
@@ -764,13 +847,36 @@ test("GET /api/dsh-mneme/features returns empty overrides and effective config d
   // 顶层扁平键，不需要 NESTED_FLAG_PATHS 条目）= 112。
   // chorography M3 新增 chorographyInject（开局注入档位；枚举键走 ENUMS 表，
   // 顶层扁平原值 "light"，不需要 NESTED_FLAG_PATHS 条目）= 113。
-  assert.equal(Object.keys(data.effective).length, 113);
+  // 「Agent 眼中的你」自动事实新增 profileFactsEnabled（dream 后逐卡维护 + 手动轮
+  // + 注入段的顶层总闸；顶层扁平键，不需要 NESTED_FLAG_PATHS 条目）= 114。
+  // 2026-11-08 kb-qoder parity（契约 §3.1）新增 chorographyAutoRefresh /
+  // chorographyT1FromPanel / kbEnabled（面板闭环的两个授权闸 + kb 子系统总闸；
+  // 三个都是顶层扁平键，不需要 NESTED_FLAG_PATHS 条目）= 117。
+  // issue #603 第 4 层再新增 conflictAutoResolveEnabled（自动裁决档开关；顶层布尔键）
+  // 与 conflictAutoResolveMinSimilarity（阈值，走 NUMBER_RANGES 表）= 119。
+  // v0.13 再新增 diaryEnabled（QQ 日记本：跨天判定 + 手写入口 + 面板页的总闸；
+  // 顶层扁平键，不需要 NESTED_FLAG_PATHS 条目）= 120。
+  // v0.13 diaryWriteEveryMinutes（日记定时写间隔，走 INT_RANGES 表）= 121。
+  // issue #557 新增 dreamInputSummaryEnabled（顶层布尔键，不需要 NESTED_FLAG_PATHS 条目）
+  // = +1；issue #275 新增 capacityWarning 三个嵌套点号键 = +3。两个 PR 各自把锁从
+  // 121 往上加，合并时只能做加法（选边会写回旧值，锁当场红）。
+  // issue #619 情感归因相位再新增 sleepAffectiveEnabled（顶层布尔键）、
+  // sleepAffectiveTraitMinSessions 与 sleepAffectiveMaxRelationsPerRun
+  // （两个都走 INT_RANGES 表）= +3，故 121 + 1 + 3 + 3 = 128。
+  assert.equal(Object.keys(data.effective).length, 128);
+  // 三个 kb 新键的默认值单独钉一遍：计数锁只钉数量，钉不住值（缺省值翻转时
+  // 面板会静默换上一套授权语义），这里补上值这一层。
+  assert.equal(data.effective.chorographyAutoRefresh, false);
+  assert.equal(data.effective.chorographyT1FromPanel, true);
+  assert.equal(data.effective.kbEnabled, false);
   assert.equal(data.effective.chorographyEnabled, false);
   assert.equal(data.effective.chorographyInject, "light");
   assert.equal(data.effective.dreamSkipInvalid, true);
   assert.equal(data.effective.allowCrossTypeMerge, false);
   assert.equal(data.effective.dreamMergeGuard, true);
   assert.equal(data.effective.injectHeatEnabled, false);
+  // issue #557：审计行快照瘦身默认关（默认审计行逐字节一致）
+  assert.equal(data.effective.dreamInputSummaryEnabled, false);
   // issue #380：注入前判定两级开关，默认全关（默认路径零行为变化）
   assert.equal(data.effective["preInjectGate.enabled"], false);
   assert.equal(data.effective["preInjectGate.enforce"], false);
@@ -951,6 +1057,12 @@ test("PUT /api/dsh-mneme/features round-trips nested, string, url and enum keys"
     // #471：政策轴的两个点号键往返——白名单与 NESTED_FLAG_PATHS 成对缺一即静默缺键。
     "scopeState.enabled": true,
     "scopeState.enforce": true,
+    // #275：三个容量阈值点号键往返——两个 int 走 INT_RANGES、一个浮点走
+    // NUMBER_RANGES，都必须同时进 settings 白名单与 api.js 的 NESTED_FLAG_PATHS
+    //（成对缺一即静默缺键）。
+    "capacityWarning.dbSizeWarnMb": 128,
+    "capacityWarning.archivedRowsWarn": 6000,
+    "capacityWarning.archivedRatioWarn": 0.9,
     // #164 A2：顶层扁平键（不是对象子字段），与上面两个点号键走同一条往返；
     // 它的默认值断言在计数锁那一条里，这里钉的是「PUT 存进去、effective 读得回」。
     sensitiveScanEnabled: true,
@@ -974,6 +1086,9 @@ test("PUT /api/dsh-mneme/features round-trips nested, string, url and enum keys"
     "distillRecords.retentionDays": 30,
     "scopeState.enabled": true,
     "scopeState.enforce": true,
+    "capacityWarning.dbSizeWarnMb": 128,
+    "capacityWarning.archivedRowsWarn": 6000,
+    "capacityWarning.archivedRatioWarn": 0.9,
     sensitiveScanEnabled: true,
     embedProvider: "local",
     ollamaBaseUrl: "http://127.0.0.1:11434",
@@ -993,6 +1108,10 @@ test("PUT /api/dsh-mneme/features round-trips nested, string, url and enum keys"
   // #471：政策轴两个点号键同款往返
   assert.equal(data.effective["scopeState.enabled"], true);
   assert.equal(data.effective["scopeState.enforce"], true);
+  // #275：容量阈值 int 与浮点两类点号键都读得回来
+  assert.equal(data.effective["capacityWarning.dbSizeWarnMb"], 128, "整数点号键也要读得回来");
+  assert.equal(data.effective["capacityWarning.archivedRowsWarn"], 6000);
+  assert.equal(data.effective["capacityWarning.archivedRatioWarn"], 0.9, "浮点点号键同款往返");
   assert.equal(data.effective.sensitiveScanEnabled, true);
   assert.equal(data.effective.embedProvider, "local");
   assert.equal(data.effective.ollamaBaseUrl, "http://127.0.0.1:11434");
@@ -1014,6 +1133,37 @@ test("PUT /api/dsh-mneme/features round-trips nested, string, url and enum keys"
   assert.deepEqual(settings.getFeatureFlags(), data.overrides, "rejected writes persist nothing");
 });
 
+test("GET/PUT /api/dsh-mneme/features 带 invalidPeakHours（#622：时段串解析失败在面板可见）", async () => {
+  const { routes } = setup(undefined, "", FLAGS_CFG);
+  const route = routes.find((r) => r.path === "/api/dsh-mneme/features");
+  // 默认配置（空串）与合法串：不报——不骚扰没配错峰的用户（验收第 2 条）
+  const get0 = new FakeRes();
+  await route.handler(req("/api/dsh-mneme/features"), get0);
+  assert.deepEqual(JSON.parse(get0.body).invalidPeakHours, []);
+  await route.handler(req("/api/dsh-mneme/features", "PUT", { summarizePeakHours: "09:00-18:00" }), new FakeRes());
+  await route.handler(req("/api/dsh-mneme/features", "PUT", { summarizePeakHours: "" }), new FakeRes());
+  const get1 = new FakeRes();
+  await route.handler(req("/api/dsh-mneme/features"), get1);
+  assert.deepEqual(JSON.parse(get1.body).invalidPeakHours, []);
+  // 非法串（越界 / 点号当冒号——#621 归一救不了的那类）经 PUT 存进去后要被点名
+  await route.handler(req("/api/dsh-mneme/features", "PUT", { summarizePeakHours: "24:00-08:00" }), new FakeRes());
+  const get2 = new FakeRes();
+  await route.handler(req("/api/dsh-mneme/features"), get2);
+  assert.deepEqual(JSON.parse(get2.body).invalidPeakHours, ["summarizePeakHours"]);
+  await route.handler(req("/api/dsh-mneme/features", "PUT", { dreamPeakHours: "09.00-18.00" }), new FakeRes());
+  const get3 = new FakeRes();
+  await route.handler(req("/api/dsh-mneme/features"), get3);
+  assert.deepEqual([...JSON.parse(get3.body).invalidPeakHours].sort(), ["dreamPeakHours", "summarizePeakHours"]);
+  // PUT 答复同走 featureSnapshot：保存后提示立即跟着换（改回合法值即消失）
+  const put = new FakeRes();
+  await route.handler(req("/api/dsh-mneme/features", "PUT", { dreamPeakHours: "23:00-06:00" }), put);
+  assert.deepEqual(JSON.parse(put.body).invalidPeakHours, ["summarizePeakHours"]);
+  // 校验只读 effective：不因提示改任何行为面（空 patch 依旧 400，语义零变化）
+  const empty = new FakeRes();
+  await route.handler(req("/api/dsh-mneme/features", "PUT", {}), empty);
+  assert.equal(empty.statusCode, 400);
+});
+
 test("PUT /api/dsh-mneme/features rejects unknown keys, bad types and bad ranges with 400", async () => {
   const { routes, settings } = setup(undefined, "", FLAGS_CFG);
   const route = routes.find((r) => r.path === "/api/dsh-mneme/features");
@@ -2613,3 +2763,226 @@ test("GET /api/dsh-mneme/memory/provenance?sessionId=：limit 越界 → 400；
   assert.equal(data.windows.length, 2);
   assert.equal(data.truncated, true, "还有第三个窗口没回——必须说出来，否则半份转录会被当成全部");
 });
+
+// --- 日记库两条路由（左侧「ta 的日记」面板的数据源）-----------------------
+// 这两条与上面按 project 定位的五条日记路由不是一回事：面板拿不到当前会话，
+// 只能整体扫 diaries 根目录。所以这里也必须不传 project 就能读。
+
+/** 造一个带 diaries 目录的临时 memoryDir，并按 bucket/date 铺文件。 */
+function diaryFixture(buckets) {
+  const memoryDir = mkdtempSync(join(tmpdir(), "mneme-api-diary-"));
+  const root = join(memoryDir, "diaries");
+  mkdirSync(root, { recursive: true });
+  for (const [bucket, files] of Object.entries(buckets)) {
+    mkdirSync(join(root, bucket), { recursive: true });
+    for (const [date, text] of Object.entries(files)) {
+      writeFileSync(join(root, bucket, `${date}.md`), text, "utf8");
+    }
+  }
+  return { memoryDir, root };
+}
+
+function diaryPage(agent, body = "正文") {
+  return `---\ndate: 2026-11-08\nproject: p\npersona: settings (${agent})\n---\n\n${body}\n`;
+}
+
+/** 只装配日记要的那一个位置参数（第 14 个），其余留空。 */
+function setupDiary(config, diary = { compose: async () => ({ ok: true }) }) {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config: {} });
+  const settings = createSettings(store.db);
+  const routes = [];
+  const handlers = {};
+  const ctx = {
+    webServer: { register(route) { routes.push(route); return () => {}; } },
+    // 用真的 session/event 通道：agentBySession 账本正是从这里喂料的，
+    // 换成假函数就只测了「我自己的桩」，测不到真实接线。
+    on(name, fn) { handlers[name] = fn; return () => { delete handlers[name]; }; }
+  };
+  createApi(ctx, service, settings, { add() {}, remove() {}, list: () => [] }, undefined,
+    undefined, "", config, null, null, null, null, null, diary);
+  const emitSession = (session) => {
+    const fn = handlers["session/event"];
+    if (fn) fn(session);
+  };
+  return { routes, emitSession }; 
+}
+
+/**
+ * 一个在本平台一定是绝对路径的项目根。
+ *
+ * 这里原先写死 `D:/proj`：Windows 上 isAbsolute() 为真、Linux/macOS 上为假，
+ * 于是 src/api.js 的 diaryProject() 直接回 400 project-not-absolute，ubuntu 22/24
+ * 与 test-host-legacy 两腿全红，而本机 Windows 全绿——产品代码没错，是断言不可移植。
+ * tmpdir() 在两种平台上都返回绝对路径，用例才真正等价。
+ */
+function portableProjectRoot() {
+  return join(tmpdir(), "mneme-diary-compose");
+}
+
+/** 抓一个 compose 调用参数的 spy：既要知道调没调、也要知道传了什么。 */
+function composeSpy() {
+  const calls = [];
+  const diary = {
+    compose: async (args) => {
+      calls.push(args);
+      return { ok: true, status: "written", date: "2026-11-08", path: "x.md" };
+    }
+  };
+  return { calls, diary };
+}
+
+test("GET /api/dsh-mneme/diary/library：不传 project 也能列清单（面板拿不到会话）", async (t) => {
+  const { memoryDir } = diaryFixture({
+    "amarre-c836db6a": { "2026-11-08": diaryPage("amarre") },
+    "attune-dd7a5103": { "2026-11-07": diaryPage("attune") }
+  });
+  t.after(() => rmSync(memoryDir, { recursive: true, force: true }));
+
+  const { routes } = setupDiary({ memoryDir, diaryEnabled: true });
+  const route = findHandler(routes, "/api/dsh-mneme/diary/library");
+  assert.ok(route, "路由必须注册在 /api/dsh-mneme/diary/library");
+  const res = new FakeRes();
+  await route.handler(req("/api/dsh-mneme/diary/library"), res);
+  assert.equal(res.statusCode, 200);
+  const data = JSON.parse(res.body);
+  assert.equal(data.contract, "mneme.diary/v1");
+  assert.equal(data.buckets.length, 2);
+});
+
+test("GET /api/dsh-mneme/diary/library/entry：正常读到正文", async (t) => {
+  const { memoryDir } = diaryFixture({ "amarre-c836db6a": { "2026-11-08": diaryPage("amarre", "今天很好") } });
+  t.after(() => rmSync(memoryDir, { recursive: true, force: true }));
+
+  const { routes } = setupDiary({ memoryDir, diaryEnabled: true });
+  const route = findHandler(routes, "/api/dsh-mneme/diary/library/entry");
+  const res = new FakeRes();
+  await route.handler(req("/api/dsh-mneme/diary/library/entry?bucket=amarre-c836db6a&date=2026-11-08"), res);
+  assert.equal(res.statusCode, 200);
+  const data = JSON.parse(res.body);
+  assert.equal(data.bucket, "amarre-c836db6a");
+  assert.equal(data.date, "2026-11-08");
+  assert.match(data.text, /今天很好/);
+});
+
+test("GET /api/dsh-mneme/diary/library/entry：越界桶名与坏日期都回 400，不伪装成 404", async (t) => {
+  const { memoryDir } = diaryFixture({ ok: { "2026-11-08": diaryPage("x") } });
+  t.after(() => rmSync(memoryDir, { recursive: true, force: true }));
+
+  const { routes } = setupDiary({ memoryDir, diaryEnabled: true });
+  const route = findHandler(routes, "/api/dsh-mneme/diary/library/entry");
+
+  // 越界是一种**坏请求**，不是「这本不存在」——回 404 会让调用方以为换个名字再试就行。
+  for (const bad of ["..", "../x", "ok/../ok", ""]) {
+    const res = new FakeRes();
+    await route.handler(req(`/api/dsh-mneme/diary/library/entry?bucket=${encodeURIComponent(bad)}&date=2026-11-08`), res);
+    assert.equal(res.statusCode, 400, `桶名 ${JSON.stringify(bad)} 该回 400`);
+    assert.equal(JSON.parse(res.body).error, "bucket-required");
+  }
+  for (const bad of ["2026-1-1", "../../etc/passwd", ""]) {
+    const res = new FakeRes();
+    await route.handler(req(`/api/dsh-mneme/diary/library/entry?bucket=ok&date=${encodeURIComponent(bad)}`), res);
+    assert.equal(res.statusCode, 400, `日期 ${JSON.stringify(bad)} 该回 400`);
+    assert.equal(JSON.parse(res.body).error, "date-required");
+  }
+});
+
+test("GET /api/dsh-mneme/diary/library/entry：合法但不存在 → 404 diary-not-found", async (t) => {
+  const { memoryDir } = diaryFixture({ ok: { "2026-11-08": diaryPage("x") } });
+  t.after(() => rmSync(memoryDir, { recursive: true, force: true }));
+
+  const { routes } = setupDiary({ memoryDir, diaryEnabled: true });
+  const route = findHandler(routes, "/api/dsh-mneme/diary/library/entry");
+  const res = new FakeRes();
+  await route.handler(req("/api/dsh-mneme/diary/library/entry?bucket=ok&date=2026-01-01"), res);
+  assert.equal(res.statusCode, 404);
+  assert.equal(JSON.parse(res.body).error, "diary-not-found");
+});
+
+test("日记库两条路由与右栏同源：装配缺件 503、开关关着 409", async (t) => {
+  const { memoryDir } = diaryFixture({ ok: { "2026-11-08": diaryPage("x") } });
+  t.after(() => rmSync(memoryDir, { recursive: true, force: true }));
+  for (const path of ["/api/dsh-mneme/diary/library", "/api/dsh-mneme/diary/library/entry?bucket=ok&date=2026-11-08"]) {
+    // 503：diary 位置参数没装配。
+    const off = setupDiary({ memoryDir, diaryEnabled: true }, null);
+    const r1 = new FakeRes();
+    await findHandler(off.routes, "/api/dsh-mneme/diary/library").handler(req(path), r1);
+    assert.equal(r1.statusCode, 503, `${path} 装配缺件该回 503`);
+    assert.equal(JSON.parse(r1.body).reason, "diary-unavailable");
+
+    // 409：装配了但用户没开。
+    const disabled = setupDiary({ memoryDir, diaryEnabled: false });
+    const r2 = new FakeRes();
+    await findHandler(disabled.routes, "/api/dsh-mneme/diary/library").handler(req(path), r2);
+    assert.equal(r2.statusCode, 409, `${path} 开关关着该回 409`);
+    assert.equal(JSON.parse(r2.body).reason, "diary-not-enabled");
+  }
+});
+
+test("中文桶名：清单里列得出来就必须读得到（否则就是点了没反应）", async (t) => {
+  // 现场真有一个保留中文的历史桶。上一版这里两层用了不同判据——清单按路径语义、
+  // 路由按 ASCII 白名单——结果是列得出来、点进去 400。这条用例锁住两者同源。
+  const { memoryDir } = diaryFixture({ "QQ对话-4f061790": { "2026-11-07": diaryPage("amarre", "旧的那篇") } });
+  t.after(() => rmSync(memoryDir, { recursive: true, force: true }));
+
+  const { routes } = setupDiary({ memoryDir, diaryEnabled: true });
+  const list = new FakeRes();
+  await findHandler(routes, "/api/dsh-mneme/diary/library").handler(req("/api/dsh-mneme/diary/library"), list);
+  const buckets = JSON.parse(list.body).buckets.map((b) => b.key);
+  assert.ok(buckets.includes("QQ对话-4f061790"), "中文桶必须出现在清单里");
+
+  const res = new FakeRes();
+  await findHandler(routes, "/api/dsh-mneme/diary/library/entry")
+    .handler(req(`/api/dsh-mneme/diary/library/entry?bucket=${encodeURIComponent("QQ对话-4f061790")}&date=2026-11-07`), res);
+  assert.equal(res.statusCode, 200, "清单里列得出来的桶，点进去必须读得到");
+  assert.match(JSON.parse(res.body).text, /旧的那篇/);
+});
+
+// --- 手动写日记必须带身份（「设定好人格的 agent 只以这个人格的口吻写日记」）-----
+// 自动轮（src/diary/auto.js:47）一直传 agentId，手动轮的 /diary/compose 却不传，
+// 于是永远落 default 人格卡：同一天从两个入口写，是两张卡的两种声音。
+// 这三条锁住「带 ?agent= / ?session= 就传、都不带就不猜」。
+
+test("POST /diary/compose 带 ?agent= 时把它作为 agentId 传下去", async () => {
+  const { calls, diary } = composeSpy();
+  const { routes } = setupDiary({ diaryEnabled: true }, diary);
+  const route = findHandler(routes, "/api/dsh-mneme/diary/compose");
+  const project = portableProjectRoot();
+  const res = new FakeRes();
+  await route.handler(
+    req("/api/dsh-mneme/diary/compose?project=" + encodeURIComponent(project) + "&agent=amarre", "POST", {}),
+    res
+  );
+  assert.equal(res.statusCode, 200);
+  assert.equal(calls.length, 1);
+  assert.equal(calls[0].agentId, "amarre");
+  assert.equal(calls[0].trigger, "manual");
+  assert.equal(calls[0].projectRoot, project);
+});
+
+test("POST /diary/compose 只带 ?session= 时按会话账本反查身份", async () => {
+  const { calls, diary } = composeSpy();
+  const { routes, emitSession } = setupDiary({ diaryEnabled: true }, diary);
+  // 账本由真实的 session/event 通道喂料，不手搓内部结构。
+  emitSession({ id: "sess-1", header: { agentPreset: "attune" } });
+  const route = findHandler(routes, "/api/dsh-mneme/diary/compose");
+  const project = portableProjectRoot();
+  const res = new FakeRes();
+  await route.handler(
+    req("/api/dsh-mneme/diary/compose?project=" + encodeURIComponent(project) + "&session=sess-1", "POST", {}),
+    res
+  );
+  assert.equal(res.statusCode, 200);
+  assert.equal(calls[0].agentId, "attune", "会话身份必须从账本里查出来，不能落 default");
+});
+
+test("POST /diary/compose 两个身份参数都没有时传 null，不假装自己是 default", async () => {
+  const { calls, diary } = composeSpy();
+  const { routes } = setupDiary({ diaryEnabled: true }, diary);
+  const route = findHandler(routes, "/api/dsh-mneme/diary/compose");
+  const project = portableProjectRoot();
+  const res = new FakeRes();
+  await route.handler(req("/api/dsh-mneme/diary/compose?project=" + encodeURIComponent(project), "POST", {}), res);
+  assert.equal(res.statusCode, 200);
+  assert.equal(calls[0].agentId, null, "不知道是谁 ≠ 以为是 default");
+});