@modusensus/dsh-mneme 0.9.4 → 0.10.0

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();
@@ -33,11 +45,56 @@ function normalizeDistilledOccurredAt(raw, nowMs = Date.now()) {
   }
 }
 
-function parseSummaryJsonResult(raw) {
+/**
+ * 失败形态分类（#502），只在结果不 ok 时产出：
+ * - no-array：连 `[` 都没有——模型在说话，不是没按格式；
+ * - syntax：有方括号、整体 parse 失败且括号扫描也没救回条目（#339 那一族）；
+ * - filtered-empty：JSON 合法、`arr` 非空，条目却被 VALID 全数滤掉。**这一种最贵**：
+ *   读起来像「没按格式写」，实际是分类词不在枚举内，而游标不推进会让整窗反复重放。
+ */
+function describeParseFailure(arr, entries, salvaged, hasBracket) {
+  if (!Array.isArray(arr) || salvaged) return { kind: hasBracket ? "syntax" : "no-array", arrCount: 0, sampleTypes: [] };
+  if (arr.length === 0) return { kind: "no-array", arrCount: 0, sampleTypes: [] };
+  if (entries.length > 0) return null;
+  const sampleTypes = [...new Set(arr.map((item) => (typeof item?.type === "string" ? item.type.trim() : "")).filter(Boolean))].slice(0, 5);
+  return { kind: "filtered-empty", arrCount: arr.length, sampleTypes };
+}
+
+/**
+ * 失败行的审计读数（纯函数：不驱动整条蒸馏管线也能测）。filtered-empty 的
+ * errorMessage 直接写出 arr/valid 两个数，一眼可辨；metadata 补 failure_kind /
+ * arr_count / invalid_entries / sample_types / raw_tail——尾巴是给「先写几条合法
+ * 条目再跑偏」那种输出准备的，前 300 字看不出来。
+ */
+export function summarizeParseFailureAudit(raw, failure) {
+  const text = String(raw ?? "");
+  const kind = failure?.kind ?? (text.includes("[") ? "syntax" : "no-array");
+  const tail = text.length > 500 ? text.slice(-200) : "";
+  const filtered = kind === "filtered-empty" ? failure : null;
+  return {
+    errorMessage: filtered ? `no valid summary entries (arr=${filtered.arrCount}, valid=0)` : "invalid summary JSON",
+    metadata: {
+      parse_failure: true,
+      failure_kind: kind,
+      raw_len: text.length,
+      raw_head: text.slice(0, 300),
+      ...(tail ? { raw_tail: tail } : {}),
+      raw_has_bracket: text.includes("["),
+      ...(filtered ? { arr_count: filtered.arrCount, invalid_entries: filtered.arrCount, sample_types: filtered.sampleTypes } : {})
+    }
+  };
+}
+
+/** 导出的原因：#502 要能锁住「哪一种失败」这条判据本身，而不是只锁它的下游读数。 */
+export function parseSummaryJsonResult(raw) {
   const text = String(raw ?? "");
   const start = text.indexOf("[");
   const end = text.lastIndexOf("]");
-  if (start === -1 || end === -1 || end <= start) return { ok: false, entries: [] };
+  // 连方括号都没有 = 模型在说话（#493 的 B 臂正是这一型）。早退也要带上下：否则下游
+  // 只能靠「输出里有没有 [」再猜一次，而猜出来的东西不该写进错误消息。
+  if (start === -1 || end === -1 || end <= start) {
+    return { ok: false, entries: [], failure: describeParseFailure(null, [], false, text.includes("[")) };
+  }
   let arr;
   let salvaged = false;
   try {
@@ -77,10 +134,16 @@ function parseSummaryJsonResult(raw) {
   // 空数组表示模型明确判断本轮没有可沉淀内容；非空数组若全部无效，
   // 则不能消费窗口，否则无效输出会永久推进 seq 游标。salvage 路径
   // 没有「显式空数组」可言——ok 只看是否救回了条目。
+  const ok = salvaged ? entries.length > 0 : (arr.length === 0 || entries.length > 0);
   return {
-    ok: salvaged ? entries.length > 0 : (arr.length === 0 || entries.length > 0),
+    ok,
     entries,
-    salvaged
+    salvaged,
+    // #502：失败时要能说出**是哪一种**失败。「压根没写数组」与「写了合法数组、但条目
+    // type 全不在枚举里」过去共用一句 invalid summary JSON，而两者要修的地方完全不同
+    // ——后者是菜单与闸门不一致（summary prompt 只列 4 个类型、VALID 吃 7 个），且失败
+    // 路径游标不推进，同一窗口会被一遍遍重放（社区报告 #493 追加的实测形态）。
+    ...(!ok ? { failure: describeParseFailure(arr, entries, salvaged, text.includes("[")) } : {})
   };
 }
 
@@ -415,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" }
       })]
@@ -521,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 项）：时钟与定时器可注入——排程不绑死真实时钟，测试才能确定性
@@ -552,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 审计行（审计失败绝不阻塞蒸馏本身）。 */
@@ -619,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.
@@ -683,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"
@@ -749,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,
@@ -890,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);
@@ -899,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 = 关闭，行为与
@@ -914,19 +1050,21 @@ 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";
-          audit.errorMessage = "invalid summary JSON";
+          audit.errorMessage = failureAudit.errorMessage;
           audit.metadata = {
             distillChars,
-            parse_failure: true,
-            raw_len: raw.length,
-            raw_head: raw.slice(0, 300),
-            // 有没有出现过 `[` 是区分「模型没按格式写」与「格式对但内容救不回来」
-            // 的唯一低成本判据，也正是 #493 现场那 20 条失败的关键特征。
-            raw_has_bracket: raw.includes("["),
+            ...failureAudit.metadata,
             streak,
             ...(maxParseRetries > 0 ? { maxRetries: maxParseRetries } : {}),
             ...(skipWindow ? { skipped: "parse-failure-streak" } : {})
@@ -934,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——此前产出条数完全由模型输出决定，用户无从自查。
@@ -1013,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) {
@@ -1023,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
               });
             }
           }
@@ -1046,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,
@@ -1059,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);
@@ -1075,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",
@@ -1098,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);
     }
   }
@@ -1124,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);
   }