@modusensus/dsh-mneme 0.9.4 → 0.9.5

package/test/provenance-http.test.js

@@ -0,0 +1,184 @@
+// 记忆级溯源读出口的 HTTP 口径 —— 共用模块自己的锁。
+//
+// 这个文件盯三类回归：
+//   a) 口径本身（id 解析、两种「空」的区分、窗口形状、原文按序）；
+//   b) distillRecords.enabled 门（#509 评审整改）：判据 fail-closed、409 赢 503、
+//      关着时一次都不碰 service；
+//   c) **不许再长出第二份实现**。#509 第一版曾把整段复製到 api.js 与
+//      api-standalone.js 各一份，维护者在 review 里点名（本仓 #411 之后不收这个
+//     形状）。静态锁把三件事写成断言：口径字面量与开关判据只许出现在本模块、两个
+//     壳都真的把 config 转交进来、读侧判据与写侧 summarize.js 逐字同源。谁要是再
+//     复制一段出去，这里直接转红。
+import test from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import {
+  DISTILL_RECORDS_DISABLED,
+  PROVENANCE_UNAVAILABLE,
+  isDistillRecordsEnabled,
+  parseProvenanceQuery,
+  provenanceReply
+} from "../src/provenance-http.js";
+
+const ROOT = resolve(dirname(fileURLToPath(import.meta.url)), "..");
+
+// 开着开关的 cfg：这个端点返回蒸馏窗口的逐字原文，所以测试里的「正常路径」必须
+// 显式把开关打开——不传就是关（fail-closed），没有「默认开」这回事。
+const RECORDS_ON = { distillRecords: { enabled: true } };
+
+function fakeService(over = {}) {
+  return {
+    provenanceFor: (id) => over.links ?? [],
+    distillRecordsFor: (sessionId, from, to) => over.records ?? [],
+    ...over.service
+  };
+}
+
+test("parseProvenanceQuery：空/缺失 id 报 400，非空原样通过", () => {
+  for (const raw of [null, undefined, "", "   "]) {
+    const r = parseProvenanceQuery(raw);
+    assert.equal(r.ok, false, `${JSON.stringify(raw)} 不该通过`);
+    assert.equal(r.status, 400);
+    assert.equal(r.error, "missing-id");
+  }
+  assert.deepEqual(parseProvenanceQuery(" m1 "), { ok: true, id: "m1" }, "id 两端空白要裁掉");
+});
+
+test("provenanceReply：一个链接一个窗口，原文按 seq 升序且不越界", () => {
+  const seen = [];
+  const service = {
+    provenanceFor: () => [{ session_id: "s1", seq_start: 10, seq_end: 12, created_at: "2026-10-23T00:00:00Z" }],
+    distillRecordsFor: (sessionId, from, to) => {
+      seen.push([sessionId, from, to]);
+      return [{ seq: 12 }, { seq: 10 }, { seq: 11 }];
+    }
+  };
+  const r = provenanceReply({ service, id: "m1", config: RECORDS_ON });
+  assert.equal(r.status, 200);
+  assert.equal(r.body.memoryId, "m1");
+  assert.equal(r.body.windows.length, 1);
+  const w = r.body.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((x) => x.seq), [12, 10, 11], "次序由 store 的 ORDER BY seq 保证，答复层不改序");
+  assert.deepEqual(seen, [["s1", 10, 12]], "区间原样透传给 store");
+});
+
+test("provenanceReply：没有链接是有效答案——空 windows，200 不是 404", () => {
+  const r = provenanceReply({ service: fakeService(), id: "m1", config: RECORDS_ON });
+  assert.equal(r.status, 200);
+  assert.deepEqual(r.body, { memoryId: "m1", windows: [] });
+});
+
+test("provenanceReply：方法没接线是装配坏了——503，不与「没有来源」混为一个读数", () => {
+  // headless / 旧装配：service 上没有这两个方法。
+  const r = provenanceReply({ service: {}, id: "m1", config: RECORDS_ON });
+  assert.equal(r.status, 503);
+  assert.equal(r.body.error, PROVENANCE_UNAVAILABLE);
+});
+
+test("provenanceReply：读抛错只 warn 并回 500，不把异常漏给调用方", () => {
+  const warnings = [];
+  const service = {
+    provenanceFor: () => { throw new Error("db locked"); },
+    distillRecordsFor: () => []
+  };
+  const r = provenanceReply({ service, id: "m1", config: RECORDS_ON, warn: (m) => warnings.push(m) });
+  assert.equal(r.status, 500);
+  assert.equal(r.body.error, "internal");
+  assert.equal(warnings.length, 1, "失败要留痕");
+  assert.match(warnings[0], /memory provenance read failed/);
+});
+
+// --- distillRecords.enabled 门（#509 评审整改）--------------------------------
+// 写侧（src/summarize.js:988）早就吃这个开关，读出口此前一处都不读：关着时历史
+// 原文照旧留在库里、还多一个能读出去的口。门加在共用模块里，两个壳都吃它。
+
+test("isDistillRecordsEnabled：只认严格的 true，其余一律算关（fail-closed）", () => {
+  assert.equal(isDistillRecordsEnabled({ distillRecords: { enabled: true } }), true);
+  for (const cfg of [
+    null, undefined, {}, { distillRecords: null }, { distillRecords: {} },
+    { distillRecords: { enabled: false } },
+    // 非布尔值：字符串 / 数字都不该被当成开——那是配置写错了，不是用户开了
+    { distillRecords: { enabled: "true" } },
+    { distillRecords: { enabled: 1 } }
+  ]) {
+    assert.equal(isDistillRecordsEnabled(cfg), false, `${JSON.stringify(cfg)} 必须算关`);
+  }
+});
+
+test("provenanceReply：开关没开 → 409 distill-records-disabled，一个键都不多带", () => {
+  // config 整个缺失（旧调用方直连、daemon 最小 cfg）也走这一格：默认方向必须是关。
+  for (const cfg of [null, undefined, {}, { distillRecords: { enabled: false } }]) {
+    const r = provenanceReply({ service: fakeService(), id: "m1", config: cfg });
+    assert.equal(r.status, 409, `${JSON.stringify(cfg)} → 409`);
+    assert.deepEqual(r.body, { error: DISTILL_RECORDS_DISABLED },
+      "body 只准有 error 一个键——不带 memoryId / windows，调用方不会把「功能关了」读成「这条记忆没有来源」");
+  }
+});
+
+test("provenanceReply：409 赢 503——「用户关了」比「装配坏了」更具体", () => {
+  // 关着 + service 上连方法都没有：报 503 会让人去查一个没坏的部署。
+  const r = provenanceReply({ service: {}, id: "m1", config: { distillRecords: { enabled: false } } });
+  assert.equal(r.status, 409);
+  assert.equal(r.body.error, DISTILL_RECORDS_DISABLED);
+});
+
+test("provenanceReply：开关关着时一次 SQL 都不发（不碰 service）", () => {
+  // 门要在读之前：关着还被调用方当成「能读」是次要的，白跑一趟库才是真浪费。
+  let touched = 0;
+  const service = fakeService({ service: {
+    provenanceFor: () => { touched++; return []; },
+    distillRecordsFor: () => { touched++; return []; }
+  } });
+  provenanceReply({ service, id: "m1", config: null });
+  assert.equal(touched, 0);
+});
+
+test("provenanceReply：开关开着才读得到——200 与 409 是同一把门的两个方向", () => {
+  const service = fakeService({ links: [{ session_id: "s1", seq_start: 1, seq_end: 1, created_at: "t" }], records: [{ seq: 1 }] });
+  const on = provenanceReply({ service, id: "m1", config: RECORDS_ON });
+  assert.equal(on.status, 200);
+  assert.equal(on.body.windows.length, 1);
+  const off = provenanceReply({ service, id: "m1", config: { distillRecords: { enabled: false } } });
+  assert.equal(off.status, 409);
+  assert.deepEqual(off.body, { error: DISTILL_RECORDS_DISABLED });
+});
+
+test("🔴 静态锁：口径字面量与共用答复只许出现在本模块，两个入口都要真的走它", () => {
+  // #509 第一版把整段复制到了两张皮各一份——本仓 #411 之后不收这个形状。
+  for (const name of ["api.js", "api-standalone.js"]) {
+    const src = readFileSync(join(ROOT, "src", name), "utf8");
+    assert.ok(src.includes("provenance-http.js"), `src/${name} 必须从共用模块取口径`);
+    assert.ok(src.includes("provenanceReply("), `src/${name} 要真的走共用答复`);
+    assert.ok(!src.includes("provenance-unavailable"), `src/${name} 不准自己写错误码字面量`);
+    assert.ok(!src.includes("distill-records-disabled"), `src/${name} 不准自己写「功能关了」的错误码字面量`);
+    // 判据也不许重写：两个壳各自算一遍 config?.distillRecords?.enabled === true，
+    // 就是读写两道门漂移的形状（本文件上面的注释写过这笔账）。
+    assert.ok(!src.includes("distillRecords?.enabled === true"),
+      `src/${name} 不准自己写开关判据——只许把 config 转交给共用模块`);
+    // 而且要真的转交了：壳里调 provenanceReply 时必须带上 config。
+    assert.match(src, /provenanceReply\(\{ service, id: parsed\.id, config,/,
+      `src/${name} 要把本入口的 config 传给共用模块，否则门永远读不到用户的开关`);
+  }
+});
+
+test("🔴 静态锁：读侧判据与写侧 src/summarize.js 逐字同源", () => {
+  // 「读写两道门永不分歧」不能只活在注释里：写侧那句话在 summarize.js，读侧在本
+  // 模块，两边必须是同一个字符串。谁改了其中一边，这里转红。
+  const shared = readFileSync(join(ROOT, "src", "provenance-http.js"), "utf8");
+  const writeSide = readFileSync(join(ROOT, "src", "summarize.js"), "utf8");
+  const readSide = readFileSync(join(ROOT, "src", "index.js"), "utf8");
+  const criterion = "config?.distillRecords?.enabled === true";
+  assert.ok(shared.includes(criterion), "共用模块要写判据（读侧唯一一份）");
+  assert.ok(writeSide.includes(criterion), "写侧 summarize.js 要还在用同一个判据");
+  // 读侧只准有一份：两个壳各写一遍的漂移形状，静态锁上一节已经禁了壳，这里禁
+  // 共用模块自己长出第二份。
+  assert.equal(shared.split(criterion).length - 1, 1, "共用模块里判据只许出现一次");
+  // 写侧那一处（启动期裁剪）与它同源，所以三处各一份、彼此逐字相同。
+  assert.ok(readSide.includes("cfg.distillRecords?.enabled === true"), "index.js 的启动裁剪判据应保持同族");
+});

package/test/readme-claims.test.js

@@ -66,3 +66,48 @@ test("隐私节必须写出「巩固与摘要走宿主模型」这个出站事
     "English Privacy section should disclose that consolidation uses the host model",
   );
 });
