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

package/test/peer-blockers.test.js

@@ -1,193 +1,193 @@
-import test from "node:test";
-import assert from "node:assert/strict";
-import { mkdtempSync, rmSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { fileURLToPath } from "node:url";
-import { execFile } from "node:child_process";
-import { promisify } from "node:util";
-import { createStore } from "../src/store.js";
-import { createMirror } from "../src/mirror.js";
-import { createService } from "../src/service.js";
-
-const execFileP = promisify(execFile);
-
-/**
- * v0.3.8 回归测试（audit peer 6 项运行时阻断 → INSTALLATION_NOT_APPROVED）。
- *
- * 测试点：
- *  A. 崩溃窗口（真实语义）：store.save 在业务事务内原子递增 desired generation，
- *     崩溃在 COMMIT 后、syncMirror 前 → 重启 recoverMirror 仅凭
- *     generation > applied_generation 捕获并收敛（peer blocker 1）
- *  B. 业务写同事务原子性：INSERT 失败回滚时 generation 不得递增（peer blocker 1/3）
- *  C. 多进程并发原子递增：8 进程 × 10 次不丢增量（peer blocker 3）
- *  D. generation 上界/负数拒绝（peer blocker 6）
- */
-
-function setup(dbPath) {
-  const dir = mkdtempSync(join(tmpdir(), "dsh-mneme-peer-"));
-  const mirrorDir = join(dir, "mirror");
-  const store = createStore(dbPath ?? ":memory:");
-  const mirror = createMirror(mirrorDir);
-  const warns = [];
-  const logger = { warn: (...a) => warns.push(a.join(" ")) };
-  const service = createService({ store, mirror, config: {}, logger });
-  return { dir, mirrorDir, store, mirror, service, warns };
-}
-
-test("peer-A: 崩溃窗口——save 后（generation 已递增）不 sync 直接关闭重开，recoverMirror 捕获并收敛", () => {
-  const dir = mkdtempSync(join(tmpdir(), "dsh-mneme-peer-"));
-  const dbPath = join(dir, "mneme.db");
-  const mirrorDir = join(dir, "mirror");
-  try {
-    const store = createStore(dbPath);
-    const mirror = createMirror(mirrorDir);
-    const service = createService({ store, mirror, config: {}, logger: { warn() {} } });
-    try {
-      // 业务写：store.save 在事务内递增 desired generation，但不触发 mirror 渲染
-      store.save({ type: "project", title: "P", content: "x", importance: 3 });
-      const afterSave = store.getMirrorState();
-      assert.ok(afterSave.generation > afterSave.applied_generation,
-        "save 后 generation > applied（COMMIT 完成，mirror 未同步=崩溃窗口）");
-    } finally {
-      // 模拟崩溃：不调 syncMirror，直接关库
-      store.close();
-    }
-
-    // 重启：重新打开同一 DB，recoverMirror 必须捕获债务并收敛
-    const store2 = createStore(dbPath);
-    const mirror2 = createMirror(mirrorDir);
-    const service2 = createService({ store: store2, mirror: mirror2, config: {}, logger: { warn() {} } });
-    try {
-      const result = service2.recoverMirror();
-      assert.equal(result.recovered, true, "崩溃窗口必须被 recover 捕获");
-      assert.equal(result.error, null);
-      const state = store2.getMirrorState();
-      assert.equal(state.dirty, false, "收敛后 dirty 清");
-      assert.ok(state.generation <= state.applied_generation, "收敛后无未应用债务");
-    } finally {
-      store2.close();
-    }
-  } finally {
-    rmSync(dir, { recursive: true, force: true });
-  }
-});
-
-test("peer-B: 业务写同事务原子性——INSERT 失败回滚时 generation 不得递增", () => {
-  const { dir, store } = setup();
-  try {
-    store.save({ id: "dup", type: "project", title: "A", content: "x", importance: 3 });
-    const before = store.getMirrorState().generation;
-    assert.throws(
-      () => store.save({ id: "dup", type: "project", title: "B", content: "y", importance: 3 }),
-      /UNIQUE|constraint/i,
-      "重复主键 INSERT 必须抛错"
-    );
-    assert.equal(store.getMirrorState().generation, before,
-      "回滚后 generation 不递增（写与 desired generation 同事务，失败一起回滚）");
-  } finally {
-    store.close();
-    rmSync(dir, { recursive: true, force: true });
-  }
-});
-
-test("peer-C: 多进程并发原子递增——8 进程×10 次 incrementGeneration 不丢增量", async () => {
-  const dir = mkdtempSync(join(tmpdir(), "dsh-mneme-peer-"));
-  const dbPath = join(dir, "concurrent.db");
-  const N = 8;
-  const M = 10;
-  try {
-    // 子进程：静态 worker 脚本（test/helpers/peer-worker.mjs，可审查、无动态
-    // 生成代码），execFile 参数数组、无 shell；DB 路径与迭代数经 argv 传入。
-    const workerPath = fileURLToPath(new URL("./helpers/peer-worker.mjs", import.meta.url));
-    await Promise.all(
-      Array.from({ length: N }, () =>
-        execFileP(process.execPath, [workerPath, dbPath, String(M)], { timeout: 30000 })
-      )
-    );
-    const store = createStore(dbPath);
-    try {
-      const state = store.getMirrorState();
-      assert.equal(state.generation, N * M,
-        `并发 ${N} 进程 × ${M} 次必须无丢失增量，得到 ${state.generation}`);
-    } finally {
-      store.close();
-    }
-  } finally {
-    // Windows：8 个 SQLite 子进程退出后 -shm/-wal 句柄延迟释放，删目录偶发 EPERM；
-    // rm 带 maxRetries 自动重试（30×100ms 共 3s），仍失败则放行——清理只是收尾，
-    // 并发断言正确性由上方 generation 断言保证，残留临时目录交给 OS/CI 回收，
-    // 绝不让句柄释放慢把 flaky 标红。
-    try {
-      rmSync(dir, { recursive: true, force: true, maxRetries: 30, retryDelay: 100 });
-    } catch (err) {
-      if (!["EPERM", "EBUSY", "EACCES"].includes(err.code)) throw err;
-    }
-  }
-});
-
-test("peer-D: generation 上界与负数拒绝", () => {
-  const { dir, store } = setup();
-  try {
-    // 负数拒绝
-    assert.throws(() => store.setMirrorState({ generation: -1 }), RangeError, "负数必须拒绝");
-    assert.throws(() => store.setMirrorState({ applied_generation: -5 }), RangeError, "负数 applied 必须拒绝");
-    // 超 MAX_SAFE_INTEGER 拒绝
-    assert.throws(
-      () => store.setMirrorState({ generation: Number.MAX_SAFE_INTEGER + 1 }),
-      RangeError,
-      "超出 MAX_SAFE_INTEGER 必须拒绝"
-    );
-    // 到上界后再 increment 必须抛错（读回不会 ERR_OUT_OF_RANGE）
-    store.setMirrorState({ generation: Number.MAX_SAFE_INTEGER });
-    assert.throws(() => store.incrementGeneration(), /exceeded MAX_SAFE_INTEGER/, "上界后再递增必须抛错");
-    // 正常递增仍工作
-    store.setMirrorState({ generation: 5 });
-    assert.equal(store.incrementGeneration().generation, 6, "正常递增不受影响");
-  } finally {
-    store.close();
-    rmSync(dir, { recursive: true, force: true });
-  }
-});
-
-test("v0.3.9-A: compareAndUpdate 的 CAS UPDATE 与 generation 同事务——miss 不得递增", () => {
-  const { dir, store } = setup();
-  try {
-    const saved = store.save({ type: "project", title: "CAS 原子", content: "v0" });
-    const before = store.getById(saved.id);
-    const genBefore = store.getMirrorState().generation;
-
-    // 成功 CAS：业务写入 + generation 递增必须一次提交（同事务）
-    const updated = store.compareAndUpdate(saved.id, before.updated_at, { content: "v1" });
-    assert.ok(updated, "当前版本 CAS 必须成功");
-    const genAfterOk = store.getMirrorState().generation;
-    assert.equal(genAfterOk, genBefore + 1, "成功 CAS 必须恰好递增一次 generation");
-
-    // miss CAS：不写任何东西，generation 也不得递增
-    const stale = store.getById(saved.id).updated_at; // v1 的 token
-    store.compareAndUpdate(saved.id, before.updated_at, { content: "v2" }); // 用旧 token → miss
-    assert.equal(store.getById(saved.id).content, "v1", "miss 不得改数据");
-    assert.equal(store.getMirrorState().generation, genAfterOk,
-      "CAS miss 不得递增 generation（UPDATE 与 increment 必须同事务）");
-  } finally {
-    store.close();
-    rmSync(dir, { recursive: true, force: true });
-  }
-});
-
-test("v0.3.9-F: generation 非整数必须拒绝（不得截断）", () => {
-  const { dir, store } = setup();
-  try {
-    // 审计 peer F：1.5 这类小数此前被 Math.trunc 截断 + SQLite CHECK 接受 → 静默脏值。
-    // fail-closed：JS 与 SQL 统一只接受整数。
-    assert.throws(() => store.setMirrorState({ generation: 1.5 }), RangeError, "小数 generation 必须拒绝");
-    assert.throws(() => store.setMirrorState({ applied_generation: -1.5 }), RangeError, "负数小数必须拒绝");
-    assert.throws(() => store.setMirrorState({ generation: Number.MAX_SAFE_INTEGER + 0.5 }), RangeError, "超界小数必须拒绝");
-    // 整数仍正常
-    const s = store.setMirrorState({ generation: 7 });
-    assert.equal(s.generation, 7, "整数 generation 正常");
-  } finally {
-    store.close();
-    rmSync(dir, { recursive: true, force: true });
-  }
-});
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { createStore } from "../src/store.js";
+import { createMirror } from "../src/mirror.js";
+import { createService } from "../src/service.js";
+
+const execFileP = promisify(execFile);
+
+/**
+ * v0.3.8 回归测试（audit peer 6 项运行时阻断 → INSTALLATION_NOT_APPROVED）。
+ *
+ * 测试点：
+ *  A. 崩溃窗口（真实语义）：store.save 在业务事务内原子递增 desired generation，
+ *     崩溃在 COMMIT 后、syncMirror 前 → 重启 recoverMirror 仅凭
+ *     generation > applied_generation 捕获并收敛（peer blocker 1）
+ *  B. 业务写同事务原子性：INSERT 失败回滚时 generation 不得递增（peer blocker 1/3）
+ *  C. 多进程并发原子递增：8 进程 × 10 次不丢增量（peer blocker 3）
+ *  D. generation 上界/负数拒绝（peer blocker 6）
+ */
+
+function setup(dbPath) {
+  const dir = mkdtempSync(join(tmpdir(), "dsh-mneme-peer-"));
+  const mirrorDir = join(dir, "mirror");
+  const store = createStore(dbPath ?? ":memory:");
+  const mirror = createMirror(mirrorDir);
+  const warns = [];
+  const logger = { warn: (...a) => warns.push(a.join(" ")) };
+  const service = createService({ store, mirror, config: {}, logger });
+  return { dir, mirrorDir, store, mirror, service, warns };
+}
+
+test("peer-A: 崩溃窗口——save 后（generation 已递增）不 sync 直接关闭重开，recoverMirror 捕获并收敛", () => {
+  const dir = mkdtempSync(join(tmpdir(), "dsh-mneme-peer-"));
+  const dbPath = join(dir, "mneme.db");
+  const mirrorDir = join(dir, "mirror");
+  try {
+    const store = createStore(dbPath);
+    const mirror = createMirror(mirrorDir);
+    const service = createService({ store, mirror, config: {}, logger: { warn() {} } });
+    try {
+      // 业务写：store.save 在事务内递增 desired generation，但不触发 mirror 渲染
+      store.save({ type: "project", title: "P", content: "x", importance: 3 });
+      const afterSave = store.getMirrorState();
+      assert.ok(afterSave.generation > afterSave.applied_generation,
+        "save 后 generation > applied（COMMIT 完成，mirror 未同步=崩溃窗口）");
+    } finally {
+      // 模拟崩溃：不调 syncMirror，直接关库
+      store.close();
+    }
+
+    // 重启：重新打开同一 DB，recoverMirror 必须捕获债务并收敛
+    const store2 = createStore(dbPath);
+    const mirror2 = createMirror(mirrorDir);
+    const service2 = createService({ store: store2, mirror: mirror2, config: {}, logger: { warn() {} } });
+    try {
+      const result = service2.recoverMirror();
+      assert.equal(result.recovered, true, "崩溃窗口必须被 recover 捕获");
+      assert.equal(result.error, null);
+      const state = store2.getMirrorState();
+      assert.equal(state.dirty, false, "收敛后 dirty 清");
+      assert.ok(state.generation <= state.applied_generation, "收敛后无未应用债务");
+    } finally {
+      store2.close();
+    }
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test("peer-B: 业务写同事务原子性——INSERT 失败回滚时 generation 不得递增", () => {
+  const { dir, store } = setup();
+  try {
+    store.save({ id: "dup", type: "project", title: "A", content: "x", importance: 3 });
+    const before = store.getMirrorState().generation;
+    assert.throws(
+      () => store.save({ id: "dup", type: "project", title: "B", content: "y", importance: 3 }),
+      /UNIQUE|constraint/i,
+      "重复主键 INSERT 必须抛错"
+    );
+    assert.equal(store.getMirrorState().generation, before,
+      "回滚后 generation 不递增（写与 desired generation 同事务，失败一起回滚）");
+  } finally {
+    store.close();
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test("peer-C: 多进程并发原子递增——8 进程×10 次 incrementGeneration 不丢增量", async () => {
+  const dir = mkdtempSync(join(tmpdir(), "dsh-mneme-peer-"));
+  const dbPath = join(dir, "concurrent.db");
+  const N = 8;
+  const M = 10;
+  try {
+    // 子进程：静态 worker 脚本（test/helpers/peer-worker.mjs，可审查、无动态
+    // 生成代码），execFile 参数数组、无 shell；DB 路径与迭代数经 argv 传入。
+    const workerPath = fileURLToPath(new URL("./helpers/peer-worker.mjs", import.meta.url));
+    await Promise.all(
+      Array.from({ length: N }, () =>
+        execFileP(process.execPath, [workerPath, dbPath, String(M)], { timeout: 30000 })
+      )
+    );
+    const store = createStore(dbPath);
+    try {
+      const state = store.getMirrorState();
+      assert.equal(state.generation, N * M,
+        `并发 ${N} 进程 × ${M} 次必须无丢失增量，得到 ${state.generation}`);
+    } finally {
+      store.close();
+    }
+  } finally {
+    // Windows：8 个 SQLite 子进程退出后 -shm/-wal 句柄延迟释放，删目录偶发 EPERM；
+    // rm 带 maxRetries 自动重试（30×100ms 共 3s），仍失败则放行——清理只是收尾，
+    // 并发断言正确性由上方 generation 断言保证，残留临时目录交给 OS/CI 回收，
+    // 绝不让句柄释放慢把 flaky 标红。
+    try {
+      rmSync(dir, { recursive: true, force: true, maxRetries: 30, retryDelay: 100 });
+    } catch (err) {
+      if (!["EPERM", "EBUSY", "EACCES"].includes(err.code)) throw err;
+    }
+  }
+});
+
+test("peer-D: generation 上界与负数拒绝", () => {
+  const { dir, store } = setup();
+  try {
+    // 负数拒绝
+    assert.throws(() => store.setMirrorState({ generation: -1 }), RangeError, "负数必须拒绝");
+    assert.throws(() => store.setMirrorState({ applied_generation: -5 }), RangeError, "负数 applied 必须拒绝");
+    // 超 MAX_SAFE_INTEGER 拒绝
+    assert.throws(
+      () => store.setMirrorState({ generation: Number.MAX_SAFE_INTEGER + 1 }),
+      RangeError,
+      "超出 MAX_SAFE_INTEGER 必须拒绝"
+    );
+    // 到上界后再 increment 必须抛错（读回不会 ERR_OUT_OF_RANGE）
+    store.setMirrorState({ generation: Number.MAX_SAFE_INTEGER });
+    assert.throws(() => store.incrementGeneration(), /exceeded MAX_SAFE_INTEGER/, "上界后再递增必须抛错");
+    // 正常递增仍工作
+    store.setMirrorState({ generation: 5 });
+    assert.equal(store.incrementGeneration().generation, 6, "正常递增不受影响");
+  } finally {
+    store.close();
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test("v0.3.9-A: compareAndUpdate 的 CAS UPDATE 与 generation 同事务——miss 不得递增", () => {
+  const { dir, store } = setup();
+  try {
+    const saved = store.save({ type: "project", title: "CAS 原子", content: "v0" });
+    const before = store.getById(saved.id);
+    const genBefore = store.getMirrorState().generation;
+
+    // 成功 CAS：业务写入 + generation 递增必须一次提交（同事务）
+    const updated = store.compareAndUpdate(saved.id, before.updated_at, { content: "v1" });
+    assert.ok(updated, "当前版本 CAS 必须成功");
+    const genAfterOk = store.getMirrorState().generation;
+    assert.equal(genAfterOk, genBefore + 1, "成功 CAS 必须恰好递增一次 generation");
+
+    // miss CAS：不写任何东西，generation 也不得递增
+    const stale = store.getById(saved.id).updated_at; // v1 的 token
+    store.compareAndUpdate(saved.id, before.updated_at, { content: "v2" }); // 用旧 token → miss
+    assert.equal(store.getById(saved.id).content, "v1", "miss 不得改数据");
+    assert.equal(store.getMirrorState().generation, genAfterOk,
+      "CAS miss 不得递增 generation（UPDATE 与 increment 必须同事务）");
+  } finally {
+    store.close();
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test("v0.3.9-F: generation 非整数必须拒绝（不得截断）", () => {
+  const { dir, store } = setup();
+  try {
+    // 审计 peer F：1.5 这类小数此前被 Math.trunc 截断 + SQLite CHECK 接受 → 静默脏值。
+    // fail-closed：JS 与 SQL 统一只接受整数。
+    assert.throws(() => store.setMirrorState({ generation: 1.5 }), RangeError, "小数 generation 必须拒绝");
+    assert.throws(() => store.setMirrorState({ applied_generation: -1.5 }), RangeError, "负数小数必须拒绝");
+    assert.throws(() => store.setMirrorState({ generation: Number.MAX_SAFE_INTEGER + 0.5 }), RangeError, "超界小数必须拒绝");
+    // 整数仍正常
+    const s = store.setMirrorState({ generation: 7 });
+    assert.equal(s.generation, 7, "整数 generation 正常");
+  } finally {
+    store.close();
+    rmSync(dir, { recursive: true, force: true });
+  }
+});

package/test/persona-addressing.test.js

@@ -1,83 +1,83 @@
-// 修复一：人格寻址的兜底口径。default 卡的存在理由是「这一帧解析不到会话身份」，
-// 而不是「所有没建卡的 agent 都该拿到它」——后者会把某个人格无条件塞进外部 bot 的
-// 会话（DS Bot 那类：它自己带身份与设定，两处身份声明撞在同一帧里）。
-// 现状（personaStrictAddressing 缺省 = false）已由 test/persona-inject.test.js:113
-// 与 :124 钉住，本文件第一条照样锁它——这是 opt-in，不是把别人的行为改了。
-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 () => {};
-      }
-    }
-  };
-  createInjector(ctx, service, settings, { maxInjectedItems: 3, importanceThreshold: 3, ...over });
-  return { store, settings, settingsCtx: contexts.find((c) => c.name === "user-settings") };
-}
-
-const withPreset = (agentPreset) => ({ agent: { session: { id: "s1", header: { agentPreset } } } });
-
-// 种子：default 卡（Amarre）开着 + 一张 zephyr 卡。
-function seed(settings, zephyrEnabled = true) {
-  settings.setPersona({ name: "Amarre", personality: "轻松幽默", enabled: true });
-  settings.setPersonaFor("zephyr", { name: "泽菲尔", personality: "冷危", enabled: zephyrEnabled });
-}
-
-test("缺省（开关关）：没建卡的身份仍落 default——本 PR 不改默认行为", () => {
-  const { store, settings, settingsCtx } = setup({ personaEnabled: true });
-  seed(settings);
-  const text = settingsCtx.text(withPreset("unknown-bot"));
-  assert.ok(text.includes("Amarre"), "personaStrictAddressing 缺省时行为逐字节不变");
-  store.close();
-});
-
-test("strict on：没建卡的身份不注入任何人格行", () => {
-  const { store, settings, settingsCtx } = setup({ personaEnabled: true, personaStrictAddressing: true });
-  seed(settings);
-  settings.setProfile("用户是规划背景");
-  const text = settingsCtx.text(withPreset("unknown-bot"));
-  assert.ok(!text.includes("Amarre"), "外部身份不该收到别人的人格");
-  assert.ok(!text.includes("你的人格名字"), "无人格时整段人格行都不出现，不是留个空标签");
-  store.close();
-});
-
-test("strict on：显式关掉的卡不再回落 default——这让「关掉这张卡」第一次有意义", () => {
-  const { store, settings, settingsCtx } = setup({ personaEnabled: true, personaStrictAddressing: true });
-  seed(settings, false);
-  const text = settingsCtx.text(withPreset("zephyr"));
-  assert.ok(!text.includes("泽菲尔"), "关掉的卡本身不注入");
-  assert.ok(!text.includes("Amarre"), "关掉之后落回 default 等于没关");
-  store.close();
-});
-
-test("strict on：解析不到身份（无 session.header）照旧用 default 卡", () => {
-  const { store, settings, settingsCtx } = setup({ personaEnabled: true, personaStrictAddressing: true });
-  seed(settings);
-  const text = settingsCtx.text({});
-  assert.ok(text.includes("你的人格名字：Amarre"), "无名会话正是 default 卡的受众，strict 不许把它一起关掉");
-  store.close();
-});
-
-test("strict on：命中的卡照常注入，画像与规则不受影响", () => {
-  const { store, settings, settingsCtx } = setup({ personaEnabled: true, personaStrictAddressing: true });
-  seed(settings);
-  settings.setProfile("用户是规划背景");
-  settings.setRules(["不提及用户名"]);
-  const hit = settingsCtx.text(withPreset("zephyr"));
-  assert.ok(hit.includes("你的人格名字：泽菲尔"), "身份命中时行为与现状一致");
-  assert.ok(hit.includes("- 用户画像：用户是规划背景"), "画像恒注入：本开关只管人格行");
-  assert.ok(hit.includes("- 规则：不提及用户名"), "规则恒注入：同上");
-  store.close();
-});
+// 修复一：人格寻址的兜底口径。default 卡的存在理由是「这一帧解析不到会话身份」，
+// 而不是「所有没建卡的 agent 都该拿到它」——后者会把某个人格无条件塞进外部 bot 的
+// 会话（DS Bot 那类：它自己带身份与设定，两处身份声明撞在同一帧里）。
+// 现状（personaStrictAddressing 缺省 = false）已由 test/persona-inject.test.js:113
+// 与 :124 钉住，本文件第一条照样锁它——这是 opt-in，不是把别人的行为改了。
+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 () => {};
+      }
+    }
+  };
+  createInjector(ctx, service, settings, { maxInjectedItems: 3, importanceThreshold: 3, ...over });
+  return { store, settings, settingsCtx: contexts.find((c) => c.name === "user-settings") };
+}
+
+const withPreset = (agentPreset) => ({ agent: { session: { id: "s1", header: { agentPreset } } } });
+
+// 种子：default 卡（Amarre）开着 + 一张 zephyr 卡。
+function seed(settings, zephyrEnabled = true) {
+  settings.setPersona({ name: "Amarre", personality: "轻松幽默", enabled: true });
+  settings.setPersonaFor("zephyr", { name: "泽菲尔", personality: "冷危", enabled: zephyrEnabled });
+}
+
+test("缺省（开关关）：没建卡的身份仍落 default——本 PR 不改默认行为", () => {
+  const { store, settings, settingsCtx } = setup({ personaEnabled: true });
+  seed(settings);
+  const text = settingsCtx.text(withPreset("unknown-bot"));
+  assert.ok(text.includes("Amarre"), "personaStrictAddressing 缺省时行为逐字节不变");
+  store.close();
+});
+
+test("strict on：没建卡的身份不注入任何人格行", () => {
+  const { store, settings, settingsCtx } = setup({ personaEnabled: true, personaStrictAddressing: true });
+  seed(settings);
+  settings.setProfile("用户是规划背景");
+  const text = settingsCtx.text(withPreset("unknown-bot"));
+  assert.ok(!text.includes("Amarre"), "外部身份不该收到别人的人格");
+  assert.ok(!text.includes("你的人格名字"), "无人格时整段人格行都不出现，不是留个空标签");
+  store.close();
+});
+
+test("strict on：显式关掉的卡不再回落 default——这让「关掉这张卡」第一次有意义", () => {
+  const { store, settings, settingsCtx } = setup({ personaEnabled: true, personaStrictAddressing: true });
+  seed(settings, false);
+  const text = settingsCtx.text(withPreset("zephyr"));
+  assert.ok(!text.includes("泽菲尔"), "关掉的卡本身不注入");
+  assert.ok(!text.includes("Amarre"), "关掉之后落回 default 等于没关");
+  store.close();
+});
+
+test("strict on：解析不到身份（无 session.header）照旧用 default 卡", () => {
+  const { store, settings, settingsCtx } = setup({ personaEnabled: true, personaStrictAddressing: true });
+  seed(settings);
+  const text = settingsCtx.text({});
+  assert.ok(text.includes("你的人格名字：Amarre"), "无名会话正是 default 卡的受众，strict 不许把它一起关掉");
+  store.close();
+});
+
+test("strict on：命中的卡照常注入，画像与规则不受影响", () => {
+  const { store, settings, settingsCtx } = setup({ personaEnabled: true, personaStrictAddressing: true });
+  seed(settings);
+  settings.setProfile("用户是规划背景");
+  settings.setRules(["不提及用户名"]);
+  const hit = settingsCtx.text(withPreset("zephyr"));
+  assert.ok(hit.includes("你的人格名字：泽菲尔"), "身份命中时行为与现状一致");
+  assert.ok(hit.includes("- 用户画像：用户是规划背景"), "画像恒注入：本开关只管人格行");
+  assert.ok(hit.includes("- 规则：不提及用户名"), "规则恒注入：同上");
+  store.close();
+});