@modusensus/dsh-mneme 0.9.2 → 0.9.4

package/test/client.test.js

@@ -1926,13 +1926,51 @@ test("M.O. empty-state, list and scope copy exist in both languages", () => {
     "memory.actions.scope.project",
     "memory.actions.scope.global",
     "memory.actions.scope.none",
-    "memory.actions.broken"
+    "memory.actions.broken",
+    // 手动沉淀的全部回执：这八句里缺任何一句，按钮点下去就是一行 key 裸奔，
+    // 而那恰好是「点了没反应」的观感来源。
+    "memory.actions.distill.action",
+    "memory.actions.distill.busy",
+    "memory.actions.distill.hint",
+    "memory.actions.distill.noProject",
+    "memory.actions.distill.saved",
+    "memory.actions.distill.none",
+    "memory.actions.distill.noSessions",
+    "memory.actions.distill.unreadable",
+    "memory.actions.distill.failed"
   ]) {
     const hits = (clientSource.match(new RegExp(`"${key.replace(/\./g, "\\.")}":`, "g")) || []).length;
     assert.equal(hits, 2, `${key} must exist in both zh and en (got ${hits})`);
   }
 });
 
+// 手动沉淀按钮：面板上「立即跑一次」的唯一入口。锁三件事，每件都对应一种会静默坏掉的情形：
+//   ① 它必须打 POST 且带上项目根——GET 是预览、不写盘，打成 GET 就成了「点了永远 0 条」；
+//   ② materialize 不许出现：按钮只产提议，落草稿是另一个决定；
+//   ③ 没有 project 时必须禁用——服务端只会回 400，点了必然失败的按钮比没有按钮更糟。
+test("M.O. pane offers a manual distill that posts the project root", () => {
+  const bodyOf = (name) => {
+    const start = clientSource.indexOf(`function ${name}(`);
+    assert.ok(start > -1, `${name} must exist`);
+    const next = clientSource.slice(start + 1).indexOf("\n    function ");
+    return clientSource.slice(start, next > -1 ? start + 1 + next : clientSource.length);
+  };
+  const bar = bodyOf("PipelineDistillButton");
+  assert.ok(bar.includes('"/api/dsh-mneme/nudge?project="'), "the button must hit the nudge route");
+  assert.ok(bar.includes("encodeURIComponent(project)"), "the project root must travel with the request");
+  assert.ok(bar.includes('method: "POST"'), "a preview GET writes nothing — the button must POST");
+  assert.ok(!bar.includes("materialize"), "the button must never materialize a draft");
+  assert.ok(bar.includes("!project"), "the button must be disabled when the project is unknown");
+  assert.ok(bar.includes("503"), "an unreadable session log must be told apart from an empty result");
+  // 座位：按钮挂在清单头上，且清单要拿到 project——漏传的话按钮永远禁用，
+  // 界面上看起来只是「这个功能没做好」。
+  assert.ok(bodyOf("PipelineWorkflowList").includes("PipelineDistillButton"), "the control belongs in the list header");
+  assert.ok(
+    bodyOf("PipelineBrowser").includes("activeId, onOpen: setPicked, project }"),
+    "the browser must hand the project root down to the list"
+  );
+});
+
 // 画布能放大缩小。锁的重点不是「有没有缩放」，而是滚轮那一条必须**自己挂非被动监听**：
 // React 的 onWheel 挂在 root 上且是 passive 的，preventDefault 会被浏览器忽略，
 // 于是 Ctrl+滚轮既缩放画布又缩放整页，谁也没拦住——这个错本地测不出来，只在真浏览器里响。
