@modusensus/dsh-mneme 0.12.0 → 0.13.0

package/test/peak-hours-observability.test.js

@@ -0,0 +1,70 @@
+// Issue #622 可观测性回归：错峰时段串解析失败不许静默。
+//
+// parsePeakSpec 的失败语义（整串视为未配置）是刻意的契约——排程是省钱手段，绝不
+// 该因为写错格式把蒸馏/巩固停掉。但「不救错」不等于「不吭声」：#424 的排查只能靠
+// 「高峰期还在巩固」倒推，正是静默的全貌。本文件锁三件事：
+//   ① invalidPeakSpecs 只报「非空且解析失败」——空串/未配置/合法串/全角归一救得了
+//     的写法一律不报（验收第 2 条：不骚扰没配错峰的用户；#621 已落归一，两处共存）；
+//   ② index.js 的启动告警真的接在 cfg 装配之后（接线锁，仿 failure-retention 的
+//     写法）：告警读的是装配后的 cfg——面板改的 flatFlags 合并进来的值也算数；
+//   ③ /features 答复的 invalidPeakHours 与 helper 同源（api.test.js 里另有往返）。
+import test from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import path from "node:path";
+import { parsePeakSpec, invalidPeakSpecs, PEAK_SPEC_KEYS } from "../src/peak-hours.js";
+
+const here = path.dirname(fileURLToPath(import.meta.url));
+const indexSrc = readFileSync(path.join(here, "..", "src", "index.js"), "utf8");
+
+test("invalidPeakSpecs: 只报非空且解析失败的键；空串/未配置/合法串不报", () => {
+  // 未配置（undefined）与空串：合法的「未配置」，不告警
+  assert.deepEqual(invalidPeakSpecs({}), {});
+  assert.deepEqual(invalidPeakSpecs({ summarizePeakHours: "" }), {});
+  assert.deepEqual(invalidPeakSpecs({ summarizePeakHours: "   " }), {});
+  assert.deepEqual(invalidPeakSpecs({ dreamPeakHours: undefined }), {});
+  // 合法串：不报
+  assert.deepEqual(invalidPeakSpecs({ summarizePeakHours: "09:00-18:00" }), {});
+  assert.deepEqual(invalidPeakSpecs({ dreamPeakHours: "mon-fri 08:00-12:00,14:00-18:00" }), {});
+  // 全角等价写法：本批原基于未含 #621 归一的主线，当时 parsePeakSpec 解析失败、
+  // 「报」是真话。**#621 已并入 main**（全角逗号/冒号/数字归一），解析现在成功，
+  // 本断言随之翻转为不报——这正是 helper「只转述解析器、不自带第二套对错标准」
+  // 的意义：判据翻转由解析器驱动，本文件不需要改任何逻辑。
+  // ⚠️ 原注释里「两批共存无需联动改动」这句是错的：判据确实会翻，只是翻的位置
+  // 在这里而不在 src/。合并 #621 后必须同步翻这一行，否则就是假红。
+  assert.deepEqual(invalidPeakSpecs({ summarizePeakHours: "０９:００-１８:００" }), {});
+  // 非法串：报，且带原串（告警要对得上配置文件里那一行）
+  assert.deepEqual(invalidPeakSpecs({ summarizePeakHours: "24:00-08:00" }), { summarizePeakHours: "24:00-08:00" });
+  assert.deepEqual(invalidPeakSpecs({ dreamPeakHours: "09.00-18.00" }), { dreamPeakHours: "09.00-18.00" });
+  // 两个键互相独立，各查各的（"ok" 没有冒号、没有时段段——解析器视为非法，报得对）
+  const both = invalidPeakSpecs({ summarizePeakHours: "09:00-18:00", dreamPeakHours: "24:00-01:00" });
+  assert.deepEqual(both, { dreamPeakHours: "24:00-01:00" });
+  // 非对象（裸调用方传 undefined 之类）不抛、返回空
+  assert.deepEqual(invalidPeakSpecs(undefined), {});
+  assert.deepEqual(invalidPeakSpecs(null), {});
+  // 非字符串值（垃圾输入）不抛、不报——typeof 守卫
+  assert.deepEqual(invalidPeakSpecs({ summarizePeakHours: 42 }), {});
+});
+
+test("PEAK_SPEC_KEYS 恰好覆盖两个时段键，parsePeakSpec 对它们的失败语义不变", () => {
+  // 键名单独成表：告警点与提示点都要认同一份，谁加键谁改表（不各写数组各自漂移）
+  assert.deepEqual(PEAK_SPEC_KEYS, ["summarizePeakHours", "dreamPeakHours"]);
+  // 本 issue 不动解析语义：非法 → null、空 → null、合法 → 结构（#239 契约原样）
+  assert.equal(parsePeakSpec("24:00-08:00"), null);
+  assert.equal(parsePeakSpec(""), null);
+  assert.ok(parsePeakSpec("09:00-18:00"));
+});
+
+test("接线锁：index.js 的启动告警读装配后的 cfg，且在 sessionGate 之前", () => {
+  const cfgAt = indexSrc.indexOf("const cfg = { ...applyLightModePreset({ ...rawCfg, lightMode }), ...flatFlags };");
+  const callAt = indexSrc.indexOf("invalidPeakSpecs(cfg)");
+  const gateAt = indexSrc.indexOf("const sessionGate = createSessionGate(cfg);");
+  assert.ok(cfgAt > 0, "装配行必须在");
+  assert.ok(callAt > cfgAt, "告警必须排在 cfg 装配之后——读 rawCfg 会漏掉面板改的 flatFlags");
+  assert.ok(gateAt > callAt, "告警在 sessionGate 之前（纯 log，不参与装配顺序的实质，锁在这里只为防它被挪进更早、读不到合并值的分支）");
+  // 只 log：告警分支里不许出现改写 cfg 的语句（行为零变化是本 issue 的前提）
+  const block = indexSrc.slice(callAt, gateAt);
+  assert.ok(!/cfg\s*=[^=]/.test(block), "告警分支不得改写 cfg");
+  assert.ok(block.includes("logger?.warn?.("), "失败可见性走 logger.warn");
+});

