@modusensus/dsh-mneme 0.8.16 → 0.9.1

package/test/llm-audit.test.js

@@ -2,7 +2,7 @@ import test from "node:test";
 import assert from "node:assert/strict";
 import { EventEmitter } from "node:events";
 import { DatabaseSync } from "node:sqlite";
-import { mkdtempSync } from "node:fs";
+import { mkdtempSync, readFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { Context } from "@deepseek-ai/cordis";
@@ -622,6 +622,97 @@ test("entity extraction writes no audit row when llmAudit.enabled === false", as
   store.close();
 });
 
+// #405：实体抽取的审计行此前把失败原因压成一句常量、related_memory_ids 恒空，于是
+// 429 / 配额 / 鉴权 / 超时在库里长得一模一样（主库 735 条 entity_extract error 行全
+// 是「llm stream aborted or errored」），也查不出是哪条记忆没抽到实体。四条锁：原因
+// 落进 error_message（复用 dream 的 describeStreamFailure，全仓归一只此一份）、无
+// 细节时退回旧字面量、归属 id 传得进来且不凭空造、抛错路径同样带归属。
+test("#405: entity extraction audit records the stream failure cause, not a constant", async () => {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config: {} });
+  const streamEntityText = createEntityStreamAdapter({
+    llm: {
+      async *stream() {
+        yield {
+          type: "finish",
+          reason: { kind: "error", failure: { code: "rate_limited", message: "429 Too Many Requests", status: 429 } }
+        };
+      }
+    },
+    agentDefaultModel: { currentSelection: () => ({ provider: "mock", model: "mock-model" }) },
+    logger: { warn: () => {} },
+    service
+  });
+  const text = await streamEntityText(
+    [{ role: "user", content: [{ type: "text", text: "记忆内容" }] }],
+    { memoryId: "mem-1" }
+  );
+  assert.equal(text, undefined, "a failed stream yields no text");
+  const row = service.listLlmAudits({ source: "entityExtract" })[0];
+  assert.equal(row.status, "error");
+  assert.equal(row.error_message, "rate_limited: 429 Too Many Requests",
+    "code + message from chunk.reason.failure survive into the audit row");
+  assert.notEqual(row.error_message, "llm stream aborted or errored",
+    "the constant that made every provider failure look identical is gone");
+  assert.deepEqual(row.related_memory_ids, ["mem-1"],
+    "the row is attributable to the memory that was being extracted");
+  store.close();
+});
+
+test("#405: entity extraction audit keeps the legacy wording when the failure has no detail", async () => {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config: {} });
+  const streamEntityText = createEntityStreamAdapter({
+    llm: {
+      async *stream() {
+        // 老形态：只有 kind，既没有 failure 也没有 message（dsh-llm 早期版本、或
+        // 替身）。这时退回旧字面量——把 error_message 写成空串在库里比一句常量更
+        // 难查，那等于用另一种方式把原因丢掉。
+        yield { type: "finish", reason: { kind: "aborted" } };
+      }
+    },
+    agentDefaultModel: { currentSelection: () => ({ provider: "mock", model: "mock-model" }) },
+    logger: { warn: () => {} },
+    service
+  });
+  await streamEntityText([{ role: "user", content: [{ type: "text", text: "记忆内容" }] }], {});
+  const row = service.listLlmAudits({ source: "entityExtract" })[0];
+  assert.equal(row.error_message, "llm stream aborted or errored");
+  assert.deepEqual(row.related_memory_ids, [], "no memoryId → still empty, never fabricated");
+  store.close();
+});
+
+test("#405: entity extraction audit attributes a thrown stream error to the memory too", async () => {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config: {} });
+  const streamEntityText = createEntityStreamAdapter({
+    llm: {
+      async *stream() {
+        throw new Error("socket hang up");
+      }
+    },
+    agentDefaultModel: { currentSelection: () => ({ provider: "mock", model: "mock-model" }) },
+    logger: { warn: () => {} },
+    service
+  });
+  await streamEntityText([{ role: "user", content: [{ type: "text", text: "记忆内容" }] }], { memoryId: "mem-9" });
+  const row = service.listLlmAudits({ source: "entityExtract" })[0];
+  assert.equal(row.status, "error");
+  assert.equal(row.error_message, "socket hang up");
+  assert.deepEqual(row.related_memory_ids, ["mem-9"], "the throw path attributes too");
+  store.close();
+});
+
+test("#405: the failure-cause formatter stays a single implementation", async () => {
+  const indexSrc = readFileSync(new URL("../src/index.js", import.meta.url), "utf8");
+  const dreamSrc = readFileSync(new URL("../src/dream.js", import.meta.url), "utf8");
+  assert.match(indexSrc, /describeStreamFailure/, "index.js reuses dream.js's formatter");
+  // 有人在这里就地重写 code/message 拼接，就又多出一份口径——#411 的教训是「复制
+  // 粘贴漂移不是设计，是漂移」。锁死两端：归一逻辑只许在 dream.js 里存在一次。
+  assert.equal(indexSrc.match(/failure\.code/g), null, "index.js must not re-format the failure code itself");
+  assert.equal(dreamSrc.match(/function describeStreamFailure\(/g).length, 1, "exactly one definition");
+});
+
 // 启动期保留清理（Bug8）必须与写入侧读**同一份**配置。面板把 llmAudit.enabled 写进
 // kv、经 nestedFlags 合进 cfg，bundle 里可能是关的：清理若读 rawCfg，就会出现「面板
 // 说开 → 各写入点照写，raw 说关 → 不清理」这种无保留期的增长（写入准入 #254 也是读

package/test/mint-source.test.js

@@ -0,0 +1,202 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { createStore } from "../src/store.js";
+import { createService } from "../src/service.js";
+import { applyDecisions, validateDecisions } from "../src/dream/decisions.js";
+import { runSleep } from "../src/dream/sleep.js";
+import { createDreamScheduler } from "../src/dream.js";
+
+// 机器 mint 的记忆必须带真 source。
+//
+// 背景（现场实测，2026-10-14）：pattern 表的 144 行 source 全是 "manual"，
+// 而按 dream_runs 的 patterns.applied 逐轮求和恰好也是 144——它们全是 sleep 的
+// phasePatterns mint 的，那个 "manual" 只是 saveWithDedupe 没拿到 source 时的
+// 兜底值。于是「这类条目从哪来」在数据面上不可读，靠它做的判断（service.js 里
+// 那条「pattern 只由手工写入」）也就跟着错了。
+//
+// 这组用例锁两件事：① 三条 mint 管道各自声明自己的来源；② 来源只能由调用方给，
+// 模型写在决策对象上的 source 一律不算数——validateDecisions 不剥离未知字段，
+// 若 applyCreate 信了 d.source，模型就能给自己的输出盖「人写的」戳。
+
+function setup() {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config: {} });
+  return { store, service };
+}
+
+function mint(service, extra = {}) {
+  return service
+    .saveWithDedupe({ type: "project", title: `铺垫${Math.random()}`, content: "给扫描窗垫一条普通记忆", importance: 3 })
+    .memory;
+}
+
+// ---------------------------------------------------------------- applyDecisions
+
+test("mint source: applyDecisions stamps the caller's mintSource on create", () => {
+  const { store, service } = setup();
+  const { applied } = applyDecisions(
+    [{ action: "create", type: "pattern", title: "真模式", content: "从重复里抽出来的规律", importance: 3 }],
+    service,
+    null,
+    null,
+    { mintSource: "sleep" }
+  );
+  assert.equal(applied, 1);
+  const row = service.all().find((m) => m.type === "pattern");
+  assert.equal(row.source, "sleep", "minted row carries the pipeline provenance");
+  store.close();
+});
+
+test("mint source: dream pipeline stamps 'dream'", () => {
+  const { store, service } = setup();
+  applyDecisions(
+    [{ action: "create", type: "pattern", title: "真模式", content: "规律", importance: 3 }],
+    service,
+    null,
+    null,
+    { mintSource: "dream" }
+  );
+  const row = service.all().find((m) => m.type === "pattern");
+  assert.equal(row.source, "dream");
+  store.close();
+});
+
+// 对抗条：来源取自调用方，不取自决策对象。模型自报的 source 必须被忽略——
+// 否则「机器写的不冒充人写的」这条防线就形同虚设。
+test("mint source: a source on the decision object is ignored, pipeline wins", () => {
+  const { store, service } = setup();
+  const decisions = [
+    { action: "create", type: "pattern", title: "真模式", content: "规律", importance: 3, source: "manual" }
+  ];
+  // 先证明威胁真实存在：这类决策能整个通过校验走到 applyCreate（校验不剥离未知
+  // 字段）。若哪天真加了剥离，这条会红——那时下面的对抗断言也就不再承重了。
+  const { ok } = validateDecisions(decisions, new Map(), { maxCreatePerRun: 3 });
+  assert.equal(ok, true, "a create carrying its own source still validates — that is the threat");
+
+  applyDecisions(decisions, service, null, null, { mintSource: "sleep" });
+  const row = service.all().find((m) => m.type === "pattern");
+  assert.equal(row.source, "sleep", "the model-authored source must not win");
+  store.close();
+});
+
+// 反向：模型自报 source 而没有管道来源时，也不许它自己说了算——回落到兜底，
+// 而不是让模型指哪打哪。
+test("mint source: without a pipeline source the model-authored one still does not win", () => {
+  const { store, service } = setup();
+  applyDecisions(
+    [{ action: "create", type: "pattern", title: "真模式", content: "规律", importance: 3, source: "human" }],
+    service
+  );
+  const row = service.all().find((m) => m.type === "pattern");
+  assert.equal(row.source, "manual", "falls back to the existing default, not the model's claim");
+  store.close();
+});
+
+// 不传 mintSource 时行为与改前逐字一致（不放大行为面）。
+test("mint source: absent mintSource keeps the previous fallback", () => {
+  const { store, service } = setup();
+  applyDecisions([{ action: "create", type: "pattern", title: "真模式", content: "规律", importance: 3 }], service);
+  const row = service.all().find((m) => m.type === "pattern");
+  assert.equal(row.source, "manual");
+  store.close();
+});
+
+// 空白串按「没给」处理，不能写出 source="" 这种假装有来源的空值。
+test("mint source: blank mintSource is treated as absent", () => {
+  const { store, service } = setup();
+  applyDecisions(
+    [{ action: "create", type: "pattern", title: "真模式", content: "规律", importance: 3 }],
+    service,
+    null,
+    null,
+    { mintSource: "   " }
+  );
+  const row = service.all().find((m) => m.type === "pattern");
+  assert.equal(row.source, "manual");
+  store.close();
+});
+
+// ------------------------------------------------------------------ end to end
+
+// sleep 的 pattern 相位（唯一的真实 mint 路径）端到端：断言落库行的 source。
+// 不能靠等下一次做梦验收（要调度 + LLM 路由），所以在这里驱动相位。
+function sleepCtx(decisionsJson) {
+  return {
+    logger: { warn: () => {}, info: () => {} },
+    agentDefaultModel: { currentSelection: () => ({ provider: "mock", model: "sleep-model" }) },
+    llm: {
+      async *stream(options) {
+        const userText = options.messages.find((m) => m.role === "user")?.content?.[0]?.text ?? "";
+        yield { type: "text-delta", index: 0, text: userText.startsWith("id=") ? decisionsJson : "[]" };
+        yield { type: "finish", reason: { kind: "stop" } };
+      }
+    }
+  };
+}
+
+test("mint source: sleep pattern phase mints with source=sleep", async () => {
+  const { store, service } = setup();
+  mint(service);
+  mint(service);
+  const ctx = sleepCtx(
+    JSON.stringify([{ action: "create", type: "pattern", title: "真模式", content: "从 a 和 b 提取", importance: 3 }])
+  );
+  const config = {
+    sleepModeEnabled: true,
+    sleepPatternMinMemories: 10,
+    sleepMaxPatternPerRun: 3
+  };
+  const result = await runSleep(ctx, service, config, ctx.logger, null, null);
+  assert.equal(result.phases.patterns.status, "ok", "pattern phase minted");
+
+  const row = service.all().find((m) => m.type === "pattern");
+  assert.ok(row, "pattern minted");
+  assert.equal(row.source, "sleep", "the sleep phase declares its own provenance");
+  store.close();
+});
+
+test("mint source: dream main chain mints with source=dream", async () => {
+  const { store, service } = setup();
+  const seed = service.saveWithDedupe({ type: "project", title: "旧条目", content: "第一段内容", importance: 3 }).memory;
+  let call = 0;
+  const ctx = {
+    logger: { warn: () => {}, info: () => {} },
+    agentDefaultModel: { currentSelection: () => ({ provider: "mock", model: "mock-model" }) },
+    llm: {
+      async *stream(options) {
+        call++;
+        const userText = options.messages.find((m) => m.role === "user")?.content?.[0]?.text ?? "";
+        const text = call === 1
+          ? JSON.stringify([
+            { action: "keep", ids: [seed.id] },
+            { action: "create", type: "pattern", title: "主链路模式", content: "巩固时发现的规律", importance: 3 }
+          ])
+          : "记忆库总览摘要文本";
+        void userText;
+        yield { type: "text-delta", text };
+        yield { type: "finish", reason: { kind: "ok" } };
+      }
+    }
+  };
+  const dream = createDreamScheduler({ thresholdCount: 1, thresholdChars: 0, delayMs: 0 });
+  const result = await dream.runDream(ctx, service, { dreamProvider: "mock", dreamModel: "mock-model" });
+  assert.equal(result.ok, true);
+
+  const row = service.all().find((m) => m.type === "pattern");
+  assert.ok(row, "the create decision minted a row");
+  assert.equal(row.source, "dream");
+  store.close();
+});
+
+// 验收口径本身：全表分组统计随之可读——同一次运行 mint 的条目能按来源数出来。
+test("mint source: rows are countable by source after minting", () => {
+  const { store, service } = setup();
+  applyDecisions([{ action: "create", type: "pattern", title: "甲", content: "规律甲", importance: 3 }], service, null, null, { mintSource: "sleep" });
+  applyDecisions([{ action: "create", type: "pattern", title: "乙", content: "规律乙", importance: 3 }], service, null, null, { mintSource: "dream" });
+  const bySource = new Map();
+  for (const m of service.all()) bySource.set(m.source, (bySource.get(m.source) ?? 0) + 1);
+  assert.equal(bySource.get("sleep"), 1);
+  assert.equal(bySource.get("dream"), 1);
+  assert.equal(bySource.get("manual"), undefined, "nothing minted here fell back to the default");
+  store.close();
+});

