@modusensus/dsh-mneme 0.9.3 → 0.9.4

package/test/summarize.test.js

@@ -1813,3 +1813,228 @@ test("v0.9.0: scopeEnabled 关时蒸馏写入一个 scope 字段都不加（老
     assert.equal(row.workspace_scope_source, undefined);
   }
 });
+
+// --- Issue #493：转录围栏 / 失败护栏 / 失败行可诊断性 ------------------------------
+// 现场：转录裸放 user 位 → 模型当成「该我回话了」接着往下写 → 输出无 `[` →
+// 解析器括号早退判失败 → 不推进游标 → 下一个 turn/end 同文同温重试 → 同一窗口
+// 确定性失败、窗口越攒越大（报告者 20 条失败 input 8194→11118 单调递增）。
+
+test("#493 提示构造：转录包进围栏，user 侧重申「第三方提炼员」，system 不动", async () => {
+  const { events, calls } = setup({ distillRateLimitIntervalMs: 0 });
+  await eventHandler(events)(
+    {
+      id: "s493-prompt",
+      requestHeader: () => ({ config: { provider: "deepseek", model: "deepseek-chat" } }),
+      events: [userMessage("把这段对话蒸馏一下", 1), { seq: 2, type: "turn/end" }]
+    },
+    { seq: 2, type: "turn/end" }
+  );
+
+  const [system, user] = calls[0].messages;
+  assert.equal(system.role, "system");
+  assert.ok(system.content[0].text.includes("原子记忆"), "system 提示词保持原样（既有回归断言依赖它）");
+  assert.equal(user.role, "user");
+  const body = user.content[0].text;
+  // 角色句与围栏都必须落在 user 侧：模型对「这段文本是什么」的判断由它所在的
+  // 那条消息决定，只写进 system 救不回来（实测同段转录只加 system 约束仍 0/2 出 JSON）。
+  assert.ok(body.includes("第三方提炼员"), "user 侧必须重申角色，否则模型接着对话往下写");
+  assert.ok(body.includes("不是下面这段会话的参与者"), "角色句要明说不参与，不能只说「请输出 JSON」");
+  const open = body.indexOf("<<<会话转录开始>>>");
+  const close = body.indexOf("<<<会话转录结束>>>");
+  assert.ok(open > 0 && close > open, "转录必须被围栏包住");
+  assert.ok(body.slice(open, close).includes("把这段对话蒸馏一下"), "原文仍在围栏内");
+  assert.ok(body.indexOf("第三方提炼员") < open, "角色句在围栏之前");
+});
+
+test("#493 提示构造：围栏是确定性的，重试收到的转录与首次逐字节相同", async () => {
+  let attempt = 0;
+  const { events, calls } = setup({ distillRateLimitIntervalMs: 0 }, {
+    stream() {
+      const output = attempt++ === 0 ? "不按格式的一整段中文点评" : "[]";
+      return (async function* () {
+        yield { type: "block-start", block: { type: "text" } };
+        yield { type: "text-delta", delta: output };
+        yield { type: "finish", kind: "ok" };
+      })();
+    }
+  });
+  const handler = eventHandler(events);
+  const session = {
+    id: "s493-deterministic",
+    requestHeader: () => ({ config: { provider: "deepseek", model: "deepseek-chat" } }),
+    events: [userMessage("同一窗口重试", 1), { seq: 2, type: "turn/end" }]
+  };
+  await handler(session, { seq: 2, type: "turn/end" });
+  await handler(session, { seq: 2, type: "turn/end" });
+  assert.equal(calls.length, 2);
+  const first = calls[0].messages.find((m) => m.role === "user").content[0].text;
+  const second = calls[1].messages.find((m) => m.role === "user").content[0].text;
+  // 围栏里不能有时间戳/随机数：否则「同文同温」这条前提就不成立，护栏阈值
+  // 会变成对着一堆各不相同的输入计数。
+  assert.equal(first, second, "重试必须收到逐字节相同的转录");
+});
+
+test("#493 计量口径：distillChars 只数转录正文，不被围栏与角色句撑大", async () => {
+  // 这条是护栏的邻居而非护栏本身：#493 给 user 消息加了约 100 字的固定包裹，
+  // 若 distillChars 仍按「消息总字符数」算，4 字的窗口会凭空越过任何阈值，
+  // summarizeMinWindowChars 等于被自己的提示词旁路掉。
+  const { events, service } = setup({ summarizeMinWindowChars: 60, distillRateLimitIntervalMs: 0 });
+  await eventHandler(events)(
+    {
+      id: "s493-metric",
+      requestHeader: () => ({ config: { provider: "deepseek", model: "deepseek-chat" } }),
+      events: [userMessage("短", 1), { seq: 2, type: "turn/end" }]
+    },
+    { seq: 2, type: "turn/end" }
+  );
+  const row = service.listLlmAudits()[0];
+  assert.equal(row.error_message, "window-too-small", "4 字正文不得被包裹撑过 60 字阈值");
+  assert.equal(row.metadata.distillChars, 4, "计的是转录正文（「用户：短」= 4 字）");
+});
+
+test("#493 失败行可诊断：metadata 带 raw_head / raw_has_bracket / streak", async () => {
+  const { events, service } = setup({ distillRateLimitIntervalMs: 0 }, {
+    stream() {
+      return (async function* () {
+        yield { type: "block-start", block: { type: "text" } };
+        yield { type: "text-delta", delta: "已按你的要求将值班轮单日上限改为 5，下面是具体改动…" };
+        yield { type: "finish", kind: "ok" };
+      })();
+    }
+  });
+  await eventHandler(events)(
+    {
+      id: "s493-diag",
+      requestHeader: () => ({ config: { provider: "deepseek", model: "deepseek-chat" } }),
+      events: [userMessage("帮我改一下值班轮上限", 1), { seq: 2, type: "turn/end" }]
+    },
+    { seq: 2, type: "turn/end" }
+  );
+
+  const row = service.listLlmAudits()[0];
+  assert.equal(row.status, "error");
+  assert.equal(row.error_message, "invalid summary JSON");
+  // 原先 metadata 恒为 null，90 条历史失败一条原始输出都没留 —— 事后无法回答
+  // 「模型到底吐了什么形状」。raw_has_bracket 是区分「没按格式写」与「格式对但
+  // 内容救不回来」的唯一低成本判据，也正是 #493 现场的关键特征。
+  assert.equal(row.metadata?.parse_failure, true);
+  assert.equal(row.metadata?.raw_has_bracket, false, "这段点评里没有方括号");
+  assert.ok(row.metadata?.raw_len > 0);
+  assert.ok(row.metadata?.raw_head.startsWith("已按你的要求"), "原始输出前缀要留档");
+  assert.equal(row.metadata?.streak, 1);
+  assert.ok(Number.isInteger(row.metadata?.distillChars), "失败行同样带窗口字符数");
+});
+
+test("#493 失败护栏默认关：连续失败也不放弃窗口（历史行为逐字节不变）", async () => {
+  const { events, calls } = setup({ distillRateLimitIntervalMs: 0 }, {
+    stream() {
+      return (async function* () {
+        yield { type: "block-start", block: { type: "text" } };
+        yield { type: "text-delta", delta: "永远不是 JSON" };
+        yield { type: "finish", kind: "ok" };
+      })();
+    }
+  });
+  const handler = eventHandler(events);
+  const session = {
+    id: "s493-guard-off",
+    requestHeader: () => ({ config: { provider: "deepseek", model: "deepseek-chat" } }),
+    events: [userMessage("窗口", 1), { seq: 2, type: "turn/end" }]
+  };
+  for (let i = 0; i < 5; i++) await handler(session, { seq: 2, type: "turn/end" });
+  // 默认 0 = 关：这是本仓新行为的既定纪律（AGENTS.md），也是既有 4 个
+  // 「解析失败不消费窗口」用例语义不变的前提。
+  assert.equal(calls.length, 5, "护栏关着时每个 turn/end 仍重试同一窗口");
+});
+
+test("#493 失败护栏：连续 N 次失败后强制消费游标跳过该窗口", async () => {
+  let attempt = 0;
+  const { events, calls, service, store, summarizer } = setup(
+    { summarizeParseFailureMaxRetries: 2, distillRateLimitIntervalMs: 0 },
+    {
+      stream() {
+        attempt++;
+        const output = attempt <= 2 ? "确定性失败：一段中文点评" : "[]";
+        return (async function* () {
+          yield { type: "block-start", block: { type: "text" } };
+          yield { type: "text-delta", delta: output };
+          yield { type: "finish", kind: "ok" };
+        })();
+      }
+    }
+  );
+  const handler = eventHandler(events);
+  const session = {
+    id: "s493-guard-on",
+    requestHeader: () => ({ config: { provider: "deepseek", model: "deepseek-chat" } }),
+    events: [userMessage("会被放弃的窗口", 1), { seq: 2, type: "turn/end" }]
+  };
+
+  await handler(session, { seq: 2, type: "turn/end" });
+  assert.equal(calls.length, 1);
+  assert.equal(service.getDistillCursor("s493-guard-on"), undefined, "第一次失败仍不推进游标");
+
+  await handler(session, { seq: 2, type: "turn/end" });
+  assert.equal(calls.length, 2, "阈值内仍重试");
+  // 达到阈值（2）：窗口被放弃，游标推进到本窗末尾，下一轮从全新窗口起算。
+  const cursor = service.getDistillCursor("s493-guard-on");
+  assert.equal(cursor?.last_seq, 2, "达到阈值后强制消费游标");
+  const errorRows = service.listLlmAudits().filter((r) => r.status === "error");
+  assert.equal(errorRows.length, 2);
+  // 按 streak 定位而不是按下标：审计表的返回顺序是存储层的事，不该被这条断言锁住。
+  const abandoned = errorRows.find((r) => r.metadata?.streak === 2);
+  assert.equal(abandoned?.metadata?.skipped, "parse-failure-streak", "放弃必须可观测");
+  assert.equal(abandoned?.metadata?.maxRetries, 2);
+  assert.equal(errorRows.find((r) => r.metadata?.streak === 1)?.metadata?.skipped, undefined,
+    "阈值前的那次失败仍按「可重试」记账，不得提前宣告放弃");
+
+  // 游标已消费 → 同一 turn/end 不再重试；新事件开新窗口并正常落库。
+  await handler(session, { seq: 2, type: "turn/end" });
+  assert.equal(calls.length, 2, "被放弃的窗口不再重试");
+  session.events.push(userMessage("新的窗口", 3), { seq: 4, type: "turn/end" });
+  await handler(session, { seq: 4, type: "turn/end" });
+  assert.equal(calls.length, 3, "新窗口正常蒸馏");
+  summarizer.dispose();
+  store.close();
+});
+
+test("#493 失败护栏：一次成功即清零计数，不会隔窗累计", async () => {
+  let attempt = 0;
+  const { events, calls, service, store, summarizer } = setup(
+    { summarizeParseFailureMaxRetries: 2, distillRateLimitIntervalMs: 0 },
+    {
+      stream() {
+        // 失败 → 成功 → 失败：第 3 次是「新一轮的第一次失败」，不该被判为第 2 次。
+        const outputs = ["不是 JSON", "[]", "又不是 JSON"];
+        const output = outputs[attempt++] ?? "[]";
+        return (async function* () {
+          yield { type: "block-start", block: { type: "text" } };
+          yield { type: "text-delta", delta: output };
+          yield { type: "finish", kind: "ok" };
+        })();
+      }
+    }
+  );
+  const handler = eventHandler(events);
+  const session = {
+    id: "s493-streak-reset",
+    requestHeader: () => ({ config: { provider: "deepseek", model: "deepseek-chat" } }),
+    events: [userMessage("第一窗", 1), { seq: 2, type: "turn/end" }]
+  };
+  await handler(session, { seq: 2, type: "turn/end" });   // 失败 #1
+  await handler(session, { seq: 2, type: "turn/end" });   // 成功 → 清零
+  session.events.push(userMessage("第二窗", 3), { seq: 4, type: "turn/end" });
+  await handler(session, { seq: 4, type: "turn/end" });   // 失败 #1（不是 #2）
+
+  // 两条失败行都必须是「新一轮的第一次」：只查最后一条会让「第一条其实被
+  // 记成 streak=2」这类回归漏网。
+  const errorRows = service.listLlmAudits().filter((r) => r.status === "error");
+  assert.equal(errorRows.length, 2);
+  for (const row of errorRows) {
+    assert.equal(row.metadata?.streak, 1, "成功必须清零，否则阈值会在跨窗处误触发");
+    assert.equal(row.metadata?.skipped, undefined, "计数未达阈值，不得放弃窗口");
+  }
+  assert.equal(calls.length, 3);
+  summarizer.dispose();
+  store.close();
+});