+
+// 「模型工具」表是代码的投影，不是愿望清单（AGENTS.md 给 SECURITY.md 定的那条规矩，
+// 这张表一直没有）。它已经跑偏两次：#471 加 set_scope_state、#231 加 memory_organize，
+// 两次都没人回头改表或改那个数字——因为没人核过。所以这里全部**从代码反推**：
+// 工具集从 tools.js 的 name: "…" 取，opt-in 从 hiddenTools 的 `!== true` 判据取
+// （`=== true` 那种是「默认在、用户可关」，不能算进 opt-in，否则默认注册数会算少）。
+test("包 README 的「模型工具」表与 tools.js 注册表一致", () => {
+  const toolsSrc = readFileSync(path.join(pkgRoot, "src/tools.js"), "utf8");
+  const declared = [...toolsSrc.matchAll(/^ {6}name: "((?:memory_|set_scope)[a-z_]*)",/gm)].map((m) => m[1]);
+  assert.ok(declared.length >= 10, `tools.js 的工具名解析失败（只看到 ${declared.length} 个）——先修这条守卫，别改表`);
+  const optIn = [...toolsSrc.matchAll(/if \(config\?\.(\w+) !== true\) hiddenTools\.add\("([a-z_]+)"\)/g)]
+    .map((m) => ({ key: m[1], tool: m[2] }));
+  const defaultCount = declared.length - optIn.length;
+
+  const heading = pkgReadme.match(/^### 模型工具（([^）]*)）$/m);
+  assert.ok(heading, "包 README 应有「### 模型工具（N 个）」这一节标题（标题格式变了就同步改这条守卫）");
+  const bodyStart = pkgReadme.indexOf(heading[0]);
+  const bodyRest = pkgReadme.slice(bodyStart + heading[0].length);
+  const nextSection = bodyRest.search(/\r?\n#{2,3} /);
+  const body = nextSection === -1 ? bodyRest : bodyRest.slice(0, nextSection);
+  const rows = [...body.matchAll(/^\| `([a-z_]+)` \|/gm)].map((m) => m[1]);
+
+  assert.deepEqual(
+    [...new Set(declared)].sort(),
+    [...new Set(rows)].sort(),
+    "表与注册表必须一一对应：少了是漏文档，多了是文档写了不存在的东西"
+  );
+  assert.equal(rows.length, new Set(rows).size, "表里不许有重复行（重复行会让数量核对失效）");
+  // 按**顺序**比数字，不是各自 includes：把「默认注册 11 个；开后 12 个」写成
+  // 「默认 12、开后 11」时，两个独立的 includes 都会绿——而那正是这条守卫要防的
+  // 第二种错法（第一种是数字与表不符，已被上面的集合比对盖住）。
+  const nums = (heading[1].match(/\d+/g) ?? []).map(Number);
+  const expected = optIn.length ? [defaultCount, declared.length] : [defaultCount];
+  assert.deepEqual(
+    nums,
+    expected,
+    `标题里的数字要按序是「默认注册数、全数」= ${expected.join(" 与 ")}（实跑 ${nums.join(" 与 ") || "没有数字"}）`
+  );
+  // opt-in 工具那一行必须点名它的开关：读者看到表里有它，得知道默认是不出现的。
+  for (const { key, tool } of optIn) {
+    const row = body.match(new RegExp(`^\\| \`${tool}\` \\|(.*)$`, "m"));
+    assert.ok(row, `${tool} 必须在表里`);
+    assert.ok(row[1].includes(key), `${tool} 那行要写明它需要 ${key} 才注册`);
+  }
+});

package/test/reasoning-effort.test.js

@@ -72,8 +72,8 @@ function dreamCtx({ onConsolidation, summaryText = "记忆库总览：用户偏
       async *stream(options) {
         captured.push(options);
         const userText = options.messages.find((m) => m.role === "user")?.content?.[0]?.text ?? "";
-        if (userText.startsWith("id=")) {
-          yield { type: "text-delta", index: 0, text: onConsolidation ? onConsolidation(userText) : "[]" };
+        if (userText.includes("| type=")) {
+          yield { type: "text-delta", index: 0, text: onConsolidation ? onConsolidation(userText, options.purpose) : "[]" };
         } else {
           yield { type: "text-delta", index: 0, text: summaryText };
         }
@@ -282,7 +282,7 @@ test("issue#9: rejected reasoningEffort retries once without it and still consol
       async *stream(options) {
         calls.push(options);
         const userText = options.messages.find((m) => m.role === "user")?.content?.[0]?.text ?? "";
-        if (userText.startsWith("id=")) {
+        if (userText.includes("| type=")) {
           // First attempt forwards reasoningEffort: the provider rejects it.
           if (options.reasoningEffort) {
             throw new Error("UNSUPPORTED_REASONING_EFFORT: DeepSeek does not support reasoning effort \"low\"");
@@ -340,7 +340,7 @@ function sleepCtx(onConsolidation, selection = { provider: "mock", model: "sleep
       async *stream(options) {
         captured.push(options);
         const userText = options.messages.find((m) => m.role === "user")?.content?.[0]?.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: "finish", reason: { kind: "stop" } };
       }
     }
@@ -355,7 +355,7 @@ test("issue#9: sleep forwards sleepReasoningEffort on its LLM passes", async ()
   vectorIndex.saveEmbedding(b.id, [1, 0, 0]);
   const captured = [];
   const ctx = sleepCtx(
-    (userText) => userText.startsWith("候选冲突")
+    (userText, purpose) => purpose === "sleep-conflict"
       ? JSON.stringify([{ action: "conflict", winner: a.id, loser: b.id, reason: "重复覆盖" }])
       : "[]",
     { provider: "mock", model: "sleep-model" },
@@ -378,7 +378,7 @@ test("issue#135: sleep unset effort also resolves to the lowest supported", asyn
   vectorIndex.saveEmbedding(b.id, [1, 0, 0]);
   const captured = [];
   const ctx = sleepCtx(
-    (userText) => userText.startsWith("候选冲突")
+    (userText, purpose) => purpose === "sleep-conflict"
       ? JSON.stringify([{ action: "conflict", winner: a.id, loser: b.id, reason: "重复覆盖" }])
       : "[]",
     { provider: "mock", model: "sleep-model" },
@@ -433,7 +433,7 @@ test("rc.1 stream-level effort rejection (error finish chunk) also triggers the
           return;
         }
         const userText = options.messages.find((m) => m.role === "user")?.content?.[0]?.text ?? "";
-        if (userText.startsWith("id=")) {
+        if (userText.includes("| type=")) {
           yield { type: "text-delta", index: 0, text: JSON.stringify([
             { action: "merge", ids: [a.id, b.id], keepSource: b.id, title: "合并标题", content: "合并内容", importance: 4 }
           ]) };
@@ -500,7 +500,7 @@ test("sleep passes the stream failure accessor so a stream-level effort rejectio
       return;
     }
     const userText = options.messages.find((m) => m.role === "user")?.content?.[0]?.text ?? "";
-    yield { type: "text-delta", index: 0, text: userText.startsWith("候选冲突")
+    yield { type: "text-delta", index: 0, text: options.purpose === "sleep-conflict"
       ? JSON.stringify([{ action: "conflict", winner: a.id, loser: b.id, reason: "重复覆盖" }])
       : "[]" };
     yield { type: "finish", reason: { kind: "stop" } };
@@ -625,7 +625,7 @@ test("defaultEffort trap: capability query failure falls back to configured effo
           throw new Error("UNSUPPORTED_REASONING_EFFORT: mock does not support reasoning effort \"high\"");
         }
         const userText = options.messages.find((m) => m.role === "user")?.content?.[0]?.text ?? "";
-        if (userText.startsWith("id=")) {
+        if (userText.includes("| type=")) {
           yield { type: "text-delta", index: 0, text: JSON.stringify([
             { action: "merge", ids: [a.id, b.id], keepSource: b.id, title: "合并标题", content: "合并内容", importance: 4 }
           ]) };
@@ -655,7 +655,7 @@ test("defaultEffort trap: sleep conflict pass remaps a poison effort too", async
   vectorIndex.saveEmbedding(b.id, [1, 0, 0]);
   const captured = [];
   const ctx = sleepCtx(
-    (userText) => userText.startsWith("候选冲突")
+    (userText, purpose) => purpose === "sleep-conflict"
       ? JSON.stringify([{ action: "conflict", winner: a.id, loser: b.id, reason: "重复覆盖" }])
       : "[]",
     { provider: "mock", model: "sleep-model" },

package/test/scope-candidates.test.js

@@ -53,7 +53,7 @@ function llmCtx(captured = [], selection = { provider: "mock", model: "sleep-mod
       async *stream(options) {
         captured.push(options);
         const userText = options.messages.find((m) => m.role === "user")?.content?.[0]?.text ?? "";
-        yield { type: "text-delta", index: 0, text: userText.startsWith("候选冲突") || userText.startsWith("Candidate conflicts") ? "[]" : "[]" };
+        yield { type: "text-delta", index: 0, text: options.purpose === "sleep-conflict" ? "[]" : "[]" };
         yield { type: "finish", reason: { kind: "stop" } };
       }
     }
@@ -210,7 +210,7 @@ test("non-freeze with an LLM: cross-scope pair bypasses adjudication; same-scope
   ctx.llm.stream = async function* (options) {
     captured.push(options);
     const userText = options.messages.find((m) => m.role === "user")?.content?.[0]?.text ?? "";
-    const isConflictPass = userText.startsWith("候选冲突") || userText.startsWith("Candidate conflicts");
+    const isConflictPass = options.purpose === "sleep-conflict";
     const text = isConflictPass
       ? JSON.stringify([{ action: "conflict", winner: yNew.id, loser: yOld.id, reason: "同归属重复" }])
       : "[]";
@@ -221,9 +221,12 @@ test("non-freeze with an LLM: cross-scope pair bypasses adjudication; same-scope
   const result = await runSleep(ctx, service, baseConfig(), ctx.logger, { embedder, vectorIndex }, null);
   assert.equal(result.status, "ok");
 
+  // 认「哪一次是冲突裁决」改按 purpose，不再看 user 段首行：#493 追加的围栏让 user 段以
+  // 角色声明开头，而败者行的溯源注释里也会出现「候选冲突」这个词——用 includes 会把模式
+  // 阶段误判成冲突阶段。purpose 与 prompt 形态彻底解耦。
   const conflictPassTexts = captured
-    .map((o) => o.messages.find((m) => m.role === "user")?.content?.[0]?.text ?? "")
-    .filter((t) => t.startsWith("候选冲突") || t.startsWith("Candidate conflicts"));
+    .filter((o) => o.purpose === "sleep-conflict")
+    .map((o) => o.messages.find((m) => m.role === "user")?.content?.[0]?.text ?? "");
   assert.ok(conflictPassTexts.length >= 1, "conflict pass ran for the same-scope pair");
   for (const t of conflictPassTexts) {
     assert.ok(!t.includes(xNew.id) && !t.includes(xOld.id), "cross-scope pair must never enter the LLM prompt");

package/test/scope-state.test.js

@@ -421,6 +421,135 @@ test("睡眠侧：被按下作用域的行不进 pattern 扫描池，也就不
   store.close();
 });
 
+// --- issue #515：闸门把可扫行挡在 LIMIT 窗口之外 ---------------------------
+//
+// 上面那条用例锁的是「政策轴排在截断之前」，但它的库只有 4 行，根本碰不到
+// store.list 的 `LIMIT 200`，所以它测不到 #515 真正的症状：被按下的行**多到占满窗口**
+// 时，过滤前它们吃掉全部名额、过滤后自家行一条都不剩，相位回 `no memories to scan`
+// ——读起来像「库里没东西可扫」，实际是「闸门把可扫的行挡在了窗口里」。
+// 修复方向是不动判定、只放宽取数：窗口过滤后不够本次要扫的名额时，不带窗口重取一次。
+//
+// 造「自家行在窗口之外」用的是 importance 而不是 updated_at：默认档位是
+// `importance DESC, updated_at DESC, id`，而 store.save 的时间戳由实现内部取
+// nowIso()（调用方传不进去），同毫秒落库的行会退到 id 平局键——靠时间戳排序会依赖
+// 插入速度，快机器上自家行可能反而排进窗口，用例就成了偶发绿。importance 差（5 vs 1）
+// 让被按下的那批恒占窗口前排，与毫秒无关。
+
+/** 填满 200 窗口的按下行 + 两条落在窗口之外的自家行。 */
+function seedStarvedPatternPool(store, service) {
+  const own = [];
+  for (const t of ["own-1", "own-2"]) {
+    own.push(store.save({ type: "project", title: t, content: `${t} 正文`, importance: 1 }));
+  }
+  for (let i = 0; i < 200; i++) {
+    store.save({
+      type: "project", title: `paused-${i}`, content: `paused-${i} 正文`, importance: 5,
+      workspace_scope: "proj-a", workspace_scope_source: "explicit"
+    });
+  }
+  service.setScopeState({ dimension: "workspace", scope_value: "proj-a", state: "paused" });
+  return own;
+}
+
+/** 记录 service.list 的入参（只包 list，其余方法原样透出），用于「付了几次查询」。 */
+function countingList(service, calls) {
+  return new Proxy(service, {
+    get(target, prop) {
+      if (prop === "list") {
+        return (query) => {
+          calls.push(query);
+          return target.list(query);
+        };
+      }
+      return Reflect.get(target, prop, target);
+    }
+  });
+}
+
+test("#515：被按下的行占满 LIMIT 200 窗口时，模式扫描不报「没东西可扫」", async () => {
+  const { store, service } = setup(sleepConfig());
+  seedStarvedPatternPool(store, service);
+
+  const seen = [];
+  const ctx = {
+    ...sleepCtx(),
+    llm: {
+      async *stream(options) {
+        const text = options.messages.find((m) => m.role === "user")?.content?.[0]?.text ?? "";
+        // 认清单**形状**（行里带 `| importance=`），不认首行——#501/#493 那批围栏让 user 段以角色声明开头了
+        if (text.includes("| importance=")) seen.push(text);
+        yield { type: "text-delta", index: 0, text: "[]" };
+        yield { type: "finish", reason: { kind: "stop" } };
+      }
+    }
+  };
+  const result = await runSleep(ctx, service, sleepConfig(), ctx.logger, null, null);
+  const patterns = result.phases.patterns;
+
+  assert.notEqual(patterns?.reason, "no memories to scan",
+    `窗口被按下行占满时不该静默跳过，实得 ${JSON.stringify(patterns)}`);
+  // 反向断言：这条才是「真的扫了」的证据——只断上面那句的话，一个「相位整个没跑」
+  // 的实现（连 reason 都不产出）也能过。
+  assert.equal(seen.length, 1, "模式扫描必须真发起了这次 LLM 调用");
+  assert.ok(seen[0].includes("own-1") && seen[0].includes("own-2"), "窗口外的自家行要被重取回来");
+  // 重取只放宽窗口，不放宽判定：被按下的行一条都不许混进提示。
+  assert.ok(!seen[0].includes("paused-"), "被按下的行不该因为重取而混进扫描池");
+  store.close();
+});
+
+test("#515：重取按需——闸门没按下且窗口够用时，仍只付一次有界查询", async () => {
+  const { store, service } = setup(sleepConfig());
+  // 120 条自家行（无闸门）：过滤后的池子 ≥ sleepPatternMinMemories(100)，窗口没被吃掉，
+  // 第二趟不该发生。这一条锁的是「常态仍只付一次有界查询」那半句承诺。
+  for (let i = 0; i < 120; i++) {
+    store.save({ type: "project", title: `m-${i}`, content: `m-${i} 正文`, importance: 3 });
+  }
+  const calls = [];
+  const ctx = sleepCtx();
+  await runSleep(ctx, countingList(service, calls), sleepConfig(), ctx.logger, null, null);
+
+  assert.equal(calls.length, 1, `常态只该取一次，实得 ${calls.length} 次`);
+  assert.equal(calls[0].limit, 200, "常态走的是有界窗口");
+  store.close();
+});
+
+test("#515：窗口跟着配额走——把 sleepPatternMinMemories 配到 200 之上时，常态仍不触发无界重取", async () => {
+  // 这条锁的是我自己差点留下的坑：合法上限是 1000（src/config.js:612），若窗口仍是死的
+  // 200，凡把这个值配到 200 以上的人**每一轮**都会白付一次全表重取，跟闸门按没按下无关。
+  const config = sleepConfig({ sleepPatternMinMemories: 300 });
+  const { store, service } = setup(config);
+  for (let i = 0; i < 400; i++) {
+    store.save({ type: "project", title: `m-${i}`, content: `m-${i} 正文`, importance: 3 });
+  }
+  const calls = [];
+  const ctx = sleepCtx();
+  await runSleep(ctx, countingList(service, calls), config, ctx.logger, null, null);
+
+  assert.equal(calls.length, 1, `窗口够用时不该重取，实得 ${calls.length} 次`);
+  assert.equal(calls[0].limit, 300, "窗口至少等于本次要扫的名额");
+  store.close();
+});
+
+test("#515：窗口饿死时重取一次，且只放宽 limit——三条过滤轴一条不许动", async () => {
+  const { store, service } = setup(sleepConfig());
+  seedStarvedPatternPool(store, service);
+
+  const calls = [];
+  const ctx = sleepCtx();
+  await runSleep(ctx, countingList(service, calls), sleepConfig(), ctx.logger, null, null);
+
+  assert.equal(calls.length, 2, `饿死时补一趟无界重取，实得 ${calls.length} 次`);
+  assert.equal(calls[0].limit, 200);
+  assert.equal(calls[1].limit, null, "重取是不带窗口（store.list 的 limit == null 即无界档）");
+  // 除 limit 之外的口径必须逐字段相同：重取放宽的是窗口，不是判定。
+  assert.deepEqual(
+    { ...calls[0], limit: null },
+    calls[1],
+    "第二趟只能比第一趟少一个窗口，excludeTypes/excludeImported/includeForgotten 都得在"
+  );
+  store.close();
+});
+
 test("睡眠侧：被按下作用域的行不进关系补全的候选池", async () => {
   const { store, service } = setup(sleepConfig());
   const alpha = service.createEntity({ name: "Alpha", type: "project" });
@@ -453,7 +582,7 @@ test("巩固侧：被按下作用域的行不进总览输入——否则会被
     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: "text-delta", index: 0, text: "[]" };
           yield { type: "finish", reason: { kind: "stop" } };
           return;

package/test/serve.test.js

@@ -4,6 +4,8 @@ import { mkdtempSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { createServeRuntime } from "../src/serve.js";
+import { createStore } from "../src/store.js";
+import { createSettings } from "../src/settings.js";
 
 // daemon 装配面锁(test/serve-bin.test.js 另有真子进程 + 多进程共存):
 // in-process 起真 HTTP(port 0,OS 分配),fetch 走 health / 401 / save / search /
@@ -194,3 +196,63 @@ test("serve: 非法 embed provider 拒装配;embed=off 时 semantic 为 null", a
     try { rmSync(dir, { recursive: true, force: true }); } catch { /* 同上 */ }
   }
 });
+
+// --- GET /memory/provenance 的 distillRecords.enabled 门（#509 评审整改）--------
+// 单独立一条 daemon 级用例的理由：standalone 的既有用例是手搭 config 骗过门的，
+// 而 daemon 的 cfg 来自 serve.js 自己装配（原本是最小集，一个 distillRecords 键都没有）
+// ——不测真实装配，就会漏掉「daemon 恒定回功能关了」这一整类回归。
+async function seedFlags(dir, patch) {
+  const seed = createStore(join(dir, "memory.db"));
+  createSettings(seed.db).setFeatureFlags(patch);
+  seed.close();
+}
+
+test("serve: /memory/provenance 跟随面板开关（开着读得到）", async () => {
+  const dir = tmpDir();
+  await seedFlags(dir, { "distillRecords.enabled": true });
+  const rt = await createServeRuntime({ memoryDir: dir, port: 0, embed: "off" });
+  await rt.api.ready;
+  try {
+    const base = `http://127.0.0.1:${rt.api.port}`;
+    const auth = { authorization: `Bearer ${rt.api.token}` };
+    // 先经数据面写一条记忆，再直接落溯源链接与原文（写入面不关心是谁写的）。
+    const saved = await fetch(`${base}/memories`, {
+      method: "POST", headers: { ...auth, "content-type": "application/json" },
+      body: JSON.stringify({ type: "decision", title: "核心决策", content: "选定 SQLite 单文件库", importance: 5 })
+    });
+    const savedBody = await saved.json();
+    const memoryId = savedBody.memory?.id ?? savedBody.id;
+    rt.store.saveMemoryProvenance({ memoryId, sessionId: "s1", seqStart: 10, seqEnd: 11, createdAt: "2026-10-23T00:00:00Z" });
+    rt.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" }
+    ]);
+
+    const res = await fetch(`${base}/memory/provenance?id=${encodeURIComponent(memoryId)}`, { headers: auth });
+    assert.equal(res.status, 200, "面板开着的留存，daemon 必须读得到（serve.js 把开关展开进了 cfg）");
+    const body = await res.json();
+    assert.deepEqual(body.windows[0].records.map((r) => r.text), ["第一句原文", "第二句原文"]);
+  } finally {
+    rt.dispose();
+    try { rmSync(dir, { recursive: true, force: true }); } catch { /* win 文件锁偶发 */ }
+  }
+});
+
+test("serve: 面板从没设过 distillRecords.enabled → daemon 这一面按关处理（409）", async () => {
+  // 残留不对称（写进 docs/DAEMON.md）：只靠 bundle 配置打开、从没在面板点过的用户，
+  // 宿主认、daemon 不认——daemon 结构上看不到宿主的 bundle config。这是已知的那一半，
+  // 不是本用例要修的；这里锁的是「没设过 → 关」这个 fail-closed 方向本身。
+  const dir = tmpDir();
+  const rt = await createServeRuntime({ memoryDir: dir, port: 0, embed: "off" });
+  await rt.api.ready;
+  try {
+    const res = await fetch(`http://127.0.0.1:${rt.api.port}/memory/provenance?id=m1`, {
+      headers: { authorization: `Bearer ${rt.api.token}` }
+    });
+    assert.equal(res.status, 409);
+    assert.deepEqual(await res.json(), { error: "distill-records-disabled" });
+  } finally {
+    rt.dispose();
+    try { rmSync(dir, { recursive: true, force: true }); } catch { /* win 文件锁偶发 */ }
+  }
+});