package/test/persona-api.test.js

@@ -0,0 +1,172 @@
+// Persona API routes: internal (/api/dsh-mneme/persona, requireAuth on write)
+// and standalone (/persona behind the global Bearer gate).
+// Locks: GET reads current value; unauthorized writes are rejected; a corrupt
+// JSON body never lands in the store (design: reports/persona-page-design.md ②).
+// Call shapes mirror test/api.test.js (route registry + FakeRes) and
+// test/standalone-api.test.js (real server on port 0 + fetch).
+import test from "node:test";
+import assert from "node:assert/strict";
+import { EventEmitter } from "node:events";
+import { createStore } from "../src/store.js";
+import { createService } from "../src/service.js";
+import { createApi } from "../src/api.js";
+import { createSettings } from "../src/settings.js";
+import { createStandaloneApi } from "../src/api-standalone.js";
+
+class FakeRes extends EventEmitter {
+  constructor() { super(); this.statusCode = 200; this.body = ""; }
+  writeHead(code, headers) { this.statusCode = code; this.headers = headers; return this; }
+  end(text) { this.body = text ?? ""; this.emit("end"); return this; }
+}
+
+function req(path, method = "GET", body = null, headers = {}) {
+  const r = new EventEmitter();
+  r.url = path;
+  r.method = method;
+  r.headers = headers;
+  if (body !== null) {
+    process.nextTick(() => {
+      r.emit("data", Buffer.from(typeof body === "string" ? body : JSON.stringify(body)));
+      r.emit("end");
+    });
+  }
+  return r;
+}
+
+function setupInternal(apiToken = "") {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config: {} });
+  const settings = createSettings(store.db);
+  const commands = {
+    add: (def) => settings.addCommand(def),
+    remove: (id) => settings.removeCommand(id),
+    list: () => settings.listCommands()
+  };
+  const routes = [];
+  const ctx = {
+    webServer: {
+      register(route) {
+        routes.push(route);
+        return () => {};
+      }
+    }
+  };
+  createApi(ctx, service, settings, commands, undefined, undefined, apiToken, {});
+  const route = routes.find((r) => r.path === "/api/dsh-mneme/persona");
+  return { store, settings, route, apiToken };
+}
+
+// ---- internal API（宿主内 /api/dsh-mneme/*） --------------------------------
+
+test("internal GET /persona returns current persona without auth", async () => {
+  const { store, settings, route } = setupInternal();
+  settings.setPersona({ name: "Amarre", enabled: false });
+  const res = new FakeRes();
+  await route.handler(req("/api/dsh-mneme/persona"), res);
+  assert.equal(res.statusCode, 200);
+  assert.equal(JSON.parse(res.body).persona.default.name, "Amarre");
+  store.close();
+});
+
+test("internal PUT /persona without token is rejected and store untouched", async () => {
+  // setupInternal("t")：必须带 token 启动，无 token 的写请求才应被拒
+  // （apiToken 为空时 isAuthorized 恒放行——与 /profile 的既有语义一致）。
+  const { store, settings, route } = setupInternal("t");
+  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: {} });
+  store.close();
+});
+
+test("internal PUT /persona with token round-trips; corrupt JSON body does not land", async () => {
+  const { store, settings, route } = setupInternal("t");
+  const headers = { authorization: "Bearer t" };
+  const ok = new FakeRes();
+  await route.handler(req("/api/dsh-mneme/persona", "PUT", { persona: { name: "Amarre", enabled: true } }, headers), ok);
+  assert.equal(ok.statusCode, 200);
+  assert.equal(settings.getPersona().default.name, "Amarre");
+  const bad = new FakeRes();
+  await route.handler(req("/api/dsh-mneme/persona", "PUT", "not json", headers), bad);
+  // 路由层对坏 JSON 容错（parseBody 口径：坏体不清空库内值），原样回显现值
+  assert.equal(bad.statusCode, 200);
+  assert.equal(settings.getPersona().default.name, "Amarre");
+  store.close();
+});
+
+test("internal PUT /persona multi-card form replaces fully; legacy form merges default", async () => {
+  const { store, settings, route } = setupInternal("t");
+  const headers = { authorization: "Bearer t" };
+  // 先铺一张 byAgent 卡
+  settings.setPersonaFor("zephyr", { name: "泽菲尔", enabled: true });
+  // 旧形 PUT（单对象）：只动 default、byAgent 保留
+  const legacy = new FakeRes();
+  await route.handler(req("/api/dsh-mneme/persona", "PUT", { persona: { name: "Amarre-改", enabled: true } }, headers), legacy);
+  assert.equal(legacy.statusCode, 200);
+  assert.equal(settings.getPersona().default.name, "Amarre-改");
+  assert.equal(settings.getPersona().byAgent.zephyr.name, "泽菲尔", "legacy PUT keeps byAgent");
+  // 新形 PUT（多卡）：全量替换
+  const multi = new FakeRes();
+  await route.handler(req("/api/dsh-mneme/persona", "PUT", { persona: { default: { name: "默认卡", enabled: true }, byAgent: { zephyr: { name: "泽菲尔-新", enabled: true } } } }, headers), multi);
+  assert.equal(multi.statusCode, 200);
+  const got = settings.getPersona();
+  assert.equal(got.default.name, "默认卡");
+  assert.equal(got.byAgent.zephyr.name, "泽菲尔-新");
+  store.close();
+});
+
+// ---- standalone API（Bearer 数据面，真端口 + fetch） ------------------------
+
+async function setupStandalone() {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config: {} });
+  const settings = createSettings(store.db);
+  const api = createStandaloneApi({ service, store, config: {}, settings, logger: null, port: 0 });
+  await api.ready;
+  const base = `http://127.0.0.1:${api.port}`;
+  const auth = { authorization: `Bearer ${api.token}` };
+  return {
+    store, settings, base, auth,
+    close: () => {
+      api.server.closeIdleConnections?.();
+      api.server.close();
+      store.close();
+    }
+  };
+}
+
+test("standalone GET/PUT /persona behind Bearer gate round-trips", async () => {
+  const t = await setupStandalone();
+  try {
+    const get1 = await fetch(`${t.base}/persona`, { headers: t.auth });
+    assert.equal(get1.status, 200);
+    assert.deepEqual((await get1.json()).persona, { default: {}, byAgent: {} });
+    const put = await fetch(`${t.base}/persona`, {
+      method: "PUT",
+      headers: { ...t.auth, "content-type": "application/json" },
+      body: JSON.stringify({ persona: { name: "Zelphi", enabled: false } })
+    });
+    assert.equal(put.status, 200);
+    assert.equal((await put.json()).persona.default.name, "Zelphi");
+    const bad = await fetch(`${t.base}/persona`, {
+      method: "PUT",
+      headers: { ...t.auth, "content-type": "application/json" },
+      body: "not json"
+    });
+    assert.equal(bad.status, 400);
+    assert.equal(t.settings.getPersona().default.name, "Zelphi");
+  } finally {
+    t.close();
+  }
+});
+
+test("standalone /persona without Bearer is 401", async () => {
+  const t = await setupStandalone();
+  try {
+    const res = await fetch(`${t.base}/persona`, { method: "PUT", body: "{}" });
+    assert.equal(res.status, 401);
+    assert.deepEqual(t.settings.getPersona(), { default: {}, byAgent: {} });
+  } finally {
+    t.close();
+  }
+});

