@modusensus/dsh-mneme 0.9.4 → 0.9.5

package/test/api.test.js

@@ -8,7 +8,7 @@ import { createApi } from "../src/api.js";
 import { createInjector } from "../src/inject.js";
 import { createSettings } from "../src/settings.js";
 import { createVectorIndex } from "../src/vector-index.js";
-import { Config } from "../src/config.js";
+import { Config, applyLightModePreset } from "../src/config.js";
 import { parseHumanEdits } from "../src/mirror.js";
 
 // 解析后的 schema 默认值，作为 /features effective 的 bundle 配置侧样本。
@@ -1272,6 +1272,120 @@ test("POST /api/dsh-mneme/import is token-gated", async () => {
   assert.equal(res.statusCode, 401);
 });
 
+// #521：面板要能一眼看出「一整类动作 100% 被拦」。此前 skipped 只存在库里，
+// 响应里没有聚合，status: degraded + applied: 3 从外面看完全是健康轮的样子。
+test("GET /api/dsh-mneme/dream-status aggregates skipped reasons by kind (issue #521)", async () => {
+  const { routes, service } = setup();
+  // 三条同因（序号前缀不同）+ 一条不同因，模拟 #521 现场：merge 被 mergeGuard
+  // 全拦，前缀 decision[N]: 让朴素 GROUP BY 拆成三组。
+  service.saveDreamRun({
+    created_at: "2026-01-03T00:00:00.000Z",
+    status: "degraded",
+    snapshot_hash: "h3",
+    input_count: 200,
+    receipt: "r3",
+    skipped: [
+      { index: 0, action: "merge", ids: ["p1", "p2"], error: 'decision[0]: merge of long-retention type(s) preference is blocked by dreamMergeGuard' },
+      { index: 1, action: "merge", ids: ["p3", "p4"], error: 'decision[1]: merge of long-retention type(s) preference is blocked by dreamMergeGuard' },
+      { index: 2, action: "merge", ids: ["p5", "p6"], error: 'decision[2]: merge of long-retention type(s) preference is blocked by dreamMergeGuard' },
+      { index: 3, action: "archive", ids: ["x"], error: 'decision[3]: archive of long-retention type(s) constraint needs a duplicate/outdated rationale' }
+    ]
+  });
+  const route = routes.find((r) => r.path === "/api/dsh-mneme/dream-status");
+  const res = new FakeRes();
+  await route.handler(req("/api/dsh-mneme/dream-status"), res);
+  const data = JSON.parse(res.body);
+  assert.equal(data.lastRun.skippedCount, 4, "raw skipped count is preserved");
+  assert.equal(data.lastRun.skippedReasons.length, 2, "three same-cause skips collapse into one bucket");
+  assert.equal(data.lastRun.skippedReasons[0].count, 3, "largest bucket first");
+  assert.equal(data.lastRun.skippedReasons[0].action, "merge");
+  assert.match(data.lastRun.skippedReasons[0].reason, /dreamMergeGuard/);
+  assert.doesNotMatch(data.lastRun.skippedReasons[0].reason, /decision\[/, "index prefix is stripped");
+  assert.equal(data.lastRun.skippedReasons[1].action, "archive", "same wording on a different action stays separate");
+});
+
+// #522 评审：一条决策可能攒下多条错误（skipped[].error 用 "; " 拼），原先的剥
+// 前缀正则 ^ 锚定、只剥得掉第一个，后面的 decision[1]: 留在字符串中间，聚合时
+// 同类原因又被拆成多组。另外校验器回给模型的自由文本尾巴（got: "…"）可能夹带
+// 记忆正文、也可能被截断成没有右引号，靠引号配对剥不掉——这条路由是 open 的，
+// 审计文本不该这样出网关。两件事一起锁在下面这条用例里。
+test("GET /api/dsh-mneme/dream-status strips every decision index and the free-text tail (issue #522)", async () => {
+  const { routes, service } = setup();
+  service.saveDreamRun({
+    created_at: "2026-01-04T00:00:00.000Z",
+    status: "degraded",
+    snapshot_hash: "h4",
+    input_count: 200,
+    receipt: "r4",
+    skipped: [
+      {
+        index: 0,
+        action: "merge",
+        ids: ["p1", "p2"],
+        // 两条错误拼成一句：第二个前缀必须也剥掉，否则同一类原因会被拆成两组。
+        error: 'decision[0]: merge of long-retention type(s) preference is blocked by dreamMergeGuard (needs a duplicate/outdated rationale, 重复/过时); decision[0]: unknown id "p9"'
+      },
+      {
+        index: 1,
+        action: "archive",
+        ids: ["x"],
+        // got: 后面是模型写的理由原文（这里故意放一段像记忆正文的话），整段该被丢掉。
+        error: 'decision[1]: archive of long-retention type(s) constraint needs a duplicate/outdated rationale, got: "用户说过预算是 12400 元"'
+      },
+      {
+        // #522 第二轮评审：模型写的理由里可能正好含 "; decision[0]: "，先切分就会把
+        // 这段自由文本变成新的一段，而新段没有 got: 前缀，剥尾正则够不着它——原文
+        // 于是随 open 路由出网关。切分必须排在剥 got: 之后。
+        index: 2,
+        action: "archive",
+        ids: ["z"],
+        error: 'decision[2]: archive of long-retention type(s) preference needs a duplicate/outdated rationale (重复/过时), got: "并不过时; decision[0]: email@example.com 说的"'
+      },
+      {
+        index: 3,
+        // action 不在 ACTIONS 枚举里：聚合结果会随 open 路由出网关，来路不明的动作名
+        // 不该由上游脏数据自己决定响应形状，一律归成空串。
+        action: "drop-everything",
+        ids: ["y"],
+        error: "decision[3]: unknown action"
+      },
+      {
+        // #522 三轮评审：分隔符本身可能出现在 id 里。旧实现按 ", got: " 猜自由文本
+        // 起点，会把这里的引号截断成未闭合状态，后面的引号配对替换随之失效，邮箱
+        // 原样留下。判据必须只看引号，不看分隔符。
+        index: 4,
+        action: "merge",
+        ids: ["q"],
+        error: 'decision[4]: unknown id "alice@example.com, got: x"'
+      },
+      {
+        // 旧版把理由先截到 60 字再 stringify，落库的历史行可能带着一个未闭合引号
+        // （字符串从中间断开）。抹不干净就得砍到结尾——宁可少一句尾巴。
+        index: 5,
+        action: "archive",
+        ids: ["w"],
+        error: 'decision[5]: archive of long-retention type(s) constraint needs a duplicate/outdated rationale, got: "用户说过预算是 12400'
+      }
+    ]
+  });
+  const route = routes.find((r) => r.path === "/api/dsh-mneme/dream-status");
+  const res = new FakeRes();
+  await route.handler(req("/api/dsh-mneme/dream-status"), res);
+  const data = JSON.parse(res.body);
+  assert.equal(data.lastRun.skippedCount, 6, "raw skipped count is preserved");
+  const unknownAction = data.lastRun.skippedReasons.find((b) => b.reason === "unknown action");
+  assert.equal(unknownAction.action, "", "an action outside the enum is not echoed back to the open route");
+  for (const bucket of data.lastRun.skippedReasons) {
+    assert.doesNotMatch(bucket.reason, /decision\[/, "every index prefix is stripped, not just the first");
+    assert.doesNotMatch(bucket.reason, /got:/, "the free-text tail never leaves the gateway");
+    assert.doesNotMatch(bucket.reason, /12400/, "model-authored text must not ride along with the audit reason");
+    assert.doesNotMatch(bucket.reason, /email@example\.com/, "free text split on a fake decision boundary must not leak either");
+    assert.doesNotMatch(bucket.reason, /并不过时/, "the whole free-text tail is dropped, not just its first half");
+    assert.doesNotMatch(bucket.reason, /alice@example\.com/, "an id carrying the tail separator is masked by quote pairing, not by the separator");
+    assert.doesNotMatch(bucket.reason, /用户说过预算是/, "a historical row whose reason was cut mid-string still gets masked");
+    assert.doesNotMatch(bucket.reason, /\b12400\b/, "nor does the truncated number survive");
+  }
+});
 test("GET /api/dsh-mneme/dream-status returns runs and pending conflict ids", async () => {
   const { routes, service } = setup();
   service.saveDreamRun({ created_at: "2026-01-01T00:00:00.000Z", status: "ok", provider: "ollama", model: "qwen", snapshot_hash: "h1", input_count: 2, receipt: "r1" });
@@ -1286,7 +1400,9 @@ test("GET /api/dsh-mneme/dream-status returns runs and pending conflict ids", as
   assert.equal(data.runs.length, 2);
   assert.equal(data.runs[0].created_at, "2026-01-02T00:00:00.000Z", "created_at DESC");
   assert.deepEqual(data.lastRun, data.runs[0]);
-  assert.deepEqual(Object.keys(data.lastRun).sort(), ["created_at", "demotion", "error", "model", "provider", "run_type", "status"]);
+  // #521：skippedCount / skippedReasons 是本轮新增的两个字段（面板按归一化原因
+  // 显示跳过明细）。这行锁的是 dream-status 的响应形状，加字段必须同步改这里。
+  assert.deepEqual(Object.keys(data.lastRun).sort(), ["created_at", "demotion", "error", "model", "provider", "run_type", "skippedCount", "skippedReasons", "status"]);
   assert.equal(data.lastRun.run_type, "auto", "default run_type is auto");
   assert.equal(data.lastRun.demotion, null, "no demotion info for non-sleep runs");
   assert.equal(data.runs[0].error, "boom");
@@ -2090,3 +2206,255 @@ test("GET /api/dsh-mneme/pipeline 带观察旁挂：observationsById 真的进
     rmSync(root, { recursive: true, force: true });
   }
 });
+
+// --- 记忆级溯源读出口（#399 写、#421 读）---------------------------------------
+// distill_records 与 memory_provenance 自 #399 起就只有写入路径：库里有答案、
+// service.provenanceFor 能查，但外部（面板 / standalone API / 脚本）拿不到——
+// 「这条记忆是从哪几句蒸出来的」只能开 sqlite 手写 JOIN。
+//
+// #509 评审整改：读出口吃 distillRecords.enabled（与写侧同一个开关、同一个判据）。
+// 关着时 409 {error:"distill-records-disabled"}。所以这一族的用例必须显式把开关
+// 打开——setup 的 config 缺省 null，而 null 在这道门上的含义就是「关」（fail-closed）。
+const RECORDS_ON = { distillRecords: { enabled: true } };
+
+test("GET /api/dsh-mneme/memory/provenance 返回窗口区间与原文行", async () => {
+  const { routes, service, store } = setup(null, "secret-token", RECORDS_ON);
+  // 直接落溯源链接与原文：读取面不关心是谁写的，只关心库里的形状。
+  service.saveWithDedupe({ type: "decision", title: "核心决策", content: "选定 SQLite 单文件库", importance: 5 });
+  const memory = service.all()[0];
+  store.saveMemoryProvenance({
+    memoryId: memory.id, sessionId: "s1", seqStart: 10, seqEnd: 12, createdAt: "2026-10-23T00:00:00Z"
+  });
+  store.saveDistillRecords([
+    { sessionId: "s1", seq: 10, role: "user", text: "第一句原文", windowId: "w1", distilledAt: "2026-10-23T00:00:00Z" },
+    { sessionId: "s1", seq: 11, role: "assistant", text: "第二句原文", windowId: "w1", distilledAt: "2026-10-23T00:00:00Z" },
+    { sessionId: "s1", seq: 12, role: "user", text: "第三句原文", windowId: "w1", distilledAt: "2026-10-23T00:00:00Z" },
+    // 区间外的一句：不该被带出来
+    { sessionId: "s1", seq: 99, role: "user", text: "区间外", windowId: "w1", distilledAt: "2026-10-23T00:00:00Z" }
+  ]);
+
+  const route = routes.find((r) => r.path === "/api/dsh-mneme/memory/provenance");
+  assert.equal(route.policy, "token", "records 带会话原文，与开放的 /list 串起来即可枚举 id 后捞回原文——必须受门控");
+
+  const res = new FakeRes();
+  const r = req("/api/dsh-mneme/memory/provenance?id=" + memory.id);
+  r.headers = { authorization: "Bearer secret-token" };
+  await route.handler(r, res);
+  assert.equal(res.statusCode, 200);
+  const data = JSON.parse(res.body);
+  assert.equal(data.memoryId, memory.id);
+  assert.equal(data.windows.length, 1, "一个链接一个窗口");
+  const w = data.windows[0];
+  assert.equal(w.session_id, "s1");
+  assert.equal(w.seq_start, 10);
+  assert.equal(w.seq_end, 12);
+  assert.equal(w.created_at, "2026-10-23T00:00:00Z");
+  assert.deepEqual(w.records.map((r) => r.text), ["第一句原文", "第二句原文", "第三句原文"],
+    "原文按 seq 升序，且不越出区间");
+  assert.deepEqual(w.records.map((r) => r.seq), [10, 11, 12]);
+});
+
+test("GET /api/dsh-mneme/memory/provenance：无 token 401，装配没接线 503", async () => {
+  const { routes, service } = setup(null, "secret-token", RECORDS_ON);
+  service.saveWithDedupe({ type: "preference", title: "语言", content: "中文" });
+  const route = routes.find((r) => r.path === "/api/dsh-mneme/memory/provenance");
+
+  // 没 token → 401（policy=token 的机械结果）
+  const noAuth = new FakeRes();
+  await route.handler(req("/api/dsh-mneme/memory/provenance?id=x"), noAuth);
+  assert.equal(noAuth.statusCode, 401);
+
+  // 装配没接线（headless / 旧装配：service 上没有这两个方法）→ 503。
+  // 这与「这条记忆没有来源」是两件事，必须分开读数——后者是事实，前者是接线坏了。
+  const store = createStore(":memory:");
+  const settings = createSettings(store.db);
+  const bare = createService({ store, mirror: null, config: {} });
+  delete bare.provenanceFor;
+  delete bare.distillRecordsFor;
+  const bareRoutes = [];
+  createApi(
+    { webServer: { register(r) { bareRoutes.push(r); return () => {}; } } },
+    bare, settings, { add() {}, remove() {}, list: () => [] }, null, undefined, "secret-token",
+    RECORDS_ON
+  );
+  const bareRoute = bareRoutes.find((r) => r.path === "/api/dsh-mneme/memory/provenance");
+  const res503 = new FakeRes();
+  const authed = req("/api/dsh-mneme/memory/provenance?id=x");
+  authed.headers = { authorization: "Bearer secret-token" };
+  await bareRoute.handler(authed, res503);
+  assert.equal(res503.statusCode, 503, "装配缺方法 → provenance-unavailable，不是空 windows");
+  assert.equal(JSON.parse(res503.body).error, "provenance-unavailable");
+  store.close();
+});
+
+test("GET /api/dsh-mneme/memory/provenance：非蒸馏来源的记忆返回空窗口而非报错", async () => {
+  // memory_save 写进来的记忆没有溯源链接——「这条不是蒸馏来的」本身是有效答案，
+  // 不能 404/500。契约：空 windows，不是错误。
+  const { routes, service } = setup(null, "secret-token", RECORDS_ON);
+  service.saveWithDedupe({ type: "preference", title: "语言", content: "中文" });
+  const memory = service.all()[0];
+  const route = routes.find((r) => r.path === "/api/dsh-mneme/memory/provenance");
+  const res = new FakeRes();
+  const r = req("/api/dsh-mneme/memory/provenance?id=" + memory.id);
+  r.headers = { authorization: "Bearer secret-token" };
+  await route.handler(r, res);
+  assert.equal(res.statusCode, 200);
+  const data = JSON.parse(res.body);
+  assert.deepEqual(data.windows, [], "没有链接 → 空窗口，不是错误");
+});
+
+test("GET /api/dsh-mneme/memory/provenance 缺 id 报 400，未知 id 返回空窗口", async () => {
+  const { routes } = setup(null, "secret-token", RECORDS_ON);
+  const route = routes.find((r) => r.path === "/api/dsh-mneme/memory/provenance");
+  // 400 要赢过 401：调用方发坏了，报「没鉴权」是误导（reclaimReply 同款顺序）。
+  const bad = new FakeRes();
+  const badReq = req("/api/dsh-mneme/memory/provenance");
+  badReq.headers = { authorization: "Bearer secret-token" };
+  await route.handler(badReq, bad);
+  assert.equal(bad.statusCode, 400);
+
+  // 库里有 distill 数据但这条 id 不存在：读端点不替调用方判断记忆是否存在，
+  // 「没有链接」对未知 id 与对非蒸馏记忆是同一个答案。
+  const unknown = new FakeRes();
+  const unknownReq = req("/api/dsh-mneme/memory/provenance?id=nope");
+  unknownReq.headers = { authorization: "Bearer secret-token" };
+  await route.handler(unknownReq, unknown);
+  assert.equal(unknown.statusCode, 200);
+  assert.deepEqual(JSON.parse(unknown.body).windows, []);
+});
+
+test("GET /api/dsh-mneme/memory/provenance：读失败要留痕，500 不能把 warn 一起吞掉", async () => {
+  // 共用模块的测试已经锁了「抛错 → 调 warn」（provenance-http.test.js），但锁不住
+  // **壳把哪个 logger 递进去**。#509 第二次迭代在这里栽过：壳里写的是裸 `logger`，
+  // 而 createApi 的作用域只有 ctx.logger——warn 回调自己抛 ReferenceError，被外层
+  // catch 吞掉，响应还是 500，但「为什么失败」一个字都不留。下面这条把接线本身锁住。
+  const store = createStore(":memory:");
+  const settings = createSettings(store.db);
+  const service = createService({ store, mirror: null, config: {} });
+  const realFor = service.provenanceFor;
+  service.provenanceFor = (id) => { realFor(id); throw new Error("db locked"); };
+
+  const routes = [];
+  const warnings = [];
+  createApi(
+    {
+      webServer: { register(r) { routes.push(r); return () => {}; } },
+      logger: { warn: (m) => warnings.push(m) }
+    },
+    service, settings, { add() {}, remove() {}, list: () => [] }, null, undefined, "secret-token",
+    RECORDS_ON
+  );
+  const route = routes.find((r) => r.path === "/api/dsh-mneme/memory/provenance");
+  const res = new FakeRes();
+  const r = req("/api/dsh-mneme/memory/provenance?id=m1");
+  r.headers = { authorization: "Bearer secret-token" };
+  await route.handler(r, res);
+
+  assert.equal(res.statusCode, 500, "读失败回 500");
+  assert.equal(JSON.parse(res.body).error, "internal");
+  assert.equal(warnings.length, 1, "500 必须伴随一条 warn——否则失败原因只存在于调用方的猜测里");
+  assert.match(warnings[0], /memory provenance read failed/, "留痕要带原始异常");
+  assert.match(warnings[0], /db locked/);
+  store.close();
+});
+
+// --- distillRecords.enabled 门（#509 评审整改）--------------------------------
+// 维护者在 #509 里指出的缺口：读出口此前一处都不读这个开关，于是「把 distill_records
+// 关掉」的语义是不再写、也不再删，却还多一个能读出去的口。门落在共用模块，两个壳
+// 都吃它；这里锁宿主面的外壳与顺序。
+
+test("GET /api/dsh-mneme/memory/provenance：distillRecords.enabled 关着 → 409，不是 404 也不是空 windows", async () => {
+  const { routes, service } = setup(null, "secret-token", { distillRecords: { enabled: false } });
+  service.saveWithDedupe({ type: "preference", title: "语言", content: "中文" });
+  const memory = service.all()[0];
+  const route = routes.find((r) => r.path === "/api/dsh-mneme/memory/provenance");
+  const res = new FakeRes();
+  const r = req("/api/dsh-mneme/memory/provenance?id=" + memory.id);
+  r.headers = { authorization: "Bearer secret-token" };
+  await route.handler(r, res);
+
+  assert.equal(res.statusCode, 409, "用户关了功能 = 409（src/api.js:525 的 profileExtract 同型先例）");
+  assert.deepEqual(JSON.parse(res.body), { error: "distill-records-disabled" });
+});
+
+test("GET /api/dsh-mneme/memory/provenance：config 整个缺席也按关处理（fail-closed）", async () => {
+  // 旧调用方直连 createApi 不传第 8 参、或宿主没装配 cfg：这个端点返回逐字原文，
+  // 判不出来时必须往「不读」那一侧倒。
+  const { routes } = setup(null, "secret-token");
+  const route = routes.find((r) => r.path === "/api/dsh-mneme/memory/provenance");
+  const res = new FakeRes();
+  const r = req("/api/dsh-mneme/memory/provenance?id=whatever");
+  r.headers = { authorization: "Bearer secret-token" };
+  await route.handler(r, res);
+  assert.equal(res.statusCode, 409);
+  assert.deepEqual(JSON.parse(res.body), { error: "distill-records-disabled" });
+});
+
+test("GET /api/dsh-mneme/memory/provenance：400 赢 409——缺 id 是语法畸形，与服务端状态无关", async () => {
+  const { routes } = setup(null, "secret-token", { distillRecords: { enabled: false } });
+  const route = routes.find((r) => r.path === "/api/dsh-mneme/memory/provenance");
+  const res = new FakeRes();
+  const r = req("/api/dsh-mneme/memory/provenance");
+  r.headers = { authorization: "Bearer secret-token" };
+  await route.handler(r, res);
+  assert.equal(res.statusCode, 400, "请求本身不成立时报「功能关了」是误导");
+  assert.equal(JSON.parse(res.body).error, "missing-id");
+});
+
+test("GET /api/dsh-mneme/memory/provenance：409 赢 503——功能关比装配坏更具体", async () => {
+  // 关着 + service 上连方法都没有：503 会让人去查一个没坏的部署。
+  const store = createStore(":memory:");
+  const settings = createSettings(store.db);
+  const bare = createService({ store, mirror: null, config: {} });
+  delete bare.provenanceFor;
+  delete bare.distillRecordsFor;
+  const bareRoutes = [];
+  createApi(
+    { webServer: { register(r) { bareRoutes.push(r); return () => {}; } } },
+    bare, settings, { add() {}, remove() {}, list: () => [] }, null, undefined, "secret-token",
+    { distillRecords: { enabled: false } }
+  );
+  const route = bareRoutes.find((r) => r.path === "/api/dsh-mneme/memory/provenance");
+  const res = new FakeRes();
+  const r = req("/api/dsh-mneme/memory/provenance?id=x");
+  r.headers = { authorization: "Bearer secret-token" };
+  await route.handler(r, res);
+  assert.equal(res.statusCode, 409);
+  assert.equal(JSON.parse(res.body).error, "distill-records-disabled");
+  store.close();
+});
+
+test("GET /api/dsh-mneme/memory/provenance：关着时对已知 id 与未知 id 同一个答案——不当存在性预言机", async () => {
+  // 如果关着只对「有原文的 id」回 409、对别的 id 回空 windows，调用方就能拿这个
+  // 端点枚举「哪些记忆有蒸馏原文」。功能关是端点的属性，每个 id 答案必须一样。
+  const { routes, service } = setup(null, "secret-token", { distillRecords: { enabled: false } });
+  service.saveWithDedupe({ type: "preference", title: "语言", content: "中文" });
+  const memory = service.all()[0];
+  const route = routes.find((r) => r.path === "/api/dsh-mneme/memory/provenance");
+  for (const id of [memory.id, "nope", ""]) {
+    const res = new FakeRes();
+    const r = req("/api/dsh-mneme/memory/provenance?id=" + id);
+    r.headers = { authorization: "Bearer secret-token" };
+    await route.handler(r, res);
+    if (id === "") {
+      assert.equal(res.statusCode, 400, "空 id 仍是语法问题，409 不该吃掉它");
+      continue;
+    }
+    assert.equal(res.statusCode, 409, `${id} → 409`);
+    assert.deepEqual(JSON.parse(res.body), { error: "distill-records-disabled" });
+  }
+});
+
+test("GET /api/dsh-mneme/memory/provenance：lightMode 预设把关掉 → 409（与写侧同源）", async () => {
+  // applyLightModePreset 把 distillRecords.enabled 置 false（pre-inject-gate.test.js
+  // 锁的是写入侧那个方向）；读侧必须跟着变，否则轻量模式下用户以为自己关了、原文
+  // 却还能从 HTTP 读出去。
+  const { routes } = setup(null, "secret-token", applyLightModePreset({ lightMode: true, distillRecords: { enabled: true } }));
+  const route = routes.find((r) => r.path === "/api/dsh-mneme/memory/provenance");
+  const res = new FakeRes();
+  const r = req("/api/dsh-mneme/memory/provenance?id=m1");
+  r.headers = { authorization: "Bearer secret-token" };
+  await route.handler(r, res);
+  assert.equal(res.statusCode, 409);
+  assert.equal(JSON.parse(res.body).error, "distill-records-disabled");
+});

package/test/audit.test.js

@@ -30,9 +30,9 @@ function mockCtx({ onConsolidation, summaryText = "记忆库总览：用户偏
     llm: {
       async *stream(options) {
         const userText = options.messages.find((m) => m.role === "user")?.content?.[0]?.text ?? "";
-        if (userText.startsWith("id=")) {
+        if (userText.includes("| type=")) {
           yield { type: "block-start", index: 0, blockType: "text" };
-          yield { type: "text-delta", index: 0, text: onConsolidation ? onConsolidation(userText) : "[]" };
+          yield { type: "text-delta", index: 0, text: onConsolidation ? onConsolidation(userText, options.purpose) : "[]" };
           yield { type: "block-end", index: 0, block: { type: "text" } };
           yield { type: "finish", reason: { kind: "stop" } };
           return;