package/test/tools-dto-schema-matrix.test.js

@@ -39,6 +39,7 @@ const TOOL_NAMES = [
   "memory_archive",
   "memory_register_document",
   "memory_runtime",
+  "memory_organize",
   "set_scope_state"
 ];
 
@@ -117,13 +118,16 @@ function seedShapes(store) {
   return rows;
 }
 
+// 清单比对必须在**暴露闸全开**的配置下做：#230 的 document 与 #231 的 organize 都是
+// opt-in 工具，用默认配置跑会让「注册表里少一个工具」和「清单没更新」两件事互相
+// 抵消——这条护栏就此静默失效，而漏登记正是 #195 要防的那类事故。
 test("工具矩阵与 TOOL_NAMES 清单一致（新增工具必须补进矩阵）", () => {
-  const { byName } = setup();
+  const { byName } = setup({ documentMemoryEnabled: true, organizeEnabled: true });
   assert.deepEqual(Object.keys(byName).sort(), [...TOOL_NAMES].sort());
 });
 
-test("A 实跑：11 个工具每个可安全触达的分支，真实返回 ⊆ 声明的 output schema", async () => {
-  const { store, service, byName } = setup({ documentMemoryEnabled: true });
+test("A 实跑：12 个工具每个可安全触达的分支，真实返回 ⊆ 声明的 output schema", async () => {
+  const { store, service, byName } = setup({ documentMemoryEnabled: true, organizeEnabled: true });
   const shapes = seedShapes(store);
   const annotated = shapes[shapes.length - 1];
   const plain = shapes[0];
@@ -245,6 +249,43 @@ test("A 实跑：11 个工具每个可安全触达的分支，真实返回 ⊆
     rmSync(docDir, { recursive: true, force: true });
   }
 
+  // --- memory_organize（#231 第二批）：dryRun 与 apply 两个分支各驱动一次 ---
+  // 两条分支的返回键集不同（dryRun 有 counts/items/created_at，apply 有
+  // saved/merged/archived/memory_ids/dry_run_id/degraded）。只跑一边会让另一边
+  // 「声明了却没被真实返回值验过」，正是本矩阵要抓的空洞。自建种子行而不是复用
+  // plain：register_document 那一支会归档它吸收的 evidence，两支不该互相改状态。
+  const organizeSeed = store.save({ type: "project", title: "organize-target", content: "库内既有的一行。", source: "test" });
+  const organizeReport = await drive(byName, "memory_organize", {
+    mode: "dryRun",
+    candidates: [
+      { type: "project", title: "organize-target", content: "同标题的另一段表述 → 应当判成 exact" },
+      { type: "project", title: "organize-brand-new", content: "库里没有的新条目" },
+      { type: "project", title: "", content: "缺标题 → 进 skipped，报告如实记 degraded" }
+    ]
+  });
+  assert.equal(organizeReport.status, "degraded", "有候选被拒就不得报 ok（红线 4 的如实标记）");
+  assert.equal(organizeReport.items.length, 2);
+  assert.equal(organizeReport.items[0].verdict, "exact");
+  assert.equal(organizeReport.items[0].match.id, organizeSeed.id);
+  assert.equal(organizeReport.skipped.length, 1);
+  const organized = await drive(byName, "memory_organize", {
+    mode: "apply",
+    run_id: organizeReport.run_id,
+    decisions: [
+      { action: "archive", id: organizeSeed.id },
+      { action: "save", index: 1 },
+      // index 99 不在这份报告的快照里 → 逐条跳过、应用合法子集（红线 4）。
+      // 故意不用「非法 action」走这条路：枚举在宿主参数校验层就挡掉了，能到达
+      // skipped 的只有索引与可见性两类，测试必须挑真实可达的那条。
+      { action: "save", index: 99 }
+    ]
+  });
+  assert.equal(organized.archived, 1);
+  assert.equal(organized.saved, 1);
+  assert.equal(organized.skipped.length, 1, "报告没收下过的索引逐条跳过 + 应用合法子集，绝不整单拒绝");
+  assert.equal(organized.degraded, true);
+  note("memory_organize");
+
   assert.deepEqual([...driven].sort(), [...TOOL_NAMES].sort(), "每个工具都必须至少被驱动一次（矩阵不允许空缺）");
 });
 
@@ -294,8 +335,10 @@ test("B' search / list / get 三个消费方共用同一份 item schema（#184
   }
 });
 