package/test/persona-api.test.js

@@ -75,7 +75,7 @@ test("internal PUT /persona without token is rejected and store untouched", asyn
   const res = new FakeRes();
   await route.handler(req("/api/dsh-mneme/persona", "PUT", { persona: { name: "evil" } }), res);
   assert.equal(res.statusCode, 401);
-  assert.deepEqual(settings.getPersona(), { default: {}, byAgent: {} });
+  assert.deepEqual(settings.getPersona(), { default: {}, byAgent: {}, bySession: {} });
   store.close();
 });
 
@@ -140,7 +140,7 @@ test("standalone GET/PUT /persona behind Bearer gate round-trips", async () => {
   try {
     const get1 = await fetch(`${t.base}/persona`, { headers: t.auth });
     assert.equal(get1.status, 200);
-    assert.deepEqual((await get1.json()).persona, { default: {}, byAgent: {} });
+    assert.deepEqual((await get1.json()).persona, { default: {}, byAgent: {}, bySession: {} });
     const put = await fetch(`${t.base}/persona`, {
       method: "PUT",
       headers: { ...t.auth, "content-type": "application/json" },
@@ -165,7 +165,7 @@ test("standalone /persona without Bearer is 401", async () => {
   try {
     const res = await fetch(`${t.base}/persona`, { method: "PUT", body: "{}" });
     assert.equal(res.status, 401);
-    assert.deepEqual(t.settings.getPersona(), { default: {}, byAgent: {} });
+    assert.deepEqual(t.settings.getPersona(), { default: {}, byAgent: {}, bySession: {} });
   } finally {
     t.close();
   }

package/test/persona-by-session.test.js

@@ -0,0 +1,568 @@
+// 绑会话的人格卡（#606）。为什么需要这一维：人格卡原本只有 agentPreset 一个寻址键，
+// 而 DS Bot 这类宿主把它写成常量——实测 bot 工作区 50 个会话里 43 个是 "standard"，
+// 四条主 bot（Amarre / Ephor / Loom / Persis）全部相同，但它们的 session.id 各不相同。
+// 所以「一个 bot 一张卡」只能用会话 id 当键。
+//
+// 本文件锁四件事：
+// 1. 纯加法：没有 bySession 的老数据读回仍是空对象，注入文本逐字节不变。
+// 2. 优先级：bySession > byAgent > default（会话比预设具体）。
+// 3. 严格寻址的两维合判：只建了 bySession 卡时，按 byAgent 寻址的会话也不许被兜底。
+// 4. scenario / mesExample：未设置零输出，设置后排在 replyStyle 之后。
+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 { createInjector } from "../src/inject.js";
+import { createApi } from "../src/api.js";
+import { createSettings } from "../src/settings.js";
+import { resolvePersonaCard, renderUserSettingsBlock } from "../src/user-settings.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") {
+  return { url: path, method, headers: {}, on() {}, emit() {} };
+}
+
+// 注入器 + API 共用同一份 settings/config（同源纪律），两边都能按 {agentPreset, sessionId} 寻址。
+function setup(config = {}) {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config });
+  const settings = createSettings(store.db);
+  const contexts = [];
+  const ctx = { systemPrompt: { context(def) { contexts.push(def); return () => {}; } } };
+  createInjector(ctx, service, settings, config);
+  const settingsCtx = contexts.find((c) => c.name === "user-settings");
+  // 造 ctx：只给要测的那几个键，缺省不给（模拟宿主解析不到）。
+  const makeCtx = ({ agentPreset = null, sessionId = null, parentSession = null } = {}) => {
+    if (!agentPreset && !sessionId && !parentSession) return {};
+    const session = {};
+    if (sessionId) session.id = sessionId;
+    if (agentPreset || parentSession) {
+      session.header = {};
+      if (agentPreset) session.header.agentPreset = agentPreset;
+      if (parentSession) session.header.parentSession = parentSession;
+    }
+    return { agent: { session } };
+  };
+  const injectorText = (opts) => settingsCtx.text(makeCtx(opts));
+  const routes = [];
+  createApi(
+    { webServer: { register: (route) => { routes.push(route); return () => {}; } } },
+    service,
+    settings,
+    { add: () => {}, remove: () => {}, list: () => [] },
+    undefined,
+    undefined,
+    "",
+    config
+  );
+  const route = routes.find((r) => r.path === "/api/dsh-mneme/persona");
+  const preview = async ({ agent = null, session = null, parent = null } = {}) => {
+    const qs = [];
+    if (agent) qs.push(`agent=${encodeURIComponent(agent)}`);
+    if (session) qs.push(`session=${encodeURIComponent(session)}`);
+    if (parent) qs.push(`parent=${encodeURIComponent(parent)}`);
+    const res = new FakeRes();
+    await route.handler(req(`/api/dsh-mneme/persona${qs.length ? `?${qs.join("&")}` : ""}`), res);
+    return JSON.parse(res.body);
+  };
+  return { store, settings, settingsCtx, injectorText, preview };
+}
+
+function seed(settings) {
+  settings.setProfile("用户是规划背景");
+  settings.setPersona({ name: "Amarre", personality: "轻松幽默", enabled: true }); // default
+  settings.setPersonaFor("standard", { name: "标准卡", personality: "通用", enabled: true }); // byAgent
+}
+
+// ---- 1. 纯加法：老数据零变化 -------------------------------------------------
+
+test("老数据（只有 {default, byAgent}）读回 bySession 为空对象，注入文本逐字节不变", () => {
+  const { store, settings } = setup({ personaEnabled: true });
+  // 直写 v1.2 形（无 bySession 键）模拟存量库
+  store.db.prepare("INSERT INTO user_settings (key, value) VALUES ('persona', ?)")
+    .run(JSON.stringify({
+      default: { name: "Amarre", enabled: true },
+      byAgent: { standard: { name: "标准卡", enabled: true } }
+    }));
+  const got = settings.getPersona();
+  assert.deepEqual(got.bySession, {}, "缺 bySession 键必须读成空对象，不是 undefined");
+  assert.equal(got.default.name, "Amarre");
+  assert.equal(got.byAgent.standard.name, "标准卡");
+  // 寻址结果与改动前一致：按 preset 命中 byAgent，不因多了这一维而变
+  assert.equal(resolvePersonaCard(settings, "standard").source, "byAgent");
+  assert.equal(resolvePersonaCard(settings, "unknown").source, "default");
+  store.close();
+});
+
+test("v1 单对象老数据：读作 default，bySession 为 {}（零迁移）", () => {
+  const { store, settings } = setup();
+  store.db.prepare("INSERT INTO user_settings (key, value) VALUES ('persona', ?)")
+    .run(JSON.stringify({ name: "Amarre", personality: "轻松幽默", enabled: true }));
+  const got = settings.getPersona();
+  assert.equal(got.default.name, "Amarre");
+  assert.deepEqual(got.byAgent, {});
+  assert.deepEqual(got.bySession, {});
+  store.close();
+});
+
+test("没设 scenario / mesExample 时，注入文本与历史版本逐字节一致", () => {
+  const { store, settings, injectorText } = setup({ personaEnabled: true });
+  settings.setProfile("用户是规划背景");
+  settings.setRules(["不提及用户名"]);
+  settings.setPersona({ name: "Amarre", personality: "轻松幽默", replyStyle: "先结论后展开", enabled: true });
+  const text = injectorText({});
+  assert.equal(text, [
+    "[用户设置] 来自 dsh-mneme 的用户画像与规则：",
+    "- 你的人格名字：Amarre",
+    "- 人格性格设定：轻松幽默",
+    "- 回复要求：先结论后展开",
+    "- 用户画像：用户是规划背景",
+    "- 规则：不提及用户名"
+  ].join("\n"), "两个新字段都没设时不许留下空标签或空行");
+  store.close();
+});
+
+// ---- 2. 存储往返 -------------------------------------------------------------
+
+test("bySession 存取往返：写入 → 读回 → 列出 → 删除", () => {
+  const { store, settings } = setup();
+  const card = { name: "Ephor", personality: "审计口径", enabled: true };
+  assert.equal(settings.setPersonaForSession("session-389faaa7", card), true);
+  assert.deepEqual(resolvePersonaCard(settings, null, { sessionId: "session-389faaa7" }).card, card);
+  assert.deepEqual(settings.listPersonaSessions(), ["session-389faaa7"]);
+  // 与 byAgent 互不干扰
+  settings.setPersonaFor("standard", { name: "标准卡", enabled: true });
+  assert.deepEqual(settings.listPersonas(), ["standard"]);
+  assert.deepEqual(settings.listPersonaSessions(), ["session-389faaa7"]);
+  // 删
+  assert.equal(settings.removePersonaForSession("session-389faaa7"), true);
+  assert.deepEqual(settings.listPersonaSessions(), []);
+  assert.equal(settings.removePersonaForSession("session-389faaa7"), false, "删不存在的卡返回 false");
+  store.close();
+});
+
+test("setPersonaForSession 拒绝空 id 与 default（兜底位不可被顶替）", () => {
+  const { store, settings } = setup();
+  assert.equal(settings.setPersonaForSession("", { name: "x" }), false);
+  assert.equal(settings.setPersonaForSession("   ", { name: "x" }), false);
+  assert.equal(settings.setPersonaForSession(null, { name: "x" }), false);
+  assert.equal(settings.setPersonaForSession("default", { name: "x" }), false);
+  assert.deepEqual(settings.listPersonaSessions(), []);
+  store.close();
+});
+
+test("写空卡等于删除该会话卡（与 setPersonaFor 同形）", () => {
+  const { store, settings } = setup();
+  settings.setPersonaForSession("s1", { name: "甲", enabled: true });
+  assert.deepEqual(settings.listPersonaSessions(), ["s1"]);
+  settings.setPersonaForSession("s1", {});
+  assert.deepEqual(settings.listPersonaSessions(), [], "空卡不留空壳键");
+  store.close();
+});
+
+test("setPersona 单对象形只改 default，bySession 保留", () => {
+  const { store, settings } = setup();
+  settings.setPersonaForSession("s1", { name: "会话卡", enabled: true });
+  settings.setPersona({ name: "Amarre-新", enabled: true }); // 旧面板写法
+  const got = settings.getPersona();
+  assert.equal(got.default.name, "Amarre-新");
+  assert.equal(got.bySession.s1.name, "会话卡", "bySession 必须活过一次 legacy 形写入");
+  store.close();
+});
+
+test("多卡形全量替换：带 bySession 键即整份替换", () => {
+  const { store, settings } = setup();
+  settings.setPersonaForSession("old", { name: "旧卡", enabled: true });
+  settings.setPersona({ default: { name: "新默认", enabled: true }, byAgent: {}, bySession: { new: { name: "新卡", enabled: true } } });
+  assert.deepEqual(settings.listPersonaSessions(), ["new"]);
+  store.close();
+});
+
+// ---- 3. 寻址优先级 -----------------------------------------------------------
+
+test("优先级：bySession 盖过 byAgent（会话比预设具体）", () => {
+  const { store, settings, injectorText } = setup({ personaEnabled: true });
+  seed(settings); // default=Amarre, byAgent.standard=标准卡
+  settings.setPersonaForSession("session-abc", { name: "会话专属", personality: "只在这次会话", enabled: true });
+  const text = injectorText({ agentPreset: "standard", sessionId: "session-abc" });
+  assert.ok(text.includes("你的人格名字：会话专属"), "会话卡必须赢");
+  assert.ok(!text.includes("标准卡"), "byAgent 卡不该同时出现");
+  assert.ok(!text.includes("Amarre"), "default 更不该出现");
+  store.close();
+});
+
+test("优先级：会话卡被关掉时落回 byAgent（不是直接跳 default）", () => {
+  const { store, settings, injectorText } = setup({ personaEnabled: true });
+  seed(settings);
+  settings.setPersonaForSession("session-abc", { name: "会话专属", enabled: false });
+  const text = injectorText({ agentPreset: "standard", sessionId: "session-abc" });
+  assert.ok(text.includes("你的人格名字：标准卡"), "关掉的会话卡让位给身份卡");
+  assert.ok(!text.includes("会话专属"));
+  store.close();
+});
+
+test("优先级：没有会话卡时按 byAgent 走（老行为不变）", () => {
+  const { store, settings } = setup({ personaEnabled: true });
+  seed(settings);
+  const hit = resolvePersonaCard(settings, "standard", { sessionId: "session-unknown" });
+  assert.equal(hit.source, "byAgent");
+  assert.equal(hit.card.name, "标准卡");
+  store.close();
+});
+
+test("两个键都没有：落 default", () => {
+  const { store, settings } = setup({ personaEnabled: true });
+  seed(settings);
+  const hit = resolvePersonaCard(settings, null, { sessionId: null });
+  assert.equal(hit.source, "default");
+  assert.equal(hit.card.name, "Amarre");
+  store.close();
+});
+
+test("只给 sessionId、不给 agentId 也能命中会话卡（宿主可能只有会话 id）", () => {
+  const { store, settings, injectorText } = setup({ personaEnabled: true });
+  seed(settings);
+  settings.setPersonaForSession("session-only", { name: "仅会话卡", enabled: true });
+  const text = injectorText({ sessionId: "session-only" });
+  assert.ok(text.includes("你的人格名字：仅会话卡"));
+  store.close();
+});
+
+// ---- 4. 严格寻址：两维合判 ---------------------------------------------------
+
+test("strict：只建了 bySession 卡时，按 byAgent 寻址的会话也不许被兜底", () => {
+  // #587 的例外是「一张卡都没建」才回落 default。用户建了会话卡就已经做过分区，
+  // 此时一个没建卡的 preset 会话再拿 default 去兜，等于把分区抹掉一半。
+  const { store, settings } = setup();
+  settings.setPersona({ name: "Amarre", enabled: true });
+  assert.deepEqual(settings.getPersona().byAgent, {}, "前提：byAgent 为空");
+  assert.deepEqual(settings.getPersona().bySession, {}, "前提：bySession 也为空");
+  // 两维都空 → 仍回落 default（#587 例外保持）
+  assert.equal(resolvePersonaCard(settings, "standard", { strict: true }).source, "default");
+  // 只建会话卡之后，例外立即失效
+  settings.setPersonaForSession("session-x", { name: "会话卡", enabled: true });
+  assert.equal(resolvePersonaCard(settings, "standard", { strict: true }).source, "none");
+  // 而那张会话卡自己仍然命中
+  assert.equal(resolvePersonaCard(settings, null, { strict: true, sessionId: "session-x" }).source, "bySession");
+  store.close();
+});
+
+test("strict：只建了 byAgent 卡时，按会话寻址的会话也不许被兜底", () => {
+  const { store, settings } = setup();
+  settings.setPersona({ name: "Amarre", enabled: true });
+  settings.setPersonaFor("standard", { name: "标准卡", enabled: true });
+  // 有会话 id 但没建会话卡 → none（用户已经做过 byAgent 分区）
+  assert.equal(resolvePersonaCard(settings, null, { strict: true, sessionId: "session-y" }).source, "none");
+  store.close();
+});
+
+test("strict：两个键都解析不到时仍用 default（无名会话是 default 的受众）", () => {
+  const { store, settings } = setup();
+  settings.setPersona({ name: "Amarre", enabled: true });
+  settings.setPersonaForSession("session-x", { name: "会话卡", enabled: true });
+  assert.equal(resolvePersonaCard(settings, null, { strict: true }).source, "default");
+  store.close();
+});
+
+// ---- 5. scenario / mesExample ------------------------------------------------
+
+test("scenario / mesExample 设置在 replyStyle 之后渲染", () => {
+  const { store, settings, injectorText } = setup({ personaEnabled: true });
+  settings.setPersona({
+    name: "Amarre",
+    personality: "轻松幽默",
+    replyStyle: "先结论后展开",
+    scenario: "深夜陪你赶论文",
+    mesExample: "桉桉：好累。Amarre：先睡，剩下的我盯着。",
+    enabled: true
+  });
+  const text = injectorText({});
+  const idxReply = text.indexOf("回复要求：先结论后展开");
+  const idxScene = text.indexOf("场景设定：深夜陪你赶论文");
+  const idxExample = text.indexOf("对话示例：桉桉：好累。");
+  assert.ok(idxReply > -1 && idxScene > -1 && idxExample > -1, "三段都在");
+  assert.ok(idxScene > idxReply, "场景在语气之后：身份 → 语气 → 场景 → 示例");
+  assert.ok(idxExample > idxScene, "示例在场景之后");
+  store.close();
+});
+
+test("scenario 只设一个字段时只出一行，不牵连另一个", () => {
+  const { store, settings, injectorText } = setup({ personaEnabled: true });
+  settings.setPersona({ name: "Amarre", scenario: "只在夜里出现", enabled: true });
+  const text = injectorText({});
+  assert.ok(text.includes("场景设定：只在夜里出现"));
+  assert.ok(!text.includes("对话示例"), "没设 mesExample 就不出那一行");
+  store.close();
+});
+
+test("卡里存着空白 scenario / mesExample 时不出空标签（未设置零输出）", () => {
+  // 未设置的字段被 parsePersona 白名单挡在外面，但「存了空白」是另一条路：
+  // 卡里确实有这个键、值是空白串。这一行必须整行不出现，不能渲染成「场景设定：」。
+  const { store, settings, injectorText } = setup({ personaEnabled: true });
+  settings.setPersona({ name: "Amarre", scenario: "   ", mesExample: "\t ", enabled: true });
+  const card = settings.getPersona().default;
+  assert.equal(card.scenario, "   ", "空白串仍被存下（白名单不负责裁空白）");
+  const text = injectorText({});
+  assert.ok(!text.includes("场景设定"), "空白 scenario 不许渲染出标签");
+  assert.ok(!text.includes("对话示例"), "空白 mesExample 不许渲染出标签");
+  assert.ok(text.includes("你的人格名字：Amarre"), "其余段落照常");
+  store.close();
+});
+
+test("scenario / mesExample 走同一个转义（花括号不许漏出去）", () => {
+  const { store, settings, injectorText } = setup({ personaEnabled: true });
+  settings.setPersona({ name: "Amarre", scenario: "{{evil}}", mesExample: "{{x}}", enabled: true });
+  const text = injectorText({});
+  assert.ok(!text.includes("{{"), "no raw {{ in user-settings block");
+  assert.ok(!text.includes("}}"), "no raw }} in user-settings block");
+  store.close();
+});
+
+test("scenario / mesExample 只在卡 enabled 时渲染（关掉的卡一个字都不出）", () => {
+  const { store, settings, injectorText } = setup({ personaEnabled: true });
+  settings.setPersona({ name: "Amarre", scenario: "深夜", enabled: false });
+  settings.setProfile("有画像");
+  const text = injectorText({});
+  assert.ok(!text.includes("场景设定"), "卡关着时新字段同样不渲染");
+  assert.ok(text.includes("用户画像："));
+  store.close();
+});
+
+test("scenario / mesExample 过字段白名单（未知字段仍被丢弃）", () => {
+  const { store, settings } = setup();
+  settings.setPersona({ name: "Amarre", scenario: "场景", mesExample: "示例", sneaky: "x" });
+  const card = settings.getPersona().default;
+  assert.equal(card.scenario, "场景");
+  assert.equal(card.mesExample, "示例");
+  assert.equal("sneaky" in card, false, "白名单没放宽");
+  store.close();
+});
+
+// ---- 6. 端到端：注入链路 + 预览路由 ------------------------------------------
+
+test("注入链路端到端：同一个 agentPreset、不同 sessionId 拿到不同人格", () => {
+  // 这就是 #606 要解决的场景本身：DS Bot 里四个 bot 的 agentPreset 全是 standard。
+  const { store, settings, injectorText } = setup({ personaEnabled: true });
+  settings.setPersona({ name: "Amarre", enabled: true });
+  settings.setPersonaForSession("session-d530e132", { name: "Amarre", personality: "主控", enabled: true });
+  settings.setPersonaForSession("session-389faaa7", { name: "Ephor", personality: "审计", enabled: true });
+  const a = injectorText({ agentPreset: "standard", sessionId: "session-d530e132" });
+  const b = injectorText({ agentPreset: "standard", sessionId: "session-389faaa7" });
+  assert.ok(a.includes("你的人格名字：Amarre"));
+  assert.ok(b.includes("你的人格名字：Ephor"), "同一个 standard 预设下，会话卡必须分得开");
+  assert.ok(!b.includes("你的人格名字：Amarre"));
+  store.close();
+});
+
+test("预览路由支持 &session=，且与注入器逐字节同源", async () => {
+  const { store, settings, injectorText, preview } = setup({ personaEnabled: true });
+  seed(settings);
+  settings.setPersonaForSession("session-abc", { name: "会话专属", personality: "只在这里", enabled: true });
+  const fromInjector = injectorText({ agentPreset: "standard", sessionId: "session-abc" });
+  const body = await preview({ agent: "standard", session: "session-abc" });
+  assert.equal(body.preview.text, fromInjector, "预览必须等于注入器这一帧的输出");
+  assert.equal(body.preview.source, "bySession");
+  assert.equal(body.preview.session, "session-abc", "面板要靠它说清用的是哪张会话卡");
+  assert.ok(body.preview.text.includes("你的人格名字：会话专属"));
+  store.close();
+});
+
+test("预览只给 session 不给 agent 也走会话卡", async () => {
+  const { store, settings, preview } = setup({ personaEnabled: true });
+  seed(settings);
+  settings.setPersonaForSession("session-only", { name: "仅会话卡", enabled: true });
+  const body = await preview({ session: "session-only" });
+  assert.equal(body.preview.source, "bySession");
+  assert.equal(body.preview.agent, null);
+  assert.equal(body.preview.session, "session-only");
+  store.close();
+});
+
+test("预览的 session 参数在 strict 下同样生效（不许比注入更乐观）", async () => {
+  const { store, settings, preview } = setup({ personaEnabled: true, personaStrictAddressing: true });
+  seed(settings);
+  const miss = await preview({ session: "session-unknown" });
+  assert.equal(miss.preview.source, "none", "建过卡、这次会话没建 → 不兜底");
+  assert.ok(!miss.preview.text.includes("Amarre"));
+  settings.setPersonaForSession("session-hit", { name: "命中卡", enabled: true });
+  const hit = await preview({ session: "session-hit" });
+  assert.equal(hit.preview.source, "bySession");
+  store.close();
+});
+
+// ---- 7. 健壮性 ---------------------------------------------------------------
+
+test("session.id 取不到（宿主 accessor 抛错）时不影响 agentPreset 寻址", () => {
+  const { store, settings, settingsCtx } = setup({ personaEnabled: true });
+  seed(settings);
+  // session.id 是抛错的 getter，header 正常——两个键各自护住，不许互相拖累
+  const hostile = {
+    agent: {
+      session: {
+        get id() { throw new Error("no id accessor"); },
+        header: { agentPreset: "standard" }
+      }
+    }
+  };
+  const text = settingsCtx.text(hostile);
+  assert.ok(text.includes("你的人格名字：标准卡"), "id 抛错不该让 preset 也丢掉");
+  store.close();
+});
+
+test("bySession 里的损坏卡（非对象）被丢弃，不抛错", () => {
+  const { store, settings } = setup();
+  store.db.prepare("INSERT INTO user_settings (key, value) VALUES ('persona', ?)")
+    .run(JSON.stringify({ default: {}, byAgent: {}, bySession: { bad: "not a card", good: { name: "好卡", enabled: true } } }));
+  const got = settings.getPersona();
+  assert.equal("bad" in got.bySession, false, "坏卡读成空对象后不收（与 byAgent 同口径）");
+  assert.equal(got.bySession.good.name, "好卡");
+  store.close();
+});
+
+test("renderUserSettingsBlock 返回值带 session 字段（面板定位用）", () => {
+  const { store, settings } = setup({ personaEnabled: true });
+  settings.setPersona({ name: "Amarre", enabled: true });
+  const out = renderUserSettingsBlock({ settings, config: { personaEnabled: true }, agentId: "standard", sessionId: "s1" });
+  assert.equal(out.session, "s1");
+  assert.equal(out.agent, "standard");
+  assert.equal(out.source, "default");
+  store.close();
+});
+
+// ---- 8. 子 agent 继承父会话人格卡 --------------------------------------------
+//
+// 子 agent 是新会话（header 带 parentSession / origin:"subagent"），用户不可能给每个
+// 派生会话建卡。strict 一开，「有身份、没这张身份的卡」= 不注入人格，子 agent 会从
+// 「自称父会话的人格」变成「不知道自己是谁」。所以自己没卡时继承父会话的卡。
+
+test("子 agent 没自己的卡时继承父会话卡（source 是 parentSession）", () => {
+  const { store, settings, injectorText } = setup({ personaEnabled: true });
+  settings.setPersona({ name: "兜底卡", enabled: true });
+  settings.setPersonaForSession("session-parent", { name: "主控人格", personality: "轻松诙谐", enabled: true });
+  const text = injectorText({ agentPreset: "standard", sessionId: "session-child", parentSession: "session-parent" });
+  assert.ok(text.includes("你的人格名字：主控人格"), "子 agent 必须拿到父会话那张卡");
+  assert.ok(!text.includes("兜底卡"), "不许回落到 default");
+  const out = renderUserSettingsBlock({
+    settings,
+    config: { personaEnabled: true },
+    agentId: "standard",
+    sessionId: "session-child",
+    parentSessionId: "session-parent"
+  });
+  assert.equal(out.source, "parentSession");
+  store.close();
+});
+
+test("子 agent 自己有卡时自己的卡优先（继承不覆盖专门指定的卡）", () => {
+  const { store, settings } = setup({ personaEnabled: true });
+  settings.setPersonaForSession("session-parent", { name: "父卡", enabled: true });
+  settings.setPersonaForSession("session-child", { name: "子卡", enabled: true });
+  const hit = resolvePersonaCard(settings, "standard", { sessionId: "session-child", parentSessionId: "session-parent" });
+  assert.equal(hit.source, "bySession");
+  assert.equal(hit.card.name, "子卡");
+  store.close();
+});
+
+test("父卡优先于 byAgent（同一段对话比同一预设更能说明用谁的人格）", () => {
+  const { store, settings } = setup({ personaEnabled: true });
+  settings.setPersonaFor("standard", { name: "预设卡", enabled: true });
+  settings.setPersonaForSession("session-parent", { name: "父卡", enabled: true });
+  const hit = resolvePersonaCard(settings, "standard", { sessionId: "session-child", parentSessionId: "session-parent" });
+  assert.equal(hit.source, "parentSession");
+  assert.equal(hit.card.name, "父卡");
+  store.close();
+});
+
+test("父卡被显式关掉时不继承，落回 byAgent（关掉就是关掉）", () => {
+  const { store, settings } = setup({ personaEnabled: true });
+  settings.setPersonaFor("standard", { name: "预设卡", enabled: true });
+  settings.setPersonaForSession("session-parent", { name: "父卡", enabled: false });
+  const hit = resolvePersonaCard(settings, "standard", { sessionId: "session-child", parentSessionId: "session-parent" });
+  assert.equal(hit.source, "byAgent");
+  assert.equal(hit.card.name, "预设卡");
+  store.close();
+});
+
+test("strict：子 agent 只解析到父会话 id 时也不许被 default 兜底", () => {
+  const { store, settings } = setup({ personaEnabled: true, personaStrictAddressing: true });
+  settings.setPersonaForSession("session-other", { name: "别人的卡", enabled: true });
+  // 子会话与父会话都没有卡；anyCard=true 且确实有身份 → none
+  const miss = resolvePersonaCard(settings, "standard", {
+    strict: true,
+    sessionId: "session-child",
+    parentSessionId: "session-nobody"
+  });
+  assert.equal(miss.source, "none", "有身份但没卡，strict 下不兜底");
+  store.close();
+});
+
+test("strict 关时子 agent 没父卡照旧落 default（零行为变化）", () => {
+  const { store, settings } = setup({ personaEnabled: true });
+  settings.setPersona({ name: "Amarre", enabled: true });
+  settings.setPersonaForSession("session-other", { name: "别人的卡", enabled: true });
+  const hit = resolvePersonaCard(settings, "standard", { sessionId: "session-child", parentSessionId: "session-nope" });
+  assert.equal(hit.source, "default");
+  assert.equal(hit.card.name, "Amarre");
+  store.close();
+});
+
+test("parentSession 与自身 id 相同（脏数据）时不重复查同一个键", () => {
+  const { store, settings } = setup({ personaEnabled: true });
+  settings.setPersonaForSession("session-same", { name: "同一张", enabled: true });
+  const hit = resolvePersonaCard(settings, "standard", {
+    sessionId: "session-same",
+    parentSessionId: "session-same"
+  });
+  assert.equal(hit.source, "bySession", "自身维度先命中，不会误标成继承");
+  store.close();
+});
+
+test("父会话 id 是空白/非字符串时不影响其余寻址", () => {
+  const { store, settings } = setup({ personaEnabled: true });
+  settings.setPersonaFor("standard", { name: "预设卡", enabled: true });
+  for (const bad of ["", "   ", null, undefined, 42, {}]) {
+    const hit = resolvePersonaCard(settings, "standard", { sessionId: "session-child", parentSessionId: bad });
+    assert.equal(hit.source, "byAgent", `parentSessionId=${JSON.stringify(bad)} 应被忽略`);
+  }
+  store.close();
+});
+
+test("session.header 取不到时不影响 agentPreset 寻址（新加的父会话读取也各自兜错）", () => {
+  const { store, settings, settingsCtx } = setup({ personaEnabled: true });
+  seed(settings);
+  const hostile = {
+    agent: {
+      session: {
+        id: "session-x",
+        get header() { throw new Error("no header accessor"); }
+      }
+    }
+  };
+  const text = settingsCtx.text(hostile);
+  // header 整体取不到 → agentId/parentSessionId 皆 null，只剩 sessionId，落 default
+  assert.ok(text.includes("你的人格名字：Amarre"), "会话卡字段可用时不该整块崩掉");
+  store.close();
+});
+
+test("注入链路端到端：子 agent 拿到父会话人格，且与预览同源", async () => {
+  const { store, settings, injectorText, preview } = setup({ personaEnabled: true });
+  settings.setPersona({ name: "兜底", enabled: true });
+  settings.setPersonaForSession("session-parent", { name: "父会话人格", personality: "父的性格", enabled: true });
+  const fromInjector = injectorText({
+    agentPreset: "standard",
+    sessionId: "session-child",
+    parentSession: "session-parent"
+  });
+  assert.ok(fromInjector.includes("你的人格名字：父会话人格"));
+  const body = await preview({ agent: "standard", session: "session-child", parent: "session-parent" });
+  assert.equal(body.preview.text, fromInjector, "预览必须与注入器逐字节同源");
+  assert.equal(body.preview.source, "parentSession");
+  assert.equal(body.preview.parent, "session-parent");
+  store.close();
+});