@modusensus/dsh-mneme 0.9.4 → 0.10.0

package/src/dream.js

@@ -10,6 +10,13 @@ import { scopeKeyOf } from "./scope.js";
 import { isInPeakWindow, nextOffPeakAt } from "./peak-hours.js";
 import { createHash, randomUUID } from "node:crypto";
 import { STR, langOf } from "./lang.js";
+// 巩固读的是行池，而动行的写手不经汇流口：applyDecisions 归档败者直接走
+// service.setArchived（dream/decisions.js），所以「不许改写外来行」这条契约要在
+// 每个池子各挡一遍。清单与静态锁见 share-imported-guard.test.js。
+import { isImportedRow } from "./memory-source.js";
+// 断链是围栏的共同底子：三处围栏（巩固/睡眠清单、蒸馏转录、画像条目）共用这一份，
+// 不许各写一条（#493 补充 §③）。
+import { breakFenceMarkers } from "./fence.js";
 export { validateDecisions, applyDecisions, withEffortFallback, withMaxTokensFallback, parseMaxTokensCap, describeStreamFailure, resolveDreamEffort, resolveRoute, streamText, runAuditedLlm };
 
 // Extract the first JSON array from LLM output, tolerating markdown fences,
@@ -57,7 +64,7 @@ function totalChars(memories) {
 // 两处若各写一份过滤条件，重启播种读到的基线就会和运行期判定口径漂移（一个把
 // document 算进去、一个不算），阈值随之失真，且这种漂移只会在重启后才显形。
 function activeStoreSize(service) {
-  const memories = withoutPaused(service, service.all().filter((m) => !m.archived && m.type !== "summary" && m.type !== "document"));
+  const memories = withoutPaused(service, service.all().filter((m) => !isImportedRow(m) && !m.archived && m.type !== "summary" && m.type !== "document"));
   return { count: memories.length, chars: totalChars(memories) };
 }
 
@@ -243,7 +250,8 @@ function buildRecordReceipts({ runId, committed, snapshot, policyEpoch }) {
       });
     } else if (c.action === "differentiate") {
       // Issue #126：互补型裁决——两条都保留，各记一条 receipt。数量没有变化，
-      // count_before/after 固定 1/1（该记录只是被追加了差异注记）。
+      // count_before/after 固定 1/1。Issue #533 起正文不再追加差异注记、一个字节
+      // 都不动，这里记的是「这一对被裁定为互补」，配对关系另见 differentiated_pairs。
       for (const id of c.ids ?? []) {
         receipts.push({
           ...base,
@@ -309,6 +317,94 @@ function describeStreamFailure(reason) {
  * operation_type, model_id, related_memory_ids); `body(reportUsage)` performs
  * the actual stream consumption and is handed a usage reporter for the chunks.
  */
+/**
+ * 把喂给模型的清单包进围栏（#493 的另一半：dream / sleep 那 5 处 user 消息以前是裸放）。
+ * 三个细节各自有原因，别当装饰删：
+ * - 角色声明落在**开头**：判断「这段文本是什么」的是它所在的那条 user 消息，只写在 system
+ *   里实测救不回来（#493 的 A/C 臂：只加 system 约束仍 0/2 出 JSON）；
+ * - 正文里的 `<<<` / `>>>` 用零宽空格断链——**只中和标记，不删内容**。不这么做时，一条写着
+ *   「<<<记忆清单结束>>>」的记忆就能提前闭合围栏，把后面的文字升格成指令；而记忆正文本来就
+ *   是模型的可影响输入，这是最省事的注入入口；
+ * - 纯函数、不带 nonce：同一批记忆在下一次巩固阈值到来时会被原样再喂一次，重试收到的 prompt
+ *   必须与首次逐字节相同，否则「同输入同错」这条诊断依据就没了（#493 的重试 20 次现场就靠它）。
+ * @param {"json"|"text"} [shape] 该次调用的**输出契约**：巩固/叙述/冲突/模式要 JSON 数组，
+ *   总览摘要要散文。角色声明里那句「只输出 JSON 数组」必须跟着契约走——对散文契约说它，
+ *   模型会回 `[]`，而 `summaryText.trim()` 判非空通过，`[]` 就被当成摘要存进库（评审实测）。
+ */
+export function fenceListBody(language, text, shape = "json") {
+  const open = STR.memoryFenceOpen[language] ?? STR.memoryFenceOpen.en;
+  const close = STR.memoryFenceClose[language] ?? STR.memoryFenceClose.en;
+  const table = shape === "text" ? STR.dreamTextRoleReminder : STR.dreamRoleReminder;
+  const reminder = table[language] ?? table.en;
+  const body = breakFenceMarkers(text);
+  return `${reminder}\n\n${open}\n${body}\n${close}`;
+}
+
+/**
+ * 解析失败行的审计读数（#493 同款，报告者提的第 2 条）。dream 的 warn 日志本来就带
+ * raw length + 前 300 字，缺的是**可查询**的那一面：日志要翻、按不了、也进不了面板的
+ * 「LLM 消耗」。`raw_has_bracket` 是区分「模型压根没按格式写」与「格式对但内容救不回来」
+ * 的唯一低成本判据。
+ */
+export function parseFailureMeta(text) {
+  const raw = typeof text === "string" ? text : "";
+  return {
+    parse_failure: true,
+    raw_len: raw.length,
+    raw_head: raw.slice(0, 300).replace(/\s+/g, " ").trim(),
+    raw_has_bracket: raw.includes("[")
+  };
+}
+
+/**
+ * #534 建议 3（分账读数）：一轮巩固在「校验层」判了什么。
+ *
+ * 调用层的审计行在 LLM 返回时就写死了 status=success，而这一轮可能整单被校验
+ * 拒绝、也可能只跳过几条（degraded）。把这三个数字补进那一行的 metadata，
+ * 「调用成功率」与「整轮有效率」就有了同一份可对齐的分母，不必再拿两张表硬拼。
+ *
+ * 只记计数与动作名，不记原文——原文已经在 raw_output 列（失败轮）与 skipped
+ * （逐条 error）里了，这里再抄一遍等于同一份数据存三处。
+ */
+export function decisionValidationMeta({ verdict, errors, skipped, survivorCount } = {}) {
+  const skips = Array.isArray(skipped) ? skipped : [];
+  const actions = [...new Set(skips.map((s) => s?.action).filter((a) => typeof a === "string" && a.length > 0))];
+  // verdict 由调用方给：它知道这一轮是「没解析出数组」「整单拒绝」还是「合法子集」，
+  // 判据复用校验器的返回值而不是在这里再推一遍布尔组合。
+  return {
+    decision_validation: {
+      verdict: typeof verdict === "string" ? verdict : "unknown",
+      error_count: Array.isArray(errors) ? errors.length : 0,
+      skipped_count: skips.length,
+      survivor_count: Number.isFinite(survivorCount) ? survivorCount : 0,
+      invalid_actions: actions
+    }
+  };
+}
+
+/**
+ * #534 建议 2：失败轮把模型原文留在行上。此前失败只有一条 warn，日志一滚现场
+ * 就没了——作者实测 19 轮里 17 轮整轮无效，事后连模型是怎么坏的都复不了盘。
+ *
+ * 截断口径沿用 #502/#504（summarize.js 的 summarizeParseFailureAudit）：头部
+ * 300 字，仅当原文 >500 字时补末 200 字。只留头尾是刻意的——模型跑飞时中段是
+ * 重复噪声，头尾才分别在「它怎么起手」「它怎么收尾」上给线索；整段原文既不必要
+ * 也不该进库（一轮可有数十 KB）。
+ *
+ * 空文本返回 undefined，调用方据此整键不写（与 saveDreamRun 的 undefined→NULL
+ * 约定一致，不落一个空壳对象冒充「有原文」）。
+ */
+export function rawOutputPayload(text) {
+  if (typeof text !== "string" || text.length === 0) return undefined;
+  const tail = text.length > 500 ? text.slice(-200) : "";
+  return {
+    raw_len: text.length,
+    raw_head: text.slice(0, 300),
+    ...(tail ? { raw_tail: tail } : {}),
+    raw_has_bracket: text.includes("[")
+  };
+}
+
 async function runAuditedLlm(ctx, service, config, spec, body) {
   const audit = config?.llmAudit;
   if (audit?.enabled === false || typeof service?.saveLlmAudit !== "function") return body(() => {});
@@ -351,8 +447,19 @@ async function runAuditedLlm(ctx, service, config, spec, body) {
     errorMessage = String(error?.message ?? error);
     throw error;
   } finally {
+    // spec.metadataFrom(result)：调用方按**这一轮的原始输出**决定要不要带读数（解析成功就
+    // 返回 null → 整键不写）。判据函数必须是纯的：它读的是 result，不读控制流里的缓存，
+    // 否则「审计说了什么」会随调用方走到哪一行而变（sleep.js 同一条硬约定）。
+    let metadata;
+    if (result !== undefined && typeof spec.metadataFrom === "function") {
+      try {
+        metadata = spec.metadataFrom(result) ?? undefined;
+      } catch {
+        metadata = undefined; // 读数失败不许把审计行整个弄没
+      }
+    }
     try {
-      service.saveLlmAudit({
+      const row = service.saveLlmAudit({
         timestamp,
         trigger_source: spec.triggerSource,
         operation_type: spec.operationType,
@@ -364,8 +471,13 @@ async function runAuditedLlm(ctx, service, config, spec, body) {
         duration_ms: Date.now() - startedAt,
         status,
         error_message: errorMessage,
-        related_memory_ids: spec.relatedMemoryIds ?? []
+        related_memory_ids: spec.relatedMemoryIds ?? [],
+        ...(metadata ? { metadata } : {})
       });
+      // #534 建议 3：把刚落库这一行的 id 交回调用方。校验判决发生在调用**之后**，
+      // 只有拿到 id 才补得回去（见 store 的 annotateLlmAudit）。这里只做交接，
+      // 不改写任何调用层事实——status/token/耗时仍然是调用那一刻的真相。
+      if (spec.auditRef && typeof spec.auditRef === "object") spec.auditRef.id = row?.id;
     } catch (auditError) {
       ctx.logger?.warn?.(`dsh-mneme: llm audit write failed: ${String(auditError)}`);
     }
@@ -486,7 +598,7 @@ async function reEmbedMemory(semantic, memory, logger) {
  * 任何失败降级为 0 条，绝不反噬 dream 主流程。
  */
 async function generateNarratives({ ctx, service, config, route, language, effort, semantic, logger }) {
-  const inputs = withoutPaused(service, service.all().filter((m) => !m.archived && !m.forgotten && m.type !== "summary" && m.type !== "document"));
+  const inputs = withoutPaused(service, service.all().filter((m) => !isImportedRow(m) && !m.archived && !m.forgotten && m.type !== "summary" && m.type !== "document"));
   const clusters = clusterByTag(inputs, { minCluster: config.dreamNarrativeMinCluster ?? 3 });
   if (!clusters.length) return 0;
 
@@ -511,7 +623,7 @@ async function generateNarratives({ ctx, service, config, route, language, effor
       ...(withEffort && effort ? { reasoningEffort: effort } : {}),
       messages: [
         { role: "system", content: [{ type: "text", text: STR.prompts.narrative[language] }], source: { kind: "plugin:dsh-mneme", plugin: "dsh-mneme" } },
-        { role: "user", content: [{ type: "text", text: listing }], source: { kind: "plugin:dsh-mneme", plugin: "dsh-mneme" } }
+        { role: "user", content: [{ type: "text", text: fenceListBody(language, listing) }], source: { kind: "plugin:dsh-mneme", plugin: "dsh-mneme" } }
       ]
     }, reportUsage, (reason) => { streamFailure = describeStreamFailure(reason); }));
   };
@@ -815,13 +927,9 @@ export async function maintainIndexAfterDream(decisions, service, semantic) {
       // loser 同等处置）。winner 正文未变化，向量保持有效。
       vectorIndex.deleteEmbedding(d.loser);
     } else if (d.action === "differentiate") {
-      // Issue #126 review（Copilot）：双方正文都被追加了差异注记，而 update 在事务内
-      // 会因 txDepth>0 跳过 scheduleEmbed —— 不在这里重嵌，注记就进不了 embedding，
-      // 注释里承诺的"下一轮不再判成重复"就不成立。
-      for (const id of d.ids ?? []) {
-        const mem = service.getById(id);
-        if (mem) rebuild.set(id, [mem.title, mem.content].filter(Boolean).join("\n"));
-      }
+      // Issue #533：differentiate 现在一个字节都不改正文（只落裁决账本），两侧向量
+      // 因此保持有效，不需要重嵌。旧版在这里为「注记进 embedding 防再判重复」兜底
+      // ——那个假设已被复现证伪，重嵌反而是替它续命。
     } else if (d.action === "update") {
       const id = d.ids[0];
       const mem = service.getById(id);
@@ -1014,7 +1122,7 @@ export function createDreamScheduler({ onRun, thresholdCount = 10, thresholdChar
   async function runDream(ctx, service, config) {
     const language = langOf(config);
     const logger = ctx.logger;
-    let memories = withoutPaused(service, service.all().filter((m) => !m.archived && m.type !== "summary" && m.type !== "document"));
+    let memories = withoutPaused(service, service.all().filter((m) => !isImportedRow(m) && !m.archived && m.type !== "summary" && m.type !== "document"));
     if (memories.length === 0) return { ok: true, applied: 0, skipped: true, summary: false };
     // Issue #89：开跑时刻既喂给审计行（created_at），也是调度器闸门的时间基准。
     const dreamStartedAt = Date.now();
@@ -1132,6 +1240,12 @@ export function createDreamScheduler({ onRun, thresholdCount = 10, thresholdChar
           // 数组」消费，内联标记会污染其它读者（失败轮的 _validationFailed 是整单
           // 拒绝哨兵，语义与「部分应用」不同，也不复用）。
           skipped: result.skipped,
+          // #534 建议 2：拿到文本却解析/校验失败的轮，把模型原文的头尾留在行上。
+          // 单独一列而不是内联进 decisions——decisions 的语义是「可重放决策数组」
+          // （applyDecisions 直接吃它），塞非决策对象会污染重放者与所有按决策数组
+          // 消费的下游；失败轮哨兵 _validationFailed 也只表达「整单拒绝」这一件事。
+          // 流错误（result===undefined）没有文本可留，落 NULL。
+          raw_output: result.raw_output,
           // Issue #89（基线半边）：成功的 run 才带这两个值（见上方 baselineSnapshot
           // 的注释）。两列要么同时有值、要么同时为 NULL，读侧以「同时有值」认账。
           store_count: baselineSnapshot?.count,
@@ -1195,18 +1309,25 @@ export function createDreamScheduler({ onRun, thresholdCount = 10, thresholdChar
     const effort = await resolveDreamEffort(ctx, route, config.dreamReasoningEffort, logger);
     let decisions = null;
     let streamFailure = "";
+    // #534 建议 3：这一轮巩固的审计行 id（runAuditedLlm 落库后回填）。校验判决
+    // 出来时用它把 result 补回调用层那一行，两套账才对得上。每次重试重置，只认
+    // 最终生效的那一次调用。
+    let auditRef = {};
     const runConsolidation = (withEffort, tokens) => {
       streamFailure = "";
+      auditRef = {};
       return runAuditedLlm(ctx, service, config, {
       triggerSource: "autoDream",
       operationType: "dream_consolidate",
       modelId: `${route.provider}:${route.model}`,
       relatedMemoryIds: [...snapshot.keys()],
       streamError: () => streamFailure,
+      auditRef,
       auditError: (text) => {
         decisions = extractJsonArray(text);
         return Array.isArray(decisions) ? null : "no json array in llm output";
-      }
+      },
+      metadataFrom: (text) => (Array.isArray(decisions) ? null : parseFailureMeta(text))
     }, (reportUsage) => streamText(ctx, {
       provider: route.provider,
       model: route.model,
@@ -1215,7 +1336,7 @@ export function createDreamScheduler({ onRun, thresholdCount = 10, thresholdChar
       ...(withEffort && effort ? { reasoningEffort: effort } : {}),
       messages: [
         { role: "system", content: [{ type: "text", text: consolidationPrompt }], source: { kind: "plugin:dsh-mneme", plugin: "dsh-mneme" } },
-        { role: "user", content: [{ type: "text", text: listText }], source: { kind: "plugin:dsh-mneme", plugin: "dsh-mneme" } }
+        { role: "user", content: [{ type: "text", text: fenceListBody(language, listText) }], source: { kind: "plugin:dsh-mneme", plugin: "dsh-mneme" } }
       ]
     }, reportUsage, (reason) => { streamFailure = describeStreamFailure(reason); }));
     };
@@ -1232,10 +1353,21 @@ export function createDreamScheduler({ onRun, thresholdCount = 10, thresholdChar
       logger?.warn?.(`dsh-mneme dream: consolidation llm stream aborted or errored${streamFailure ? ` (${streamFailure})` : ""}`);
       return finish({ ok: false, error: "llm failed", summary: false });
     }
+    // #534 建议 3 的接线点：审计行已由 runAuditedLlm 落库（status=error 也只说明
+    // 「调用层这轮不算成功」），把校验层的判决补回去，两张表才说同一件事。
+    const annotateAudit = (patch) => {
+      if (!auditRef.id || typeof service?.annotateLlmAudit !== "function") return;
+      try {
+        service.annotateLlmAudit(auditRef.id, patch);
+      } catch (error) {
+        logger?.warn?.(`dsh-mneme dream: failed to annotate llm audit row: ${String(error)}`);
+      }
+    };
     if (!Array.isArray(decisions)) {
       const head = (decisionText ?? "").slice(0, 300).replace(/\s+/g, " ").trim();
       logger?.warn?.(`dsh-mneme dream: no json array in llm output (raw length ${decisionText?.length ?? 0}; head: ${head})`);
-      return finish({ ok: false, error: "no json array in llm output", summary: false });
+      annotateAudit(decisionValidationMeta({ verdict: "unparsed", errors: [], skipped: [], survivorCount: 0 }));
+      return finish({ ok: false, error: "no json array in llm output", summary: false, raw_output: rawOutputPayload(decisionText) });
     }
     const { ok, errors, skipped, resolvedShortIds, coverageShortfall } = validateDecisions(decisions, snapshot, {
       maxUpdatePerRun: config.reflectionUpdateMaxPerRun,
@@ -1271,11 +1403,15 @@ export function createDreamScheduler({ onRun, thresholdCount = 10, thresholdChar
       if (skipped.length > 0) {
         logger?.warn?.(`dsh-mneme dream: ${skipped.length} invalid decision(s) skipped: ${skipped.map((s) => `decision[${s.index}]: ${s.error}`).join("; ")}`);
       }
+      annotateAudit(decisionValidationMeta({ verdict: "rejected", errors, skipped, survivorCount: 0 }));
       return finish({
         ok: false,
         error: `invalid decisions: ${errors.length} errors`,
         summary: false,
-        decisions: [{ _validationFailed: true, errors, skipped }]
+        decisions: [{ _validationFailed: true, errors, skipped }],
+        // #534 建议 2：整轮被拒时最该留的就是模型原文——否则事后只能看到
+        // 「N errors」这个结论，看不到它到底吐了什么。
+        raw_output: rawOutputPayload(decisionText)
       });
     }
     const skippedInvalid = skipped.length > 0;
@@ -1288,6 +1424,22 @@ export function createDreamScheduler({ onRun, thresholdCount = 10, thresholdChar
     if (coverageDegraded) {
       logger?.warn?.(`dsh-mneme dream: ${coverageShortfall} (run degrades: valid subset applied, unclaimed ids kept implicitly)`);
     }
+    // 校验通过（可能带若干跳过、也可能只是覆盖率不足 → degraded）。判决补回审计行：
+    // 这一步之前没有任何地方能回答「调用成功的那一轮，决策层到底认不认」。
+    //
+    // verdict 必须与下方状态判定同源（CodeRabbit on #535）：coverageShortfall 同样是
+    // 校验层的降级，若这里只认 skippedInvalid，覆盖率不足的轮会被 dream_runs 记成
+    // degraded、审计 metadata 却写 ok——两套账在最该对齐的一格上又对不上，正是本
+    // PR 要消灭的病。
+    annotateAudit(decisionValidationMeta({
+      verdict: skippedInvalid || coverageDegraded ? "degraded" : "ok",
+      errors,
+      skipped,
+      // 校验器已就地 splice：这个长度就是下游 apply/audit 真正会消费的条目数
+      // （含隐式补齐的 keep）。不能再减 skipped.length——被跳过的那些早被剪掉了，
+      // 再减一次会把「跳 1 条、存活 1 条」算成 0（本分支自测当场抓到过）。
+      survivorCount: decisions.length
+    }));
 
     // Capture pre-update snapshots so the audit records what each update changed.
     const updateSnapshots = {};
@@ -1380,7 +1532,8 @@ export function createDreamScheduler({ onRun, thresholdCount = 10, thresholdChar
     // mint 来源：主链路的 create 落 source=dream。来源从管道给而非从决策对象取——
     // 见 applyDecisions 的 @param config。
     const { applied, conflicts, failures, committed } = applyDecisions(
-      applyList, service, logger, snapshot, { ...config, mintSource: "dream" }
+      // runId 让 differentiate 的账本行能追到是哪一轮 dream 判的（issue #533）。
+      applyList, service, logger, snapshot, { ...config, mintSource: "dream", runId }
     );
     // Per-record receipt chain: one row per actually-committed merge/conflict/
     // update verdict, stamped with the decision-basis digest + idempotency
@@ -1458,7 +1611,7 @@ export function createDreamScheduler({ onRun, thresholdCount = 10, thresholdChar
       ...(withEffort && effort ? { reasoningEffort: effort } : {}),
       messages: [
         { role: "system", content: [{ type: "text", text: STR.prompts.dreamSummary[language] }], source: { kind: "plugin:dsh-mneme", plugin: "dsh-mneme" } },
-        { role: "user", content: [{ type: "text", text: summaryInputs.map((m) => `- ${m.title}: ${m.content}`).join("\n") }], source: { kind: "plugin:dsh-mneme", plugin: "dsh-mneme" } }
+        { role: "user", content: [{ type: "text", text: fenceListBody(language, summaryInputs.map((m) => `- ${m.title}: ${m.content}`).join("\n"), "text") }], source: { kind: "plugin:dsh-mneme", plugin: "dsh-mneme" } }
       ]
     }, reportUsage, (reason) => { summaryStreamFailure = describeStreamFailure(reason); }));
     };
@@ -1476,7 +1629,7 @@ export function createDreamScheduler({ onRun, thresholdCount = 10, thresholdChar
     // （saveWithDedupe 不带 agent_scope/workspace_scope），所以被按下作用域的内容
     // 一旦进了总览，注入侧按作用域过滤就再也拦不住它：内容已经洗成了全局行。
     // 别的入口漏了只是「那一条漏过去」，这里漏了是「洗一遍之后一直漏」。
-    const summaryAll = withoutPaused(service, service.all().filter((m) => !m.archived && m.type !== "summary" && m.type !== "document"));
+    const summaryAll = withoutPaused(service, service.all().filter((m) => !isImportedRow(m) && !m.archived && m.type !== "summary" && m.type !== "document"));
     const summaryMaxInputs = Number.isInteger(config.dreamSummaryMaxInputs) ? config.dreamSummaryMaxInputs : 0;
     const summaryInputs = summaryMaxInputs > 0 && summaryAll.length > summaryMaxInputs
       ? [...summaryAll]

package/src/fence.js

@@ -0,0 +1,24 @@
+// dsh-mneme/src/fence.js
+// 围栏正文的「断链」——把内容里自带的 `<<<` / `>>>` 拆散，使它无法提前闭合我们围出来的围栏。
+//
+// 为什么单独成模块（#493 的补充，报告者 §③）：断链原先只长在 dream.js 的 fenceListBody
+// 里，于是同一件事在三处各有一条命：dream/sleep 的清单（有断链）、蒸馏转录（没有）、
+// 画像提取的条目（也没有）。两处一旦分叉，下次出问题就得分别查一遍——#494 与 #501/PR
+// #503 的重复劳动就是这么来的。判定逻辑只能有一份实现，这条纪律在本仓已经付过学费
+// （scopeStateGate 注释里「过滤点漂移」那条）。
+//
+// 三个刻意的性质：
+// - **只中和标记，不删内容**：被断链的文本仍逐字可读（零宽空格不占位），只是不再是
+//   一个能匹配围栏串的连续字符序列。吞掉正文会让「这段记忆说了什么」变成不可复原的。
+// - **纯函数、不带 nonce**：重试收到同输入时提示词必须逐字节相同，否则「同输入同错」
+//   这条诊断依据就没了（#493 的重试 20 次现场全靠它）。同一份文本调两次结果相同。
+// - **不认围栏名字**：三对围栏（转录 / 记忆清单 / 画像条目）都以 `<<<` 开头、`>>>` 收尾，
+//   中和这两个前缀/后缀就够了；认名字反而会在新增围栏时漏一处。
+/**
+ * 断链：`<<<` / `>>>` 中间插一个零宽空格。
+ * @param {string} text 任意正文
+ * @returns {string} 断链后的正文（未触及的文本逐字节不变）
+ */
+export function breakFenceMarkers(text) {
+  return String(text ?? "").replace(/<<<|>>>/g, (run) => `${run[0]}\u200B${run.slice(1)}`);
+}

package/src/index.js

@@ -14,6 +14,7 @@ import { createInjector } from "./inject.js";
 import { createPreInjectGate } from "./pre-inject-gate.js";
 import { createContinuityRescue } from "./continuity.js";
 import { createSummarizer } from "./summarize.js";
+import { createSessionGate } from "./session-gate.js";
 import { createDreamScheduler, describeStreamFailure } from "./dream.js";
 import { createSleepScheduler, runSleep } from "./dream/sleep.js";
 import { createApi } from "./api.js";
@@ -231,6 +232,7 @@ export const apply = (ctx, config) => {
   for (const [objKey, sub] of Object.entries(nestedFlags)) {
     cfg[objKey] = { ...(cfg[objKey] ?? {}), ...sub };
   }
+  const sessionGate = createSessionGate(cfg);
 
   // 失败表的启动期清理也放在装配之后（此前它在 createStore 之后、装配之前，写死
   // 90 天）。保留期现在是显式配置键 reflectionFailureRetentionDays；等它进面板
@@ -411,7 +413,7 @@ export const apply = (ctx, config) => {
   //
   // 门控：默认关（actionRunEnabled），并且它挂热路径，轻量档也关。
   if (cfg.actionRunEnabled === true) {
-    recorder = createExecutionRecorder({ ctx, logger: ctx.logger });
+    recorder = createExecutionRecorder({ ctx, logger: ctx.logger, sessionGate });
     const disposeMoRun = registerMoRunCommand({
       ctx,
       recorder,
@@ -535,6 +537,13 @@ export const apply = (ctx, config) => {
 
   const disposers = [];
 
+  try {
+    const disposeSessionGate = ctx.on?.("session/event", (session) => sessionGate.observe(session));
+    if (typeof disposeSessionGate === "function") disposers.push(disposeSessionGate);
+  } catch {
+    // 宿主没有该事件钩子时，注入、工具与蒸馏消费点仍直接检查当前 Session。
+  }
+
   // Issue #380：注入前判定闸门。判定 LLM 走 entity adapter 同款装配（ctx.llm +
   // agentDefaultModel 回退），gate 自持 enabled/usable 判定（未启用/llm 缺席/
   // llmAudit 关闭时内部恒 off，注入行为与现状逐字节一致）。
@@ -552,21 +561,21 @@ export const apply = (ctx, config) => {
   disposers.push(() => semantic.dispose());   // #118 重试计时器 + boot 回填计时器(搬入 semantic.js 后由它自持)
 
   ctx.inject(["systemPrompt"], (promptCtx) => {
-    if (cfg.autoInject) disposers.push(createInjector(promptCtx, service, settings, cfg, preInjectGate));
+    if (cfg.autoInject) disposers.push(createInjector(promptCtx, service, settings, cfg, preInjectGate, sessionGate));
   });
 
   // #249 N3：压缩边缘双落点。触发靠宿主自己落的压缩事件（订阅 + pre-step 追加），
   // 不需要 systemPrompt / tools 的任何能力，所以不塞进上面的 inject 回调；父／子
   // 闸门在挂载点判一次，与 inject.js 共用同一个 injectChildEnabled 判据。
   if (cfg.autoInject && injectChildEnabled(cfg, "continuityRescueEnabled")) {
-    disposers.push(createContinuityRescue(ctx, store));
+    disposers.push(createContinuityRescue(ctx, store, sessionGate));
   }
 
   ctx.inject(["tools"], (toolsCtx) => {
-    disposers.push(createTools(toolsCtx, service, cfg, embedder));
+    disposers.push(createTools(toolsCtx, service, cfg, embedder, sessionGate));
   });
 
-  const summarizer = createSummarizer(ctx, service, cfg);
+  const summarizer = createSummarizer(ctx, service, cfg, {}, sessionGate);
   disposers.push(summarizer.dispose);
 
   // #275 存储生命周期第一批：无损回收的手动入口。刻意不挂启动路径、不接定时器——
@@ -607,7 +616,7 @@ export const apply = (ctx, config) => {
   // 为什么挂 session/event 却又要进轻量档黑名单：它读的是 zstd 会话日志（同步解压），
   // 是本插件里最重的一条后台路径；且它只产「提议」，关掉不影响记忆本身的正确性。
   if (cfg.actionNudgeEnabled === true) {
-    disposers.push(createNudgeAutoRun({ ctx, memoryDir, logger: ctx.logger }));
+    disposers.push(createNudgeAutoRun({ ctx, memoryDir, logger: ctx.logger, sessionGate }));
   }
 
   // Standalone external API (v0.7.12): plain node:http server for ecosystem

package/src/inject.js

@@ -1,4 +1,4 @@
-import { createScopeResolver } from "./scope.js";
+import { createScopeResolver, sessionOf } from "./scope.js";
 import { createHotMemory, roundsFromEvents } from "./hot-memory.js";
 import { STR, langOf } from "./lang.js";
 import { escapePromptVars as escapePromptVarsWithConfig, renderUserSettingsBlock } from "./user-settings.js";
@@ -93,7 +93,7 @@ function extractRounds(ctx, maxRounds) {
   }
 }
 
-export function createInjector(ctx, service, settings, config, gate = null) {
+export function createInjector(ctx, service, settings, config, gate = null, sessionGate = null) {
   const language = langOf(config);
   const baseMaxItems = config.maxInjectedItems ?? 5;
   const threshold = config.importanceThreshold ?? 3;
@@ -343,7 +343,11 @@ export function createInjector(ctx, service, settings, config, gate = null) {
   // 第二道、也是同一个判据的显式落点——两处消费点共用 injectChildEnabled，
   // 不在各自的地方重写「父关则子不生效」。
   const guideSection = injectChildEnabled(config, "injectGuidanceEnabled") && typeof ctx.systemPrompt?.section === "function"
-    ? ctx.systemPrompt.section({ name: "memory-guide", order: 150, text: MEMORY_GUIDE_SECTION })
+    ? ctx.systemPrompt.section({
+      name: "memory-guide",
+      order: 150,
+      text: (promptCtx) => (sessionGate?.isOff(sessionOf(promptCtx)) ? "" : MEMORY_GUIDE_SECTION)
+    })
     : null;
 
   const disposers = [
@@ -352,6 +356,7 @@ export function createInjector(ctx, service, settings, config, gate = null) {
       name: "memory",
       order: 90,
       text: (ctx) => {
+        if (sessionGate?.isOff(sessionOf(ctx))) return "";
         // Bug4: pass the latest user query so injection prefers semantically
         // relevant memories; lastUserQuery is best-effort (empty → legacy).
         // The query vector is prefetched asynchronously (cached) because the
@@ -434,7 +439,7 @@ export function createInjector(ctx, service, settings, config, gate = null) {
     ctx.systemPrompt.context({
       name: "user-settings",
       order: 85,
-      text: (ctx) => renderUserSettings(ctx)
+      text: (ctx) => (sessionGate?.isOff(sessionOf(ctx)) ? "" : renderUserSettings(ctx))
     })
   ];