@@ -2039,11 +2077,13 @@ test("panel copy and icons must not silently vanish (missing dict lines, unregis
 // 人格定义页（beta）面板面回归：形状沿用 A4 的「分组 + i18n 双语 occurrences ≥ 2
 // + 关键接线」断言风格（只做源码断言，不挂 React 渲染环境）。
 test("persona page ships settings card, master switch and i18n (beta v1)", () => {
-  // 开关进 FEATURE_GROUPS 的 enhance 组（行为开关非座位闸门）
-  assert.ok(
-    /group\.enhance", items: \[(?:[^\]]|\n)*"personaEnabled"\]/.test(clientSource),
-    "FEATURE_GROUPS group.enhance must carry personaEnabled"
-  );
+  // 开关进 FEATURE_GROUPS 的 enhance 组（行为开关非座位闸门）。按组解析成员再逐个点名，
+  // 而不是把某一行写成字面量正则——那样往组里加第二个键就会把这条护栏弄红（实测踩过）。
+  const enhance = clientSource.match(/group\.enhance", items: \[((?:[^\]]|\n)*)\]/);
+  assert.ok(enhance, "FEATURE_GROUPS group.enhance must be parseable");
+  for (const flag of ["personaEnabled", "personaStrictAddressing"]) {
+    assert.ok(enhance[1].includes(`"${flag}"`), `FEATURE_GROUPS group.enhance must carry ${flag}`);
+  }
   // i18n 键中英双语齐备（occurrences ≥ 2 模式；label + .hint 两路由字典锁统一覆盖）
   for (const key of [
     "memory.features.personaEnabled",
@@ -2058,7 +2098,17 @@ test("persona page ships settings card, master switch and i18n (beta v1)", () =>
     "memory.settings.personaEnabledToggle",
     "memory.settings.personaView",
     "memory.settings.personaViewHint",
-    "memory.settings.personaViewEmpty"
+    "memory.settings.personaViewEmpty",
+    // 预览改由后端渲染之后新增的读数文案（缺一种语言就是半边界面裸奔键名）
+    "memory.features.personaStrictAddressing",
+    "memory.features.personaStrictAddressing.hint",
+    "memory.settings.personaViewUnknown",
+    "memory.settings.personaViewSourceDefault",
+    "memory.settings.personaViewSourceCard",
+    "memory.settings.personaViewSourceNone",
+    "memory.settings.personaViewSourceFallback",
+    "memory.settings.personaViewGateOff",
+    "memory.settings.personaViewRefresh"
   ]) {
     const occurrences = clientSource.split(`"${key}"`).length - 1;
     assert.ok(occurrences >= 2, `i18n key ${key} must exist in both zh and en (got ${occurrences})`);
@@ -2072,6 +2122,17 @@ test("persona page ships settings card, master switch and i18n (beta v1)", () =>
     clientSource.includes("memory.features.personaEnabled.hint"),
     "the master-switch hint must document the two-gate semantics"
   );
+  // 「注入生效文本」必须由后端给：前端再拼一份就是第二张皮（原来正是这段前端拼接
+  // 没有人格行、没有表头与前缀，却自称生效文本）。
+  assert.ok(clientSource.includes("injectedPreview.text"), "the view must render the backend-rendered block");
+  assert.ok(!clientSource.includes('"- " + profile.trim()'), "frontend hand-splicing of the injected block must be gone");
+  assert.ok(clientSource.includes("setInjectedPreview(null)"), "a failed preview must fail closed to 未知, not to a stale or guessed block");
+  // 预览只能有一个所有者，且要丢掉过期响应：先切卡 A 再切卡 B 时，A 的 GET 可能后回来。
+  // 这张卡的标题是「注入生效文本」，显示另一张卡的文本比不显示更糟。
+  assert.ok(clientSource.includes("if (seq !== previewSeq.current) return;"), "preview must drop stale responses");
+  assert.equal(clientSource.split("setInjectedPreview(").length - 1, 2, "loadPreview must be the only preview writer (success + failure)");
+  // source=default 有两种来路：带了 ?agent=<身份> 却回落 ≠ 真的解析不到身份。
+  assert.ok(clientSource.includes("injectedPreview.agent"), "the fallback label must separate a resolved-but-fallen-back identity from an unresolvable one");
 });
 
 // v1.2 多卡回归：卡列表 CRUD 可见、字段标签渲染为可见元素（v1.1 反馈：
@@ -2149,3 +2210,50 @@ test("update-check status names match the backend classify contract verbatim", (
   assert.ok(apiSource.includes('path: "/api/dsh-mneme/version-check"'),
     "the backend must register the version-check route");
 });
+
+// 画像提取草稿（#497）面板面：路由对齐、四种结局各有自己的话、以及「采用」必须把草稿
+// 文本直接交给保存。最后一条防的是一个具体陷阱——保存函数带默认参数时，把函数本身当
+// onClick 处理器会把 click 事件当成要存的文本存进去。
+test("profile extraction ships its button, distinct outcomes and correct save wiring", () => {
+  const apiSource = readFileSync(join(root, "src/api.js"), "utf8");
+  assert.ok(clientSource.includes('apiFetch("/api/dsh-mneme/profile/extract"'),
+    "the panel must call the extract route");
+  assert.ok(apiSource.includes('path: "/api/dsh-mneme/profile/extract"'),
+    "the backend must register the extract route");
+
+  // 四种结局（成功草稿 / 未启用 / 没有可用记忆 / 模型没配合）必须各有一句人话：
+  // 压成一句「没有草稿」就等于让用户自己猜是坏了还是本来就没东西。
+  for (const key of [
+    "memory.settings.profileExtract",
+    "memory.settings.profileExtracting",
+    "memory.settings.profileExtractHint",
+    "memory.settings.profileExtractDisabled",
+    "memory.settings.profileExtractEmpty",
+    "memory.settings.profileExtractNoRoute",
+    "memory.settings.profileExtractFailed",
+    "memory.settings.profileSaveFailed",
+    "memory.settings.profileDraftTitle",
+    "memory.settings.profileDraftRows",
+    "memory.settings.profileDraftTruncated",
+    "memory.settings.profileDraftApply",
+    "memory.settings.profileDraftDiscard",
+    "memory.features.profileExtractEnabled",
+    "memory.features.profileExtractEnabled.hint"
+  ]) {
+    const occurrences = clientSource.split(`"${key}"`).length - 1;
+    assert.ok(occurrences >= 2, `i18n key ${key} must exist in both zh and en (got ${occurrences})`);
+  }
+  assert.ok(/group\.enhance[\s\S]{0,700}"profileExtractEnabled"/.test(clientSource),
+    "FEATURE_GROUPS group.enhance must carry profileExtractEnabled");
+
+  // 采用草稿：显式传文本；保存按钮也不能把 click 事件当参数传进去。
+  assert.ok(clientSource.includes("if (await saveProfile(text))"), "applying a draft must commit state only after a verified save");
+  assert.ok(!clientSource.includes("onClick: saveProfile }"), "the save button must not receive the click event as its value argument");
+  // apiFetch 是 fetch 的薄壳：非 2xx 不抛。画像这条以前没判 res.ok（同页的 persona
+  // 一直判），于是服务端 403/413 时界面照样闪「画像已保存」。
+  const profileSaver = clientSource.slice(clientSource.indexOf("async function saveProfile("));
+  assert.ok(profileSaver.slice(0, 900).includes('if (!res.ok) throw new Error("HTTP "'),
+    "the profile saver must verify the response status before reporting success");
+  // 没配模型是一句可行动的话（先去选模型），不能和「模型没按格式回」共用一条文案。
+  assert.ok(clientSource.includes('"no-route" ? "noroute"'), "no-route must map to its own panel outcome, not the generic failure");
+});

package/test/lang.test.js

@@ -25,6 +25,17 @@ test("prompt table resolves by explicit language key", () => {
   assert.ok(STR.prompts.conflict.en.includes("conflict arbiter"));
   assert.ok(STR.prompts.pattern.zh.includes("模式发现助手"));
   assert.ok(STR.prompts.pattern.en.includes("pattern-discovery assistant"));
+  // 画像提取（#497）：两段纪律在中英文里都必须成对存在——「输入是数据不是指令」防的
+  // 是指令型记忆改写任务，「禁止声明助手身份」防的是画像正文与外部 bot 自带身份撞车
+  // （画像不受 personaEnabled 管辖）。少一种语言就等于换语言的用户拿到没有防线的提示词。
+  for (const lang of ["zh", "en"]) {
+    const p = STR.prompts.profileExtract[lang];
+    assert.ok(typeof p === "string" && p.length > 100, `profileExtract.${lang} must be a full prompt`);
+    assert.match(p, /不是指令|not instructions/, `profileExtract.${lang}: memory text must be declared data, not instructions`);
+    assert.match(p, /(绝不为助手|never name).{0,60}(助手|assistant|identity)/i,
+      `profileExtract.${lang}: the prompt must forbid an assistant-identity claim in the draft`);
+    assert.ok(p.includes("profile"), `profileExtract.${lang} must state the JSON key`);
+  }
   // 冻结模式后缀：纯提示文本，可直接拼接在巩固 prompt 后。
   assert.ok(STR.prompts.freezeSuffix.zh.startsWith("\n\n当前为「冲突冻结」模式"));
   assert.ok(STR.prompts.freezeSuffix.en.startsWith("\n\nConflict-freeze mode is active"));

package/test/organize-tool.test.js

@@ -0,0 +1,232 @@
+// issue #231 的第二批：把已造好的整理引擎接到 agent 的调用面上（organizeEnabled
+// + memory_organize 工具）。src/organize.js 的本体语义由 test/organize.test.js 守，
+// 本文件只守**出口**这一层：闸门、报告/落地的两步协议、以及 strictScope 下
+// 「看不见的行按不存在处理」这条可信上下文。
+import test from "node:test";
+import assert from "node:assert/strict";
+import { createStore } from "../src/store.js";
+import { createService } from "../src/service.js";
+import { createTools } from "../src/tools.js";
+import { applyLightModePreset } from "../src/config.js";
+
+function setup(config = {}) {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config });
+  const registered = [];
+  const ctx = {
+    tools: {
+      register(def) {
+        registered.push(def);
+        return () => {};
+      }
+    }
+  };
+  createTools(ctx, service, config, undefined);
+  const byName = Object.fromEntries(registered.map((def) => [def.name, def]));
+  return { store, service, byName, registered };
+}
+
+const CANDIDATES = [
+  { type: "project", title: "发布只在包目录内", content: "根目录发过坏包，发布必须在 dsh-mneme/ 内执行。" },
+  { type: "project", title: "另一条", content: "第二条候选的正文。" }
+];
+
+test("memory_organize registers when organizeEnabled is on", async () => {
+  const { byName } = setup({ organizeEnabled: true });
+  const tool = byName.memory_organize;
+  assert.ok(tool, "organizeEnabled=true 应当注册 memory_organize");
+  const report = await tool.execute({ mode: "dryRun", candidates: CANDIDATES });
+  assert.equal(report.status, "ok");
+  assert.equal(report.counts.total, 2, "两条候选都应进报告");
+  assert.equal(report.run_id ? typeof report.run_id : "none", "string", "dryRun 必须回一个 run_id 供 apply 引用");
+});
+
+// 默认关=零行为变化是仓库红线（AGENTS.md 自查清单第 1 条）。这条现在就会绿——
+// 它防的是「以后有人把默认翻成 true」，而不是今天的缺失实现。
+test("memory_organize stays unregistered by default", () => {
+  const { registered } = setup();
+  assert.equal(registered.some((t) => t.name === "memory_organize"), false, "organizeEnabled 缺省时不得注册");
+});
+
+test("lightMode preset turns organize off, but an explicit user switch wins", () => {
+  // 轻量档那一格是**预设**，不是强制（合并顺序「用户开关 > 轻量预设 > bundle」在
+  // index.js），所以这里断言的是预设值本身——同 continuity.test.js 的
+  // continuityRescueEnabled 那条。工具侧的注册与否由上一条默认关用例守着。
+  assert.equal(applyLightModePreset({ lightMode: true }).organizeEnabled, false);
+  assert.equal(applyLightModePreset({ lightMode: true, organizeEnabled: true }).organizeEnabled, false, "预设写死 false，赢的是合并时的用户开关，不是这里");
+});
+
+test("dryRun writes no memory rows but leaves one organize audit row", () => {
+  const { store, byName } = setup({ organizeEnabled: true });
+  return byName.memory_organize.execute({ mode: "dryRun", candidates: CANDIDATES }).then((report) => {
+    assert.deepEqual(store.list({ limit: null }), [], "比对是报告，不是动作：记忆表必须一行不写");
+    const runs = store.listDreamRuns({ limit: 10 });
+    assert.equal(runs.length, 1, "dryRun 只留 dream_runs 一行回执");
+    assert.equal(runs[0].run_type, "organize");
+    assert.equal(runs[0].id, report.run_id);
+  });
+});
+
+test("apply lands the decisions it references and reports counters", async () => {
+  const { store, byName } = setup({ organizeEnabled: true });
+  const report = await byName.memory_organize.execute({ mode: "dryRun", candidates: CANDIDATES });
+  const applied = await byName.memory_organize.execute({
+    mode: "apply",
+    run_id: report.run_id,
+    decisions: [
+      { action: "save", index: 0 },
+      { action: "discard", index: 1 }
+    ]
+  });
+  assert.equal(applied.saved, 1, "只数新建的行");
+  assert.equal(applied.discarded, 1);
+  assert.equal(applied.status, "ok");
+  assert.equal(store.list({ limit: null }).length, 1, "一条 save、一条 discard → 库里只有一行");
+  const types = store.listDreamRuns({ limit: 10 }).map((r) => r.run_type);
+  assert.deepEqual(types, ["organize", "organize"], "报告与落地各留一行审计");
+});
+
+test("apply refuses a run_id that was never reported", async () => {
+  const { byName } = setup({ organizeEnabled: true });
+  await assert.rejects(
+    () => byName.memory_organize.execute({ mode: "apply", run_id: "no-such-run", decisions: [{ action: "discard", index: 0 }] }),
+    /unknown organize run/,
+    "没有比对过的候选一律不落库（organize 硬规则 2）"
+  );
+});
+
+test("apply refuses a missing run_id", async () => {
+  const { byName } = setup({ organizeEnabled: true });
+  await assert.rejects(
+    () => byName.memory_organize.execute({ mode: "apply", decisions: [{ action: "discard", index: 0 }] }),
+    /run_id is required/,
+    "apply 必须引用一次真实 dryRun"
+  );
+});
+
+// 整理接口不能成为第二条「写进库却不带 scope」的通道：memory_save 在 scopeEnabled
+// 下按会话身份盖 auto 章，organize 落地的候选必须同源。显式参数改盖 explicit，
+// 与 memory_save / memory_register_document 同一规则。
+test("save lands candidates stamped with the session scope (auto), like memory_save", async () => {
+  const { store, byName } = setup({ organizeEnabled: true, scopeEnabled: true });
+  const exec = { agent: { session: { id: "s1", header: { agentPreset: "me", cwd: "D:\\p" } } } };
+  const report = await byName.memory_organize.execute({ mode: "dryRun", candidates: CANDIDATES }, exec);
+  await byName.memory_organize.execute({ mode: "apply", run_id: report.run_id, decisions: [{ action: "save", index: 0 }] }, exec);
+  const row = store.list({ limit: null })[0];
+  assert.equal(row.agent_scope, "me", "缺省吃会话身份");
+  assert.equal(row.agent_scope_source, "auto");
+  assert.equal(row.workspace_scope, "D:\\p");
+});
+
+test("explicit scope arguments stamp as explicit and win over the session label", async () => {
+  const { store, byName } = setup({ organizeEnabled: true, scopeEnabled: true });
+  const exec = { agent: { session: { id: "s1", header: { agentPreset: "me", cwd: "D:\\p" } } } };
+  const report = await byName.memory_organize.execute(
+    { mode: "dryRun", candidates: CANDIDATES, agent_scope: "other-agent" },
+    exec
+  );
+  await byName.memory_organize.execute({ mode: "apply", run_id: report.run_id, decisions: [{ action: "save", index: 0 }] }, exec);
+  const row = store.list({ limit: null })[0];
+  assert.equal(row.agent_scope, "other-agent", "显式参数盖在会话身份之上");
+  assert.equal(row.agent_scope_source, "explicit");
+});
+
+test("unknown mode is rejected", async () => {
+  const { byName } = setup({ organizeEnabled: true });
+  await assert.rejects(() => byName.memory_organize.execute({ mode: "force" }), /unknown mode/);
+});
+
+// #170 复核项 4 的口径延伸到整理接口的**两侧**：报告侧不得泄漏存在性，落地侧不得
+// 绕过 scope 治理改库。用例形状是刻意挑的：比对键只看三列**值**（sensitivity/agent/
+// workspace），可见性还多认一个 `explicit` 来源，所以要造出「按值该命中、但会话看不见」
+// 那一格——匿名会话（解析不到 agentPreset）对 explicit 行 fail-closed。
+// 报告侧少了过滤就是探测口：`agent_scope` 是模型自己给的参数，A 会话可以拿 B 的标题问
+// 「那一档有没有这行」，拿回 id/title 就等于确认存在——memory_get 在同一条件下回「不存在」。
+test("dryRun reports an invisible match as new, with no id or title", async () => {
+  const config = { organizeEnabled: true, scopeEnabled: true, strictScope: true };
+  const { store, byName } = setup(config);
+  store.save({
+    type: "project",
+    title: "发布只在包目录内",
+    content: "team-a 名下的旧行。",
+    agent_scope: "team-a",
+    agent_scope_source: "explicit",
+    workspace_scope: "D:\\p",
+    workspace_scope_source: "auto"
+  });
+  const exec = { agent: { session: { id: "s-anon", header: { cwd: "D:\\p" } } } };
+  const report = await byName.memory_organize.execute(
+    {
+      mode: "dryRun",
+      candidates: [{ type: "project", title: "发布只在包目录内", content: "换一种说法的同一件事。" }],
+      agent_scope: "team-a",
+      workspace_scope: "D:\\p"
+    },
+    exec
+  );
+  assert.equal(report.items[0].verdict, "new", "看不见的行按不存在处理 → 报告只能说「新条目」");
+  assert.equal(report.items[0].match, undefined, "不得带回落点 id/title/sim");
+  assert.equal(report.counts.new, 1);
+});
+
+// 反面对照：strictScope 是**可选**硬过滤，关掉它时那行本来就可读（A2 只降权）。少了这条，
+// 过滤就变成「闸门关着也少召回」的第二重惩罚——修安全问题不许顺手改默认行为。
+test("the same row is still reported as exact when strictScope is off", async () => {
+  const config = { organizeEnabled: true, scopeEnabled: true };
+  const { store, byName } = setup(config);
+  const row = store.save({
+    type: "project",
+    title: "发布只在包目录内",
+    content: "team-a 名下的旧行。",
+    agent_scope: "team-a",
+    agent_scope_source: "explicit",
+    workspace_scope: "D:\\p",
+    workspace_scope_source: "auto"
+  });
+  const exec = { agent: { session: { id: "s-anon", header: { cwd: "D:\\p" } } } };
+  const report = await byName.memory_organize.execute(
+    {
+      mode: "dryRun",
+      candidates: [{ type: "project", title: "发布只在包目录内", content: "换一种说法的同一件事。" }],
+      agent_scope: "team-a",
+      workspace_scope: "D:\\p"
+    },
+    exec
+  );
+  assert.equal(report.items[0].verdict, "exact");
+  assert.equal(report.items[0].match.id, row.id, "闸门关着时照常给出落点，否则比对报告失去意义");
+});
+
+// 落地侧：报告已按「不存在」说了，archive 也不许真的动那一行（`opts.hiddenIds` 由可信
+// 调用层算好传入，绝不取 payload 字段——那是调用方可自选的内容，不是授权）。
+test("archive of a row the caller cannot see is skipped as out of scope", async () => {
+  const config = { organizeEnabled: true, scopeEnabled: true, strictScope: true };
+  const { store, byName } = setup(config);
+  const teamRow = store.save({
+    type: "project",
+    title: "发布只在包目录内",
+    content: "team-a 名下的旧行。",
+    agent_scope: "team-a",
+    agent_scope_source: "explicit",
+    workspace_scope: "D:\\p",
+    workspace_scope_source: "auto"
+  });
+  const exec = { agent: { session: { id: "s-anon", header: { cwd: "D:\\p" } } } };
+  const report = await byName.memory_organize.execute(
+    {
+      mode: "dryRun",
+      candidates: [{ type: "project", title: "发布只在包目录内", content: "换一种说法的同一件事。" }],
+      agent_scope: "team-a",
+      workspace_scope: "D:\\p"
+    },
+    exec
+  );
+  const applied = await byName.memory_organize.execute(
+    { mode: "apply", run_id: report.run_id, decisions: [{ action: "archive", id: teamRow.id }] },
+    exec
+  );
+  assert.equal(applied.archived, 0, "看不见的行按不存在处理，不得归档");
+  assert.equal(applied.skipped.length, 1);
+  assert.match(applied.skipped[0].error, /out of scope/, "文案维持「unknown, archived or out of scope」：不泄漏存在性");
+  assert.equal(store.getById(teamRow.id).archived, false, "他人的行原样未动");
+});

package/test/persona-addressing.test.js

@@ -0,0 +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();
+});

package/test/persona-settings.test.js

@@ -7,6 +7,7 @@ import test from "node:test";
 import assert from "node:assert/strict";
 import { createStore } from "../src/store.js";
 import { createSettings } from "../src/settings.js";
+import { resolvePersonaCard } from "../src/user-settings.js";
 
 function setup() {
   const store = createStore(":memory:");
@@ -81,10 +82,14 @@ test("v1 legacy single-object persona reads as default (zero migration)", () =>
   store.close();
 });
 
-test("byAgent card round-trips via setPersonaFor/getPersonaFor", () => {
+// 寻址口径住在 src/user-settings.js（注入与面板预览共用一份），不在 settings 里——
+// settings 只存卡。原来那两个 getPersonaFor 用例因此改指向 resolvePersonaCard：
+// 断言的是同一件事，但落在唯一那份实现上。
+test("byAgent card round-trips via setPersonaFor/resolvePersonaCard", () => {
   const { store, settings } = setup();
   settings.setPersonaFor("zephyr", { name: "泽菲尔", personality: "冷危占有", enabled: true });
-  assert.deepEqual(settings.getPersonaFor("zephyr"), { name: "泽菲尔", personality: "冷危占有", enabled: true });
+  assert.deepEqual(resolvePersonaCard(settings, "zephyr").card, { name: "泽菲尔", personality: "冷危占有", enabled: true });
+  assert.equal(resolvePersonaCard(settings, "zephyr").source, "byAgent");
   // default 仍在且未被影响
   assert.deepEqual(settings.getPersona().default, {});
   // 卡列表含 zephyr
@@ -92,17 +97,34 @@ test("byAgent card round-trips via setPersonaFor/getPersonaFor", () => {
   store.close();
 });
 
-test("getPersonaFor falls back to default when id card missing or disabled", () => {
+test("缺省寻址：身份没建卡、或卡被关掉，都落 default", () => {
   const { store, settings } = setup();
   settings.setPersona({ name: "Amarre", enabled: true }); // 单对象形写 default
   settings.setPersonaFor("zephyr", { name: "泽菲尔", enabled: false }); // 卡存在但关
-  // 未注册身份 → default
-  assert.equal(settings.getPersonaFor("unknown-bot").name, "Amarre");
+  assert.equal(resolvePersonaCard(settings, "unknown-bot").card.name, "Amarre");
   // 身份卡存在但 enabled=false → 落 default（兜底优先，不注入半张卡）
-  assert.equal(settings.getPersonaFor("zephyr").name, "Amarre");
+  assert.equal(resolvePersonaCard(settings, "zephyr").card.name, "Amarre");
   // 身份缺失（null/空串）→ default
-  assert.equal(settings.getPersonaFor(null).name, "Amarre");
-  assert.equal(settings.getPersonaFor("").name, "Amarre");
+  assert.equal(resolvePersonaCard(settings, null).card.name, "Amarre");
+  assert.equal(resolvePersonaCard(settings, "").card.name, "Amarre");
+  store.close();
+});
+
+test("strict 寻址：身份没建卡与卡被关掉都不注入，无名会话仍用 default", () => {
+  const { store, settings } = setup();
+  settings.setPersona({ name: "Amarre", enabled: true });
+  settings.setPersonaFor("zephyr", { name: "泽菲尔", enabled: false });
+  const strict = { strict: true };
+  for (const id of ["unknown-bot", "zephyr"]) {
+    const { card, source } = resolvePersonaCard(settings, id, strict);
+    assert.equal(source, "none", `${id} 在严格寻址下不该拿到任何卡`);
+    assert.deepEqual(card, {});
+  }
+  // 开着的身份卡照样命中（strict 不改变命中语义）
+  settings.setPersonaFor("mentor", { name: "导师", enabled: true });
+  assert.equal(resolvePersonaCard(settings, "mentor", strict).source, "byAgent");
+  // 解析不到身份 = default 卡的受众，strict 不动这一格
+  assert.equal(resolvePersonaCard(settings, null, strict).card.name, "Amarre");
   store.close();
 });