@modusensus/dsh-mneme 0.9.5 → 0.10.1

package/src/summarize.js

@@ -6,6 +6,12 @@ import { STR, langOf } from "./lang.js";
 import { withEffortFallback, describeStreamFailure, EFFORT_REJECT_RE } from "./dream.js";
 // v0.9.0（M.O. 项目记忆）：蒸馏写入复用工具路径那把作用域解析器，见 createSummarizer。
 import { createScopeResolver } from "./scope.js";
+// #493 补充 §③：断链与巩固侧同一份实现（src/fence.js）。转录里出现闭合标记时
+// 原先能提前闭合围栏——那是把用户消息升格成指令最短的一条路。
+import { breakFenceMarkers } from "./fence.js";
+// #512：每轮蒸馏一个 run id（归因主体）。store 侧也能铸造，但这里必须知道它——
+// 写记忆时要把它一路带到 saveMemoryProvenance / 落 run 行，拿回来再写就是两次往返。
+import { randomUUID } from "node:crypto";
 
 // 编码记忆蒸馏 prompt（codingRetrospect 开启时启用）：在通用记忆之外，额外提取
 // 三类编码专属记忆，专治重复踩坑 / 遗忘被否决方案 / 丢失工程约束。字段仍沿用
@@ -18,6 +24,12 @@ import { createScopeResolver } from "./scope.js";
 // occurred_from 过滤。未知/无法换算的相对时间必须整条省略字段，不能落 null。
 // 纯函数：唯一外部输入是显式入参 nowMs（测试注入假时钟即可确定性复现）。
 const OCCURRED_AT_FUTURE_TOLERANCE_MS = 24 * 60 * 60 * 1000;
+// #493 补充 §②：持久化的解析失败计数超过这么久没更新就按 0 算（读侧失效，见
+// store.getDistillParseFailureStreak）。7 天：够长，能跨一次长假/一次停机；够短，
+// 不至于让「停了很久的会话」拿几周前的 streak 直接熔断一个其实健康的窗口。
+// 刻意不做成配置键：护栏本身默认关（summarizeParseFailureMaxRetries=0），一个只为
+// 护栏服务的失效窗口不该再占一档用户可见配置（AGENTS.md 旗标计数锁也要跟着动）。
+const PARSE_FAILURE_STREAK_STALE_MS = 7 * 24 * 60 * 60 * 1000;
 function normalizeDistilledOccurredAt(raw, nowMs = Date.now()) {
   if (typeof raw !== "string") return undefined;
   const text = raw.trim();
@@ -466,7 +478,7 @@ function collectMessages(session, maxChars = 8000, language = "zh", afterSeq, th
           // 角色重申把「这段文本是被提炼的素材」写进**它所在的那条消息**，而不是
           // 只写在 system 里——实测同段转录只加 system 约束仍 0/2 出 JSON。
           // 围栏是确定性的：重试收到的转录与首次逐字节相同（既有回归用例依赖）。
-          text: `${STR.distillRoleReminder[language]}\n\n${STR.transcriptFenceOpen[language]}\n${transcriptBody}\n${STR.transcriptFenceClose[language]}`
+          text: `${STR.distillRoleReminder[language]}\n\n${STR.transcriptFenceOpen[language]}\n${breakFenceMarkers(transcriptBody)}\n${STR.transcriptFenceClose[language]}`
         }],
         source: { kind: "plugin:dsh-mneme", plugin: "dsh-mneme" }
       })]