-test("C 结构：全部 11 个工具的 output schema 闭合、required ⊆ properties、每项带 type", () => {
-  const { byName } = setup();
+// 同清单比对那条：opt-in 工具在默认配置下不在注册表里，C 层按 TOOL_NAMES 取
+// byName[name]，所以必须用暴露闸全开的配置，否则新工具的 schema 结构从未被检查。
+test("C 结构：全部 12 个工具的 output schema 闭合、required ⊆ properties、每项带 type", () => {
+  const { byName } = setup({ organizeEnabled: true });
   for (const name of TOOL_NAMES) {
     const schema = byName[name].output.schema;
     assert.ok(schema, `${name} 必须声明 output.schema`);

package/test/tools.test.js

@@ -91,7 +91,12 @@ test("memory_search/archive descriptions carry tool-use discipline", () => {
 test("compiled schemas pass the enforced DSH subset (defineTool projection)", () => {
   const { registered } = setup();
   assert.equal(registered.length, 11);
-  for (const tool of registered) {
+  // opt-in 暴露的工具在默认配置下不注册（#231 的 memory_organize），所以本用例还得
+  // 把暴露闸打开再走一遍——否则新工具的编译 schema 从来没被这条护栏看过，
+  // 「子集不支持的写法」要到运行时才炸。
+  const { registered: exposed } = setup(undefined, { organizeEnabled: true });
+  assert.equal(exposed.length, 12, "organizeEnabled 只多带一个工具，不许顺手改在场的别的东西");
+  for (const tool of [...registered, ...exposed]) {
     assertSupportedJsonSchema(tool.parameters);
     assertSupportedJsonSchema(tool.output.schema);
     const problems = [];

package/test/user-settings-preview.test.js

@@ -0,0 +1,127 @@
+// 修复二：面板「Agent 眼中的画像」那张卡标榜的是「注入生效文本」，但它原本是前端
+// 自己拼的（只有 profile + rules，既没有 [用户设置] 表头、没有「- 用户画像：」前缀，
+// 也完全没有人格三行）。两块渲染代码各写各的，就一定会漂——所以这里要的是**同源**：
+// 预览必须由注入器用的同一个渲染函数产出，而不是第二份实现。
+// 本文件最关键的一条是第 1 条：拿同一个 settings、同一个 config、同一个会话身份，
+// 让注入器与路由各渲染一次，断言逐字节相等。前端复刻模板的写法永远锁不住这条。
+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";
+
+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() {} };
+}
+
+// 一份 settings/config 同时喂注入器与 API：两侧必须读同一个源，否则「同源」是假的。
+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 injectorText = (agentPreset) =>
+    contexts.find((c) => c.name === "user-settings").text(agentPreset ? { agent: { session: { header: { agentPreset } } } } : {});
+  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) => {
+    const res = new FakeRes();
+    await route.handler(req(`/api/dsh-mneme/persona${agent ? `?agent=${agent}` : ""}`), res);
+    return JSON.parse(res.body);
+  };
+  return { store, settings, injectorText, preview };
+}
+
+function seed(settings) {
+  settings.setProfile("用户是规划背景");
+  settings.setRules(["不提及用户名"]);
+  settings.setPersona({ name: "Amarre", personality: "轻松幽默", replyStyle: "先结论后展开", enabled: true });
+  settings.setPersonaFor("zephyr", { name: "泽菲尔", personality: "冷危", enabled: true });
+}
+
+test("预览与注入器逐字节同源（同身份、同配置渲染两次必须一致）", async () => {
+  const { store, settings, injectorText, preview } = setup({ personaEnabled: true });
+  seed(settings);
+  for (const agent of ["zephyr", "unknown-bot", undefined]) {
+    const fromInjector = injectorText(agent);
+    const body = await preview(agent);
+    assert.equal(body.preview.text, fromInjector, `agent=${agent ?? "(无)"} 的预览必须等于注入器这一帧的输出`);
+  }
+  store.close();
+});
+
+test("预览含表头与画像前缀，且人格行在最前（原样复刻注入文本，不是前端拼的三条）", async () => {
+  const { store, settings, preview } = setup({ personaEnabled: true });
+  seed(settings);
+  const { preview: p } = await preview();
+  assert.ok(p.text.startsWith("[用户设置] 来自 dsh-mneme 的用户画像与规则："), "表头缺失就不是「生效文本」");
+  assert.ok(p.text.includes("- 你的人格名字：Amarre"), "人格行必须在预览里——原来那段完全没有它");
+  assert.ok(p.text.includes("- 用户画像：用户是规划背景"), "画像前缀同理");
+  assert.ok(p.text.indexOf("你的人格名字") < p.text.indexOf("用户画像："), "顺序即优先级：人格先出、画像与规则后出");
+  assert.equal(p.source, "default", "无 agent 参数 = 按「解析不到身份」寻址");
+  // agent 是面板区分两种 default 的唯一依据：解析不到身份（null）与「身份解析到了、
+  // 但没建卡/卡被关」（回显那个身份）。少了这条断言，面板那条回落文案就没有依据。
+  assert.equal(p.agent, null);
+  store.close();
+});
+
+test("身份解析到了却没有可用的卡：source=default 且回显该身份", async () => {
+  const { store, settings, preview } = setup({ personaEnabled: true });
+  seed(settings);
+  settings.setPersonaFor("ghost", { name: "无人格", enabled: false });
+  const { preview: p } = await preview("ghost");
+  assert.equal(p.source, "default", "默认口径下这张关掉的卡落回默认卡");
+  assert.equal(p.agent, "ghost", "但身份是解析到的——面板要靠它说「回落」而不是「解析不到」");
+  store.close();
+});
+
+test("预览按 agent 参数寻址，并说明用的是哪张卡", async () => {
+  const { store, settings, preview } = setup({ personaEnabled: true });
+  seed(settings);
+  const hit = await preview("zephyr");
+  assert.equal(hit.preview.source, "byAgent");
+  assert.equal(hit.preview.agent, "zephyr");
+  assert.ok(hit.preview.text.includes("你的人格名字：泽菲尔"));
+  store.close();
+});
+
+test("总闸关着时预览如实说「人格不会注入」，且不把人格行混进去", async () => {
+  const { store, settings, preview } = setup({ personaEnabled: false });
+  seed(settings);
+  const { preview: p } = await preview();
+  assert.equal(p.configGate, false, "面板要靠这个字段解释「卡开着为什么没生效」");
+  assert.ok(!p.text.includes("你的人格名字"), "预览里也不许出现实际不会注入的行");
+  assert.ok(p.text.includes("用户画像："), "画像与规则照旧注入——闸只管人格");
+  store.close();
+});
+
+test("strict 寻址 + 身份未命中：source=none，人格行一段都不出现", async () => {
+  const { store, settings, preview } = setup({ personaEnabled: true, personaStrictAddressing: true });
+  seed(settings);
+  const { preview: p } = await preview("unknown-bot");
+  assert.equal(p.source, "none");
+  assert.ok(!p.text.includes("Amarre"), "外部身份在严格寻址下拿不到任何人格");
+  assert.ok(p.text.includes("用户画像："), "画像与规则不受影响");
+  store.close();
+});