package/test/persona-flag.test.js

@@ -0,0 +1,36 @@
+// personaEnabled flag wiring (#254-style): schema key + whitelist pair must
+// surface in /features effective with default false — a missing key would make
+// the panel toggle silently ineffective (client reads effective to register).
+import test from "node:test";
+import assert from "node:assert/strict";
+import { Config } from "../src/config.js";
+import { createSettings, FEATURE_FLAG_SPEC } from "../src/settings.js";
+import { createStore } from "../src/store.js";
+
+test("config schema has personaEnabled defaulting to false", () => {
+  const cfg = Config({});
+  assert.equal(cfg.personaEnabled, false);
+  // 顶层扁平布尔：显式 true 穿透
+  const cfgOn = Config({ personaEnabled: true });
+  assert.equal(cfgOn.personaEnabled, true);
+});
+
+test("personaEnabled is in the boolean whitelist and spec export", () => {
+  assert.ok(FEATURE_FLAG_SPEC.booleans.includes("personaEnabled"));
+  // 默认关：不在 lightMode 排除名单（轻量纯文本注入物，用户显式勾选赢——
+  // 定性同 actionPipelineEnabled；若未来要进名单，此处会失败并提示改设计稿④）
+  const cfg = Config({});
+  const light = cfg.lightMode === true ? cfg : cfg;
+  void light; // lightMode 定性由 api.test.js 计数锁与 config.js 注释共同钉住
+});
+
+test("effective snapshot includes personaEnabled (false default) via featureSnapshot path", () => {
+  const store = createStore(":memory:");
+  const settings = createSettings(store.db);
+  // settings.setFeatureFlags 逐键校验合并写：白名单键可写（w1 已锁 TypeError 面）
+  settings.setFeatureFlags({ personaEnabled: true });
+  assert.equal(settings.getFeatureFlags().personaEnabled, true);
+  // 清掉覆盖后 effective 应回落到 config 默认 false——由 api.test.js 的
+  // 计数锁 + personaEnabled 默认值断言在 /features 路径上完整验证（w1 已同步 +1）。
+  store.close();
+});