@@ -572,7 +584,7 @@ function enqueueDistill(task, intervalMs = 0) {
 // import + re-export 两行都要。
 import { parsePeakSpec, isInPeakWindow, nextOffPeakAt } from "./peak-hours.js";
 export { parsePeakSpec, isInPeakWindow, nextOffPeakAt };
-export function createSummarizer(ctx, service, config, deps = {}) {
+export function createSummarizer(ctx, service, config, deps = {}, sessionGate = null) {
   if (!config.autoSummarize) return { dispose: () => {} };
 
   // Issue #239（第 4 项）：时钟与定时器可注入——排程不绑死真实时钟，测试才能确定性
@@ -603,9 +615,54 @@ export function createSummarizer(ctx, service, config, deps = {}) {
   // Issue #210：只在一次蒸馏完整成功后记录已消费的最后事件 seq。
   const lastDistilledSeq = new Map();
   // Issue #493：per-session 连续解析失败计数（失败护栏用）。同一窗口在确定性
-  // 失败下会被每个 turn/end 重试一次、且窗口只会越攒越大——没有出口。成功即
-  // 清零；dispose 一并清理（与 runsUsed / lastRunAt 同生命周期）。
-  const parseFailureStreak = new Map();
+  // 失败下会被每个 turn/end 重试一次、且窗口只会越攒越大——没有出口。成功即清零。
+  //
+  // #493 补充 §②：**落库**，不再是进程内 Map。原先的 Map 有两个洞：重启即清零
+  // （护栏可被重启绕过，而它防的正是「确定性失败反复重试」），以及进程内无法跨
+  // 两个宿主共享同一个库时保持一致。库里读出来的值带读侧失效窗口（见
+  // PARSE_FAILURE_STREAK_STALE_MS），停了很久的会话不会被旧 streak 误伤。
+  // service 没这一步（旧装配 / 测试替身）时退回进程内 Map，行为与历史版本一致。
+  const parseFailureStreakFallback = new Map();
+  const persistentStreak = () => typeof service?.getDistillParseFailureStreak === "function"
+    && typeof service?.bumpDistillParseFailureStreak === "function"
+    && typeof service?.clearDistillParseFailureStreak === "function";
+  function readParseFailureStreak(sessionId) {
+    if (!persistentStreak()) return parseFailureStreakFallback.get(sessionId) ?? 0;
+    try {
+      return Number(service.getDistillParseFailureStreak(sessionId, { staleAfterMs: PARSE_FAILURE_STREAK_STALE_MS })) || 0;
+    } catch (error) {
+      // 读数坏了不许把蒸馏本身拖下水：退回进程内计数（最坏是多试一次）。
+      ctx.logger?.warn?.(`dsh-mneme: parse failure streak read failed: ${String(error)}`);
+      return parseFailureStreakFallback.get(sessionId) ?? 0;
+    }
+  }
+  function bumpParseFailureStreak(sessionId) {
+    if (!persistentStreak()) {
+      const next = (parseFailureStreakFallback.get(sessionId) ?? 0) + 1;
+      parseFailureStreakFallback.set(sessionId, next);
+      return next;
+    }
+    try {
+      // 失效判断由 store 那一侧负责（同一个 staleAfterMs），这里不再自己算一遍——
+      // 算两遍就等于有两份失效口径，迟早分叉。
+      const written = Number(service.bumpDistillParseFailureStreak(sessionId, { staleAfterMs: PARSE_FAILURE_STREAK_STALE_MS }));
+      if (Number.isFinite(written) && written > 0) return written;
+    } catch (error) {
+      ctx.logger?.warn?.(`dsh-mneme: parse failure streak write failed: ${String(error)}`);
+    }
+    const next = readParseFailureStreak(sessionId) + 1;
+    parseFailureStreakFallback.set(sessionId, next);
+    return next;
+  }
+  function clearParseFailureStreak(sessionId) {
+    parseFailureStreakFallback.delete(sessionId);
+    if (!persistentStreak()) return;
+    try {
+      service.clearDistillParseFailureStreak(sessionId);
+    } catch (error) {
+      ctx.logger?.warn?.(`dsh-mneme: parse failure streak clear failed: ${String(error)}`);
+    }
+  }
   let disposed = false;
 
   /** 写一条 autoSummarize 的 LLM 审计行（审计失败绝不阻塞蒸馏本身）。 */
@@ -670,6 +727,7 @@ export function createSummarizer(ctx, service, config, deps = {}) {
 
   async function summarize(session, triggerEvent, opts = {}) {
     if (disposed || inFlight.has(session.id)) return;
+    if (sessionGate?.isOff(session)) return;
 
     const header = session.requestHeader?.()?.config;
     // Config override takes priority, then session header, then nothing.
@@ -734,6 +792,14 @@ export function createSummarizer(ctx, service, config, deps = {}) {
     // ever blocking the summarization itself.
     let audit = null;
     let abortedRun = false;
+    // #512：run 的三个事实必须活在 try 之外——finally 要落 run 行，而 finally 看不见
+    // try 块内声明的 let/const（会 ReferenceError，且那一下会把 inFlight 的清理一起跳过）。
+    let distillRunId = null;
+    let distillRunOpenedAt = null;
+    let distilledMemoryCount = 0;
+    let distilledWindow = null;
+    let distillRunStatus = null;
+    let distillRunError = null;
     try {
       if (!route) return;
       const persistedCursor = typeof service.getDistillCursor === "function"
@@ -800,6 +866,19 @@ export function createSummarizer(ctx, service, config, deps = {}) {
       lastRunAt.set(session.id, Date.now());
       runsUsed.set(session.id, (prevRuns ?? 0) + 1);
 
+      // #512：一轮蒸馏 = 一个 run。落点选在这里而不是更早——上面所有 return（间隔门、
+      // 高峰门、run 预算、空窗口、窗口过小）都不是一轮真蒸馏，各有自己的审计口径；
+      // 从这里往下就是「调用确实发生过」，与 lastRunAt 那两行的边界完全重合。
+      // run 的落盘在 finally 里独立 try/catch：归因是审计主体，写不成只该 warn，
+      // 不该把已经落盘的记忆连坐。所以本函数在 store 没有该能力时整体降级为无归因。
+      // 归因用的三件事都从**真正发生的事**里取，不从推断里取：区间取实际写进
+      // memory_provenance 的那个窗口（transcript 关了就没有），条数取实际写成功的
+      // 记忆数（含 merged——被并入的既有行确实由这段原文改动）。
+      if (typeof service?.saveDistillRun === "function") {
+        distillRunId = randomUUID();
+        distillRunOpenedAt = new Date(now()).toISOString();
+      }
+
       if (config?.llmAudit?.enabled !== false && typeof service.saveLlmAudit === "function") {
         audit = {
           route,
@@ -941,6 +1020,13 @@ export function createSummarizer(ctx, service, config, deps = {}) {
       const { text, assembledText, aborted } = result ?? { text: "", assembledText: "", aborted: true };
       if (aborted) {
         abortedRun = true;
+        // #512：aborted 不等于「没发生」——LLM 调用真的发出去了，窗口也因此没被消费。
+        // 只有 dispose / 会话关闭才是「这一轮被主动打断」；模型侧流失败是一次失败的轮次，
+        // 两者在 run 台账上必须分得开，否则「这个窗口为什么一直没记忆」查不到原因。
+        distillRunStatus = controller.signal.aborted ? "aborted" : "failed";
+        distillRunError = controller.signal.aborted
+          ? "disposed"
+          : (streamFailure || "llm stream aborted");
         return;
       }
       const parsedResult = parseSummaryJsonResult(text || assembledText);
@@ -950,8 +1036,7 @@ export function createSummarizer(ctx, service, config, deps = {}) {
         // null —— 事后无法回答「模型到底吐了什么形状」。这里只加计量、不做任何
         // 跳过决策（raw_head 截断到 300 字符，避免把审计表撑大）。
         const raw = text || assembledText || "";
-        const streak = (parseFailureStreak.get(session.id) ?? 0) + 1;
-        parseFailureStreak.set(session.id, streak);
+        const streak = bumpParseFailureStreak(session.id);
         // Issue #493 失败护栏：同一窗口连续失败到阈值后强制消费游标跳过它。
         // 确定性失败（finish_reason=stop、同文同温）重试收益为 0，而窗口只会随
         // 新事件继续变大——没有出口时它会一直失败下去。默认 0 = 关闭，行为与
@@ -965,13 +1050,17 @@ export function createSummarizer(ctx, service, config, deps = {}) {
         if (skipWindow) {
           // 先提交游标再复位计数：窗口已放弃，下一窗从全新状态起算。
           commitCursor(session.id, nextSeq);
-          parseFailureStreak.delete(session.id);
+          clearParseFailureStreak(session.id);
         }
+        // 读数与错误文案由同一个纯函数产出（#502）：三种失败形态各有各的说法，
+        // 「模型在说话」与「分类词不在枚举内」不能都写成 invalid summary JSON。
+        const failureAudit = summarizeParseFailureAudit(raw, parsedResult?.failure);
+        // #512：解析失败也是失败轮，run 要和 audit 记同一句原因（两个口径不一致
+        // 等于让人去猜哪一边是对的）。
+        distillRunStatus = "failed";
+        distillRunError = failureAudit.errorMessage;
         if (audit) {
           audit.status = "error";
-          // 读数与错误文案由同一个纯函数产出（#502）：三种失败形态各有各的说法，
-          // 「模型在说话」与「分类词不在枚举内」不能都写成 invalid summary JSON。
-          const failureAudit = summarizeParseFailureAudit(raw, parsedResult?.failure);
           audit.errorMessage = failureAudit.errorMessage;
           audit.metadata = {
             distillChars,
@@ -983,7 +1072,7 @@ export function createSummarizer(ctx, service, config, deps = {}) {
         }
         return;
       }
-      parseFailureStreak.delete(session.id);
+      clearParseFailureStreak(session.id);
       const parsed = parsedResult.entries;
       // Issue #127 条数上限：0 = 不限（现状）。被截断的条数与去重命中数一并进
       // 审计 metadata——此前产出条数完全由模型输出决定，用户无从自查。
@@ -1062,8 +1151,14 @@ export function createSummarizer(ctx, service, config, deps = {}) {
           // 被并入的既有记忆——本次窗口的原文确实贡献了它，链接它是诚实的。
           if (outcome?.memory?.id) savedIds.push(outcome.memory.id);
         }
+        // #512：run 的条数口径是「本次写成功的记忆行数」，与 savedIds 同源——
+        // 另起一个计数器会在 merged 分支上与它对不上（那一路也 push 了 id）。
+        distilledMemoryCount = savedIds.length;
         if (transcript && transcript.records.length) {
           service.saveDistillRecords(transcript.records);
+          if (transcript.seqStart !== undefined && transcript.seqEnd !== undefined) {
+            distilledWindow = { seqStart: transcript.seqStart, seqEnd: transcript.seqEnd };
+          }
           if (transcript.seqStart !== undefined && transcript.seqEnd !== undefined
             && typeof service.saveMemoryProvenance === "function") {
             for (const memoryId of savedIds) {
@@ -1072,7 +1167,11 @@ export function createSummarizer(ctx, service, config, deps = {}) {
                 sessionId: session.id,
                 seqStart: transcript.seqStart,
                 seqEnd: transcript.seqEnd,
-                createdAt: distilledAt
+                createdAt: distilledAt,
+                // #512：链接指回产出它的那一轮。distillRecords 关着时这里本就不跑，
+                // 于是那一轮不会留下任何窗口级归因——这是诚实的（没存原文就没有
+                // 「这段原文」可指），run 行本身照落，条数与状态仍然可查。
+                distillRunId: distillRunId ?? undefined
               });
             }
           }
@@ -1095,6 +1194,12 @@ export function createSummarizer(ctx, service, config, deps = {}) {
       // Issue #239 定标：窗口字符数无条件随成功行落进 metadata。原先只有
       // capped / deduped / salvaged 其中一项发生时才建 metadata，默认档位下
       // 一条都不留——下一级预判规则的阈值就无从定标。
+      // #512：走到这里说明整轮真的落地了（记忆写入 + 游标提交都没抛）。状态按
+      // 实际产出分档，与 dream_runs 的 status 词表对齐：没有可写的记忆是 noop，
+      // 有记忆就是 ok。degraded 留给「写了但解析有损」那一路（下面按 salvaged 判）。
+      distillRunStatus = distilledMemoryCount > 0
+        ? (parsedResult.salvaged ? "degraded" : "ok")
+        : "noop";
       if (audit) {
         audit.metadata = {
           distillChars,
@@ -1108,6 +1213,8 @@ export function createSummarizer(ctx, service, config, deps = {}) {
       // 都会在此之前退出，从而保留窗口供下一次重试。
       if (Number.isFinite(nextSeq)) lastDistilledSeq.set(session.id, nextSeq);
     } catch (error) {
+      distillRunStatus = abortedRun || controller.signal.aborted ? "aborted" : "failed";
+      distillRunError = String(error?.message ?? error);
       if (audit) {
         audit.status = "error";
         audit.errorMessage = String(error?.message ?? error);
@@ -1124,9 +1231,14 @@ export function createSummarizer(ctx, service, config, deps = {}) {
         if (prevRuns === undefined) runsUsed.delete(session.id);
         else runsUsed.set(session.id, prevRuns);
       }
+      // #512：run 与它的开销读数（audit 行）分开落，且都不许把已经写好的记忆连坐——
+      // 归因是审计，写不成只该 warn。顺序刻意是「先 audit 后 run」：run.audit_id 要
+      // 引用刚插进去的那一行，而 saveLlmAudit 是按 lastInsertRowid 回读的
+      // （#534/#535 那条注释），拿到的就是自己那行，不会被并发写串。
+      let auditRow = null;
       if (audit) {
         try {
-          service.saveLlmAudit({
+          auditRow = service.saveLlmAudit({
             timestamp: audit.timestamp,
             trigger_source: "autoSummarize",
             operation_type: "summarize_compress",
@@ -1147,6 +1259,31 @@ export function createSummarizer(ctx, service, config, deps = {}) {
           ctx.logger?.warn?.(`dsh-mneme: llm audit write failed: ${String(auditError)}`);
         }
       }
+      // #512：一轮真蒸馏对应一行 distill_runs，落点必须在这里（finally）而不是
+      // 事务里：run 是审计主体，事务只负责「记忆 + 原文 + 链接」同生共死；把 run
+      // 塞进事务会让一个审计写失败回滚掉已经算出来的记忆。
+      // status 为 null 说明在开轮之前就退出了（间隔门/高峰门/短窗口），那不是一轮。
+      if (distillRunId && distillRunStatus) {
+        try {
+          service.saveDistillRun({
+            id: distillRunId,
+            created_at: distillRunOpenedAt,
+            status: distillRunStatus,
+            error: distillRunError ?? undefined,
+            run_type: "autoSummarize",
+            trigger_source: "autoSummarize",
+            session_id: session.id,
+            seq_start: distilledWindow?.seqStart,
+            seq_end: distilledWindow?.seqEnd,
+            memory_count: distilledMemoryCount,
+            provider: audit?.route?.provider ?? route?.provider,
+            model: audit?.route?.model ?? route?.model,
+            audit_id: auditRow?.id
+          });
+        } catch (runError) {
+          ctx.logger?.warn?.(`dsh-mneme: distill run write failed: ${String(runError)}`);
+        }
+      }
       inFlight.delete(session.id);
     }
   }
@@ -1173,7 +1310,7 @@ export function createSummarizer(ctx, service, config, deps = {}) {
       inFlight.clear();
       lastRunAt.clear();
       lastDistilledSeq.clear();
-      parseFailureStreak.clear();
+      parseFailureStreakFallback.clear();
     }
   };
 }

package/src/tools.js

@@ -1,5 +1,5 @@
 import { defineTool } from "@deepseek-ai/dsh-tools";
-import { createScopeResolver, normalizeExplicitScope, sessionKeyOf } from "./scope.js";
+import { createScopeResolver, normalizeExplicitScope, sessionKeyOf, sessionOf } from "./scope.js";
 import { describeLocalRuntime, resolveRuntimeEntry } from "./runtime/loader.js";
 import { defaultRuntimeDir } from "./runtime/layout.js";
 import { hostModulesDir, loadRuntimeManifest, provisionRuntime } from "./runtime/provision.js";
@@ -76,13 +76,15 @@ const MEMORY_PROVENANCE = (m) => {
   return parts.length ? ` | ${parts.join(" | ")}` : "";
 };
 
-export function createTools(ctx, service, config, embedder) {
+export function createTools(ctx, service, config, embedder, sessionGate = null) {
   const toolsRegistry = ctx.tools;
-  let registeredTools = REGISTERED_TOOLS.get(toolsRegistry);
-  if (!registeredTools) {
-    registeredTools = new Set();
-    REGISTERED_TOOLS.set(toolsRegistry, registeredTools);
+  let registration = REGISTERED_TOOLS.get(toolsRegistry);
+  if (!registration) {
+    registration = { names: new Set(), sessionGate: null };
+    REGISTERED_TOOLS.set(toolsRegistry, registration);
   }
+  registration.sessionGate = sessionGate;
+  const registeredTools = registration.names;
   // v0.8.0 A1/A2（issue #17）：会话 scope 解析（agentPreset + workspace 反查）。
   // flag 关闭时恒返回 null——写入不标注，检索不加权，行为与 A1 前完全一致。
   // logger 透传：registry 反查失败时 warnOnce 才有出口（否则静默降级无观测）。
@@ -1054,6 +1056,24 @@ export function createTools(ctx, service, config, embedder) {
         ctx.logger?.warn?.(`[dsh-mneme] tool "${tool.name}" already registered, skipping duplicate`);
         continue;
       }
+      // #539：闸门包在**注册期**，而不是在 execute 内部各写一遍。已注册的执行器
+      // 不会被宿主反注册（同上面 disableMemorySearch 那段 v0.8.5 的定性），所以
+      // 包一层的意义在于：热重载后 registration.sessionGate 换成新实例，旧的执行器
+      // 也跟着读新的闸门，不会拿着过期 config 继续放行。
+      //
+      // 取会话走 sessionOf(exec) = exec.agent.session。ToolExecutionInput.agent 在
+      // 宿主类型里是**可选**的，PTC 内层派发可能压根不带 agent；这种调用会拿到
+      // null → isOff(null) 为 false → 放行。这是有意的：不认识调用者的工具调用
+      // 不能一律拒绝（那会把正常会话也打死），闸门只对「能证明自己是谁」的调用生效。
+      if (typeof tool.execute === "function") {
+        const execute = tool.execute.bind(tool);
+        tool.execute = async (args, exec) => {
+          if (registration.sessionGate?.isOff(sessionOf(exec))) {
+            throw new Error("dsh-mneme: memory tools are disabled for this incognito session");
+          }
+          return execute(args, exec);
+        };
+      }
       registeredTools.add(tool.name);
       ctx.tools.register(tool);
   }

package/test/api.test.js

@@ -754,7 +754,13 @@ test("GET /api/dsh-mneme/features returns empty overrides and effective config d
   // 不需要 NESTED_FLAG_PATHS 条目）= 104。
   // 人格寻址口径新增 personaStrictAddressing（顶层扁平键，同上）= 105。
   // issue #497 新增 profileExtractEnabled（画像提取草稿；顶层扁平键，同上）= 106。
-  assert.equal(Object.keys(data.effective).length, 106);
+  // issue #539 新增 sessionGateEnabled / sessionGateSubagents（逐会话无痕闸门，总开关
+  // 与子代理选择器；manual id 名单是数组配置，不进 feature_flags）= 108。
+  // issue #529 新增 sleepConflictMaxPairs / sleepConflictMaxPairsPerRun（冲突阶段的
+  // 输入侧预算，两个 int 键都走 INT_RANGES 表）= 110。
+  // issue #529 再新增 sleepFailureBackoff（sleep 连续失败退避；顶层布尔键，
+  // 不需要 NESTED_FLAG_PATHS 条目）= 111。
+  assert.equal(Object.keys(data.effective).length, 111);
   assert.equal(data.effective.dreamSkipInvalid, true);
   assert.equal(data.effective.allowCrossTypeMerge, false);
   assert.equal(data.effective.dreamMergeGuard, true);
@@ -803,6 +809,8 @@ test("GET /api/dsh-mneme/features returns empty overrides and effective config d
   assert.equal(data.effective.personaStrictAddressing, false);
   // 画像提取默认关：面板按钮在用户没开启前不该偷偷花一次 LLM 调用。
   assert.equal(data.effective.profileExtractEnabled, false);
+  assert.equal(data.effective.sessionGateEnabled, false);
+  assert.equal(data.effective.sessionGateSubagents, true);
   // v0.9.3：M.O. 自动沉淀的第三个键。与 actionPipelineEnabled（看图）、
   // actionRunEnabled（记账）都不是一件事——它挂 session/event 并解压会话日志，
   // 是三者里最重的一条，所以独立开关、默认关、且进 LIGHT_MODE_OFF。
@@ -883,16 +891,36 @@ test("PUT /api/dsh-mneme/features round-trips, overrides effective and persists"
   const { routes, settings } = setup(undefined, "", FLAGS_CFG);
   const route = routes.find((r) => r.path === "/api/dsh-mneme/features");
   const res = new FakeRes();
-  await route.handler(req("/api/dsh-mneme/features", "PUT", { autoDream: false, distillMaxChars: 48000, actionPipelineEnabled: true }), res);
+  await route.handler(req("/api/dsh-mneme/features", "PUT", {
+    autoDream: false,
+    distillMaxChars: 48000,
+    actionPipelineEnabled: true,
+    sessionGateEnabled: true,
+    sessionGateSubagents: false
+  }), res);
   assert.equal(res.statusCode, 200);
   const data = JSON.parse(res.body);
-  assert.deepEqual(data.overrides, { autoDream: false, distillMaxChars: 48000, actionPipelineEnabled: true });
+  assert.deepEqual(data.overrides, {
+    autoDream: false,
+    distillMaxChars: 48000,
+    actionPipelineEnabled: true,
+    sessionGateEnabled: true,
+    sessionGateSubagents: false
+  });
   assert.equal(data.effective.autoDream, false, "override wins over config default");
   assert.equal(data.effective.distillMaxChars, 48000);
   // v0.9.0：默认关的键也能被 PUT 打开并读回（beta 功能的启用路径）。
   assert.equal(data.effective.actionPipelineEnabled, true, "override flips the beta gate on");
+  assert.equal(data.effective.sessionGateEnabled, true);
+  assert.equal(data.effective.sessionGateSubagents, false);
   assert.equal(data.effective.autoInject, true, "keys not in the patch still report config");
-  assert.deepEqual(settings.getFeatureFlags(), { autoDream: false, distillMaxChars: 48000, actionPipelineEnabled: true });
+  assert.deepEqual(settings.getFeatureFlags(), {
+    autoDream: false,
+    distillMaxChars: 48000,
+    actionPipelineEnabled: true,
+    sessionGateEnabled: true,
+    sessionGateSubagents: false
+  });
 });
 
 test("PUT /api/dsh-mneme/features round-trips nested, string, url and enum keys", async () => {
@@ -1400,6 +1428,7 @@ 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(data.lastConsolidation, data.runs[0], "no organize row => same as lastRun");
   // #521：skippedCount / skippedReasons 是本轮新增的两个字段（面板按归一化原因
   // 显示跳过明细）。这行锁的是 dream-status 的响应形状，加字段必须同步改这里。
   assert.deepEqual(Object.keys(data.lastRun).sort(), ["created_at", "demotion", "error", "model", "provider", "run_type", "skippedCount", "skippedReasons", "status"]);
@@ -1419,6 +1448,59 @@ test("GET /api/dsh-mneme/dream-status returns runs and pending conflict ids", as
   assert.deepEqual(afterData.pendingMemoryIds, []);
 });
 
+// Issue #495：organize 与巩固共用 dream_runs，一次 agent 主动整理写两行（dryRun
+// 报告 + apply 回执）。面板那张卡的标题是「最近巩固」，若继续取 runs[0]，一次整理
+// 就会把它顶成整理回执——测的是「卡面数字取的是巩固轮」，不是「runs 里没有 organize」。
+test("GET /api/dsh-mneme/dream-status keeps organize rows out of lastConsolidation (issue #495)", async () => {
+  const { routes, service } = setup();
+  service.saveDreamRun({ created_at: "2026-01-01T00:00:00.000Z", status: "ok", snapshot_hash: "h1", input_count: 2, receipt: "r1" });
+  // 一次整理的两行：报告在前、回执在后，都晚于那次巩固。
+  service.saveDreamRun({
+    created_at: "2026-01-02T00:00:00.000Z", status: "ok", run_type: "organize",
+    snapshot_hash: "h2", input_count: 0, receipt: "r2",
+    outcome: { dryRun: true, byId: {} }
+  });
+  service.saveDreamRun({
+    created_at: "2026-01-02T00:00:01.000Z", status: "ok", run_type: "organize",
+    snapshot_hash: "h3", input_count: 0, receipt: "r3",
+    outcome: { dry_run_id: "dry-1", byId: {} }
+  });
+
+  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);
+
+  // 审计面不缩：runs 仍是全类型 5 条，organize 照旧排在最前。
+  assert.equal(data.runs.length, 3, "runs keeps every run type — the audit surface is not filtered");
+  assert.equal(data.runs[0].run_type, "organize");
+  assert.equal(data.lastRun.run_type, "organize", "lastRun still means the newest row of any type");
+  // 卡面取数：跳过 organize，回到那次真巩固。
+  assert.ok(data.lastConsolidation, "lastConsolidation must not be empty when a consolidation exists");
+  assert.equal(data.lastConsolidation.run_type, "auto");
+  assert.equal(data.lastConsolidation.created_at, "2026-01-01T00:00:00.000Z");
+  // 两条路径共用同一份投影，字段形状必须一致（否则面板得写两套渲染）。
+  assert.deepEqual(Object.keys(data.lastConsolidation).sort(), Object.keys(data.lastRun).sort());
+});
+
+// 只有 organize 跑过时：宁可留空让面板说「尚未运行」并加脚注，也不能拿整理回执
+// 冒充巩固——那是这条 issue 要治的那个错。
+test("dream-status: organize-only history leaves lastConsolidation null, never the organize row (issue #495)", async () => {
+  const { routes, service } = setup();
+  service.saveDreamRun({
+    created_at: "2026-01-02T00:00:00.000Z", status: "ok", run_type: "organize",
+    snapshot_hash: "h1", input_count: 0, receipt: "r1",
+    outcome: { dry_run_id: "dry-1", byId: {} }
+  });
+  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.run_type, "organize");
+  assert.equal(data.lastConsolidation, null, "an organize receipt must never be reported as the last consolidation");
+  assert.equal(data.runs.length, 1);
+});
+
 // v0.8.0 冲突集中处理：GET /conflicts 队列联表 + POST /conflicts/resolve 人工确认。
 test("GET /api/dsh-mneme/conflicts joins both sides of unresolved conflicts", async () => {
   const { routes, service } = setup();
@@ -2458,3 +2540,70 @@ test("GET /api/dsh-mneme/memory/provenance：lightMode 预设把关掉 → 409
   assert.equal(res.statusCode, 409);
   assert.equal(JSON.parse(res.body).error, "distill-records-disabled");
 });
+
+// #524 方向 2：按会话列窗口（store 侧 GROUP BY 成一行一窗口）。这条用例盯三件事：
+// 同一窗口派生的多条记忆不许变成多行、区间按 seq_start 排、答复用 sessionId 认领。
+test("GET /api/dsh-mneme/memory/provenance?sessionId= 列出该会话的蒸馏窗口（#524）", async () => {
+  const { routes, service, store } = setup(null, "secret-token", RECORDS_ON);
+  service.saveWithDedupe({ type: "decision", title: "核心决策", content: "选定 SQLite 单文件库", importance: 5 });
+  service.saveWithDedupe({ type: "decision", title: "备选", content: "先用 JSON 文件顶着", importance: 3 });
+  const [m1, m2] = service.all();
+  // 两个窗口：后一个 seq 更小，用来验证答复按 seq_start 排而不是按写入序。
+  store.saveMemoryProvenance({ memoryId: m1.id, sessionId: "s1", seqStart: 10, seqEnd: 12, createdAt: "t2" });
+  store.saveMemoryProvenance({ memoryId: m2.id, sessionId: "s1", seqStart: 10, seqEnd: 12, createdAt: "t2" });
+  store.saveMemoryProvenance({ memoryId: m1.id, sessionId: "s1", seqStart: 1, seqEnd: 3, createdAt: "t1" });
+  // 另一个会话的窗口不该出现。
+  store.saveMemoryProvenance({ memoryId: m1.id, sessionId: "s2", seqStart: 50, seqEnd: 51, createdAt: "t3" });
+
+  const route = routes.find((r) => r.path === "/api/dsh-mneme/memory/provenance");
+  const res = new FakeRes();
+  const r = req("/api/dsh-mneme/memory/provenance?sessionId=s1");
+  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.sessionId, "s1", "方向 2 的答复用 sessionId 认领，不冒充 memoryId");
+  assert.equal(data.memoryId, undefined, "两个方向的认领键不许同时出现");
+  assert.equal(data.truncated, false);
+  assert.deepEqual(data.windows.map((w) => [w.seq_start, w.seq_end]), [[1, 3], [10, 12]],
+    "同一 (seq_start, seq_end) 的两条记忆必须并成一行，且按 seq_start 升序");
+  assert.deepEqual(data.windows.map((w) => w.link_count), [1, 2],
+    "link_count 说明该窗口派生出几条记忆——这是一行一窗口之后唯一还剩的「多」的信息");
+});
+
+test("GET /api/dsh-mneme/memory/provenance：两个主键都给 → 400，不静默择一（#524）", async () => {
+  const { routes } = setup(null, "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&sessionId=s1");
+  r.headers = { authorization: "Bearer secret-token" };
+  await route.handler(r, res);
+  assert.equal(res.statusCode, 400);
+  assert.equal(JSON.parse(res.body).error, "ambiguous-id");
+});
+
+test("GET /api/dsh-mneme/memory/provenance?sessionId=：limit 越界 → 400；撞上限时 truncated=true（#524）", async () => {
+  const { routes, service, store } = setup(null, "secret-token", RECORDS_ON);
+  service.saveWithDedupe({ type: "decision", title: "核心决策", content: "x", importance: 5 });
+  const memory = service.all()[0];
+  for (const n of [1, 2, 3]) {
+    store.saveMemoryProvenance({ memoryId: memory.id, sessionId: "s1", seqStart: n, seqEnd: n, createdAt: "t" });
+  }
+  const route = routes.find((r) => r.path === "/api/dsh-mneme/memory/provenance");
+
+  const bad = new FakeRes();
+  const badReq = req("/api/dsh-mneme/memory/provenance?sessionId=s1&limit=0");
+  badReq.headers = { authorization: "Bearer secret-token" };
+  await route.handler(badReq, bad);
+  assert.equal(bad.statusCode, 400);
+  assert.equal(JSON.parse(bad.body).error, "invalid-limit");
+
+  const ok = new FakeRes();
+  const okReq = req("/api/dsh-mneme/memory/provenance?sessionId=s1&limit=2");
+  okReq.headers = { authorization: "Bearer secret-token" };
+  await route.handler(okReq, ok);
+  assert.equal(ok.statusCode, 200);
+  const data = JSON.parse(ok.body);
+  assert.equal(data.windows.length, 2);
+  assert.equal(data.truncated, true, "还有第三个窗口没回——必须说出来，否则半份转录会被当成全部");
+});