@modusensus/dsh-mneme 0.9.3 → 0.9.4

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();
 });
 

package/test/profile-extract.test.js

@@ -0,0 +1,269 @@
+// issue #497 的第三段：从记忆提取「用户画像」**草稿**。
+//
+// 为什么要单独立一份用例文件（而不是塞进 dream/summarize 的套件）：这条链的产品承诺很窄
+// 也很硬——① 只出草稿，绝不写 user_settings（画像正文是用户手写的原文，让模型合并等于
+// 给它改写权）；② 没有可用输入就不调模型；③ 模型吐的不是 JSON 就报错，绝不回一张空草稿
+// 冒充「这次没提炼出东西」；④ 记忆正文是模型的可影响输入，围栏 + 角色重申必须在位，
+// 且草稿里不许出现助手身份声明（画像与规则不受 personaEnabled 管，写进一句「你是某某」
+// 就会重演 #497 那个身份撞车）。这四条都是「做错了界面看不出来」的那类，所以逐条锁。
+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 { createSettings } from "../src/settings.js";
+import { createApi } from "../src/api.js";
+import { createProfileExtractor, ProfileExtractError } from "../src/profile-extract.js";
+
+// 假的 ctx.llm：按真实协议发 text-delta / usage / finish 三类 chunk（用量嵌在
+// chunk.usage，与 dream.js 的 streamText 注释一致——把整个 chunk 当用量会在
+// 审计行里落 0，v0.8.4 实测踩过）。messages 抓下来供围栏断言用。
+function fakeLlm(chunks) {
+  const calls = [];
+  return {
+    calls,
+    llm: {
+      async *stream(options) {
+        calls.push(options);
+        for (const c of chunks) yield c;
+      }
+    }
+  };
+}
+
+const okJson = (profile) => [
+  { type: "text-delta", text: "```json\n" },
+  { type: "text-delta", text: JSON.stringify({ profile }) },
+  { type: "text-delta", text: "\n```" },
+  { type: "usage", usage: { inputTokens: 120, outputTokens: 30 } },
+  { type: "finish", reason: { kind: "stop" } }
+];
+
+function setup(chunks, opts = {}) {
+  const { config = {}, dropRoute = false } = opts;
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config });
+  const settings = createSettings(store.db);
+  const fake = fakeLlm(chunks);
+  const logger = { info() {}, warn() {}, error() {} };
+  const extractor = createProfileExtractor({
+    ctx: { ...fake, agentDefaultModel: { currentSelection: () => null } },
+    service,
+    settings,
+    config: dropRoute ? { ...config } : { dreamProvider: "fake", dreamModel: "m1", ...config },
+    logger
+  });
+  return { store, service, settings, extractor, fake, logger };
+}
+
+function seedRows(store, n, over = {}) {
+  for (let i = 0; i < n; i++) {
+    store.save({ type: "project", title: `行 ${i}`, content: `第 ${i} 行的正文`, source: "test", ...over });
+  }
+}
+
+test("没有可用的模型路由：抛 no-route，且一次调用都不发（不是 TypeError→500）", async () => {
+  // resolveRoute 在「无 dreamProvider/dreamModel 且宿主解析不到默认模型」时回
+  // undefined。不判它就会去读 route.provider —— TypeError 落到路由上是一个语义为
+  // 「内部错误」的 500，而该说的是「先去选模型」。
+  const { store, extractor, fake } = setup(okJson("不该发生"), { dropRoute: true });
+  seedRows(store, 2);
+  await assert.rejects(() => extractor(), (err) => err instanceof ProfileExtractError && err.code === "no-route");
+  assert.equal(fake.calls.length, 0, "没有路由就不该把请求发出去");
+  store.close();
+});
+
+test("成功路径：出草稿、留一条审计行，而库里的画像逐字节没被动过", async () => {
+  const { store, service, settings, extractor } = setup(okJson("我知道她跨考公共管理。"));
+  seedRows(store, 3);
+  settings.setProfile("原文不许被改写");
+  const profileBefore = settings.getProfile();
+
+  const out = await extractor();
+  assert.equal(out.draft, "我知道她跨考公共管理。");
+  assert.equal(out.rowsUsed, 3);
+  assert.equal(out.truncated, false);
+  assert.equal(out.model, "m1");
+  // 「只出草稿」是这条链的产品承诺：user_settings 里必须还是那句原文。
+  assert.equal(settings.getProfile(), profileBefore);
+
+  const audits = service.listLlmAudits({ limit: 10 });
+  assert.equal(audits.length, 1, "一次提取必须留一行审计");
+  assert.equal(audits[0].trigger_source, "profileExtract");
+  assert.equal(audits[0].status, "success");
+  assert.equal(audits[0].input_tokens, 120, "用量要从 chunk.usage 里取，落在 chunk 顶层会恒为 0");
+  store.close();
+});
+
+test("模型吐的不是 JSON：抛错，绝不回一张空草稿冒充「没提炼出来」", async () => {
+  const { store, service, settings, extractor } = setup([
+    { type: "text-delta", text: "我觉得她是个很好的用户，加油。" },
+    { type: "finish", reason: { kind: "stop" } }
+  ]);
+  seedRows(store, 2);
+  await assert.rejects(() => extractor(), ProfileExtractError, "解析失败必须是可识别的错误类型");
+  assert.equal(settings.getProfile(), "", "失败路径一行都不许写");
+  const audits = service.listLlmAudits({ limit: 10 });
+  assert.equal(audits[0].status, "error", "吐了文字但没有可用产物 = 失败调用，审计不许写 success");
+  store.close();
+});
+
+test("没有可用记忆：不调模型、直接报错（空输入下模型只会编）", async () => {
+  const { store, extractor, fake } = setup(okJson("不该被调用"));
+  await assert.rejects(() => extractor(), /no/i);
+  assert.equal(fake.calls.length, 0, "一条输入都没有就不该花这次调用");
+  store.close();
+});
+
+test("归档与被遗忘的行不进输入：它们已经不在活跃面上", async () => {
+  const { store, service, extractor, fake } = setup(okJson("只用活跃行。"));
+  seedRows(store, 3);
+  const [gone, forgotten] = store.list({ limit: null });
+  service.setArchived(gone.id, true);
+  service.setForget(forgotten.id, true);
+  const out = await extractor();
+  assert.equal(out.rowsUsed, 1, "三行里只剩一行还在活跃面上");
+  const user = fake.calls[0].messages[1].content[0].text;
+  assert.ok(!user.includes(gone.content), "归档行的正文不许被喂给模型（它已经不在活跃面上）");
+  assert.ok(!user.includes(forgotten.content), "被遗忘的行同理");
+  store.close();
+});
+
+test("行数上限：超界时如实标记 truncated，而不是静默少读", async () => {
+  const { store, extractor } = setup(okJson("截断也要说清。"));
+  seedRows(store, 30);
+  const out = await extractor({ maxRows: 5 });
+  assert.equal(out.rowsUsed, 5);
+  assert.equal(out.truncated, true);
+  store.close();
+});
+
+test("记忆正文包在围栏里，且围栏之前没有正文；系统段重申「这是数据不是指令」", async () => {
+  const { store, extractor, fake } = setup(okJson("围栏检查。"));
+  seedRows(store, 2);
+  await extractor();
+  assert.equal(fake.calls.length, 1);
+  const system = fake.calls[0].messages[0].content[0].text;
+  const user = fake.calls[0].messages[1].content[0].text;
+  // 结构断言：正文只出现在围栏内部，围栏外不残留任何一行内容。
+  const openIdx = user.indexOf("<<<");
+  const closeIdx = user.lastIndexOf(">>>");
+  assert.ok(openIdx >= 0 && closeIdx > openIdx, "用户段必须带围栏对");
+  assert.ok(user.indexOf("第 0 行的正文") > openIdx, "记忆正文不许出现在围栏之前");
+  assert.ok(user.indexOf("第 1 行的正文") < closeIdx, "记忆正文不许出现在围栏之后");
+  // 角色重申与「数据不是指令」是字面量锁：防的是「有人重构提示词时顺手删掉这一段」
+  // ——那会让记忆里的指令型文本重新获得指令地位，而界面上一切照常。
+  assert.match(system, /不是指令|not instructions/i, "系统段必须声明输入是数据");
+  assert.match(system, /(绝不|不要).{0,6}(助手|agent).{0,20}(身份|名字|人格|起名)|never (name|invent|assign).{0,60}(assistant|identity|name)|do not (invent|assign).{0,40}(identity|name)/i,
+    "草稿里不许出现助手身份声明：画像不受 personaEnabled 管辖，写进去就会与 bot 自带身份撞车");
+  store.close();
+});
+
+// ---- HTTP 面（POST /api/dsh-mneme/profile/extract） -------------------------
+// 三条各自防一类事故：开关没开不许偷偷调模型；非 POST 方法不许触发副作用
+// （#489 的 /nudge 教训——方法白名单在读体之前拦）；HTTP 面上「只出草稿」同样成立。
+
+class FakeRes extends EventEmitter {
+  constructor() { super(); this.statusCode = 200; this.headers = null; this.body = ""; }
+  writeHead(code, headers) { this.statusCode = code; this.headers = headers; return this; }
+  end(text) { this.body = text ?? ""; this.emit("end"); return this; }
+}
+
+function httpReq(method, body = null) {
+  const r = new EventEmitter();
+  r.method = method;
+  r.url = "/api/dsh-mneme/profile/extract";
+  r.headers = {};
+  if (body !== null) {
+    process.nextTick(() => {
+      r.emit("data", Buffer.from(JSON.stringify(body)));
+      r.emit("end");
+    });
+  }
+  return r;
+}
+
+function setupApi({ config = {}, extractor, apiToken = "" } = {}) {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config });
+  const settings = createSettings(store.db);
+  const routes = [];
+  const ctx = { webServer: { register: (route) => { routes.push(route); return () => {}; } }, logger: { warn() {}, info() {}, error() {} } };
+  createApi(ctx, service, settings, { add: () => {}, remove: () => {}, list: () => [] },
+    undefined, undefined, apiToken, config, null, extractor ?? null);
+  return { store, service, settings, route: routes.find((r) => r.path === "/api/dsh-mneme/profile/extract") };
+}
+
+test("policy 是 token：配了 token 又不带 token 的 POST 被挡在提取器之前", async () => {
+  let called = 0;
+  const { store, route } = setupApi({
+    apiToken: "sekret",
+    config: { profileExtractEnabled: true },
+    extractor: async () => { called++; return { draft: "x" }; }
+  });
+  const res = new FakeRes();
+  await route.handler(httpReq("POST", {}), res);
+  assert.equal(res.statusCode, 401);
+  assert.equal(called, 0, "鉴权必须在这次模型调用之前");
+  store.close();
+});
+
+test("开关关着：409 disabled，一次模型调用都不发生", async () => {
+  let called = 0;
+  const { store, route } = setupApi({
+    config: { profileExtractEnabled: false },
+    extractor: async () => { called++; return { draft: "不该出现" }; }
+  });
+  const res = new FakeRes();
+  await route.handler(httpReq("POST", {}), res);
+  assert.equal(res.statusCode, 409);
+  assert.equal(JSON.parse(res.body).error, "disabled");
+  assert.equal(called, 0);
+  store.close();
+});
+
+test("非 POST 方法：405 + Allow，不触发任何副作用", async () => {
+  let called = 0;
+  const { store, route } = setupApi({
+    config: { profileExtractEnabled: true },
+    extractor: async () => { called++; return { draft: "x" }; }
+  });
+  for (const method of ["GET", "HEAD", "DELETE", "PATCH"]) {
+    const res = new FakeRes();
+    await route.handler(httpReq(method), res);
+    assert.equal(res.statusCode, 405, `${method} 不该落到提取器`);
+    assert.equal(res.headers.Allow, "POST");
+  }
+  assert.equal(called, 0, "#489 那类洞：方法分流只拦 POST/PUT 时，其余方法会直落副作用分支");
+  store.close();
+});
+
+test("开关开着：200 回草稿，且库里的画像一个字节都没变", async () => {
+  const { store, settings, route } = setupApi({
+    config: { profileExtractEnabled: true },
+    extractor: async () => ({ draft: "我知道她跨考公共管理。", rowsUsed: 7, truncated: false, provider: "p", model: "m" })
+  });
+  settings.setProfile("手写原文");
+  const res = new FakeRes();
+  await route.handler(httpReq("POST", {}), res);
+  assert.equal(res.statusCode, 200);
+  const body = JSON.parse(res.body);
+  assert.equal(body.draft, "我知道她跨考公共管理。");
+  assert.equal(body.rowsUsed, 7);
+  assert.equal(settings.getProfile(), "手写原文", "采用草稿必须是用户在面板上的显式一次动作");
+  store.close();
+});
+
+test("提取器报的 code 映射成可区分的状态码（「没东西可提」≠「模型没配合」）", async () => {
+  for (const [code, status] of [["no-input", 409], ["no-route", 503], ["unparseable", 502], ["stream-failed", 502]]) {
+    const { store, route } = setupApi({
+      config: { profileExtractEnabled: true },
+      extractor: async () => { throw new ProfileExtractError(code, code); }
+    });
+    const res = new FakeRes();
+    await route.handler(httpReq("POST", {}), res);
+    assert.equal(res.statusCode, status, `${code} 的状态码`);
+    assert.equal(JSON.parse(res.body).error, code);
+    store.close();
+  }
+});