@modusensus/dsh-mneme 0.9.5 → 0.10.0

package/lib/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/lib/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/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@modusensus/dsh-mneme",
   "description": "Cross-session memory plugin for DeepSeek Harness with autoDream consolidation: SQLite store, Markdown mirrors, 10 model tools, automatic injection, session summarization, user profile/rules, custom slash commands, vector (semantic) search, and a Web GUI panel",
-  "version": "0.9.5",
+  "version": "0.10.0",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -110,7 +110,9 @@
   },
   "overrides": {
     "adm-zip": "0.6.1",
-    "brace-expansion": "5.0.12"
+    "brace-expansion": "5.0.12",
+    "glob": "14.0.3",
+    "minimatch": "11.0.3"
   },
   "allowScripts": {
     "onnxruntime-node@1.30.0": true

package/src/api-standalone.js

@@ -21,7 +21,7 @@ import { bootstrapFromDirectory } from "./bootstrap.js";
 import { PACKAGE_VERSION } from "./version-check.js";
 import { parseReclaimJson, readReclaimFields, reclaimReply, RECLAIM_UNAVAILABLE } from "./reclaim-http.js";
 import { parseShareBody, shareReply, parseReceiveBody, receiveReply, parseUndoBody, undoReply } from "./share-http.js";
-import { parseProvenanceQuery, provenanceReply } from "./provenance-http.js";
+import { parseProvenanceSelector, provenanceReply } from "./provenance-http.js";
 
 const DEFAULT_PORT = 8790;
 const DEFAULT_HOST = "127.0.0.1";
@@ -487,6 +487,10 @@ export function createStandaloneApi({ service, store, config = {}, logger, setti
       // 一个链接一个窗口（区间 + 区间内原文行，按 seq 升序）；没有链接的记忆返回
       // 空 windows——「不是蒸馏来的」是有效答案，不是错误。
       //
+      // 两个读方向共一条路径（#524）：?id=<memoryId> 走方向 1（记忆 → 窗口），
+      // ?sessionId=<sid> 走方向 2（会话 → 窗口）。互斥校验在共用模块里（都缺/都给
+      // 都是 400），本壳只把三个 query 参数原样递进去——拆分与择一的判断只准写一份。
+      //
       // 这张面本来就要 Bearer token（除 /health 外无例外），所以不涉及宿主侧那次
       // open → token 的归类调整；daemon 与宿主共用 service，口径天然一致。
       //
@@ -497,12 +501,16 @@ export function createStandaloneApi({ service, store, config = {}, logger, setti
       // 方向，别当成 bug 修掉。阶梯全貌（401 → 400 → 409 → 503 → 读）见
       // provenance-http.js 文件头。
       if (req.method === "GET" && pathname === "/memory/provenance") {
-        const parsed = parseProvenanceQuery(url.searchParams.get("id"));
+        const parsed = parseProvenanceSelector({
+          memoryId: url.searchParams.get("id"),
+          sessionId: url.searchParams.get("sessionId"),
+          limit: url.searchParams.get("limit")
+        });
         if (!parsed.ok) {
           sendJson(res, parsed.status, { error: parsed.error });
           return;
         }
-        const { status, body } = provenanceReply({ service, id: parsed.id, config, warn: (m) => logger?.warn?.(m) });
+        const { status, body } = provenanceReply({ service, selector: parsed.selector, config, warn: (m) => logger?.warn?.(m) });
         sendJson(res, status, body);
         return;
       }

package/src/api.js

@@ -14,7 +14,7 @@ import { EFFORT_REJECT_RE, describeStreamFailure, resolveRoute, withEffortFallba
 import { summarizeSkipped } from "./dream/decisions.js";
 import { getInjectionSnapshot } from "./inject.js";
 import { renderUserSettingsBlock } from "./user-settings.js";
-import { parseProvenanceQuery, provenanceReply } from "./provenance-http.js";
+import { parseProvenanceSelector, provenanceReply } from "./provenance-http.js";
 import { describeLocalRuntime, publicRuntimeStatus } from "./runtime/loader.js";
 import { hostModulesDir, provisionRuntime } from "./runtime/provision.js";
 import { classify, fetchLatestVersion, PACKAGE_VERSION } from "./version-check.js";
@@ -1314,6 +1314,12 @@ export function createApi(ctx, service, settings, commands, embedder, semantic =
   // 能查，外部（面板 / standalone API / 脚本）拿不到，「这条记忆是从哪几句蒸出来
   // 的」只能开 sqlite 手写 JOIN。本端点补最后一段接线。
   //
+  // 两个读方向共一条路径（#524）：?id=<memoryId> 是「这条记忆从哪几句蒸出来的」，
+  // ?sessionId=<sid> 是「这个会话蒸出了哪几段」。两个主键互斥——都缺 400、都给
+  // 400（择一意味着调用方发一个自己也不知道会被读哪个主键的请求，而两边结果形状
+  // 不同）。共用路径是有意的：多一条路径就多一处要登记的地方（SECURITY.md 两张
+  // 表、README 路由表、security-doc 的清单锁），而两者读的是同一批数据。
+  //
   // 一个链接一个窗口：区间 + 区间里的原文行（按 seq 升序）。没有链接的记忆
   // （memory_save / 工具写入 / 冷启动）返回空 windows——「不是蒸馏来的」本身是
   // 有效答案，不是错误，所以不 404。
@@ -1341,12 +1347,16 @@ export function createApi(ctx, service, settings, commands, embedder, semantic =
     handler(req, res) {
       try {
         const url = new URL(req.url, "http://localhost");
-        const parsed = parseProvenanceQuery(url.searchParams.get("id"));
+        const parsed = parseProvenanceSelector({
+          memoryId: url.searchParams.get("id"),
+          sessionId: url.searchParams.get("sessionId"),
+          limit: url.searchParams.get("limit")
+        });
         if (!parsed.ok) {
           sendJson(res, parsed.status, { error: parsed.error });
           return;
         }
-        const { status, body } = provenanceReply({ service, id: parsed.id, config, warn: (m) => ctx.logger?.warn?.(m) });
+        const { status, body } = provenanceReply({ service, selector: parsed.selector, config, warn: (m) => ctx.logger?.warn?.(m) });
         sendJson(res, status, body);
       } catch {
         sendJson(res, 500, { error: "internal" });
@@ -1759,7 +1769,7 @@ export function createApi(ctx, service, settings, commands, embedder, semantic =
     policy: "open",
     handler(req, res) {
       try {
-        const runs = (service.listDreamRuns?.({ limit: 5 }) ?? []).map((r) => ({
+        const toRun = (r) => ({
           created_at: r.created_at,
           status: r.status,
           provider: r.provider ?? null,
@@ -1777,7 +1787,16 @@ export function createApi(ctx, service, settings, commands, embedder, semantic =
           // 被发现。这里只回聚合（原因 + 动作 + 条数），明细仍留在库里。
           skippedCount: Array.isArray(r.skipped) ? r.skipped.length : 0,
           skippedReasons: summarizeSkipped(r.skipped)
-        }));
+        });
+        // Issue #495：organize 上线后 runs 会混进 run_type="organize"，而面板那张
+        // 卡的标题是「最近巩固」——一次 agent 主动整理就会把它顶成整理回执。
+        // 两条路里选了「标注」而不是过滤：runs 仍是全类型 5 条（审计面是证据，
+        // 不因显示面积省略），另给一个只含 auto/sleep 的 lastConsolidation 供那张
+        // 卡取数；面板再用 lastRun 是否为 organize 决定要不要标一句脚注。
+        // 这里不能只靠 runs[0] 的 run_type 过滤——一次整理写两行（dryRun 报告 +
+        // apply 回执），挤空 5 个名额时 runs 里可能一条巩固都没有。
+        const runs = (service.listDreamRuns?.({ limit: 5 }) ?? []).map(toRun);
+        const lastConsolidation = service.listDreamRuns?.({ limit: 1, excludeRunType: "organize" })?.[0];
         const pendingConflicts = service.countConflictPending?.() ?? 0;
         const ids = new Set();
         for (const row of service.listConflictPending?.({ limit: 200, includeResolved: false }) ?? []) {
@@ -1788,6 +1807,7 @@ export function createApi(ctx, service, settings, commands, embedder, semantic =
         }
         sendJson(res, 200, {
           lastRun: runs[0] ?? null,
+          lastConsolidation: lastConsolidation ? toRun(lastConsolidation) : null,
           runs,
           pendingConflicts,
           pendingMemoryIds: [...ids].slice(0, 200)

package/src/config.js

@@ -586,6 +586,16 @@ export const Config = z.object({
   // Minimum gap between two sleep runs (hours) — a second idle window within
   // this interval does not retrigger.
   sleepMinIntervalHours: z.natural().min(1).max(168).default(8),
+  // Issue #529（C 项的替代实现）：sleep 连续失败退避（默认关 = 行为逐字节不变）。
+  // 基数是 sleepMinIntervalHours，有效间隔 = 基数 × 2^连续失败数（成功清零），
+  // 封顶 max(基数, 24 小时)——不是硬 24 小时：这个键允许配到 168，用户配 48 就是
+  // 明说「两天跑一次」，退避只能放宽间隔、不该把用户自己的基数压小。
+  // 为什么不按 issue 原案用 snapshot_hash 判据：sleep 的
+  // snapshot_hash 是**跑完之后**对 phases 结果算的哈希（dream/sleep.js 的
+  // createHash(JSON.stringify(phases))），不是输入快照；同一批输入跑两次结果不同
+  // 就会得到不同哈希，用它当「同一输入又在失败」的判据不成立。退避与 #292 的
+  // autoDreamFailureBackoff 同构：只放大既有的最小间隔闸，不新增状态面。
+  sleepFailureBackoff: z.boolean().default(false),
   // Conflict adjudication strictness:
   //   gentle    only high-confidence conflicts (threshold 0.92) are resolved
   //   normal    standard dream-level (threshold 0.85)
@@ -653,6 +663,22 @@ export const Config = z.object({
   // 增长）；流式计费按实际用量，不按上限。
   sleepMaxTokens: z.natural().min(256).max(131072).default(8192).description("sleep 冲突消解与模式发现阶段的 LLM 输出预算上限（token）。原为硬编码 2048，sleepActionSet=full 实测需约 7000 导致裁决被截断而整轮失败；流式计费按实际用量，调大不增加成本。"),
 
+  // Issue #529：冲突阶段此前没有任何输入侧预算——同 scope 的全部相似对被一次性
+  // 拼进一个 prompt，实测单请求 163,054 输入 token（服务端 --ctx-size 163,840，
+  // 占 99.5%），449 对的池子必然撞墙；而失败的轮次不落 pairs、判 keep 又是
+  // no-op，下一轮冷却结束再送**完全相同的输入**，于是 23 轮连续 llm failed。
+  // 输出侧早有 sleepMaxTokens（#257），输入侧这一半一直是空的。
+  //
+  // 每批上限：0 = 不设上限（严格回退到旧的一次性全送，用于排查"是不是分批
+  // 引入的差异"）。取 12 是因为实测单对约 112~168 输入 token、12 对落在
+  // 1.5K~2K 区间，远低于任何服务商的上下文窗口，也不至于让 LLM 在长清单里
+  // 走神。
+  sleepConflictMaxPairs: z.natural().min(0).max(500).default(12).description("sleep 冲突阶段每批送给 LLM 的候选对上限（0 = 不设上限，回退旧的一次性全送）。实测单对约 112~168 输入 token，默认 12 对约 1.5K~2K。"),
+  // 每轮总上限：分批之后仍要有个总闸，否则一个 449 对的池子会拆成 38 批、
+  // 每批一次 LLM 往返，单轮跑上几小时（本身也没比撞墙好）。0 = 不设上限。
+  // 未入选的对不是"被丢弃"——它们留在 conflict_pending 与下一轮的候选池里。
+  sleepConflictMaxPairsPerRun: z.natural().min(0).max(5000).default(60).description("sleep 冲突阶段单轮累计裁定的候选对上限（0 = 不设上限）。默认 60 对 ≈ 5 批，约 10K 输入 token。"),
+
   // --- epistemic trust: memory source credibility (v0.4.5) -----------------
   // Distinguish memories by source: observation (measured / witnessed),
   // subjective (opinion / guess) and inferred (derived from other evidence).
@@ -966,7 +992,13 @@ export const Config = z.object({
   // 显式保存，画像正文必须是用户手写的原文，不给模型改写权。
   // 进 LIGHT_MODE_OFF：一次调用要读上百行记忆 + 一轮模型生成，与低资源档互斥（同
   // preInjectGate.enabled 的定性）；是预设不是强制，用户显式勾选仍然赢。
-  profileExtractEnabled: z.boolean().default(false)
+  profileExtractEnabled: z.boolean().default(false),
+
+  // #539 逐会话无痕：总开关默认关，保持旧用户行为；子代理选择器默认开，但总开关
+  // 未开时不生效。手动名单是精确的 session id 匹配。
+  sessionGateEnabled: z.boolean().default(false),
+  sessionGateSubagents: z.boolean().default(true),
+  sessionGateSessions: z.array(z.string()).default([])
 });
 
 // Fields forced to false by the light-mode preset. Everything not listed here

package/src/continuity.js

@@ -173,10 +173,10 @@ function noticeAlreadyInSurface(session, text) {
  * 挂两条监听（#249 §7 的 `agent/pre-step` 触发位 + 压缩事件面），返回 { dispose }。
  *
  * `store` 直接注入：本模块只写提案表、不碰检索/嵌入，没有用到 service 的任何能力。
- * 调用方负责父／子闸门（`autoInject` + `continuityRescueEnabled`）；本函数不做开关判定，
- * 保持"挂上就是开"的单一口径。
+ * 调用方负责父／子开关（`autoInject` + `continuityRescueEnabled`），本函数另检查逐会话
+ * 无痕闸门；保持"挂上就是开、命中会话就不处理"的单一口径。
  */
-export function createContinuityRescue(ctx, store) {
+export function createContinuityRescue(ctx, store, sessionGate = null) {
   // 待处理的边缘：sessionId → 压缩事件序号。**真落地**的压缩事件到达时置位，下一次 pre-step 消费后
   // 删除（同一个边缘绝不注入第二次）。只留序号、不留 Session：插件在宿主进程里只 apply
   // 一次、服务所有会话，握着 Session 就是握着它的全量日志不放——压缩完就收工、不再有
@@ -184,6 +184,10 @@ export function createContinuityRescue(ctx, store) {
   const edge = new Map();
 
   const unsubscribe = ctx.on("session/event", (session, event) => {
+    if (sessionGate?.isOff(session)) {
+      if (session?.id) edge.delete(session.id);
+      return;
+    }
     if (!isCompactionEdge(event)) return;
     if (!session?.id) return;
     if (!edge.has(session.id) && edge.size >= MAX_TRACKED_EDGES) {
@@ -200,6 +204,10 @@ export function createContinuityRescue(ctx, store) {
     // reject 是"这一步不该发生"，往里面塞消息没有意义；未知形状原样放行。
     if (decision?.kind !== "enter") return decision;
     const session = payload?.agent?.session;
+    if (sessionGate?.isOff(session)) {
+      if (session?.id) edge.delete(session.id);
+      return decision;
+    }
     const sessionId = session?.id;
     if (!sessionId) return decision;
     if (!edge.has(sessionId)) return decision;