@modusensus/dsh-mneme 0.9.5 → 0.10.1

package/test/pipeline-nudge.test.js

@@ -37,6 +37,7 @@ import {
   nudgeForProject,
   resolveProjectSessionDir
 } from "../src/pipeline-nudge.js";
+import { createSessionGate } from "../src/session-gate.js";
 
 // 这组测试守的是 M.O. 的**沉淀链**：一条工作流能不能从真实数据里自己长出来。
 // 三条不许越的分界线（见 src/pipeline-nudge.js 文件头），测试逐条守：
@@ -103,6 +104,92 @@ test("多帧 zstd 要逐帧解：只解第一帧会静默丢掉后面的回合",
   });
 });
 
+test("#539：nudge 日志扫描按精确 id 与真实子代理头过滤会话", () => {
+  withDir((dir) => {
+    const sessions = join(dir, "sessions");
+    const manualDir = join(sessions, "ws", "manual");
+    const childDir = join(sessions, "ws", "child");
+    const captainDir = join(sessions, "ws", "captain");
+    mkdirSync(manualDir, { recursive: true });
+    mkdirSync(childDir, { recursive: true });
+    mkdirSync(captainDir, { recursive: true });
+    const privateCall = sessionLine({ turn: 1, calls: [skill("private-skill"), skill("private-next")] });
+    writeFileSync(join(manualDir, "session.v4.jsonl.zstd"), zlib.zstdCompressSync(Buffer.from(privateCall)));
+    const childHeader = JSON.stringify({
+      type: "session",
+      cwd: "C:\\proj",
+      parentSession: "captain",
+      origin: "subagent",
+      delegationDepth: 1
+    });
+    writeFileSync(join(childDir, "session.v4.jsonl.zstd"), zlib.zstdCompressSync(Buffer.from(`${childHeader}\n${privateCall}`)));
+    const publicCall = sessionLine({ turn: 1, calls: [skill("public-skill"), skill("public-next")] });
+    const captainHeader = JSON.stringify({ type: "session", cwd: "C:\\proj", origin: "main", delegationDepth: 0 });
+    writeFileSync(join(captainDir, "session.v4.jsonl.zstd"), zlib.zstdCompressSync(Buffer.from(`${captainHeader}\n${publicCall}`)));
+    // 只带 parentSession 的会话 = sessions.fork() 出来的主会话分支，不是子代理。
+    // 本机 641 个真实会话头里这样的有 3 个（各 74–136 条用户消息），把它们当子代理
+    // 过滤掉就是「fork 一下就失忆」。
+    const forkedDir = join(sessions, "ws", "forked");
+    mkdirSync(forkedDir, { recursive: true });
+    const forkedHeader = JSON.stringify({
+      type: "session",
+      version: 4,
+      cwd: "C:\\proj",
+      parentSession: "captain",
+      isSeeded: true,
+      delegationDepth: 0
+    });
+    const forkedCall = sessionLine({ turn: 1, calls: [skill("forked-skill"), skill("forked-next")] });
+    writeFileSync(join(forkedDir, "session.v4.jsonl.zstd"), zlib.zstdCompressSync(Buffer.from(`${forkedHeader}\n${forkedCall}`)));
+
+    const gate = createSessionGate({
+      sessionGateEnabled: true,
+      sessionGateSubagents: true,
+      sessionGateSessions: ["manual"]
+    });
+    const read = readSessionObservations({ sessionDir: sessions, sessionGate: gate });
+    assert.deepEqual([...new Set(read.observations.map((item) => item.sessionId))], ["captain", "forked"]);
+    assert.ok(!read.observations.some((item) => item.name.startsWith("private")));
+    assert.ok(read.observations.some((item) => item.name === "forked-skill"), "a forked captain session keeps its observations");
+
+    const disabled = createSessionGate({ sessionGateEnabled: false, sessionGateSessions: ["manual"] });
+    const unchanged = readSessionObservations({ sessionDir: sessions, sessionGate: disabled });
+    assert.ok(unchanged.observations.some((item) => item.sessionId === "manual"), "master-off keeps existing scan behavior");
+  });
+});
+
+// 形状锁：只有首行是 {"type":"session",...} 时才把整行当作会话头。
+// 旧实现的兜底链末尾是 `?? row?.data?.header ?? row?.data?.config ?? row?.data ?? row`，
+// 等于**任何**首行都能被当成 header。这不只是「会不会漏」的问题：一条非会话记录
+// 里只要出现 `origin` / `delegationDepth`，就会被读成一条子代理头，把这个**正常
+// 会话**的观测从扫描结果里整批划掉——M.O. 的提议因此静默少掉一块数据，而现场
+// 回头看日志时那条会话明明在。本机 641 个真实会话首行的 `type` 全部是
+// "session"（v3/v4 都是头字段直接躺在首行顶层），先认 `type` 不漏任何真实会话；
+// 认不出来时返回 null、退回只按 id 判——**宁可少认一条头，也不要凭空造一个头**。
+test("#539：非 session 首行不许把委派标记带进闸门", () => {
+  withDir((dir) => {
+    const sessions = join(dir, "sessions");
+    const captainDir = join(sessions, "ws", "captain");
+    mkdirSync(captainDir, { recursive: true });
+    const call = sessionLine({ turn: 1, calls: [skill("captain-skill")] });
+    // 首行是一条 permission/preset 记录，且 data 里带着委派标记——这一帧里
+    // 根本没有会话头，那两个字只是某条普通记录的字段。
+    const preset = JSON.stringify({ type: "permission/preset", seq: 0, time: 1, data: { origin: "subagent", delegationDepth: 1 } });
+    writeFileSync(join(captainDir, "session.v4.jsonl.zstd"), zlib.zstdCompressSync(Buffer.from(`${preset}\n${call}`)));
+
+    const automatic = createSessionGate({ sessionGateEnabled: true, sessionGateSubagents: true });
+    const read = readSessionObservations({ sessionDir: sessions, sessionGate: automatic });
+    assert.ok(
+      read.observations.some((item) => item.name === "captain-skill"),
+      "首行认不出头时不许凭它的字段判子代理——按 id 判、放行"
+    );
+
+    const manual = createSessionGate({ sessionGateEnabled: true, sessionGateSessions: ["captain"] });
+    const filtered = readSessionObservations({ sessionDir: sessions, sessionGate: manual });
+    assert.equal(filtered.observations.length, 0, "手动名单仍然按目录名里的精确 id 生效");
+  });
+});
+
 test("截断帧：半行被丢掉，不抛错、也不把半行当成一条记录", () => {
   withDir((dir) => {
     const sessions = join(dir, "sessions");

package/test/pipeline-runner.test.js

@@ -5,6 +5,7 @@ import { writeFileSync, rmSync } from "node:fs";
 import { join } from "node:path";
 import { createExecutionRecorder, projectRootOf, MAX_BUFFERED_EVENTS } from "../src/pipeline-runner.js";
 import { validatePipeline } from "../src/pipeline.js";
+import { createSessionGate } from "../src/session-gate.js";
 
 // 这组测试守的是串联层：把「事件 → 观察 → 归属 → 窗口 → 落盘」串起来的那一层。
 // 它最要紧的两条性质：
@@ -61,6 +62,31 @@ test("没开窗时一个字都不记：事件到了也不缓冲（这是整个
   assert.equal(rec.stop({ session }).reason, "no-open-window");
 });
 
+test("#539：无痕会话不开始、缓冲或结算执行记录", () => {
+  const f = fakeCtx();
+  const config = { sessionGateEnabled: false, sessionGateSessions: ["s-private"] };
+  const gate = createSessionGate(config);
+  let writes = 0;
+  const rec = createExecutionRecorder({
+    ctx: f.ctx,
+    sessionGate: gate,
+    resolvePipeline: () => PIPE,
+    persistRun: () => { writes += 1; }
+  });
+  const session = { id: "s-private", header: { cwd: "C:\\proj" } };
+
+  assert.equal(rec.start({ session, pipelineId: "demo" }).ok, true);
+  for (const event of callAndResult("npm test")) f.emit(session, event);
+  assert.equal(rec.stop({ session }).state, "awaiting-confirmation");
+
+  config.sessionGateEnabled = true;
+  assert.equal(rec.status({ session }).incognito, true);
+  assert.equal(rec.confirm({ session, answers: { P6: "done" } }).reason, "session-incognito");
+  config.sessionGateEnabled = false;
+  assert.deepEqual(rec.status({ session }), { open: false }, "gating discards both buffered and pending session data");
+  assert.equal(writes, 0, "incognito observation never reaches persistent run storage");
+});
+
 test("开窗 → 走一遍 → 结账：产出并落盘一条账", () => {
   const f = fakeCtx();
   let written = null;

package/test/prompt-stance.test.js

@@ -0,0 +1,128 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { STR } from "../src/lang.js";
+import { createStore } from "../src/store.js";
+import { createService } from "../src/service.js";
+import { createDreamScheduler } from "../src/dream.js";
+
+// 防谄媚的**提示词侧**回归锁。
+//
+// 背景：#380 的注入前判定（pre-inject-gate）只拦「已落库的意见/立场」，而落到库里
+// 之前的两个写作环节——蒸馏（summary / codingSummary）与总览叙述（dreamSummary）
+// ——此前对谄媚内容一字未提。这两个环节写出的内容**完全不过** writeAdmission
+// （write-admission.js 只在带 sessionKey 的 memory_save 路径生效），所以提示词是
+// 唯一能施加约束的地方，本轮把「立场纪律 / 叙述纪律」写进字面量（Issue #530）。
+//
+// 这些用例锁的是**形状**（提示词里有没有这条约束、位置对不对），锁不了**行为**
+// （模型是否真的照做）——后者要 LLM 在环 + 预注册判据，属 E12 那类实验，不在单测里
+// 宣称。PR 与 CHANGELOG 不得把本文件写成「已知降低谄媚率」。
+
+const LANGS = ["zh", "en"];
+
+// 五组判据在两种语言里的对应词。写成「中英成对」是刻意的：少一种语言就等于
+// 换语言的用户拿到一份没有防线的提示词（同 lang.test.js 对 profileExtract 的锁法）。
+const STANCE_PATTERNS = [
+  [/立场纪律|Stance discipline/, "立场纪律小节本身"],
+  [/不要记录对用户本人|Never record evaluations of the user/, "规则 a：不记对用户本人的性格/能力/情绪评价"],
+  [/可信度不同|differ in trustworthiness/, "规则 b：转录三种角色可信度不同"],
+  [/事实归属以用户陈述为准|the user statement wins on the facts/, "规则 c：事实归属不记成助手推断"],
+  [/如实并存|keep both sides/, "规则 c：两种说法并存，不写成谁对谁错"],
+  [/不是提高 importance 的理由|never a reason to raise it/, "规则 d：赞许不抬 importance"],
+];
+
+for (const key of ["summary", "codingSummary"]) {
+  test(`${key} 提示词带完整立场纪律（中英成对）`, () => {
+    for (const lang of LANGS) {
+      const text = STR.prompts[key][lang];
+      for (const [re, label] of STANCE_PATTERNS) {
+        assert.match(text, re, `${key}.${lang} 缺少${label}`);
+      }
+    }
+  });
+}
+
+test("立场纪律排在任何 JSON 输出形状之前，不会被后置的时间锚点覆盖", () => {
+  // summarize.js 在提示词**之后**再拼 STR.distillTimeAnchor（「据此换算 occurred_at」）。
+  // 规则若排在那句之后，就成了「先按时间换算、再谈记什么」——指令优先级反了。
+  // 同时它必须排在 schema 行之前：schema 是输出形状，纪律是内容判据，形状压不住判据。
+  for (const key of ["summary", "codingSummary"]) {
+    for (const lang of LANGS) {
+      const text = STR.prompts[key][lang];
+      const stance = text.search(/立场纪律|Stance discipline/);
+      assert.ok(stance > 0, `${key}.${lang}: 立场纪律必须存在于提示词字面量内部`);
+      assert.ok(stance < text.search(/occurred_at|occurred_at/), `${key}.${lang}: 立场纪律必须在 occurred_at 说明之前`);
+      assert.ok(stance < text.search(/只输出 JSON 数组|Output only a JSON array/), `${key}.${lang}: 立场纪律必须在输出形状之前`);
+      assert.ok(text.indexOf("立场纪律") < 0 || stance > text.indexOf("原子记忆原则") - 1,
+        `${key}.${lang}: 立场纪律要跟在原子记忆原则之后，别抢掉开头角色句`);
+    }
+  }
+});
+
+test("工具/报错结论的豁免条款必须在场（删掉它会误杀 pitfall 与 constraint）", () => {
+  // 规则 b 说「助手的结论是推断」，但编码类记忆（pitfall / rejected_solution /
+  // constraint）的内容本来就是工具输出与报错直接给出的技术结论。没有这半句豁免，
+  // 规则 b 会把整个编码回溯功能一并否掉——这是最容易被后人顺手删掉的高危句。
+  for (const lang of LANGS) {
+    const text = STR.prompts.summary[lang];
+    assert.match(text, /工具输出、报错、命令结果|tool output, errors or command results/,
+      `summary.${lang}: 工具结论豁免条款缺失，规则 b 会误杀 pitfall/constraint`);
+  }
+});
+
+test("dreamSummary 带叙述纪律，且散文契约不被破坏", () => {
+  for (const lang of LANGS) {
+    const text = STR.prompts.dreamSummary[lang];
+    assert.match(text, /叙述纪律|Narrative discipline/, `dreamSummary.${lang}: 缺叙述纪律`);
+    assert.match(text, /不要给用户添上|add no characterisation/, `dreamSummary.${lang}: 缺「不给用户添性格评价」`);
+    // 总览是**散文**契约：dream-fence 那条锁要求这里绝不能出现「JSON 数组」，
+    // 否则模型会按数组契约回 `[]`，而 summaryText.trim() 判非空通过，`[]` 就
+    // 被当成摘要存进库（dream.js:326-328 的注释记着这次评审实测）。
+    assert.doesNotMatch(text, /JSON 数组|JSON array/, `dreamSummary.${lang}: 散文契约里不得出现 JSON 数组`);
+    // 硬输出格式锁必须留在末尾，它是「只回叙述文本」的唯一保证。
+    assert.match(lang === "zh" ? text : text, /只输出叙述文本，不要其他内容。|Output only the narrative text, nothing else./,
+      `dreamSummary.${lang}: 末尾输出格式锁丢了`);
+  }
+});
+
+// 下面这条是**输出侧**的接线锁：提示词改了，落库判据不能跟着变。
+// 空字符串仍必须判为「没有摘要」（degraded/noop），不能被新文案带成「存了个空叙述」。
+test("总览落库判据不因提示词改动而放宽", async () => {
+  function mockCtx({ summaryText }) {
+    return {
+      logger: { warn: () => {} },
+      agentDefaultModel: { currentSelection: () => ({ provider: "mock", model: "mock-model" }) },
+      llm: {
+        async *stream(options) {
+          const userText = options.messages.find((m) => m.role === "user")?.content?.[0]?.text ?? "";
+          if (userText.includes("| type=")) {
+            yield { type: "block-start", index: 0, blockType: "text" };
+            yield { type: "text-delta", index: 0, text: "[]" };
+            yield { type: "block-end", index: 0, block: { type: "text" } };
+            yield { type: "finish", reason: { kind: "stop" } };
+            return;
+          }
+          yield { type: "text-delta", index: 0, text: summaryText };
+          yield { type: "finish", reason: { kind: "stop" } };
+        }
+      }
+    };
+  }
+
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config: {} });
+  const dream = createDreamScheduler({ onRun: () => Promise.resolve({ ok: true, skipped: true }) });
+  service.saveWithDedupe({ type: "preference", title: "语言", content: "中文", importance: 3 });
+
+  const ok = await dream.runDream(mockCtx({ summaryText: "记忆库总览：用户偏好中文。" }), service, {});
+  assert.equal(ok.summary, true, "非空叙述照常落库");
+  const row = service.all().find((m) => m.type === "summary");
+  assert.ok(row, "总览行必须存在");
+  assert.equal(row.source, "dream");
+  assert.equal(row.importance, 5, "总览行的 importance 固定 5（最高注入档）");
+
+  const empty = await dream.runDream(mockCtx({ summaryText: "" }), service, {});
+  assert.equal(empty.summary, false, "空叙述不得落库");
+  const rows = service.all().filter((m) => m.type === "summary");
+  assert.equal(rows.length, 1, "旧总览存活，没有被空叙述覆盖");
+  store.close();
+});

package/test/provenance-http.test.js

@@ -16,12 +16,19 @@ import { dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import {
   DISTILL_RECORDS_DISABLED,
+  PROVENANCE_DEFAULT_WINDOWS,
+  PROVENANCE_MAX_WINDOWS,
   PROVENANCE_UNAVAILABLE,
   isDistillRecordsEnabled,
-  parseProvenanceQuery,
+  parseProvenanceLimit,
+  parseProvenanceSelector,
   provenanceReply
 } from "../src/provenance-http.js";
 
+// 方向 1 的选择器：绝大多数用例只关心「读出去的那一侧」，方向本身用这个常量固定。
+const MEM = { mode: "memory", memoryId: "m1", limit: PROVENANCE_DEFAULT_WINDOWS };
+const SES = { mode: "session", sessionId: "s1", limit: PROVENANCE_DEFAULT_WINDOWS };
+
 const ROOT = resolve(dirname(fileURLToPath(import.meta.url)), "..");
 
 // 开着开关的 cfg：这个端点返回蒸馏窗口的逐字原文，所以测试里的「正常路径」必须
@@ -31,19 +38,73 @@ const RECORDS_ON = { distillRecords: { enabled: true } };
 function fakeService(over = {}) {
   return {
     provenanceFor: (id) => over.links ?? [],
+    // #524 方向 2 的存储读法：按会话列窗口（store 侧 GROUP BY 成一行一窗口）。
+    distillWindowsFor: (sessionId, limit) => over.windows ?? [],
     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)} 不该通过`);
+// --- 入参：两个互斥主键 + limit（#524）---------------------------------------
+// 方向 2 复用同一条路径，于是「哪个主键说了算」必须是个**显式**判断：都缺是请求
+// 不成立（400 missing-id），都给也要 400——择一意味着调用方发一个自己也不知道会
+// 读哪个主键的请求，而两个方向的结果形状不同（memoryId / sessionId 各有自己的键）。
+
+test("parseProvenanceSelector：两个主键都缺 → 400 missing-id", () => {
+  for (const params of [
+    {}, { memoryId: null, sessionId: null }, { memoryId: "", sessionId: "" },
+    { memoryId: "   ", sessionId: "\t" }
+  ]) {
+    const r = parseProvenanceSelector(params);
+    assert.equal(r.ok, false, `${JSON.stringify(params)} 不该通过`);
     assert.equal(r.status, 400);
     assert.equal(r.error, "missing-id");
   }
-  assert.deepEqual(parseProvenanceQuery(" m1 "), { ok: true, id: "m1" }, "id 两端空白要裁掉");
+});
+
+test("parseProvenanceSelector：两个主键都给 → 400 ambiguous-id（不静默择一）", () => {
+  const r = parseProvenanceSelector({ memoryId: "m1", sessionId: "s1" });
+  assert.equal(r.ok, false);
+  assert.equal(r.status, 400);
+  assert.equal(r.error, "ambiguous-id");
+});
+
+test("parseProvenanceSelector：两端空白裁掉，方向按哪个主键非空确定，limit 缺省 20", () => {
+  assert.deepEqual(parseProvenanceSelector({ memoryId: " m1 " }), {
+    ok: true,
+    selector: { mode: "memory", memoryId: "m1", limit: PROVENANCE_DEFAULT_WINDOWS }
+  });
+  assert.deepEqual(parseProvenanceSelector({ sessionId: " s1 ", memoryId: "  " }), {
+    ok: true,
+    selector: { mode: "session", sessionId: "s1", limit: PROVENANCE_DEFAULT_WINDOWS }
+  }, "另一侧是空白串时按缺省处理，不算「都给」");
+});
+
+test("parseProvenanceLimit：只收十进制整数字面量，畸形与越界都算 400", () => {
+  assert.equal(parseProvenanceLimit(null).limit, PROVENANCE_DEFAULT_WINDOWS, "不带就是缺省");
+  assert.equal(parseProvenanceLimit("1").limit, 1);
+  assert.equal(parseProvenanceLimit(String(PROVENANCE_MAX_WINDOWS)).limit, PROVENANCE_MAX_WINDOWS);
+  // 两端空白是**裁掉**而不是判畸形——与 id 的处理保持一致（"  12 " 就是 12）。
+  // 但裁完必须是纯十进制字面量。
+  assert.equal(parseProvenanceLimit(" 12 ").limit, 12, "两端空白裁掉，与 id 一致");
+  // 下面这些如果走 Number()，"" / " " 会化成 0 个窗口，十六进制与指数写法也会被
+  // 静默接受——一个畸形输入拿到最坏解释。所以这里逐个钉住。
+  for (const raw of [
+    "", "   ", "0", "-1", "1.5", "1e3", "0x10", "abc", "+1", "12abc",
+    String(PROVENANCE_MAX_WINDOWS + 1), "99999999999999999999"
+  ]) {
+    const r = parseProvenanceLimit(raw);
+    assert.equal(r.ok, false, `${JSON.stringify(raw)} 不该通过`);
+    assert.equal(r.status, 400);
+    assert.equal(r.error, "invalid-limit");
+  }
+});
+
+test("parseProvenanceSelector：limit 畸形时连着主键一起 400（入参形状先于功能开关）", () => {
+  const r = parseProvenanceSelector({ sessionId: "s1", limit: "abc" });
+  assert.equal(r.ok, false);
+  assert.equal(r.status, 400);
+  assert.equal(r.error, "invalid-limit");
 });
 
 test("provenanceReply：一个链接一个窗口，原文按 seq 升序且不越界", () => {
@@ -55,7 +116,7 @@ test("provenanceReply：一个链接一个窗口，原文按 seq 升序且不越
       return [{ seq: 12 }, { seq: 10 }, { seq: 11 }];
     }
   };
-  const r = provenanceReply({ service, id: "m1", config: RECORDS_ON });
+  const r = provenanceReply({ service, selector: MEM, config: RECORDS_ON });
   assert.equal(r.status, 200);
   assert.equal(r.body.memoryId, "m1");
   assert.equal(r.body.windows.length, 1);
@@ -68,15 +129,57 @@ test("provenanceReply：一个链接一个窗口，原文按 seq 升序且不越
   assert.deepEqual(seen, [["s1", 10, 12]], "区间原样透传给 store");
 });
 
+test("provenanceReply #512：窗口带得动归属的那一轮 run，读不到就整组缺省而不是猜", () => {
+  const runs = new Map([["r1", { run_type: "autoSummarize", trigger_source: "autoSummarize", status: "ok" }]]);
+  const service = {
+    provenanceFor: () => [
+      { session_id: "s1", seq_start: 10, seq_end: 12, created_at: "2026-11-02T00:00:00Z", distill_run_id: "r1" },
+      // 改造之前写下的链接：distill_run_id 是 NULL。
+      { session_id: "s1", seq_start: 20, seq_end: 22, created_at: "2026-09-01T00:00:00Z", distill_run_id: null }
+    ],
+    distillRecordsFor: () => [],
+    getDistillRun: (id) => runs.get(id),
+    mintsFor: () => [{ run_id: "d1", run_type: "dream", trigger_source: "autoDream", created_at: "2026-11-01T00:00:00Z" }]
+  };
+  const r = provenanceReply({ service, selector: MEM, config: RECORDS_ON });
+  assert.equal(r.status, 200);
+  const [fresh, legacy] = r.body.windows;
+  assert.equal(fresh.distill_run_id, "r1");
+  assert.equal(fresh.run_type, "autoSummarize");
+  assert.equal(fresh.trigger_source, "autoSummarize");
+  assert.equal(fresh.run_status, "ok");
+  // 历史链接：id 为 null，三个派生字段也必须是 null——不许拿区间或时间戳反推一轮。
+  assert.equal(legacy.distill_run_id, null);
+  assert.equal(legacy.run_type, null, "没有 run 就不给类型，否则等于替用户编了一次归因");
+  assert.equal(legacy.trigger_source, null);
+  assert.equal(legacy.run_status, null);
+  assert.equal(r.body.mints.length, 1);
+  assert.equal(r.body.mints[0].run_type, "dream");
+});
+
+test("provenanceReply #512：service 没有 run 读取能力时，窗口字段照旧齐全但归因为空", () => {
+  // headless / 旧装配：provenanceFor 与 distillRecordsFor 在，getDistillRun / mintsFor 不在。
+  const service = {
+    provenanceFor: () => [{ session_id: "s1", seq_start: 1, seq_end: 2, created_at: "2026-11-02T00:00:00Z", distill_run_id: "r9" }],
+    distillRecordsFor: () => []
+  };
+  const r = provenanceReply({ service, selector: MEM, config: RECORDS_ON });
+  assert.equal(r.status, 200, "读 run 的能力缺一档不算装配坏——窗口本身仍可读");
+  assert.equal(r.body.windows[0].distill_run_id, "r9");
+  assert.equal(r.body.windows[0].run_type, null);
+  assert.deepEqual(r.body.mints, []);
+});
+
 test("provenanceReply：没有链接是有效答案——空 windows，200 不是 404", () => {
-  const r = provenanceReply({ service: fakeService(), id: "m1", config: RECORDS_ON });
+  const r = provenanceReply({ service: fakeService(), selector: MEM, config: RECORDS_ON });
   assert.equal(r.status, 200);
-  assert.deepEqual(r.body, { memoryId: "m1", windows: [] });
+  // #524 的 truncated 与 #512 的 mints 都是答复级读数，各自独立缺省。
+  assert.deepEqual(r.body, { memoryId: "m1", windows: [], truncated: false, mints: [] });
 });
 
 test("provenanceReply：方法没接线是装配坏了——503，不与「没有来源」混为一个读数", () => {
   // headless / 旧装配：service 上没有这两个方法。
-  const r = provenanceReply({ service: {}, id: "m1", config: RECORDS_ON });
+  const r = provenanceReply({ service: {}, selector: MEM, config: RECORDS_ON });
   assert.equal(r.status, 503);
   assert.equal(r.body.error, PROVENANCE_UNAVAILABLE);
 });
@@ -87,7 +190,7 @@ test("provenanceReply：读抛错只 warn 并回 500，不把异常漏给调用
     provenanceFor: () => { throw new Error("db locked"); },
     distillRecordsFor: () => []
   };
-  const r = provenanceReply({ service, id: "m1", config: RECORDS_ON, warn: (m) => warnings.push(m) });
+  const r = provenanceReply({ service, selector: MEM, config: RECORDS_ON, warn: (m) => warnings.push(m) });
   assert.equal(r.status, 500);
   assert.equal(r.body.error, "internal");
   assert.equal(warnings.length, 1, "失败要留痕");
@@ -114,7 +217,7 @@ test("isDistillRecordsEnabled：只认严格的 true，其余一律算关（fail
 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 });
+    const r = provenanceReply({ service: fakeService(), selector: MEM, config: cfg });
     assert.equal(r.status, 409, `${JSON.stringify(cfg)} → 409`);
     assert.deepEqual(r.body, { error: DISTILL_RECORDS_DISABLED },
       "body 只准有 error 一个键——不带 memoryId / windows，调用方不会把「功能关了」读成「这条记忆没有来源」");
@@ -123,7 +226,7 @@ test("provenanceReply：开关没开 → 409 distill-records-disabled，一个
 
 test("provenanceReply：409 赢 503——「用户关了」比「装配坏了」更具体", () => {
   // 关着 + service 上连方法都没有：报 503 会让人去查一个没坏的部署。
-  const r = provenanceReply({ service: {}, id: "m1", config: { distillRecords: { enabled: false } } });
+  const r = provenanceReply({ service: {}, selector: MEM, config: { distillRecords: { enabled: false } } });
   assert.equal(r.status, 409);
   assert.equal(r.body.error, DISTILL_RECORDS_DISABLED);
 });
@@ -135,20 +238,100 @@ test("provenanceReply：开关关着时一次 SQL 都不发（不碰 service）"
     provenanceFor: () => { touched++; return []; },
     distillRecordsFor: () => { touched++; return []; }
   } });
-  provenanceReply({ service, id: "m1", config: null });
+  provenanceReply({ service, selector: MEM, 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 });
+  const on = provenanceReply({ service, selector: MEM, 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 } } });
+  const off = provenanceReply({ service, selector: MEM, config: { distillRecords: { enabled: false } } });
   assert.equal(off.status, 409);
   assert.deepEqual(off.body, { error: DISTILL_RECORDS_DISABLED });
 });
 
+// --- 方向 2：会话 → 窗口（#524）--------------------------------------------
+
+test("provenanceReply（session 方向）：一行一窗口，原文按区间取，答复带 sessionId", () => {
+  const asked = [];
+  const service = {
+    distillWindowsFor: (sid, limit) => {
+      asked.push([sid, limit]);
+      return [
+        { session_id: "s1", seq_start: 5, seq_end: 9, created_at: "t2", link_count: 2 },
+        { session_id: "s1", seq_start: 1, seq_end: 4, created_at: "t1", link_count: 1 }
+      ];
+    },
+    distillRecordsFor: (sid, from, to) => [{ seq: from }, { seq: to }]
+  };
+  const r = provenanceReply({ service, selector: SES, config: RECORDS_ON });
+  assert.equal(r.status, 200);
+  assert.equal(r.body.sessionId, "s1", "session 方向的答复用 sessionId 认领，不冒充 memoryId");
+  assert.equal(r.body.truncated, false);
+  assert.deepEqual(r.body.windows.map((w) => [w.seq_start, w.seq_end]), [[5, 9], [1, 4]],
+    "次序由 store 的 ORDER BY seq_start 保证，答复层不改序");
+  assert.deepEqual(r.body.windows[0].records.map((x) => x.seq), [5, 9], "每个窗口装自己区间的原文");
+  assert.equal(r.body.windows[0].link_count, 2, "同一窗口派生了 2 条记忆——这个计数是「按窗口看」的第二维");
+  // 多取一行判截断：store 侧只照 limit 取，不替调用方判断「还有没有」。
+  assert.deepEqual(asked, [["s1", PROVENANCE_DEFAULT_WINDOWS + 1]]);
+});
+
+test("provenanceReply：撞上 limit 时 truncated=true，且多出来的那条不许漏出去", () => {
+  // 少了这个读数，被截断的答复与「本来就只有这么多」逐字节相同——调用方会把半份
+  // 转录当成全部，这正是这张脸最容易骗人的地方。
+  const service = {
+    distillWindowsFor: () => [1, 2, 3].map((n) => ({
+      session_id: "s1", seq_start: n, seq_end: n, created_at: "t", link_count: 1
+    })),
+    distillRecordsFor: () => []
+  };
+  const r = provenanceReply({ service, selector: { ...SES, limit: 2 }, config: RECORDS_ON });
+  assert.equal(r.status, 200);
+  assert.equal(r.body.truncated, true);
+  assert.equal(r.body.windows.length, 2, "limit=2 就只许回 2 个窗口，探针那一条不能混进答复");
+});
+
+test("provenanceReply：memory 方向也带 truncated（两个方向共一个读数）", () => {
+  const service = {
+    provenanceFor: () => [1, 2].map((n) => ({
+      session_id: "s1", seq_start: n, seq_end: n, created_at: "t"
+    })),
+    distillRecordsFor: () => []
+  };
+  const r = provenanceReply({ service, selector: { ...MEM, limit: 1 }, config: RECORDS_ON });
+  assert.equal(r.status, 200);
+  assert.equal(r.body.truncated, true);
+  assert.equal(r.body.windows.length, 1);
+  assert.equal(r.body.memoryId, "m1");
+});
+
+test("provenanceReply：503 按方向判——只缺 session 那侧的方法时，memory 查询照旧 200", () => {
+  // 把一个方向的问题报成整张脸坏了，会让人去查一个没坏的部署。
+  const onlyMemory = {
+    provenanceFor: () => [],
+    distillRecordsFor: () => []
+  };
+  const ses = provenanceReply({ service: onlyMemory, selector: SES, config: RECORDS_ON });
+  assert.equal(ses.status, 503);
+  assert.equal(ses.body.error, PROVENANCE_UNAVAILABLE);
+  const mem = provenanceReply({ service: onlyMemory, selector: MEM, config: RECORDS_ON });
+  assert.equal(mem.status, 200, "缺的只是方向 2 的方法，方向 1 不该跟着坏");
+});
+
+test("provenanceReply：开关关着时 session 方向也 409，且一次 SQL 都不发", () => {
+  let touched = 0;
+  const service = {
+    distillWindowsFor: () => { touched++; return []; },
+    distillRecordsFor: () => { touched++; return []; }
+  };
+  const r = provenanceReply({ service, selector: SES, config: { distillRecords: { enabled: false } } });
+  assert.equal(r.status, 409);
+  assert.deepEqual(r.body, { error: DISTILL_RECORDS_DISABLED }, "方向不同，门是同一把");
+  assert.equal(touched, 0);
+});
+
 test("🔴 静态锁：口径字面量与共用答复只许出现在本模块，两个入口都要真的走它", () => {
   // #509 第一版把整段复制到了两张皮各一份——本仓 #411 之后不收这个形状。
   for (const name of ["api.js", "api-standalone.js"]) {
@@ -162,7 +345,7 @@ test("🔴 静态锁：口径字面量与共用答复只许出现在本模块，
     assert.ok(!src.includes("distillRecords?.enabled === true"),
       `src/${name} 不准自己写开关判据——只许把 config 转交给共用模块`);
     // 而且要真的转交了：壳里调 provenanceReply 时必须带上 config。
-    assert.match(src, /provenanceReply\(\{ service, id: parsed\.id, config,/,
+    assert.match(src, /provenanceReply\(\{ service, selector: parsed\.selector, config,/,
       `src/${name} 要把本入口的 config 传给共用模块，否则门永远读不到用户的开关`);
   }
 });

package/test/release-docs.test.js

@@ -51,7 +51,13 @@ test("根 README 的两段式路线图能插进新 minor 占位行（旧实现
 test("真实根 README 的中英两张路线图各插一行（同一版本号，不能只插一张）", () => {
   // 两张表版本行完全一样，旧实现把全文件版本行合成一个数组判断「已存在」，
   // 于是先插的中文表会让英文表被跳过——英文读者永远等不到那一行。
-  const { actions } = syncReadmeTables(rootReadme, "0.10.0", "2026-11-01");
+  //
+  // 目标版本**不能写死**：写死当次要发的版本，这条用例在 release-prep 分支上必红——那一行
+  // 恰好已经由发版准备脚本插进去了，「各插一行」于是退化成零插入。取比现存的最高 major 再高一档，
+  // 断言就与「这次发的是哪一版」彻底无关，也不会在下一个 minor 上重新长成定时炸弹。
+  const maxMajor = Math.max(...scanReleaseRows(rootReadme).two.map((r) => Number(r.ver.split(".")[0])));
+  const target = `${maxMajor + 1}.0`;
+  const { actions } = syncReadmeTables(rootReadme, target, "2026-11-01");
   const inserts = actions.filter((a) => a.kind === "insert");
   assert.equal(inserts.length, 2, "中英路线图各一行，实际：" + JSON.stringify(actions));
 });

package/test/security-doc.test.js

@@ -104,10 +104,22 @@ function routesInBullet(line) {
   return out;
 }
 
-function bullet(prefix) {
-  const line = doc.split(/\r?\n/).find((l) => l.startsWith(prefix));
-  assert.ok(line, `SECURITY.md 里应有以「${prefix}」开头的清单行`);
-  return routesInBullet(line);
+// 清单行必须**恰好一条**。原先用 .find() 只读第一条命中，于是「同一条目出现两份」
+// 这件事守卫完全无感：#509 的 merge 把两份 Open reads / Gated routes 一起解进来，
+// 其中一份 stale（少 /memory/provenance），CI 却全绿——因为 .find() 读的是第一份。
+// 「文档与代码平价」的全部信心都来自这个文件，一旦它对重复条目零感知，第二份就是没有守卫的谎话。
+// 所以这里先收全部命中，再判唯一；多于一条时把行号报出来，避免变成「哪份算数」的新谜题。
+// source 参数只为可测：守卫本身是「唯一性」，喂一份合成的重复文档就能验，不必真去改 SECURITY.md。
+function bullet(prefix, source = doc) {
+  const hits = [];
+  source.split(/\r?\n/).forEach((line, i) => {
+    if (line.startsWith(prefix)) hits.push({ line, no: i + 1 });
+  });
+  assert.ok(hits.length > 0, `SECURITY.md 里应有以「${prefix}」开头的清单行`);
+  assert.equal(hits.length, 1,
+    `SECURITY.md 里以「${prefix}」开头的清单行必须恰好一条，实际 ${hits.length} 条（行号 ${hits.map((h) => h.no).join(", ")}）。` +
+    "清单只许有一份：多出来的那份不会被本文件校验，改它不会红，只能靠删掉来保持平价。");
+  return routesInBullet(hits[0].line);
 }
 
 // 文档里的 /semantic/graph/* 覆盖代码里的 /semantic/graph/ego 与 /semantic/graph/entity-attrs。
@@ -137,3 +149,30 @@ test("SECURITY.md 的受门控清单与代码里的 policy 声明一致", () =>
     assert.deepEqual(stale, [], `${prefix} 写了代码里并不受门控的路由：${stale.join(", ")}`);
   }
 });
+
+// 上面那条唯一性断言本身要有回归：把 SECURITY.md 的清单行复制成两份必须红。
+// 这条用例喂合成文档，不碰真文件——真文件的平价由上面两条双向比对负责。
+// 变异自证（人工做过一次，记录在 PR 里）：把 Gated routes 那一行原样复制一份 → 红；
+// 复制成两份且第二份把 /memory/provenance 换成别的 → 也红。两种都只在「恰好一条」上红。
+test("重复的清单行会被守卫抓住（#523）", () => {
+  const gated = doc.split(/\r?\n/).find((l) => l.startsWith("- **Gated routes"));
+  assert.ok(gated, "SECURITY.md 里应有 Gated routes 清单行");
+
+  const withDup = ["# synthetic", gated, gated].join("\n");
+  assert.throws(
+    () => bullet("- **Gated routes", withDup),
+    /必须恰好一条，实际 2 条（行号 2, 3）/,
+    "同一清单行出现两份时必须报出重复的行号——这正是 #509 merge 时守卫看不见的形状"
+  );
+
+  // 内容不同的两份同样要红：危险的不是写错了什么，而是那份副本对守卫隐形。
+  const staleDup = ["# synthetic", gated, gated.replace("/memory/provenance", "/memory/provenance-OLD")].join("\n");
+  assert.throws(
+    () => bullet("- **Gated routes", staleDup),
+    /必须恰好一条，实际 2 条/,
+    "两份内容不同的清单同样必须红，否则陈旧副本可以一直过期"
+  );
+
+  // 只有一份时不能误伤。
+  assert.ok(bullet("- **Gated routes", gated).length > 0);
+});