package/test/persona-inject.test.js

@@ -0,0 +1,145 @@
+// Persona injection via renderUserSettings (user-settings context, order 85).
+// Locks: with either gate off, output is byte-identical to the legacy rendering
+// (old users see zero change); with both gates on, persona lines lead the block
+// (design ⑥: persona → profile → rules, rules stay hardest) and go through
+// escapePromptVars.
+import test from "node:test";
+import assert from "node:assert/strict";
+import { createStore } from "../src/store.js";
+import { createService } from "../src/service.js";
+import { createInjector } from "../src/inject.js";
+import { createSettings } from "../src/settings.js";
+
+function setup(over = {}) {
+  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 () => {};
+      }
+    }
+  };
+  const config = { maxInjectedItems: 3, importanceThreshold: 3, ...over };
+  createInjector(ctx, service, settings, config);
+  const settingsCtx = contexts.find((c) => c.name === "user-settings");
+  return { store, settings, settingsCtx };
+}
+
+test("legacy output unchanged when config gate off (persona stored but ignored)", () => {
+  const { store, settings, settingsCtx } = setup({ personaEnabled: false });
+  settings.setProfile("用户是规划背景");
+  settings.setRules(["不提及用户名"]);
+  settings.setPersona({ name: "Amarre", personality: "轻松幽默", enabled: true });
+  const text = settingsCtx.text({});
+  // 逐字节等于历史渲染：无人格行、无人格名
+  assert.equal(text, escapeless([
+    "[用户设置] 来自 dsh-mneme 的用户画像与规则：",
+    "- 用户画像：用户是规划背景",
+    "- 规则：不提及用户名"
+  ].join("\n")));
+  store.close();
+});
+
+test("legacy output unchanged when persona.enabled off (config gate on)", () => {
+  const { store, settings, settingsCtx } = setup({ personaEnabled: true });
+  settings.setProfile("用户是规划背景");
+  settings.setPersona({ name: "Amarre", personality: "轻松幽默", enabled: false });
+  const text = settingsCtx.text({});
+  assert.ok(text.includes("用户画像"));
+  assert.ok(!text.includes("人格"));
+  store.close();
+});
+
+test("empty block stays empty when only persona exists but a gate is off", () => {
+  const { store, settings, settingsCtx } = setup({ personaEnabled: false });
+  settings.setPersona({ name: "Amarre", enabled: true });
+  assert.equal(settingsCtx.text({}), "");
+  store.close();
+});
+
+test("both gates on: persona lines lead, then profile, then rules", () => {
+  const { store, settings, settingsCtx } = setup({ personaEnabled: true });
+  settings.setProfile("用户是规划背景");
+  settings.setRules(["不提及用户名"]);
+  settings.setPersona({ name: "Amarre", personality: "轻松幽默", replyStyle: "先给结论再解释", enabled: true });
+  const text = settingsCtx.text({});
+  const idxPersona = text.indexOf("你的人格名字：Amarre");
+  const idxProfile = text.indexOf("用户画像：用户是规划背景");
+  const idxRule = text.indexOf("规则：不提及用户名");
+  assert.ok(idxPersona > -1, "persona line present");
+  assert.ok(idxProfile > idxPersona, "profile after persona (design ⑥)");
+  assert.ok(idxRule > idxProfile, "rules after profile (rules hardest)");
+  assert.ok(text.includes("人格性格设定：轻松幽默"));
+  assert.ok(text.includes("回复要求：先给结论再解释"));
+  store.close();
+});
+
+test("persona with blank text fields renders no persona lines (no empty bullets)", () => {
+  const { store, settings, settingsCtx } = setup({ personaEnabled: true });
+  settings.setPersona({ name: "  ", personality: "", enabled: true });
+  assert.equal(settingsCtx.text({}), "");
+  settings.setProfile("有画像");
+  const text = settingsCtx.text({});
+  assert.ok(!text.includes("人格"));
+  store.close();
+});
+
+test("persona text goes through escapePromptVars (no raw braces)", () => {
+  const { store, settings, settingsCtx } = setup({ personaEnabled: true });
+  settings.setPersona({ name: "{{evil}}", enabled: true });
+  const text = settingsCtx.text({});
+  assert.ok(!text.includes("{{"), "no raw {{ in user-settings block");
+  assert.ok(!text.includes("}}"), "no raw }} in user-settings block");
+  store.close();
+});
+
+// ---- v1.2 多卡寻址：按会话身份取卡，取不到落 default ------------------------
+
+test("session identity hit: byAgent card wins over default", () => {
+  const { store, settings, settingsCtx } = setup({ personaEnabled: true });
+  settings.setPersona({ name: "Amarre", enabled: true }); // default
+  settings.setPersonaFor("zephyr", { name: "泽菲尔", personality: "冷危占有", enabled: true });
+  const ctxWithId = { agent: { session: { header: { agentPreset: "zephyr" } } } };
+  const text = settingsCtx.text(ctxWithId);
+  assert.ok(text.includes("你的人格名字：泽菲尔"), "byAgent card injected");
+  assert.ok(!text.includes("Amarre"), "default card not injected when identity hit");
+  store.close();
+});
+
+test("session identity miss: falls back to default card", () => {
+  const { store, settings, settingsCtx } = setup({ personaEnabled: true });
+  settings.setPersona({ name: "Amarre", enabled: true });
+  settings.setPersonaFor("zephyr", { name: "泽菲尔", enabled: true });
+  const ctxUnknown = { agent: { session: { header: { agentPreset: "unknown-bot" } } } };
+  const text = settingsCtx.text(ctxUnknown);
+  assert.ok(text.includes("Amarre"), "default on identity miss");
+  assert.ok(!text.includes("泽菲尔"), "other card not leaked");
+  store.close();
+});
+
+test("identity card disabled (enabled=false) falls back to default, not partial card", () => {
+  const { store, settings, settingsCtx } = setup({ personaEnabled: true });
+  settings.setPersona({ name: "Amarre", enabled: true });
+  settings.setPersonaFor("zephyr", { name: "泽菲尔", personality: "冷", enabled: false });
+  const ctxWithId = { agent: { session: { header: { agentPreset: "zephyr" } } } };
+  const text = settingsCtx.text(ctxWithId);
+  assert.ok(text.includes("Amarre"), "disabled id card → default");
+  assert.ok(!text.includes("泽菲尔"), "disabled card never partially injected");
+  store.close();
+});
+
+test("session without header (mock/old host) behaves exactly like v1 (default)", () => {
+  const { store, settings, settingsCtx } = setup({ personaEnabled: true });
+  settings.setPersona({ name: "Amarre", personality: "轻松幽默", enabled: true });
+  const text = settingsCtx.text({}); // 无 session.header → default，与 v1 一致
+  assert.ok(text.includes("你的人格名字：Amarre"));
+  assert.ok(text.includes("人格性格设定：轻松幽默"));
+  store.close();
+});
+
+// 期望值工具：直接写明文（本组用例不含需转义字符，escapePromptVars 为恒等）。
+function escapeless(s) { return s; }