@modusensus/dsh-mneme 0.14.0-beta.1 → 0.14.0-beta.2

package/lib/summarize.js

@@ -1,1343 +1,1388 @@
-import { BlockAssembler, createUserMessage } from "@deepseek-ai/dsh-llm";
-import { STR, langOf } from "./lang.js";
-// Issue #315：蒸馏链路的 effort 降级复用巩固侧的 withEffortFallback（拒绝
-// 重试一次不带 effort 字段）与 describeStreamFailure（流失败原因归一）——
-// 三条链路同一降级语义，不另造第二份实现。
-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";
-// Issue #611：图片块的文本口径（占位，不是空串）。三个 textOf 副本共用这一份。
-import { contentToText, countImages } from "./attachment-text.js";
-// #512：每轮蒸馏一个 run id（归因主体）。store 侧也能铸造，但这里必须知道它——
-// 写记忆时要把它一路带到 saveMemoryProvenance / 落 run 行，拿回来再写就是两次往返。
-import { randomUUID } from "node:crypto";
-
-// 编码记忆蒸馏 prompt（codingRetrospect 开启时启用）：在通用记忆之外，额外提取
-// 三类编码专属记忆，专治重复踩坑 / 遗忘被否决方案 / 丢失工程约束。字段仍沿用
-// title/content 单列结构（store 无结构化字段），信息浓缩进 content。
-/** 解析 LLM 输出中的 JSON 数组，并保留数组是否有效的结果。 */
-// 蒸馏产物的事件时间锚定（SimpleMem，arXiv 2601.02553：抽取与时间锚定在同一次
-// 生成里完成，消融去掉后时间类问题 F1 掉 56.7%）。归一放在解析层而不是交给
-// store.normalizeOccurredAt：后者只判「可解析就 UTC ISO、否则 NULL」，拦不住模型
-// 编造的未来时间——而未来时间的记忆会污染注入侧的时间排序与 memory_search 的
-// 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();
-  if (!text) return undefined;
-  const ms = Date.parse(text);
-  if (!Number.isFinite(ms)) return undefined;
-  // 容忍 1 天：模型给的绝对时间可能略晚于当下（时区/时钟偏移），超出即视为瞎填。
-  if (ms - nowMs > OCCURRED_AT_FUTURE_TOLERANCE_MS) return undefined;
-  try {
-    return new Date(ms).toISOString();
-  } catch {
-    return undefined;
-  }
-}
-
-/**
- * 失败形态分类（#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("]");
-  // 连方括号都没有 = 模型在说话（#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 {
-    arr = JSON.parse(text.slice(start, end + 1));
-  } catch {
-    // issue #339 / E8 实测：10-20% 的窗口输出了含记忆条目的完整对象，只因中段
-    // 一处语法错误被整窗 JSON.parse 拒收；而失败路径的生产行为是游标不推进 +
-    // 温度 0 重试同文同错 = 该窗口记忆静默丢失。这里做失败路径修复：括号配对
-    // 扫描截出完整的顶层对象逐个 parse，救活多少算多少；截出 0 个不视为「模型
-    // 显式说无内容」（那是 ok:true 专属于真实空数组的语义）。
-    arr = salvageArrayItems(text.slice(start, end + 1));
-    salvaged = true;
-  }
-  if (!Array.isArray(arr)) return { ok: false, entries: [] };
-  const VALID = new Set(["preference", "project", "decision", "history", "rejected_solution", "pitfall", "constraint"]);
-  const entries = arr.filter(
-    (item) =>
-      item &&
-      typeof item === "object" &&
-      VALID.has(item.type) &&
-      typeof item.title === "string" &&
-      item.title.trim() &&
-      typeof item.content === "string" &&
-      item.content.trim()
-  ).map((item) => {
-    const occurredAt = normalizeDistilledOccurredAt(item.occurred_at);
-    return {
-      type: item.type,
-      title: item.title.trim(),
-      content: item.content.trim(),
-      importance: Number.isInteger(item.importance) ? Math.min(5, Math.max(1, item.importance)) : 3,
-      // 不可解析 / 未来时间：省略该键（不写 null、不写空串），让「模型没给」与
-      // 「给了但站不住」在库里同为「无时间锚」，避免下游把空值当成已锚定。
-      ...(occurredAt !== undefined ? { occurred_at: occurredAt } : {})
-    };
-  });
-  // 空数组表示模型明确判断本轮没有可沉淀内容；非空数组若全部无效，
-  // 则不能消费窗口，否则无效输出会永久推进 seq 游标。salvage 路径
-  // 没有「显式空数组」可言——ok 只看是否救回了条目。
-  const ok = salvaged ? entries.length > 0 : (arr.length === 0 || entries.length > 0);
-  return {
-    ok,
-    entries,
-    salvaged,
-    // #502：失败时要能说出**是哪一种**失败。「压根没写数组」与「写了合法数组、但条目
-    // type 全不在枚举里」过去共用一句 invalid summary JSON，而两者要修的地方完全不同
-    // ——后者是菜单与闸门不一致（summary prompt 只列 4 个类型、VALID 吃 7 个），且失败
-    // 路径游标不推进，同一窗口会被一遍遍重放（社区报告 #493 追加的实测形态）。
-    ...(!ok ? { failure: describeParseFailure(arr, entries, salvaged, text.includes("[")) } : {})
-  };
-}
-
-/**
- * Salvage scanner for malformed JSON arrays (issue #339): extracts every
- * complete top-level {...} span, parsing each independently. Two passes,
- * merged with de-duplication:
- *  - pass 1 is string-aware (handles valid objects whose string values
- *    legitimately contain braces);
- *  - pass 2 ignores string state entirely — E8 现场的坏对象带奇数个引号
- *    （stray quote），pass 1 的奇偶失配会把后续对象的收尾 } 吞进字符串里，
- *    盲扫按括号深度截取反而能救回它们。坏对象两种扫法都 parse 失败，自然
- *    被丢弃；两遍的去重靠序列化键。
- */
-function salvageArrayItems(chunk) {
-  const out = [];
-  const seen = new Set();
-  const push = (obj) => {
-    if (!obj || typeof obj !== "object" || Array.isArray(obj)) return;
-    const key = JSON.stringify(obj);
-    if (!seen.has(key)) { seen.add(key); out.push(obj); }
-  };
-  for (const obj of scanBraceSpans(chunk, true)) push(obj);
-  for (const obj of scanBraceSpans(chunk, false)) push(obj);
-  return out;
-}
-
-function scanBraceSpans(chunk, respectStrings) {
-  // 修订（CodeRabbit review on #350）：只接受「最外层数组的直接子对象」——
-  // 候选 { 必须满足 arrayDepth===1 && objDepth===0 且前一非空白 token 是 [ 或
-  // ,。否则 (a) 嵌套子数组里的对象会被误捞成顶层记忆；(b) 盲扫遇到字符串值
-  // 里的 } 会提前断 span，把属性值对象当独立记忆落库。误拦的代价只是少救回
-  // （安全侧），误捞的代价是写进假记忆。
-  const items = [];
-  let arrayDepth = 0;
-  let objDepth = 0;
-  let inString = false;
-  let escape = false;
-  let objStart = -1;
-  let prev = "";
-  for (let i = 0; i < chunk.length; i++) {
-    const ch = chunk[i];
-    if (respectStrings && inString) {
-      if (escape) escape = false;
-      else if (ch === "\\") escape = true;
-      else if (ch === '"') inString = false;
-      continue;
-    }
-    if (respectStrings && ch === '"') { inString = true; continue; }
-    if (ch === "[") {
-      arrayDepth++;
-      prev = "[";
-      continue;
-    }
-    if (ch === "]") {
-      arrayDepth = Math.max(0, arrayDepth - 1);
-      prev = "]";
-      continue;
-    }
-    if (ch === "{") {
-      if (arrayDepth === 1 && objDepth === 0 && (prev === "[" || prev === ",")) {
-        objStart = i;
-      }
-      objDepth++;
-      prev = "{";
-      continue;
-    }
-    if (ch === "}") {
-      objDepth = Math.max(0, objDepth - 1);
-      if (objDepth === 0 && objStart !== -1) {
-        try { items.push(JSON.parse(chunk.slice(objStart, i + 1))); } catch { /* 坏对象跳过 */ }
-        objStart = -1;
-      }
-      prev = "}";
-      continue;
-    }
-    if (ch === ",") { prev = ","; continue; }
-    if (!/\s/.test(ch)) prev = ch;
-  }
-  return items;
-}
-
-/** Extract a JSON array from LLM output that may contain prose around it. */
-export function parseSummaryJson(raw) {
-  return parseSummaryJsonResult(raw).entries;
-}
-
-// The dsh-llm StreamChunk protocol BlockAssembler.push() consumes:
-// block-start {index, blockType}, text-delta {index, text},
-// block-end {index, block}, finish {reason}. Some consumers observe a
-// looser shape ({block} / {delta} / {kind}); normalize before pushing so
-// both real adapter streams and shape-tolerant test doubles assemble.
-const STREAM_CHUNK_TYPES = new Set([
-  "block-start",
-  "text-delta",
-  "reasoning-delta",
-  "tool-call-delta",
-  "block-end",
-  "usage",
-  "finish"
-]);
-
-function toProtocolChunk(chunk) {
-  switch (chunk.type) {
-    case "block-start":
-      return { type: "block-start", index: chunk.index ?? 0, blockType: chunk.blockType ?? chunk.block?.type ?? "text" };
-    case "text-delta":
-      return { type: "text-delta", index: chunk.index ?? 0, text: chunk.text ?? chunk.delta ?? "" };
-    case "reasoning-delta":
-      return { type: "reasoning-delta", index: chunk.index ?? 0, text: chunk.text ?? chunk.delta ?? "" };
-    case "block-end":
-      return { type: "block-end", index: chunk.index ?? 0, block: chunk.block ?? { type: "text" } };
-    case "finish":
-      return {
-        type: "finish",
-        reason: chunk.reason ?? { kind: chunk.kind === "error" ? "error" : "stop" },
-        replayState: chunk.replayState
-      };
-    default:
-      return chunk;
-  }
-}
-
-// Only direct human prompts are summarized: plugin-injected context
-// (AGENTS.md, skill bodies, file-change notices) and other machine-originated
-// events must not leak into the memory store. Events without a data payload
-// (minimal test doubles) pass the kind check and are handled by the content
-// check below.
-//
-// codingRetrospect: each new distill window contains the complete available
-// transcript for that window — user prompts plus assistant public replies, tool
-// calls + results and code dispatch output — so the summarizer can see tool
-// errors and extract pitfall root causes, not just what the user typed. The same
-// filtering stays: only source.kind === "user" prompts enter (plugin/machine
-// content is excluded). The result is a single text transcript passed to the
-// LLM as one user message (SUMMARY_PROMPT already says "根据下面的会话内容").
-//
-// Privacy: assistant `reasoning` (private thought) blocks are deliberately NOT
-// collected — distilled memories must never sink private reasoning chains.
-// Only public text blocks (type "text") reach the summarizer.
-function eventSeq(event) {
-  return Number.isSafeInteger(event?.seq) ? event.seq : undefined;
-}
-
-const SUBAGENT_MESSAGE_KINDS = new Set(["agent-message", "subagent-settled"]);
-
-// 兼容严格形状 [{type:"text",text}] 与宽松形状 ["字符串", ...]（lib-smoke 用例
-// 直接传字符串数组）。只取公开文本块；reasoning 私有推理块不进蒸馏上下文。
-//
-// Issue #611：图片块曾经在这里一律变空串，于是图-only 消息整条被丢、图+文消息只剩
-// 文字——静默，没有任何计数。现在改由 attachment-text 统一产占位，
-// `[图: 屏幕截图 … 1543x983]`。抽取口径只有一份，三个调用方（本文件 /
-// continuity / hot-memory）共用，避免同一件事写成三份会漂移的实现。
-function textOf(content) {
-  return contentToText(content);
-}
-
-/**
- * Issue #399：公开会话正文的**单一隐私谓词**。
- *
- * 渲染（喂给 LLM 的转录）与落盘（distill_records 原始记录）必须走同一份判定，
- * 各写一遍必然漂移——而漂移方向是「存下来的比 LLM 看过的更多」，也就是把从未
- * 交给模型的内容留在盘上，是最糟的那个方向。所以这里只回答一个问题：这个事件
- * 里有没有**可公开的会话正文**，是什么角色、什么原文；裁剪与格式化交给调用方。
- *
- * 返回 `[]` 表示不含可公开正文，包含三种情形：
- * - 机器注入内容（AGENTS.md、skill 正文、文件变更通知）：source.kind 不是
- *   user / agent-message / subagent-settled，整个事件被挡在门外；
- * - 私有推理（assistant 的 reasoning 块）：textOf 只认 `type:"text"` 块，
- *   思考链在两条路径上都到不了；
- * - 工具调用与结果、code 输出：它们是**渲染专属**内容（codingRetrospect 需要
- *   模型看见工具报错才能沉淀踩坑根因），但 #399 明确不落盘（已知边界 3），
- *   因此由 collectMessages 的渲染分支单独处理，不进这个函数。
- *
- * @returns {Array<{role: "user"|"assistant"|"agent", text: string, key?: string}>}
- *   text 是**未截断**原文；key 仅子会话消息用于跨事件去重。
- */
-function publicTranscriptParts(event) {
-  const data = event?.data ?? {};
-  const kind = data?.source?.kind;
-  const parts = [];
-  const pushAgentMessage = (message) => {
-    const messageKind = message?.source?.kind;
-    if (!SUBAGENT_MESSAGE_KINDS.has(messageKind)) return;
-    const text = textOf(message?.content);
-    if (!text.trim()) return;
-    parts.push({
-      role: "agent",
-      text,
-      // Issue #611：把产文本的那份 content 一起带出去。判定与文本同源，计量才能
-      // 跟着同一份判定走（见 collectMessages 里的 imageCount）——另写一套「哪些块
-      // 算公开」给计量用，就是第二份实现，迟早与这份漂移。
-      blocks: Array.isArray(message?.content) ? message.content : [],
-      // 同一条子会话消息可能同时出现在 user/message 与 agent/inbox/spliced
-      // 里（投递路径重叠），按 id（无 id 时按内容）去重，否则转录会重复。
-      key: typeof message?.id === "string" && message.id
-        ? `id:${message.id}`
-        : `content:${messageKind}:${text}`
-    });
-  };
-  switch (event?.type) {
-    case "user/message": {
-      if (kind !== undefined && kind !== "user" && !SUBAGENT_MESSAGE_KINDS.has(kind)) break;
-      const text = textOf(data?.content);
-      if (!text.trim()) break;
-      if (SUBAGENT_MESSAGE_KINDS.has(kind)) pushAgentMessage(data);
-      else parts.push({ role: "user", text, blocks: Array.isArray(data?.content) ? data.content : [] });
-      break;
-    }
-    case "agent/inbox/spliced": {
-      const inserted = Array.isArray(data?.inserted) ? data.inserted : [];
-      for (const message of inserted) pushAgentMessage(message);
-      break;
-    }
-    case "assistant/message": {
-      const blocks = Array.isArray(data?.message?.content) ? data.message.content : [];
-      const text = textOf(blocks);
-      // 私有推理块（reasoning）刻意不采集：蒸馏记忆不得沉淀模型私有思考链。
-      if (text.trim()) parts.push({ role: "assistant", text, blocks });
-      break;
-    }
-    default:
-      break;
-  }
-  return parts;
-}
-
-// DSH 0.1.2-rc.1 起 Session 改用 snapshotEvents()，兼容旧版 .events。
-// snapshotEvents 的范围参数按 seq 传入；再做一次事件级过滤，是为了兼容
-// 旧实现忽略参数、或把边界解释为闭区间的情况，同时避免用数组下标充当游标。
-function snapshotSessionEvents(session, afterSeq, throughSeq) {
-  let events;
-  if (typeof session?.snapshotEvents === "function") {
-    events = afterSeq === undefined && throughSeq === undefined
-      ? session.snapshotEvents()
-      : session.snapshotEvents(afterSeq, throughSeq);
-  } else {
-    events = session?.events ?? [];
-  }
-  if (!Array.isArray(events)) events = session?.events ?? [];
-  if (!Array.isArray(events)) return [];
-  return events.filter((event) => {
-    const seq = eventSeq(event);
-    // 一旦已有 seq 游标，没有 seq 的事件就无法证明是新增事件，不能重新打开
-    // 已经成功消费过的窗口。
-    if (afterSeq !== undefined && (seq === undefined || seq <= afterSeq)) return false;
-    if (throughSeq !== undefined && seq !== undefined && seq > throughSeq) return false;
-    return true;
-  });
-}
-
-function collectMessages(session, maxChars = 8000, language = "zh", afterSeq, throughSeq) {
-  const events = snapshotSessionEvents(session, afterSeq, throughSeq);
-  const lines = [];
-  const seenSubagentMessages = new Set();
-  // Issue #611：这一窗里被折成占位的图片张数。占位本身不丢信息，但「折了几张」
-  // 必须是个能读到的数——否则 off 档和旧版静默丢弃在观测上无法区分，下次再有人
-  // 问「图到底进来没有」还是得翻源码。计量只数窗口内事件，不受截断影响。
-  let imageCount = 0;
-  const trim = (s, n) => (typeof s === "string" && s.length > n ? `${s.slice(0, n)}…` : s);
-  const trimTranscript = (s, n) => {
-    if (typeof s !== "string" || s.length <= n) return s;
-    if (n <= 1) return "…".slice(0, n);
-    return `…${s.slice(-(n - 1))}`;
-  };
-  const appendSubagentMessage = (message) => {
-    const kind = message?.source?.kind;
-    if (!SUBAGENT_MESSAGE_KINDS.has(kind)) return;
-    const text = textOf(message?.content);
-    if (!text.trim()) return;
-    const key = typeof message?.id === "string" && message.id
-      ? `id:${message.id}`
-      : `content:${kind}:${text}`;
-    if (seenSubagentMessages.has(key)) return;
-    seenSubagentMessages.add(key);
-    lines.push(STR.transcriptAgent[language](text));
-  };
-  for (const event of events) {
-    const data = event?.data ?? {};
-    // #399：用户提示 / 助手公开正文 / 子会话交付三种可公开内容由共享谓词产出，
-    // 渲染与落盘因此不可能对「什么算公开」产生分歧（见 publicTranscriptParts）。
-    for (const part of publicTranscriptParts(event)) {
-      if (part.role === "agent") {
-        if (part.key && seenSubagentMessages.has(part.key)) continue;
-        if (part.key) seenSubagentMessages.add(part.key);
-      }
-      // Issue #611 计量：数「真正进了转录的图块」，所以按 part 数、并且在去重之后
-      // ——同一条子会话消息会同时出现在 user/message 与 agent/inbox/spliced 里
-      // （投递路径重叠），按事件数会把它算两遍。
-      //
-      // 不按事件数还有个更要紧的理由：被 publicTranscriptParts 挡掉的注入消息
-      // （工具结果、插件注入、陌生 source.kind）里的图根本进不了转录，按事件累加
-      // 会报「这一窗有 2 张图」而转录里一张都没有。part 是渲染与落盘共用的同一份
-      // 判定，计量跟着它走，两处不会再各有一套口径。
-      imageCount += countImages(part.blocks);
-      if (part.role === "user") {
-        lines.push(STR.transcriptUser[language](part.text));
-      } else if (part.role === "agent") {
-        lines.push(STR.transcriptAgent[language](part.text));
-      } else {
-        lines.push(STR.transcriptAssistant[language](part.text));
-      }
-    }
-    // 渲染专属内容：工具调用/结果与 code 输出进 LLM 转录（codingRetrospect 靠
-    // 它们沉淀踩坑根因），但不进 distill_records——#399 已知边界 3 明说不覆盖。
-    switch (event.type) {
-      case "tool/call": {
-        const args = typeof data.arguments === "string"
-          ? data.arguments
-          : data.arguments ? JSON.stringify(data.arguments) : "";
-        lines.push(STR.transcriptToolCall[language](data.name ?? "?", trim(args, 300)));
-        break;
-      }
-      case "tool/result": {
-        // 工具结果有两种形状：旧形状把载荷与 isError 装在 content 内的
-        // `type:"tool-result"` 块上；DSH 0.2.x 起内核改为直接投递 `role:"tool"`
-        // 消息本身，content 里只有 `type:"text"` 块、isError 挂在消息上。只认
-        // 旧块形状时新形状落进 undefined 分支，工具输出与工具报错被静默丢弃。
-        const message = data?.message;
-        const blocks = Array.isArray(message?.content) ? message.content : [];
-        const legacy = blocks.find((block) => block?.type === "tool-result");
-        const result = legacy ?? (message?.role === "tool" ? message : undefined);
-        const out = textOf(result?.content);
-        const status = result?.isError === true ? STR.statusFail[language] : STR.statusOk[language];
-        lines.push(STR.transcriptToolResult[language](status, trim(out, 500)));
-        break;
-      }
-      case "tool/code-dispatch": {
-        const out = textOf(data.content);
-        const status = data.isError === true ? STR.statusFail[language] : STR.statusOk[language];
-        lines.push(STR.transcriptCode[language](status, trim(out, 500)));
-        break;
-      }
-      default:
-        break;
-    }
-  }
-  const lastSeq = events.reduce((max, event) => {
-    const seq = eventSeq(event);
-    if (seq === undefined) return max;
-    return max === undefined ? seq : Math.max(max, seq);
-  }, undefined);
-  const transcriptBody = trimTranscript(lines.join("\n"), maxChars);
-  return {
-    messages: lines.length
-      ? [createUserMessage({
-        content: [{
-          type: "text",
-          // Issue #493：转录裸放 user 位时，模型把它当成「轮到我说了」接着对话
-          // 往下写，输出里连 `[` 都没有（解析器在括号早退处直接判失败）。围栏 +
-          // 角色重申把「这段文本是被提炼的素材」写进**它所在的那条消息**，而不是
-          // 只写在 system 里——实测同段转录只加 system 约束仍 0/2 出 JSON。
-          // 围栏是确定性的：重试收到的转录与首次逐字节相同（既有回归用例依赖）。
-          text: `${STR.distillRoleReminder[language]}\n\n${STR.transcriptFenceOpen[language]}\n${breakFenceMarkers(transcriptBody)}\n${STR.transcriptFenceClose[language]}`
-        }],
-        source: { kind: "plugin:dsh-mneme", plugin: "dsh-mneme" }
-      })]
-      : [],
-    hasEvents: events.length > 0,
-    lastSeq,
-    // Issue #611：这一窗折成占位的图片张数。调用方把它写进审计 metadata，
-    // 让「图进来了几张」成为可对账的事实而不是推断。
-    imageCount,
-    // Issue #493：只数**转录正文**的字符数。minWindowChars 闸门与审计里的
-    // distillChars 量的都是「这一窗有多少可提炼内容」，不是「我们额外包了多少
-    // 提示词」——若把围栏与角色句算进去，一条「短」也会凭空越过任何阈值，
-    // 闸门随之失效（实测 summarizeMinWindowChars=10 会被 4 字正文 + 包裹放行）。
-    transcriptChars: lines.length ? transcriptBody.length : 0
-  };
-}
-
-/**
- * Issue #399：把当前蒸馏窗口里**可公开的会话正文**收集成待落盘记录。
- *
- * 与 collectMessages 共用 publicTranscriptParts，但**不截断**：留存的意义就是
- * 整段原文（超长用户提示在记录里必须全文，而喂给 LLM 的转录仍受 distillMaxChars
- * 约束）——两条路径在裁剪上的差异是设计的一部分，测试锁 3 显式覆盖。
- *
- * 只收有 seq 的事件：distill_records 的主键是 (session_id, seq)，seq 也是溯源
- * 区间与幂等的唯一依据；没有 seq 就无法表达「这条记录属于哪个窗口」。
- */
-function collectTranscriptRecords(session, afterSeq, throughSeq, distilledAt) {
-  const events = snapshotSessionEvents(session, afterSeq, throughSeq);
-  const records = [];
-  const seenKeys = new Set();
-  // 窗口的 seq 区间取窗口内**全部**事件的 min/max（不只是公开正文那些）：这是
-  // LLM 实际看到的那个窗口，溯源链接要回答的是「这条记忆出自哪个窗口」。
-  let seqStart;
-  let seqEnd;
-  for (const event of events) {
-    const seq = eventSeq(event);
-    if (seq !== undefined) {
-      if (seqStart === undefined || seq < seqStart) seqStart = seq;
-      if (seqEnd === undefined || seq > seqEnd) seqEnd = seq;
-    }
-    if (seq === undefined) continue;
-    const parts = [];
-    for (const part of publicTranscriptParts(event)) {
-      if (part.key) {
-        if (seenKeys.has(part.key)) continue;
-        seenKeys.add(part.key);
-      }
-      parts.push(part);
-    }
-    if (!parts.length) continue;
-    // 主键是 (session_id, seq)：一个事件一行。agent/inbox/spliced 一次可投递多条
-    // 子会话消息（同 seq、同 role），各自成行会被 INSERT OR IGNORE 静默丢掉后几条；
-    // 按事件合并成一行才是这套主键的真实语义（角色同事件内不会混：user/message 与
-    // assistant/message 各只产出一条公开 part）。
-    records.push({
-      sessionId: session.id,
-      seq,
-      role: parts[0].role,
-      text: parts.map((part) => part.text).join("\n"),
-      windowId: `session:${session.id}:${seq}`,
-      distilledAt
-    });
-  }
-  return { records, seqStart, seqEnd };
-}
-
-// ── 智能调速器（429 保护）─────────────────────────────────────────────
-// 对话一多时 turn/end 会批量触发蒸馏，多个 LLM 请求"一拥而上"正是 429 的
-// 来源。这里借鉴机场安检的思路：所有蒸馏调用进同一个全局串行队列，按间隔
-// distillRateLimitIntervalMs 分批放行；命中 429 时按 distillRateLimitBaseDelayMs
-// 指数退避（1s→2s→4s…）自动重试 distillRateLimitRetries 次，全程对用户透明，
-// 不把 429 错误码直接抛出去。
-const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
-
-function isRateLimited(error) {
-  const status = error?.status ?? error?.statusCode ?? error?.response?.status;
-  if (status === 429) return true;
-  const msg = String(error?.message ?? error ?? "");
-  return /429|rate.?limit|too many requests|请求过于频繁/i.test(msg);
-}
-
-// 全局串行链：每个蒸馏任务在前一个结束后才开始，单次失败不阻塞后续。
-// 相邻请求间隔按"距上一个结束不足 intervalMs 就补齐等待"实现——单次蒸馏
-// 零延迟（上次结束距今已超过间隔，直接放行），只有连续批量蒸馏才触发限速。
-let distillQueue = Promise.resolve();
-let lastDistillEnd = 0;
-function enqueueDistill(task, intervalMs = 0) {
-  const run = distillQueue.then(async () => {
-    if (intervalMs > 0) {
-      const wait = Math.max(0, intervalMs - (Date.now() - lastDistillEnd));
-      if (wait > 0) await sleep(wait);
-    }
-    lastDistillEnd = Date.now();
-    return task();
-  });
-  distillQueue = run.catch(() => {});
-  return run;
-}
-
-// Issue #239（第 4 项，错峰队列）：高峰时段解析与判定已抽到独立零依赖模块
-// src/peak-hours.js（PR #320 review：#316 后 summarize 反向依赖 dream，dream 镜像
-// 错峰再 import 本文件会成真循环；时段调度本就不是蒸馏私有语义）。这里 re-export
-// 兼容既有调用方与测试（test/summarize.test.js 从本文件 import），零改动。
-// 注意 re-export 不引入本地作用域——本文件 331/387 行仍调用这两个函数，
-// import + re-export 两行都要。
-import { parsePeakSpec, isInPeakWindow, nextOffPeakAt } from "./peak-hours.js";
-export { parsePeakSpec, isInPeakWindow, nextOffPeakAt };
-export function createSummarizer(ctx, service, config, deps = {}, sessionGate = null) {
-  if (!config.autoSummarize) return { dispose: () => {} };
-
-  // Issue #239（第 4 项）：时钟与定时器可注入——排程不绑死真实时钟，测试才能确定性
-  // 覆盖「高峰顺延 → 非高峰补跑」。房型同 dream/sleep.js 的注入参数。
-  const now = typeof deps.now === "function" ? deps.now : () => Date.now();
-  const setTimer = typeof deps.setTimeoutFn === "function" ? deps.setTimeoutFn : setTimeout;
-  const clearTimer = typeof deps.clearTimeoutFn === "function" ? deps.clearTimeoutFn : clearTimeout;
-
-  // v0.9.0（M.O. 项目记忆）：蒸馏写入也要盖作用域章。此前只有 memory_save 那条工具
-  // 路径盖章（tools.js 的 resolveSessionScope 盖章块，2026-10-14 在 :174-181），而机器提炼是写入量的绝大多数——于是「项目记忆」
-  // 在库里根本不存在（全库带 scope 的行不足 3%，且带 scope 的全部来自工具路径）。
-  // 这里不另造口径：同一把解析器（scope.js 的 createScopeResolver，2026-10-13 在 :24）、同一把闸门
-  // （config.scopeEnabled === true）、同一对列（*_scope + *_scope_source='auto'），
-  // 与工具路径逐字对齐。解析器的入参形状是「工具 exec」（内部读 exec.agent.session），
-  // 蒸馏路径手里直接有会话对象，所以包一层壳喂进去——不改解析器的公共契约。
-  const resolveSessionScope = createScopeResolver({ ctx, config, logger: ctx.logger });
-
-  const inFlight = new Map();
-  // Issue #127：per-session 上一次实际开跑时刻（最小间隔闸门用）。与 inFlight
-  // 同生命周期，dispose 时一并清空。
-  const lastRunAt = new Map();
-  // Issue #239：per-session 已发起的蒸馏次数（有界检查点用）。只在实际发起 LLM
-  // 调用时自增，因此被零 LLM 预判挡下的窗口不消耗预算。
-  const runsUsed = new Map();
-  // Issue #239（第 4 项）：每会话最多挂一个待补跑定时器（错峰队列用）；dispose 时
-  // 一并清理，避免插件卸载后还留着一个会调模型的定时器。
-  const deferredRuns = new Map();
-  // Issue #210：只在一次蒸馏完整成功后记录已消费的最后事件 seq。
-  const lastDistilledSeq = new Map();
-  // Issue #493：per-session 连续解析失败计数（失败护栏用）。同一窗口在确定性
-  // 失败下会被每个 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 审计行（审计失败绝不阻塞蒸馏本身）。 */
-  function writeAudit(entry) {
-    if (config?.llmAudit?.enabled === false || typeof service.saveLlmAudit !== "function") return;
-    try {
-      service.saveLlmAudit({
-        trigger_source: "autoSummarize",
-        operation_type: "summarize_compress",
-        related_memory_ids: [],
-        ...entry
-      });
-    } catch (auditError) {
-      ctx.logger?.warn?.(`dsh-mneme: llm audit write failed: ${String(auditError)}`);
-    }
-  }
-
-  function persistCursor(sessionId, nextSeq) {
-    if (!Number.isFinite(nextSeq)) return;
-    if (typeof service.setDistillCursor !== "function") {
-      // 第三方宿主拿旧版 service 构造时没有持久化游标能力：降级为内存游标
-      // （#274 之前的行为），本进程内不重复蒸馏，重启后窗口重放由
-      // saveWithDedupe 三元组兜底。方法存在但抛错仍向上传播——那是
-      // 「写失败须回滚」的恰一次语义，不能吞（见 summarize.test.js 回滚用例）。
-      ctx.logger?.warn?.("dsh-mneme: service.setDistillCursor unavailable, distill cursor falls back to in-memory");
-      return;
-    }
-    service.setDistillCursor(sessionId, nextSeq);
-  }
-
-  function commitCursor(sessionId, nextSeq) {
-    persistCursor(sessionId, nextSeq);
-    if (Number.isFinite(nextSeq)) lastDistilledSeq.set(sessionId, nextSeq);
-  }
-
-  /**
-   * Issue #239（第 4 项）：把这一轮蒸馏推迟到最近的「高峰结束」时刻。每会话只挂
-   * 一个定时器（重复触发不叠加）；被 summarizePeakMaxDeferMinutes 截断时到点照跑
-   * （bypassPeak），长高峰不会把蒸馏饿死。定时器 unref——不阻止宿主退出。
-   */
-  function scheduleDeferredRun(session) {
-    if (disposed || deferredRuns.has(session.id)) return;
-    const at = nextOffPeakAt(new Date(now()), config.summarizePeakHours ?? "");
-    if (!at) return;
-    const maxDeferMs = (config.summarizePeakMaxDeferMinutes ?? 0) * 60000;
-    let delay = Math.max(0, at.getTime() - now());
-    const capped = maxDeferMs > 0 && delay > maxDeferMs;
-    if (capped) delay = maxDeferMs;
-    const timer = setTimer(() => {
-      deferredRuns.delete(session.id);
-      if (disposed) return;
-      // 不传触发事件：补跑要蒸的是「累积后的整窗」（从上次成功游标到最新事件），
-      // 拿老 triggerEvent 反而会把窗口卡在它那个 seq 上。
-      summarize(session, undefined, { bypassPeak: capped }).catch((error) => {
-        if (disposed || error?.name === "AbortError") return;
-        ctx.logger?.warn?.(`dsh-mneme: deferred summarization failed: ${String(error)}`);
-      });
-    }, delay);
-    timer?.unref?.();
-    deferredRuns.set(session.id, timer);
-  }
-
-  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.
-    const route = (config.summarizeProvider && config.summarizeModel)
-      ? { provider: config.summarizeProvider, model: config.summarizeModel }
-      : (header?.provider && header?.model)
-        ? { provider: header.provider, model: header.model }
-        : undefined;
-
-    // Issue #127 间隔门：同一会话两次蒸馏之间的最小间隔（0 = 现状，不限）。进入
-    // 即打点——失败/degraded 的 run 也占用间隔，与 dreamMinIntervalMinutes 语义
-    // 一致，防止失败连发。被挡下的 turn/end 静默跳过，但留一行 status='skipped'
-    // 审计，否则「这一轮为什么没蒸馏」对用户完全不可观测。
-    const gapMs = (config.summarizeMinIntervalMinutes ?? 0) * 60000;
-    const prevClaim = lastRunAt.get(session.id);
-    if (gapMs > 0 && Date.now() - (prevClaim ?? 0) < gapMs) {
-      writeAudit({
-        timestamp: new Date().toISOString(),
-        model_id: route ? `${route.provider}:${route.model}` : "unknown",
-        status: "skipped",
-        error_message: "min-interval"
-      });
-      return;
-    }
-    // Issue #239（有界检查点）：每会话 run 预算。放在间隔门之后，两者都命中时
-    // 先报间隔——间隔是「刚刚跑过」，预算是「额度用尽」，前者信息量更大。skip
-    // 仍写审计（沿用间隔门的 error_message 口径），否则「为什么不再蒸馏了」对
-    // 用户不可观测。prevRuns 在这里捕获、finally 里按 aborted 回滚（同 lastRunAt）。
-    // 游标刻意不消费：预算是「这个会话先不再蒸馏了」，把窗口留在原地，日后调高
-    // 额度（或宿主重启）仍能蒸馏到它；这与 window-too-small 主动消费游标相反——
-    // 后者是「这些事件不值得蒸馏」，留着只会每个 turn/end 重评一次。
-    // Issue #239（第 4 项，错峰队列）：高峰期不调模型——只登记一行 skip 审计并择时
-    // 补跑。游标刻意不消费：窗口继续累积，留到非高峰一次性蒸馏（批量比逐轮碎蒸更
-    // 省）。被 maxDefer 截断后到点仍处高峰时，由 opts.bypassPeak 放行。
-    if (!opts.bypassPeak && isInPeakWindow(new Date(now()), config.summarizePeakHours ?? "")) {
-      writeAudit({
-        timestamp: new Date(now()).toISOString(),
-        model_id: route ? `${route.provider}:${route.model}` : "unknown",
-        status: "skipped",
-        error_message: "peak-hours"
-      });
-      scheduleDeferredRun(session);
-      return;
-    }
-    const prevRuns = runsUsed.get(session.id);
-    const maxRuns = config.summarizeMaxRunsPerSession ?? 0;
-    if (maxRuns > 0 && (prevRuns ?? 0) >= maxRuns) {
-      writeAudit({
-        timestamp: new Date().toISOString(),
-        model_id: route ? `${route.provider}:${route.model}` : "unknown",
-        status: "skipped",
-        error_message: "max-runs-per-session"
-      });
-      return;
-    }
-    const controller = new AbortController();
-    inFlight.set(session.id, controller);
-    // audit state for the compression call. null = no audit for this run
-    // (disabled, or no LLM call was actually made). The audit row is written in
-    // the finally below — once, regardless of which exit path the call took —
-    // so a failed/aborted stream still leaves a status='error' trail without
-    // 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"
-        ? service.getDistillCursor(session.id)
-        : undefined;
-      const previousSeq = persistedCursor?.last_seq ?? lastDistilledSeq.get(session.id);
-      const triggerSeq = eventSeq(triggerEvent);
-      // 只读取上次成功游标之后、当前 turn/end 之前的事件。旧版 snapshotEvents
-      // 即使忽略范围参数，collectMessages 仍会按事件 seq 二次过滤。
-      const collected = collectMessages(
-        session,
-        config.distillMaxChars ?? 24000,
-        langOf(config),
-        previousSeq,
-        triggerSeq
-      );
-      const hasNewEvents = collected.hasEvents
-        || (triggerSeq !== undefined && (previousSeq === undefined || triggerSeq > previousSeq));
-      if (!hasNewEvents) return;
-
-      const nextSeq = Math.max(collected.lastSeq ?? Number.NEGATIVE_INFINITY, triggerSeq ?? Number.NEGATIVE_INFINITY);
-      if (!collected.messages.length) {
-        // 没有可蒸馏的公开文本也算成功消费当前事件窗口，避免每个 turn/end
-        // 都重新扫描同一批无内容事件；没有 seq 时则不提交不可验证的游标。
-        commitCursor(session.id, nextSeq);
-        return;
-      }
-      const messages = collected.messages;
-      // Issue #239（成本感知级联第一级）：零 LLM 预判。窗口内可蒸馏文本不足阈值
-      // 时直接跳过——短窗口交给模型的产出多是泛泛而谈，代价却是一次完整调用。
-      // 判定纯规则（字符数），无模型参与；被挡下的窗口照常消费游标，否则每个
-      // turn/end 都会重新评估同一段短文本。skip 原因进审计，作为后续按真实负载
-      // 决定下一级规则的依据。
-      //
-      // 字符数改为无条件计算并写进审计 metadata：它是「下一级预判该不该开、阈值
-      // 该给多少」的唯一依据，而原先开关一关就一个数都不留（维护者本机 1240 条
-      // summarize_compress 成功行的 metadata 里窗口字符数为 0 条），验收 4「默认配置
-      // 下调用量可量化下降」因此无法对账。本改动只加计量，不动任何跳过决策——
-      // summarizeMinWindowChars 仍为 0 时行为逐字节不变。
-      //
-      // Issue #493：口径改为只数转录正文（collected.transcriptChars），不再把
-      // user 消息整段长度当窗口大小——#493 给转录加了围栏与角色句，若继续按
-      // 「消息总字符数」算，一条 4 字的「短」也会被包裹撑过任何阈值，闸门等于
-      // 被自己的提示词旁路掉。
-      const distillChars = collected.transcriptChars ?? messages.reduce(
-        (total, message) => total + (Array.isArray(message.content) ? message.content : [])
-          .reduce((n, part) => n + (typeof part?.text === "string" ? part.text.length : 0), 0),
-        0
-      );
-      const minWindowChars = config.summarizeMinWindowChars ?? 0;
-      const imageCount = collected.imageCount ?? 0;
-      if (minWindowChars > 0 && distillChars < minWindowChars) {
-        commitCursor(session.id, nextSeq);
-        writeAudit({
-          timestamp: new Date().toISOString(),
-          model_id: route ? `${route.provider}:${route.model}` : "unknown",
-          status: "skipped",
-          error_message: "window-too-small",
-          metadata: { distillChars, minWindowChars, ...(imageCount > 0 ? { imageCount } : {}) }
-        });
-        return;
-      }
-      // 只有真正准备发起一次 LLM 蒸馏时才占用最小间隔与 run 预算；失败路径仍按
-      // 原语义占用（调用确实发生过），aborted 则由 finally 回滚。
-      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,
-          timestamp: new Date().toISOString(),
-          startedAt: Date.now(),
-          inputTokens: 0,
-          outputTokens: 0,
-          status: "success",
-          errorMessage: null
-        };
-      }
-
-      // Issue #315：蒸馏思考强度。'none'/未配置都不发送字段（服务商默认生效，
-      // 行为与历史版本一致）；off/low/medium/high 原样传递。
-      const summarizeEffort = config.summarizeReasoningEffort;
-      const withEffort = typeof summarizeEffort === "string" && summarizeEffort !== "none";
-
-      // 时间锚点：转录行不带时间戳，prompt 要模型把「昨天/上周」换算成绝对
-      // occurred_at，就必须给基准，否则它只能编（幻觉）。锚点取本次蒸馏触发时刻
-      // （可注入 now()，测试用假时钟）；锚点行同时是 prompt 里「按提示末尾给出的
-      // 当前时间换算」那句的落点，改写/移动随两处一起动。
-      const distillPrompt = config.codingRetrospect ? STR.prompts.codingSummary[langOf(config)] : STR.prompts.summary[langOf(config)];
-      const anchoredPrompt = `${distillPrompt}${STR.distillTimeAnchor[langOf(config)](new Date(now()).toISOString())}`;
-
-      const options = {
-        provider: route.provider,
-        model: route.model,
-        purpose: "summarization",
-        messages: [
-          { role: "system", content: [{ type: "text", text: anchoredPrompt }], source: { kind: "plugin:dsh-mneme", plugin: "dsh-mneme" } },
-          ...messages
-        ],
-        signal: controller.signal
-      };
-      // 智能调速器：整段蒸馏 LLM 调用进全局串行队列，按间隔分批放行；429 时
-      // 指数退避自动重试，全程对用户透明，不把 429 错误码直接抛出去。
-      const intervalMs = config.distillRateLimitIntervalMs ?? 1000;
-      // Issue #315：流式失败原因暂存槽。蒸馏的流失败以 aborted 结果而非 throw
-      // 返回，withEffortFallback 靠它甄别「effort 被拒收」型 aborted（dream 侧
-      // runNarratives 的 streamFailure 同款模式）。
-      let streamFailure = "";
-      const runDistill = (withEffort) => {
-        streamFailure = "";
-        return enqueueDistill(async () => {
-        const retries = config.distillRateLimitRetries ?? 3;
-        const baseDelayMs = config.distillRateLimitBaseDelayMs ?? 1000;
-        // 每次尝试独立拼 effort 字段：降级重试（withEffort=false）必须真的
-        // 不带 reasoningEffort，不能复用带字段的同一 options 对象。
-        const callOptions = withEffort && summarizeEffort
-          ? { ...options, reasoningEffort: summarizeEffort }
-          : options;
-        for (let attempt = 0; ; attempt++) {
-          // 每次尝试重置审计状态：effort 拒收/429 的失败 attempt 会把 status 置
-          // error，若后续重试成功，审计必须记录最终成功而不是残留第一次的失败
-          // （否则「摘要成功但审计报失败」，污染 llm_audit_logs 统计）。
-          if (audit) audit.status = "success";
-          const assembler = new BlockAssembler();
-          let text = "";
-          let aborted = false;
-          try {
-            for await (const chunk of ctx.llm.stream(callOptions)) {
-              if (STREAM_CHUNK_TYPES.has(chunk.type)) assembler.push(toProtocolChunk(chunk));
-              if (chunk.type === "text-delta") {
-                text += chunk.text ?? chunk.delta ?? "";
-              }
-              if (chunk.type === "usage" && audit) {
-                // 同 dream.js：真实协议是 {type:"usage", usage:TokenUsage}，用量不在
-                // chunk 顶层；顶层读取只作为把用量平铺的替身兜底。
-                const usage = chunk.usage ?? chunk;
-                const i = usage.input_tokens ?? usage.inputTokens ?? usage.prompt_tokens ?? usage.promptTokens;
-                const o = usage.output_tokens ?? usage.outputTokens ?? usage.completion_tokens ?? usage.completionTokens;
-                if (Number.isFinite(i)) audit.inputTokens = i;
-                if (Number.isFinite(o)) audit.outputTokens = o;
-              }
-              if (chunk.type === "finish") {
-                const reasonKind = chunk.reason?.kind ?? chunk.kind;
-                if (reasonKind === "error" || reasonKind === "aborted") {
-                  // 429 也可能以 finish reason error 携带 rate-limit 信息，统一
-                  // 转抛错走指数退避重试。
-                  if (isRateLimited(chunk.reason ?? chunk)) {
-                    throw Object.assign(new Error("rate limited"), { status: 429 });
-                  }
-                  // Issue #315：把失败原因原样留给外层的 effort 甄别
-                  // （withEffortFallback 只认「effort 被拒收」型失败）。
-                  streamFailure = describeStreamFailure(chunk.reason ?? chunk);
-                  if (audit) {
-                    audit.status = "error";
-                    audit.errorMessage = `llm stream ${reasonKind}`;
-                  }
-                  aborted = true;
-                  break;
-                }
-              }
-            }
-            // Direct delta accumulation is the primary extraction path (it works
-            // for real protocol chunks {index,text} and looser {delta} shapes
-            // alike); the assembler blocks are a fallback for streams that only
-            // deliver text inside block-end. This dsh-llm exposes no public
-            // no-arg assemble() — blocks() is the message-level API.
-            const blocks = assembler.blocks();
-            const assembledText = blocks
-              .filter((b) => b.type === "text")
-              .map((b) => b.text ?? "")
-              .join("");
-            return { text, assembledText, aborted };
-          } catch (error) {
-            if (error?.name === "AbortError" || controller.signal.aborted) throw error; // dispose 中止直接放行
-            if (isRateLimited(error) && attempt < retries) {
-              const delay = baseDelayMs * 2 ** attempt;
-              ctx.logger?.warn?.(
-                `dsh-mneme: 蒸馏请求过于频繁(429)，为避免限流等待 ${delay}ms 后自动重试（第 ${attempt + 1}/${retries} 次）`
-              );
-              await sleep(delay);
-              continue;
-            }
-            // 429 重试耗尽或非 429 错误：记 audit 后抛出，保持原失败路径。
-            if (audit) {
-              audit.status = "error";
-              audit.errorMessage = String(error?.message ?? error);
-            }
-            throw error;
-          }
-        }
-      }, intervalMs);
-      };
-      // Issue #315：effort 被拒收时自动去掉字段重试一次（dream/sleep/entity
-      // 同一降级策略，withEffortFallback 共享）。蒸馏的流失败以 aborted 结果
-      // 而非 throw/undefined 返回，因此甄别在这里做：effort 型失败折叠成
-      // undefined，让 withEffortFallback 走 streamFailure 甄别分支触发重试；
-      // 非 effort 的 aborted 原样返回，仍走既有的 abortedRun 路径。
-      const result = await withEffortFallback(
-        ctx,
-        summarizeEffort,
-        () => runDistill(withEffort).then((r) =>
-          (r?.aborted && EFFORT_REJECT_RE.test(streamFailure)) ? undefined : r),
-        () => runDistill(false),
-        () => streamFailure
-      );
-      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);
-      // 解析失败不推进 seq 游标，下一次 turn/end 仍会重试同一窗口。
-      if (!parsedResult.ok) {
-        // Issue #493：失败也要留证据。原先 metadata 只在成功路径赋值，失败行恒为
-        // null —— 事后无法回答「模型到底吐了什么形状」。这里只加计量、不做任何
-        // 跳过决策（raw_head 截断到 300 字符，避免把审计表撑大）。
-        const raw = text || assembledText || "";
-        const streak = bumpParseFailureStreak(session.id);
-        // Issue #493 失败护栏：同一窗口连续失败到阈值后强制消费游标跳过它。
-        // 确定性失败（finish_reason=stop、同文同温）重试收益为 0，而窗口只会随
-        // 新事件继续变大——没有出口时它会一直失败下去。默认 0 = 关闭，行为与
-        // 历史版本逐字节一致（本仓新行为一律 opt-in，见 AGENTS.md）。
-        const maxParseRetries = config.summarizeParseFailureMaxRetries ?? 0;
-        // nextSeq 必须是有限数才算真的「跳过了窗口」：没有可验证的 seq 时
-        // commitCursor 是空操作（persistCursor 早退、内存游标也不写），此时若
-        // 仍按跳过记账并清零 streak，审计会宣称「已放弃」而窗口下一轮照旧重试
-        // —— 那是最坏的一种假象：用户以为止血了，实际还在烧。
-        const skipWindow = maxParseRetries > 0 && streak >= maxParseRetries && Number.isFinite(nextSeq);
-        if (skipWindow) {
-          // 先提交游标再复位计数：窗口已放弃，下一窗从全新状态起算。
-          commitCursor(session.id, nextSeq);
-          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 = failureAudit.errorMessage;
-          audit.metadata = {
-            distillChars,
-            ...(imageCount > 0 ? { imageCount } : {}),
-            ...failureAudit.metadata,
-            streak,
-            ...(maxParseRetries > 0 ? { maxRetries: maxParseRetries } : {}),
-            ...(skipWindow ? { skipped: "parse-failure-streak" } : {})
-          };
-        }
-        return;
-      }
-      clearParseFailureStreak(session.id);
-      const parsed = parsedResult.entries;
-      // Issue #127 条数上限：0 = 不限（现状）。被截断的条数与去重命中数一并进
-      // 审计 metadata——此前产出条数完全由模型输出决定，用户无从自查。
-      const cap = config.summarizeMaxEntriesPerRun ?? 0;
-      const entries = cap > 0 ? parsed.slice(0, cap) : parsed;
-      const capped = parsed.length - entries.length;
-      const dedupeMode = config.summarizeDedupeMode ?? "off";
-      let deduped = 0;
-      let dedupeMaxSim = 0;
-      // v0.9.0（M.O. 项目记忆）：一次窗口解析一次——同一蒸馏窗口里所有条目同属一个
-      // 工作区、一个 agent 身份，逐条解析是白花钱。解析不到就落 NULL（NULL = 未标注 =
-      // 全局可见），且解析器绝不抛错（scope.js 的硬约束：记忆写入不该被作用域拖挂）。
-      // 闸门与 tools.js 的 autoStamping（2026-10-14 在 :175）同一把：关着就一个字段都不加，老行为不变。
-      const writeScope = config?.scopeEnabled === true
-        ? resolveSessionScope({ agent: { session } })
-        : null;
-      const writes = [];
-      for (const entry of entries) {
-        // Provenance: the summarizer runs on a real session (turn/end hook), so
-        // session.id is always available here — it rides the human-readable
-        // source label.
-        // 编码记忆类型（codingRetrospect）不带 tag：读取侧门控/加权靠 m.type
-        // （rejected_solution/pitfall/constraint）区分即可，tag 体系
-        // sanitizeTags 不认 `type:` 前缀反而会清空 tags 列（额外一次 UPDATE）。
-        const source = `session:${session.id}`;
-        // Issue #127 落库前去重（opt-in，默认 off = 现状）：命中则并入既有条目
-        // （saveWithDedupe 的 _mergeInto 分支），不再新造一行。作用域 = 同会话 +
-        // 时间窗；跨会话的同类事实仍交给 autoDream / sleep 的批量裁决。
-        const dup = (dedupeMode !== "off" && typeof service.findSessionDuplicate === "function")
-          ? await service.findSessionDuplicate(
-            { ...entry, source },
-            {
-              mode: dedupeMode,
-              minSim: config.summarizeDedupeMinSim ?? 0.92,
-              windowHours: config.summarizeDedupeWindowHours ?? 24,
-              source
-            }
-          )
-          : undefined;
-        if (dup) {
-          deduped++;
-          dedupeMaxSim = Math.max(dedupeMaxSim, dup.sim ?? 0);
-        }
-        writes.push({ entry, source, dup });
-      }
-      // #399：蒸馏窗口的原始公开记录 + 记忆级溯源链接，与记忆写入同事务落盘。
-      // 凭证与它的派生记忆必须同生共死：记忆写了而记录没写，溯源就断在「不知道
-      // 出自哪段原文」；记录写了而记忆没写，盘上留一份没有索引的原文。默认关
-      // （enabled !== true）时连收集都不做，一次 SQL 都不发（测试锁 5）。
-      const distilledAt = new Date(now()).toISOString();
-      const transcript = config?.distillRecords?.enabled === true
-        && typeof service.saveDistillRecords === "function"
-        ? collectTranscriptRecords(session, previousSeq, triggerSeq, distilledAt)
-        : null;
-      const writeWindow = () => {
-        const savedIds = [];
-        for (const { entry, source, dup } of writes) {
-          const outcome = service.saveWithDedupe({
-            ...entry,
-            source,
-            // 合并进既有行时不盖章，但这件事由 saveWithDedupe 的合并分支自己保证
-            // （它只认 explicit 来源升级，从不采纳这里传的 auto 字段）——调用方不能
-            // 靠「省略字段」来表达这个意图，因为省略会反向把合并也挡掉：
-            // findSessionDuplicate 只按 type+source+时间窗找候选，不看 scope；找到
-            // 候选后由 saveWithDedupe 的 scopeMatches 门决定并或不并。这里一省略，
-            // 新条目的 scope 就是 null，与已盖过章的候选不等，门必拒 → 回落新建，
-            // 而那一行同样是新行、同样该带章，却没有章可带。实测两轮蒸馏正是如此：
-            // 第二轮命中第一轮、门拒后新建，留下同题两行一行 auto 一行 NULL——
-            // 作用域隔离没做成，重复倒留下了。传字段、让合并分支按自己的口径处理，
-            // 才是「不重贴」与「新行必贴」两个要求的唯一相容解。
-            ...(writeScope ? { agent_scope: writeScope.agent_scope, agent_scope_source: "auto" } : {}),
-            ...(writeScope ? { workspace_scope: writeScope.workspace_scope, workspace_scope_source: "auto" } : {}),
-            ...(dup ? { _mergeInto: dup.memory.id } : {})
-          });
-          // created 与 merged 两条成功分支都返回 memory（含 id）；merged 时 id 是
-          // 被并入的既有记忆——本次窗口的原文确实贡献了它，链接它是诚实的。
-          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) {
-              service.saveMemoryProvenance({
-                memoryId,
-                sessionId: session.id,
-                seqStart: transcript.seqStart,
-                seqEnd: transcript.seqEnd,
-                createdAt: distilledAt,
-                // #512：链接指回产出它的那一轮。distillRecords 关着时这里本就不跑，
-                // 于是那一轮不会留下任何窗口级归因——这是诚实的（没存原文就没有
-                // 「这段原文」可指），run 行本身照落，条数与状态仍然可查。
-                distillRunId: distillRunId ?? undefined
-              });
-            }
-          }
-        }
-        persistCursor(session.id, nextSeq);
-      };
-      if (writes.length || (transcript && transcript.records.length)) {
-        // 查询去重目标可以异步执行，但记忆写入必须在同一个事务中完成。
-        // 否则第 N 条写入失败时，前 N-1 条会残留，而重试同一 seq 窗口会重复
-        // 追加它们。createService 始终提供 transaction；缺失时直接失败并保留
-        // 游标窗口，避免退回到不具备原子性的部分写入。
-        if (typeof service.transaction !== "function") {
-          throw new Error("dsh-mneme: atomic summarization writes require service.transaction");
-        }
-        service.transaction(writeWindow);
-      } else {
-        // 空数组是合法成功：没有记忆写入，但本次事件窗口仍然应被持久消费。
-        persistCursor(session.id, nextSeq);
-      }
-      // 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,
-          ...(imageCount > 0 ? { imageCount } : {}),
-          parsed: parsed.length,
-          ...(parsedResult.salvaged ? { json_salvaged: true } : {}),
-          ...(capped > 0 ? { capped } : {}),
-          ...(deduped > 0 ? { deduped, mode: dedupeMode, maxSim: Number(dedupeMaxSim.toFixed(4)) } : {})
-        };
-      }
-      // 记忆写入和解析都成功后才提交窗口；流失败、中止、解析失败或写入异常
-      // 都会在此之前退出，从而保留窗口供下一次重试。
-      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);
-      }
-      throw error;
-    } finally {
-      // Issue #127：aborted（会话关闭 / 插件 dispose）不占间隔，避免误伤该会话的
-      // 下一次蒸馏；其余情况（含失败）的打点保留，与 dreamMinIntervalMinutes 一致。
-      if (abortedRun || controller.signal.aborted) {
-        if (prevClaim === undefined) lastRunAt.delete(session.id);
-        else lastRunAt.set(session.id, prevClaim);
-        // Issue #239：aborted 同样不占 run 预算——调用没有真正发生，占了会误伤
-        // 该会话后续的蒸馏（与上面的间隔回滚同一口径）。
-        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 {
-          auditRow = service.saveLlmAudit({
-            timestamp: audit.timestamp,
-            trigger_source: "autoSummarize",
-            operation_type: "summarize_compress",
-            model_id: `${audit.route.provider}:${audit.route.model}`,
-            input_tokens: audit.inputTokens,
-            output_tokens: audit.outputTokens,
-            total_tokens: audit.inputTokens + audit.outputTokens,
-            cost_usd: 0,
-            duration_ms: Date.now() - audit.startedAt,
-            status: audit.status,
-            error_message: audit.errorMessage,
-            related_memory_ids: [],
-            // Issue #127：parsed / capped / deduped 的观测数据。零 schema 变更
-            // （llm_audit_logs.metadata 已存在），一条 SQL 即可验证节流是否生效。
-            metadata: audit.metadata
-          });
-        } catch (auditError) {
-          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);
-    }
-  }
-
-  const unsubscribe = ctx.on("session/event", (session, event) => {
-    if (disposed || event.type !== "turn/end") return;
-    // Return the summarization promise so awaiters observe the writes; the
-    // catch keeps listener dispatch from rejecting. Dispose-initiated aborts
-    // and external AbortErrors are silent.
-    return summarize(session, event).catch((error) => {
-      if (disposed || error?.name === "AbortError") return;
-      ctx.logger?.warn?.(`dsh-mneme: summarization failed: ${String(error)}`);
-    });
-  });
-
-  return {
-    dispose() {
-      if (disposed) return;
-      disposed = true;
-      unsubscribe?.();
-      for (const timer of deferredRuns.values()) clearTimer(timer);
-      deferredRuns.clear();
-      for (const controller of inFlight.values()) controller.abort();
-      inFlight.clear();
-      lastRunAt.clear();
-      lastDistilledSeq.clear();
-      parseFailureStreakFallback.clear();
-    }
-  };
-}
+import { BlockAssembler, createUserMessage } from "@deepseek-ai/dsh-llm";
+import { STR, langOf } from "./lang.js";
+// Issue #315：蒸馏链路的 effort 降级复用巩固侧的 withEffortFallback（拒绝
+// 重试一次不带 effort 字段）与 describeStreamFailure（流失败原因归一）——
+// 三条链路同一降级语义，不另造第二份实现。
+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";
+// Issue #611：图片块的文本口径（占位，不是空串）。三个 textOf 副本共用这一份。
+import { contentToText, countImages } from "./attachment-text.js";
+// 图像描述档（docs/DISTILL.md:346）：占位之外再补一段「图里是什么」。本文件只
+// 负责把描述并进转录行；出描述的调用、准入判断都在 image-describe.js。
+import { appendDescriptions, describeImages, imageBlocks, canSeeImages } from "./image-describe.js";
+// #512：每轮蒸馏一个 run id（归因主体）。store 侧也能铸造，但这里必须知道它——
+// 写记忆时要把它一路带到 saveMemoryProvenance / 落 run 行，拿回来再写就是两次往返。
+import { randomUUID } from "node:crypto";
+
+// 编码记忆蒸馏 prompt（codingRetrospect 开启时启用）：在通用记忆之外，额外提取
+// 三类编码专属记忆，专治重复踩坑 / 遗忘被否决方案 / 丢失工程约束。字段仍沿用
+// title/content 单列结构（store 无结构化字段），信息浓缩进 content。
+/** 解析 LLM 输出中的 JSON 数组，并保留数组是否有效的结果。 */
+// 蒸馏产物的事件时间锚定（SimpleMem，arXiv 2601.02553：抽取与时间锚定在同一次
+// 生成里完成，消融去掉后时间类问题 F1 掉 56.7%）。归一放在解析层而不是交给
+// store.normalizeOccurredAt：后者只判「可解析就 UTC ISO、否则 NULL」，拦不住模型
+// 编造的未来时间——而未来时间的记忆会污染注入侧的时间排序与 memory_search 的
+// 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();
+  if (!text) return undefined;
+  const ms = Date.parse(text);
+  if (!Number.isFinite(ms)) return undefined;
+  // 容忍 1 天：模型给的绝对时间可能略晚于当下（时区/时钟偏移），超出即视为瞎填。
+  if (ms - nowMs > OCCURRED_AT_FUTURE_TOLERANCE_MS) return undefined;
+  try {
+    return new Date(ms).toISOString();
+  } catch {
+    return undefined;
+  }
+}
+
+/**
+ * 失败形态分类（#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("]");
+  // 连方括号都没有 = 模型在说话（#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 {
+    arr = JSON.parse(text.slice(start, end + 1));
+  } catch {
+    // issue #339 / E8 实测：10-20% 的窗口输出了含记忆条目的完整对象，只因中段
+    // 一处语法错误被整窗 JSON.parse 拒收；而失败路径的生产行为是游标不推进 +
+    // 温度 0 重试同文同错 = 该窗口记忆静默丢失。这里做失败路径修复：括号配对
+    // 扫描截出完整的顶层对象逐个 parse，救活多少算多少；截出 0 个不视为「模型
+    // 显式说无内容」（那是 ok:true 专属于真实空数组的语义）。
+    arr = salvageArrayItems(text.slice(start, end + 1));
+    salvaged = true;
+  }
+  if (!Array.isArray(arr)) return { ok: false, entries: [] };
+  const VALID = new Set(["preference", "project", "decision", "history", "rejected_solution", "pitfall", "constraint"]);
+  const entries = arr.filter(
+    (item) =>
+      item &&
+      typeof item === "object" &&
+      VALID.has(item.type) &&
+      typeof item.title === "string" &&
+      item.title.trim() &&
+      typeof item.content === "string" &&
+      item.content.trim()
+  ).map((item) => {
+    const occurredAt = normalizeDistilledOccurredAt(item.occurred_at);
+    return {
+      type: item.type,
+      title: item.title.trim(),
+      content: item.content.trim(),
+      importance: Number.isInteger(item.importance) ? Math.min(5, Math.max(1, item.importance)) : 3,
+      // 不可解析 / 未来时间：省略该键（不写 null、不写空串），让「模型没给」与
+      // 「给了但站不住」在库里同为「无时间锚」，避免下游把空值当成已锚定。
+      ...(occurredAt !== undefined ? { occurred_at: occurredAt } : {})
+    };
+  });
+  // 空数组表示模型明确判断本轮没有可沉淀内容；非空数组若全部无效，
+  // 则不能消费窗口，否则无效输出会永久推进 seq 游标。salvage 路径
+  // 没有「显式空数组」可言——ok 只看是否救回了条目。
+  const ok = salvaged ? entries.length > 0 : (arr.length === 0 || entries.length > 0);
+  return {
+    ok,
+    entries,
+    salvaged,
+    // #502：失败时要能说出**是哪一种**失败。「压根没写数组」与「写了合法数组、但条目
+    // type 全不在枚举里」过去共用一句 invalid summary JSON，而两者要修的地方完全不同
+    // ——后者是菜单与闸门不一致（summary prompt 只列 4 个类型、VALID 吃 7 个），且失败
+    // 路径游标不推进，同一窗口会被一遍遍重放（社区报告 #493 追加的实测形态）。
+    ...(!ok ? { failure: describeParseFailure(arr, entries, salvaged, text.includes("[")) } : {})
+  };
+}
+
+/**
+ * Salvage scanner for malformed JSON arrays (issue #339): extracts every
+ * complete top-level {...} span, parsing each independently. Two passes,
+ * merged with de-duplication:
+ *  - pass 1 is string-aware (handles valid objects whose string values
+ *    legitimately contain braces);
+ *  - pass 2 ignores string state entirely — E8 现场的坏对象带奇数个引号
+ *    （stray quote），pass 1 的奇偶失配会把后续对象的收尾 } 吞进字符串里，
+ *    盲扫按括号深度截取反而能救回它们。坏对象两种扫法都 parse 失败，自然
+ *    被丢弃；两遍的去重靠序列化键。
+ */
+function salvageArrayItems(chunk) {
+  const out = [];
+  const seen = new Set();
+  const push = (obj) => {
+    if (!obj || typeof obj !== "object" || Array.isArray(obj)) return;
+    const key = JSON.stringify(obj);
+    if (!seen.has(key)) { seen.add(key); out.push(obj); }
+  };
+  for (const obj of scanBraceSpans(chunk, true)) push(obj);
+  for (const obj of scanBraceSpans(chunk, false)) push(obj);
+  return out;
+}
+
+function scanBraceSpans(chunk, respectStrings) {
+  // 修订（CodeRabbit review on #350）：只接受「最外层数组的直接子对象」——
+  // 候选 { 必须满足 arrayDepth===1 && objDepth===0 且前一非空白 token 是 [ 或
+  // ,。否则 (a) 嵌套子数组里的对象会被误捞成顶层记忆；(b) 盲扫遇到字符串值
+  // 里的 } 会提前断 span，把属性值对象当独立记忆落库。误拦的代价只是少救回
+  // （安全侧），误捞的代价是写进假记忆。
+  const items = [];
+  let arrayDepth = 0;
+  let objDepth = 0;
+  let inString = false;
+  let escape = false;
+  let objStart = -1;
+  let prev = "";
+  for (let i = 0; i < chunk.length; i++) {
+    const ch = chunk[i];
+    if (respectStrings && inString) {
+      if (escape) escape = false;
+      else if (ch === "\\") escape = true;
+      else if (ch === '"') inString = false;
+      continue;
+    }
+    if (respectStrings && ch === '"') { inString = true; continue; }
+    if (ch === "[") {
+      arrayDepth++;
+      prev = "[";
+      continue;
+    }
+    if (ch === "]") {
+      arrayDepth = Math.max(0, arrayDepth - 1);
+      prev = "]";
+      continue;
+    }
+    if (ch === "{") {
+      if (arrayDepth === 1 && objDepth === 0 && (prev === "[" || prev === ",")) {
+        objStart = i;
+      }
+      objDepth++;
+      prev = "{";
+      continue;
+    }
+    if (ch === "}") {
+      objDepth = Math.max(0, objDepth - 1);
+      if (objDepth === 0 && objStart !== -1) {
+        try { items.push(JSON.parse(chunk.slice(objStart, i + 1))); } catch { /* 坏对象跳过 */ }
+        objStart = -1;
+      }
+      prev = "}";
+      continue;
+    }
+    if (ch === ",") { prev = ","; continue; }
+    if (!/\s/.test(ch)) prev = ch;
+  }
+  return items;
+}
+
+/** Extract a JSON array from LLM output that may contain prose around it. */
+export function parseSummaryJson(raw) {
+  return parseSummaryJsonResult(raw).entries;
+}
+
+// The dsh-llm StreamChunk protocol BlockAssembler.push() consumes:
+// block-start {index, blockType}, text-delta {index, text},
+// block-end {index, block}, finish {reason}. Some consumers observe a
+// looser shape ({block} / {delta} / {kind}); normalize before pushing so
+// both real adapter streams and shape-tolerant test doubles assemble.
+const STREAM_CHUNK_TYPES = new Set([
+  "block-start",
+  "text-delta",
+  "reasoning-delta",
+  "tool-call-delta",
+  "block-end",
+  "usage",
+  "finish"
+]);
+
+function toProtocolChunk(chunk) {
+  switch (chunk.type) {
+    case "block-start":
+      return { type: "block-start", index: chunk.index ?? 0, blockType: chunk.blockType ?? chunk.block?.type ?? "text" };
+    case "text-delta":
+      return { type: "text-delta", index: chunk.index ?? 0, text: chunk.text ?? chunk.delta ?? "" };
+    case "reasoning-delta":
+      return { type: "reasoning-delta", index: chunk.index ?? 0, text: chunk.text ?? chunk.delta ?? "" };
+    case "block-end":
+      return { type: "block-end", index: chunk.index ?? 0, block: chunk.block ?? { type: "text" } };
+    case "finish":
+      return {
+        type: "finish",
+        reason: chunk.reason ?? { kind: chunk.kind === "error" ? "error" : "stop" },
+        replayState: chunk.replayState
+      };
+    default:
+      return chunk;
+  }
+}
+
+// Only direct human prompts are summarized: plugin-injected context
+// (AGENTS.md, skill bodies, file-change notices) and other machine-originated
+// events must not leak into the memory store. Events without a data payload
+// (minimal test doubles) pass the kind check and are handled by the content
+// check below.
+//
+// codingRetrospect: each new distill window contains the complete available
+// transcript for that window — user prompts plus assistant public replies, tool
+// calls + results and code dispatch output — so the summarizer can see tool
+// errors and extract pitfall root causes, not just what the user typed. The same
+// filtering stays: only source.kind === "user" prompts enter (plugin/machine
+// content is excluded). The result is a single text transcript passed to the
+// LLM as one user message (SUMMARY_PROMPT already says "根据下面的会话内容").
+//
+// Privacy: assistant `reasoning` (private thought) blocks are deliberately NOT
+// collected — distilled memories must never sink private reasoning chains.
+// Only public text blocks (type "text") reach the summarizer.
+function eventSeq(event) {
+  return Number.isSafeInteger(event?.seq) ? event.seq : undefined;
+}
+
+const SUBAGENT_MESSAGE_KINDS = new Set(["agent-message", "subagent-settled"]);
+
+// 兼容严格形状 [{type:"text",text}] 与宽松形状 ["字符串", ...]（lib-smoke 用例
+// 直接传字符串数组）。只取公开文本块；reasoning 私有推理块不进蒸馏上下文。
+//
+// Issue #611：图片块曾经在这里一律变空串，于是图-only 消息整条被丢、图+文消息只剩
+// 文字——静默，没有任何计数。现在改由 attachment-text 统一产占位，
+// `[图: 屏幕截图 … 1543x983]`。抽取口径只有一份，三个调用方（本文件 /
+// continuity / hot-memory）共用，避免同一件事写成三份会漂移的实现。
+function textOf(content) {
+  return contentToText(content);
+}
+
+/**
+ * Issue #399：公开会话正文的**单一隐私谓词**。
+ *
+ * 渲染（喂给 LLM 的转录）与落盘（distill_records 原始记录）必须走同一份判定，
+ * 各写一遍必然漂移——而漂移方向是「存下来的比 LLM 看过的更多」，也就是把从未
+ * 交给模型的内容留在盘上，是最糟的那个方向。所以这里只回答一个问题：这个事件
+ * 里有没有**可公开的会话正文**，是什么角色、什么原文；裁剪与格式化交给调用方。
+ *
+ * 返回 `[]` 表示不含可公开正文，包含三种情形：
+ * - 机器注入内容（AGENTS.md、skill 正文、文件变更通知）：source.kind 不是
+ *   user / agent-message / subagent-settled，整个事件被挡在门外；
+ * - 私有推理（assistant 的 reasoning 块）：textOf 只认 `type:"text"` 块，
+ *   思考链在两条路径上都到不了；
+ * - 工具调用与结果、code 输出：它们是**渲染专属**内容（codingRetrospect 需要
+ *   模型看见工具报错才能沉淀踩坑根因），但 #399 明确不落盘（已知边界 3），
+ *   因此由 collectMessages 的渲染分支单独处理，不进这个函数。
+ *
+ * @returns {Array<{role: "user"|"assistant"|"agent", text: string, key?: string}>}
+ *   text 是**未截断**原文；key 仅子会话消息用于跨事件去重。
+ */
+function publicTranscriptParts(event) {
+  const data = event?.data ?? {};
+  const kind = data?.source?.kind;
+  const parts = [];
+  const pushAgentMessage = (message) => {
+    const messageKind = message?.source?.kind;
+    if (!SUBAGENT_MESSAGE_KINDS.has(messageKind)) return;
+    const text = textOf(message?.content);
+    if (!text.trim()) return;
+    parts.push({
+      role: "agent",
+      text,
+      // Issue #611：把产文本的那份 content 一起带出去。判定与文本同源，计量才能
+      // 跟着同一份判定走（见 collectMessages 里的 imageCount）——另写一套「哪些块
+      // 算公开」给计量用，就是第二份实现，迟早与这份漂移。
+      blocks: Array.isArray(message?.content) ? message.content : [],
+      // 同一条子会话消息可能同时出现在 user/message 与 agent/inbox/spliced
+      // 里（投递路径重叠），按 id（无 id 时按内容）去重，否则转录会重复。
+      key: typeof message?.id === "string" && message.id
+        ? `id:${message.id}`
+        : `content:${messageKind}:${text}`
+    });
+  };
+  switch (event?.type) {
+    case "user/message": {
+      if (kind !== undefined && kind !== "user" && !SUBAGENT_MESSAGE_KINDS.has(kind)) break;
+      const text = textOf(data?.content);
+      if (!text.trim()) break;
+      if (SUBAGENT_MESSAGE_KINDS.has(kind)) pushAgentMessage(data);
+      else parts.push({ role: "user", text, blocks: Array.isArray(data?.content) ? data.content : [] });
+      break;
+    }
+    case "agent/inbox/spliced": {
+      const inserted = Array.isArray(data?.inserted) ? data.inserted : [];
+      for (const message of inserted) pushAgentMessage(message);
+      break;
+    }
+    case "assistant/message": {
+      const blocks = Array.isArray(data?.message?.content) ? data.message.content : [];
+      const text = textOf(blocks);
+      // 私有推理块（reasoning）刻意不采集：蒸馏记忆不得沉淀模型私有思考链。
+      if (text.trim()) parts.push({ role: "assistant", text, blocks });
+      break;
+    }
+    default:
+      break;
+  }
+  return parts;
+}
+
+// DSH 0.1.2-rc.1 起 Session 改用 snapshotEvents()，兼容旧版 .events。
+// snapshotEvents 的范围参数按 seq 传入；再做一次事件级过滤，是为了兼容
+// 旧实现忽略参数、或把边界解释为闭区间的情况，同时避免用数组下标充当游标。
+function snapshotSessionEvents(session, afterSeq, throughSeq) {
+  let events;
+  if (typeof session?.snapshotEvents === "function") {
+    events = afterSeq === undefined && throughSeq === undefined
+      ? session.snapshotEvents()
+      : session.snapshotEvents(afterSeq, throughSeq);
+  } else {
+    events = session?.events ?? [];
+  }
+  if (!Array.isArray(events)) events = session?.events ?? [];
+  if (!Array.isArray(events)) return [];
+  return events.filter((event) => {
+    const seq = eventSeq(event);
+    // 一旦已有 seq 游标，没有 seq 的事件就无法证明是新增事件，不能重新打开
+    // 已经成功消费过的窗口。
+    if (afterSeq !== undefined && (seq === undefined || seq <= afterSeq)) return false;
+    if (throughSeq !== undefined && seq !== undefined && seq > throughSeq) return false;
+    return true;
+  });
+}
+
+async function collectMessages(session, maxChars = 8000, language = "zh", afterSeq, throughSeq, describePart) {
+  const events = snapshotSessionEvents(session, afterSeq, throughSeq);
+  const lines = [];
+  const seenSubagentMessages = new Set();
+  // Issue #611：这一窗里被折成占位的图片张数。占位本身不丢信息，但「折了几张」
+  // 必须是个能读到的数——否则 off 档和旧版静默丢弃在观测上无法区分，下次再有人
+  // 问「图到底进来没有」还是得翻源码。计量只数窗口内事件，不受截断影响。
+  let imageCount = 0;
+  const trim = (s, n) => (typeof s === "string" && s.length > n ? `${s.slice(0, n)}…` : s);
+  const trimTranscript = (s, n) => {
+    if (typeof s !== "string" || s.length <= n) return s;
+    if (n <= 1) return "…".slice(0, n);
+    return `…${s.slice(-(n - 1))}`;
+  };
+  const appendSubagentMessage = (message) => {
+    const kind = message?.source?.kind;
+    if (!SUBAGENT_MESSAGE_KINDS.has(kind)) return;
+    const text = textOf(message?.content);
+    if (!text.trim()) return;
+    const key = typeof message?.id === "string" && message.id
+      ? `id:${message.id}`
+      : `content:${kind}:${text}`;
+    if (seenSubagentMessages.has(key)) return;
+    seenSubagentMessages.add(key);
+    lines.push(STR.transcriptAgent[language](text));
+  };
+  for (const event of events) {
+    const data = event?.data ?? {};
+    // #399：用户提示 / 助手公开正文 / 子会话交付三种可公开内容由共享谓词产出，
+    // 渲染与落盘因此不可能对「什么算公开」产生分歧（见 publicTranscriptParts）。
+    for (const part of publicTranscriptParts(event)) {
+      if (part.role === "agent") {
+        if (part.key && seenSubagentMessages.has(part.key)) continue;
+        if (part.key) seenSubagentMessages.add(part.key);
+      }
+      // Issue #611 计量：数「真正进了转录的图块」，所以按 part 数、并且在去重之后
+      // ——同一条子会话消息会同时出现在 user/message 与 agent/inbox/spliced 里
+      // （投递路径重叠），按事件数会把它算两遍。
+      //
+      // 不按事件数还有个更要紧的理由：被 publicTranscriptParts 挡掉的注入消息
+      // （工具结果、插件注入、陌生 source.kind）里的图根本进不了转录，按事件累加
+      // 会报「这一窗有 2 张图」而转录里一张都没有。part 是渲染与落盘共用的同一份
+      // 判定，计量跟着它走，两处不会再各有一套口径。
+      imageCount += countImages(part.blocks);
+      // 图像描述档（docs/DISTILL.md:346）：开关开着且这一 part 真的带图时，才
+      // 去出描述。describePart 由调用方注入（默认 undefined）——本函数不认识
+      // 任何路由配置，只负责「文本最后长什么样」，这样单测可以只塞一个桩进去。
+      const described = typeof describePart === "function" && part.blocks?.length
+        ? await describePart(part)
+        : part.text;
+      if (part.role === "user") {
+        lines.push(STR.transcriptUser[language](described));
+      } else if (part.role === "agent") {
+        lines.push(STR.transcriptAgent[language](described));
+      } else {
+        lines.push(STR.transcriptAssistant[language](described));
+      }
+    }
+    // 渲染专属内容：工具调用/结果与 code 输出进 LLM 转录（codingRetrospect 靠
+    // 它们沉淀踩坑根因），但不进 distill_records——#399 已知边界 3 明说不覆盖。
+    switch (event.type) {
+      case "tool/call": {
+        const args = typeof data.arguments === "string"
+          ? data.arguments
+          : data.arguments ? JSON.stringify(data.arguments) : "";
+        lines.push(STR.transcriptToolCall[language](data.name ?? "?", trim(args, 300)));
+        break;
+      }
+      case "tool/result": {
+        // 工具结果有两种形状：旧形状把载荷与 isError 装在 content 内的
+        // `type:"tool-result"` 块上；DSH 0.2.x 起内核改为直接投递 `role:"tool"`
+        // 消息本身，content 里只有 `type:"text"` 块、isError 挂在消息上。只认
+        // 旧块形状时新形状落进 undefined 分支，工具输出与工具报错被静默丢弃。
+        const message = data?.message;
+        const blocks = Array.isArray(message?.content) ? message.content : [];
+        const legacy = blocks.find((block) => block?.type === "tool-result");
+        const result = legacy ?? (message?.role === "tool" ? message : undefined);
+        const out = textOf(result?.content);
+        const status = result?.isError === true ? STR.statusFail[language] : STR.statusOk[language];
+        lines.push(STR.transcriptToolResult[language](status, trim(out, 500)));
+        break;
+      }
+      case "tool/code-dispatch": {
+        const out = textOf(data.content);
+        const status = data.isError === true ? STR.statusFail[language] : STR.statusOk[language];
+        lines.push(STR.transcriptCode[language](status, trim(out, 500)));
+        break;
+      }
+      default:
+        break;
+    }
+  }
+  const lastSeq = events.reduce((max, event) => {
+    const seq = eventSeq(event);
+    if (seq === undefined) return max;
+    return max === undefined ? seq : Math.max(max, seq);
+  }, undefined);
+  const transcriptBody = trimTranscript(lines.join("\n"), maxChars);
+  return {
+    messages: lines.length
+      ? [createUserMessage({
+        content: [{
+          type: "text",
+          // Issue #493：转录裸放 user 位时，模型把它当成「轮到我说了」接着对话
+          // 往下写，输出里连 `[` 都没有（解析器在括号早退处直接判失败）。围栏 +
+          // 角色重申把「这段文本是被提炼的素材」写进**它所在的那条消息**，而不是
+          // 只写在 system 里——实测同段转录只加 system 约束仍 0/2 出 JSON。
+          // 围栏是确定性的：重试收到的转录与首次逐字节相同（既有回归用例依赖）。
+          text: `${STR.distillRoleReminder[language]}\n\n${STR.transcriptFenceOpen[language]}\n${breakFenceMarkers(transcriptBody)}\n${STR.transcriptFenceClose[language]}`
+        }],
+        source: { kind: "plugin:dsh-mneme", plugin: "dsh-mneme" }
+      })]
+      : [],
+    hasEvents: events.length > 0,
+    lastSeq,
+    // Issue #611：这一窗折成占位的图片张数。调用方把它写进审计 metadata，
+    // 让「图进来了几张」成为可对账的事实而不是推断。
+    imageCount,
+    // Issue #493：只数**转录正文**的字符数。minWindowChars 闸门与审计里的
+    // distillChars 量的都是「这一窗有多少可提炼内容」，不是「我们额外包了多少
+    // 提示词」——若把围栏与角色句算进去，一条「短」也会凭空越过任何阈值，
+    // 闸门随之失效（实测 summarizeMinWindowChars=10 会被 4 字正文 + 包裹放行）。
+    transcriptChars: lines.length ? transcriptBody.length : 0
+  };
+}
+
+/**
+ * Issue #399：把当前蒸馏窗口里**可公开的会话正文**收集成待落盘记录。
+ *
+ * 与 collectMessages 共用 publicTranscriptParts，但**不截断**：留存的意义就是
+ * 整段原文（超长用户提示在记录里必须全文，而喂给 LLM 的转录仍受 distillMaxChars
+ * 约束）——两条路径在裁剪上的差异是设计的一部分，测试锁 3 显式覆盖。
+ *
+ * 只收有 seq 的事件：distill_records 的主键是 (session_id, seq)，seq 也是溯源
+ * 区间与幂等的唯一依据；没有 seq 就无法表达「这条记录属于哪个窗口」。
+ */
+function collectTranscriptRecords(session, afterSeq, throughSeq, distilledAt) {
+  const events = snapshotSessionEvents(session, afterSeq, throughSeq);
+  const records = [];
+  const seenKeys = new Set();
+  // 窗口的 seq 区间取窗口内**全部**事件的 min/max（不只是公开正文那些）：这是
+  // LLM 实际看到的那个窗口，溯源链接要回答的是「这条记忆出自哪个窗口」。
+  let seqStart;
+  let seqEnd;
+  for (const event of events) {
+    const seq = eventSeq(event);
+    if (seq !== undefined) {
+      if (seqStart === undefined || seq < seqStart) seqStart = seq;
+      if (seqEnd === undefined || seq > seqEnd) seqEnd = seq;
+    }
+    if (seq === undefined) continue;
+    const parts = [];
+    for (const part of publicTranscriptParts(event)) {
+      if (part.key) {
+        if (seenKeys.has(part.key)) continue;
+        seenKeys.add(part.key);
+      }
+      parts.push(part);
+    }
+    if (!parts.length) continue;
+    // 主键是 (session_id, seq)：一个事件一行。agent/inbox/spliced 一次可投递多条
+    // 子会话消息（同 seq、同 role），各自成行会被 INSERT OR IGNORE 静默丢掉后几条；
+    // 按事件合并成一行才是这套主键的真实语义（角色同事件内不会混：user/message 与
+    // assistant/message 各只产出一条公开 part）。
+    records.push({
+      sessionId: session.id,
+      seq,
+      role: parts[0].role,
+      text: parts.map((part) => part.text).join("\n"),
+      windowId: `session:${session.id}:${seq}`,
+      distilledAt
+    });
+  }
+  return { records, seqStart, seqEnd };
+}
+
+// ── 智能调速器（429 保护）─────────────────────────────────────────────
+// 对话一多时 turn/end 会批量触发蒸馏，多个 LLM 请求"一拥而上"正是 429 的
+// 来源。这里借鉴机场安检的思路：所有蒸馏调用进同一个全局串行队列，按间隔
+// distillRateLimitIntervalMs 分批放行；命中 429 时按 distillRateLimitBaseDelayMs
+// 指数退避（1s→2s→4s…）自动重试 distillRateLimitRetries 次，全程对用户透明，
+// 不把 429 错误码直接抛出去。
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+
+function isRateLimited(error) {
+  const status = error?.status ?? error?.statusCode ?? error?.response?.status;
+  if (status === 429) return true;
+  const msg = String(error?.message ?? error ?? "");
+  return /429|rate.?limit|too many requests|请求过于频繁/i.test(msg);
+}
+
+// 全局串行链：每个蒸馏任务在前一个结束后才开始，单次失败不阻塞后续。
+// 相邻请求间隔按"距上一个结束不足 intervalMs 就补齐等待"实现——单次蒸馏
+// 零延迟（上次结束距今已超过间隔，直接放行），只有连续批量蒸馏才触发限速。
+let distillQueue = Promise.resolve();
+let lastDistillEnd = 0;
+function enqueueDistill(task, intervalMs = 0) {
+  const run = distillQueue.then(async () => {
+    if (intervalMs > 0) {
+      const wait = Math.max(0, intervalMs - (Date.now() - lastDistillEnd));
+      if (wait > 0) await sleep(wait);
+    }
+    lastDistillEnd = Date.now();
+    return task();
+  });
+  distillQueue = run.catch(() => {});
+  return run;
+}
+
+// Issue #239（第 4 项，错峰队列）：高峰时段解析与判定已抽到独立零依赖模块
+// src/peak-hours.js（PR #320 review：#316 后 summarize 反向依赖 dream，dream 镜像
+// 错峰再 import 本文件会成真循环；时段调度本就不是蒸馏私有语义）。这里 re-export
+// 兼容既有调用方与测试（test/summarize.test.js 从本文件 import），零改动。
+// 注意 re-export 不引入本地作用域——本文件 331/387 行仍调用这两个函数，
+// import + re-export 两行都要。
+import { parsePeakSpec, isInPeakWindow, nextOffPeakAt } from "./peak-hours.js";
+export { parsePeakSpec, isInPeakWindow, nextOffPeakAt };
+export function createSummarizer(ctx, service, config, deps = {}, sessionGate = null) {
+  if (!config.autoSummarize) return { dispose: () => {} };
+
+  // Issue #239（第 4 项）：时钟与定时器可注入——排程不绑死真实时钟，测试才能确定性
+  // 覆盖「高峰顺延 → 非高峰补跑」。房型同 dream/sleep.js 的注入参数。
+  const now = typeof deps.now === "function" ? deps.now : () => Date.now();
+  const setTimer = typeof deps.setTimeoutFn === "function" ? deps.setTimeoutFn : setTimeout;
+  const clearTimer = typeof deps.clearTimeoutFn === "function" ? deps.clearTimeoutFn : clearTimeout;
+
+  // v0.9.0（M.O. 项目记忆）：蒸馏写入也要盖作用域章。此前只有 memory_save 那条工具
+  // 路径盖章（tools.js 的 resolveSessionScope 盖章块，2026-10-14 在 :174-181），而机器提炼是写入量的绝大多数——于是「项目记忆」
+  // 在库里根本不存在（全库带 scope 的行不足 3%，且带 scope 的全部来自工具路径）。
+  // 这里不另造口径：同一把解析器（scope.js 的 createScopeResolver，2026-10-13 在 :24）、同一把闸门
+  // （config.scopeEnabled === true）、同一对列（*_scope + *_scope_source='auto'），
+  // 与工具路径逐字对齐。解析器的入参形状是「工具 exec」（内部读 exec.agent.session），
+  // 蒸馏路径手里直接有会话对象，所以包一层壳喂进去——不改解析器的公共契约。
+  const resolveSessionScope = createScopeResolver({ ctx, config, logger: ctx.logger });
+
+  const inFlight = new Map();
+  // Issue #127：per-session 上一次实际开跑时刻（最小间隔闸门用）。与 inFlight
+  // 同生命周期，dispose 时一并清空。
+  const lastRunAt = new Map();
+  // Issue #239：per-session 已发起的蒸馏次数（有界检查点用）。只在实际发起 LLM
+  // 调用时自增，因此被零 LLM 预判挡下的窗口不消耗预算。
+  const runsUsed = new Map();
+  // Issue #239（第 4 项）：每会话最多挂一个待补跑定时器（错峰队列用）；dispose 时
+  // 一并清理，避免插件卸载后还留着一个会调模型的定时器。
+  const deferredRuns = new Map();
+  // Issue #210：只在一次蒸馏完整成功后记录已消费的最后事件 seq。
+  const lastDistilledSeq = new Map();
+  // Issue #493：per-session 连续解析失败计数（失败护栏用）。同一窗口在确定性
+  // 失败下会被每个 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 审计行（审计失败绝不阻塞蒸馏本身）。 */
+  function writeAudit(entry) {
+    if (config?.llmAudit?.enabled === false || typeof service.saveLlmAudit !== "function") return;
+    try {
+      service.saveLlmAudit({
+        trigger_source: "autoSummarize",
+        operation_type: "summarize_compress",
+        related_memory_ids: [],
+        ...entry
+      });
+    } catch (auditError) {
+      ctx.logger?.warn?.(`dsh-mneme: llm audit write failed: ${String(auditError)}`);
+    }
+  }
+
+  function persistCursor(sessionId, nextSeq) {
+    if (!Number.isFinite(nextSeq)) return;
+    if (typeof service.setDistillCursor !== "function") {
+      // 第三方宿主拿旧版 service 构造时没有持久化游标能力：降级为内存游标
+      // （#274 之前的行为），本进程内不重复蒸馏，重启后窗口重放由
+      // saveWithDedupe 三元组兜底。方法存在但抛错仍向上传播——那是
+      // 「写失败须回滚」的恰一次语义，不能吞（见 summarize.test.js 回滚用例）。
+      ctx.logger?.warn?.("dsh-mneme: service.setDistillCursor unavailable, distill cursor falls back to in-memory");
+      return;
+    }
+    service.setDistillCursor(sessionId, nextSeq);
+  }
+
+  function commitCursor(sessionId, nextSeq) {
+    persistCursor(sessionId, nextSeq);
+    if (Number.isFinite(nextSeq)) lastDistilledSeq.set(sessionId, nextSeq);
+  }
+
+  /**
+   * Issue #239（第 4 项）：把这一轮蒸馏推迟到最近的「高峰结束」时刻。每会话只挂
+   * 一个定时器（重复触发不叠加）；被 summarizePeakMaxDeferMinutes 截断时到点照跑
+   * （bypassPeak），长高峰不会把蒸馏饿死。定时器 unref——不阻止宿主退出。
+   */
+  function scheduleDeferredRun(session) {
+    if (disposed || deferredRuns.has(session.id)) return;
+    const at = nextOffPeakAt(new Date(now()), config.summarizePeakHours ?? "");
+    if (!at) return;
+    const maxDeferMs = (config.summarizePeakMaxDeferMinutes ?? 0) * 60000;
+    let delay = Math.max(0, at.getTime() - now());
+    const capped = maxDeferMs > 0 && delay > maxDeferMs;
+    if (capped) delay = maxDeferMs;
+    const timer = setTimer(() => {
+      deferredRuns.delete(session.id);
+      if (disposed) return;
+      // 不传触发事件：补跑要蒸的是「累积后的整窗」（从上次成功游标到最新事件），
+      // 拿老 triggerEvent 反而会把窗口卡在它那个 seq 上。
+      summarize(session, undefined, { bypassPeak: capped }).catch((error) => {
+        if (disposed || error?.name === "AbortError") return;
+        ctx.logger?.warn?.(`dsh-mneme: deferred summarization failed: ${String(error)}`);
+      });
+    }, delay);
+    timer?.unref?.();
+    deferredRuns.set(session.id, timer);
+  }
+
+  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.
+    const route = (config.summarizeProvider && config.summarizeModel)
+      ? { provider: config.summarizeProvider, model: config.summarizeModel }
+      : (header?.provider && header?.model)
+        ? { provider: header.provider, model: header.model }
+        : undefined;
+
+    // Issue #127 间隔门：同一会话两次蒸馏之间的最小间隔（0 = 现状，不限）。进入
+    // 即打点——失败/degraded 的 run 也占用间隔，与 dreamMinIntervalMinutes 语义
+    // 一致，防止失败连发。被挡下的 turn/end 静默跳过，但留一行 status='skipped'
+    // 审计，否则「这一轮为什么没蒸馏」对用户完全不可观测。
+    const gapMs = (config.summarizeMinIntervalMinutes ?? 0) * 60000;
+    const prevClaim = lastRunAt.get(session.id);
+    if (gapMs > 0 && Date.now() - (prevClaim ?? 0) < gapMs) {
+      writeAudit({
+        timestamp: new Date().toISOString(),
+        model_id: route ? `${route.provider}:${route.model}` : "unknown",
+        status: "skipped",
+        error_message: "min-interval"
+      });
+      return;
+    }
+    // Issue #239（有界检查点）：每会话 run 预算。放在间隔门之后，两者都命中时
+    // 先报间隔——间隔是「刚刚跑过」，预算是「额度用尽」，前者信息量更大。skip
+    // 仍写审计（沿用间隔门的 error_message 口径），否则「为什么不再蒸馏了」对
+    // 用户不可观测。prevRuns 在这里捕获、finally 里按 aborted 回滚（同 lastRunAt）。
+    // 游标刻意不消费：预算是「这个会话先不再蒸馏了」，把窗口留在原地，日后调高
+    // 额度（或宿主重启）仍能蒸馏到它；这与 window-too-small 主动消费游标相反——
+    // 后者是「这些事件不值得蒸馏」，留着只会每个 turn/end 重评一次。
+    // Issue #239（第 4 项，错峰队列）：高峰期不调模型——只登记一行 skip 审计并择时
+    // 补跑。游标刻意不消费：窗口继续累积，留到非高峰一次性蒸馏（批量比逐轮碎蒸更
+    // 省）。被 maxDefer 截断后到点仍处高峰时，由 opts.bypassPeak 放行。
+    if (!opts.bypassPeak && isInPeakWindow(new Date(now()), config.summarizePeakHours ?? "")) {
+      writeAudit({
+        timestamp: new Date(now()).toISOString(),
+        model_id: route ? `${route.provider}:${route.model}` : "unknown",
+        status: "skipped",
+        error_message: "peak-hours"
+      });
+      scheduleDeferredRun(session);
+      return;
+    }
+    const prevRuns = runsUsed.get(session.id);
+    const maxRuns = config.summarizeMaxRunsPerSession ?? 0;
+    if (maxRuns > 0 && (prevRuns ?? 0) >= maxRuns) {
+      writeAudit({
+        timestamp: new Date().toISOString(),
+        model_id: route ? `${route.provider}:${route.model}` : "unknown",
+        status: "skipped",
+        error_message: "max-runs-per-session"
+      });
+      return;
+    }
+    const controller = new AbortController();
+    inFlight.set(session.id, controller);
+    // audit state for the compression call. null = no audit for this run
+    // (disabled, or no LLM call was actually made). The audit row is written in
+    // the finally below — once, regardless of which exit path the call took —
+    // so a failed/aborted stream still leaves a status='error' trail without
+    // 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"
+        ? service.getDistillCursor(session.id)
+        : undefined;
+      const previousSeq = persistedCursor?.last_seq ?? lastDistilledSeq.get(session.id);
+      const triggerSeq = eventSeq(triggerEvent);
+      // 只读取上次成功游标之后、当前 turn/end 之前的事件。旧版 snapshotEvents
+      // 即使忽略范围参数，collectMessages 仍会按事件 seq 二次过滤。
+      // 图像描述档（docs/DISTILL.md:346）：三件事按顺序判——开关、路由、模型
+      // 是否真能看图。任一不过就整档不跑，**并且不改变转录一个字**（describePart
+      // 缺席时 collectMessages 走原路径，输出逐字节等于 #611 的行为）。
+      //
+      // 判定放在这里而不是 image-describe.js 里：路由来自 config，准入是一次可能
+      // 很贵的 resolveModelInfo 调用，两者都该只问一次，而不是每张图问一次。
+      let describePart;
+      if (config.imageDescribeEnabled === true) {
+        const describeProvider = typeof config.imageDescribeProvider === "string" ? config.imageDescribeProvider.trim() : "";
+        const describeModel = typeof config.imageDescribeModel === "string" ? config.imageDescribeModel.trim() : "";
+        if (describeProvider && describeModel) {
+          const sight = await canSeeImages(ctx, describeProvider, describeModel);
+          // "unknown"（老适配器不声明能力）照发：宿主那侧对未知是不投影，照原样
+          // 交给适配器，它若真看不到再降级成占位——这里替它决定就是猜。
+          if (sight !== false) {
+            const describeRoute = { provider: describeProvider, model: describeModel };
+            // 同一张图在一次蒸馏里只描述一次：同一附件常被重复贴（追问、引用），
+            // 按 attachmentId 缓存，省掉重复的视觉调用。
+            const described = new Map();
+            describePart = async (part) => {
+              const blocks = imageBlocks(part.blocks);
+              if (blocks.length === 0) return part.text;
+              const fresh = blocks.filter((block, i) => {
+                const key = block?.attachment?.attachmentId ?? `#${i}`;
+                return !described.has(key);
+              });
+              if (fresh.length > 0) {
+                const got = await describeImages(ctx, describeRoute, config, fresh, { signal: controller.signal });
+                for (const [key, value] of got) described.set(key, value);
+              }
+              return appendDescriptions(part.text, blocks, described);
+            };
+          }
+        }
+      }
+      const collected = await collectMessages(
+        session,
+        config.distillMaxChars ?? 24000,
+        langOf(config),
+        previousSeq,
+        triggerSeq,
+        describePart
+      );
+      const hasNewEvents = collected.hasEvents
+        || (triggerSeq !== undefined && (previousSeq === undefined || triggerSeq > previousSeq));
+      if (!hasNewEvents) return;
+
+      const nextSeq = Math.max(collected.lastSeq ?? Number.NEGATIVE_INFINITY, triggerSeq ?? Number.NEGATIVE_INFINITY);
+      if (!collected.messages.length) {
+        // 没有可蒸馏的公开文本也算成功消费当前事件窗口，避免每个 turn/end
+        // 都重新扫描同一批无内容事件；没有 seq 时则不提交不可验证的游标。
+        commitCursor(session.id, nextSeq);
+        return;
+      }
+      const messages = collected.messages;
+      // Issue #239（成本感知级联第一级）：零 LLM 预判。窗口内可蒸馏文本不足阈值
+      // 时直接跳过——短窗口交给模型的产出多是泛泛而谈，代价却是一次完整调用。
+      // 判定纯规则（字符数），无模型参与；被挡下的窗口照常消费游标，否则每个
+      // turn/end 都会重新评估同一段短文本。skip 原因进审计，作为后续按真实负载
+      // 决定下一级规则的依据。
+      //
+      // 字符数改为无条件计算并写进审计 metadata：它是「下一级预判该不该开、阈值
+      // 该给多少」的唯一依据，而原先开关一关就一个数都不留（维护者本机 1240 条
+      // summarize_compress 成功行的 metadata 里窗口字符数为 0 条），验收 4「默认配置
+      // 下调用量可量化下降」因此无法对账。本改动只加计量，不动任何跳过决策——
+      // summarizeMinWindowChars 仍为 0 时行为逐字节不变。
+      //
+      // Issue #493：口径改为只数转录正文（collected.transcriptChars），不再把
+      // user 消息整段长度当窗口大小——#493 给转录加了围栏与角色句，若继续按
+      // 「消息总字符数」算，一条 4 字的「短」也会被包裹撑过任何阈值，闸门等于
+      // 被自己的提示词旁路掉。
+      const distillChars = collected.transcriptChars ?? messages.reduce(
+        (total, message) => total + (Array.isArray(message.content) ? message.content : [])
+          .reduce((n, part) => n + (typeof part?.text === "string" ? part.text.length : 0), 0),
+        0
+      );
+      const minWindowChars = config.summarizeMinWindowChars ?? 0;
+      const imageCount = collected.imageCount ?? 0;
+      if (minWindowChars > 0 && distillChars < minWindowChars) {
+        commitCursor(session.id, nextSeq);
+        writeAudit({
+          timestamp: new Date().toISOString(),
+          model_id: route ? `${route.provider}:${route.model}` : "unknown",
+          status: "skipped",
+          error_message: "window-too-small",
+          metadata: { distillChars, minWindowChars, ...(imageCount > 0 ? { imageCount } : {}) }
+        });
+        return;
+      }
+      // 只有真正准备发起一次 LLM 蒸馏时才占用最小间隔与 run 预算；失败路径仍按
+      // 原语义占用（调用确实发生过），aborted 则由 finally 回滚。
+      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,
+          timestamp: new Date().toISOString(),
+          startedAt: Date.now(),
+          inputTokens: 0,
+          outputTokens: 0,
+          status: "success",
+          errorMessage: null
+        };
+      }
+
+      // Issue #315：蒸馏思考强度。'none'/未配置都不发送字段（服务商默认生效，
+      // 行为与历史版本一致）；off/low/medium/high 原样传递。
+      const summarizeEffort = config.summarizeReasoningEffort;
+      const withEffort = typeof summarizeEffort === "string" && summarizeEffort !== "none";
+
+      // 时间锚点：转录行不带时间戳，prompt 要模型把「昨天/上周」换算成绝对
+      // occurred_at，就必须给基准，否则它只能编（幻觉）。锚点取本次蒸馏触发时刻
+      // （可注入 now()，测试用假时钟）；锚点行同时是 prompt 里「按提示末尾给出的
+      // 当前时间换算」那句的落点，改写/移动随两处一起动。
+      const distillPrompt = config.codingRetrospect ? STR.prompts.codingSummary[langOf(config)] : STR.prompts.summary[langOf(config)];
+      const anchoredPrompt = `${distillPrompt}${STR.distillTimeAnchor[langOf(config)](new Date(now()).toISOString())}`;
+
+      const options = {
+        provider: route.provider,
+        model: route.model,
+        purpose: "summarization",
+        messages: [
+          { role: "system", content: [{ type: "text", text: anchoredPrompt }], source: { kind: "plugin:dsh-mneme", plugin: "dsh-mneme" } },
+          ...messages
+        ],
+        signal: controller.signal
+      };
+      // 智能调速器：整段蒸馏 LLM 调用进全局串行队列，按间隔分批放行；429 时
+      // 指数退避自动重试，全程对用户透明，不把 429 错误码直接抛出去。
+      const intervalMs = config.distillRateLimitIntervalMs ?? 1000;
+      // Issue #315：流式失败原因暂存槽。蒸馏的流失败以 aborted 结果而非 throw
+      // 返回，withEffortFallback 靠它甄别「effort 被拒收」型 aborted（dream 侧
+      // runNarratives 的 streamFailure 同款模式）。
+      let streamFailure = "";
+      const runDistill = (withEffort) => {
+        streamFailure = "";
+        return enqueueDistill(async () => {
+        const retries = config.distillRateLimitRetries ?? 3;
+        const baseDelayMs = config.distillRateLimitBaseDelayMs ?? 1000;
+        // 每次尝试独立拼 effort 字段：降级重试（withEffort=false）必须真的
+        // 不带 reasoningEffort，不能复用带字段的同一 options 对象。
+        const callOptions = withEffort && summarizeEffort
+          ? { ...options, reasoningEffort: summarizeEffort }
+          : options;
+        for (let attempt = 0; ; attempt++) {
+          // 每次尝试重置审计状态：effort 拒收/429 的失败 attempt 会把 status 置
+          // error，若后续重试成功，审计必须记录最终成功而不是残留第一次的失败
+          // （否则「摘要成功但审计报失败」，污染 llm_audit_logs 统计）。
+          if (audit) audit.status = "success";
+          const assembler = new BlockAssembler();
+          let text = "";
+          let aborted = false;
+          try {
+            for await (const chunk of ctx.llm.stream(callOptions)) {
+              if (STREAM_CHUNK_TYPES.has(chunk.type)) assembler.push(toProtocolChunk(chunk));
+              if (chunk.type === "text-delta") {
+                text += chunk.text ?? chunk.delta ?? "";
+              }
+              if (chunk.type === "usage" && audit) {
+                // 同 dream.js：真实协议是 {type:"usage", usage:TokenUsage}，用量不在
+                // chunk 顶层；顶层读取只作为把用量平铺的替身兜底。
+                const usage = chunk.usage ?? chunk;
+                const i = usage.input_tokens ?? usage.inputTokens ?? usage.prompt_tokens ?? usage.promptTokens;
+                const o = usage.output_tokens ?? usage.outputTokens ?? usage.completion_tokens ?? usage.completionTokens;
+                if (Number.isFinite(i)) audit.inputTokens = i;
+                if (Number.isFinite(o)) audit.outputTokens = o;
+              }
+              if (chunk.type === "finish") {
+                const reasonKind = chunk.reason?.kind ?? chunk.kind;
+                if (reasonKind === "error" || reasonKind === "aborted") {
+                  // 429 也可能以 finish reason error 携带 rate-limit 信息，统一
+                  // 转抛错走指数退避重试。
+                  if (isRateLimited(chunk.reason ?? chunk)) {
+                    throw Object.assign(new Error("rate limited"), { status: 429 });
+                  }
+                  // Issue #315：把失败原因原样留给外层的 effort 甄别
+                  // （withEffortFallback 只认「effort 被拒收」型失败）。
+                  streamFailure = describeStreamFailure(chunk.reason ?? chunk);
+                  if (audit) {
+                    audit.status = "error";
+                    audit.errorMessage = `llm stream ${reasonKind}`;
+                  }
+                  aborted = true;
+                  break;
+                }
+              }
+            }
+            // Direct delta accumulation is the primary extraction path (it works
+            // for real protocol chunks {index,text} and looser {delta} shapes
+            // alike); the assembler blocks are a fallback for streams that only
+            // deliver text inside block-end. This dsh-llm exposes no public
+            // no-arg assemble() — blocks() is the message-level API.
+            const blocks = assembler.blocks();
+            const assembledText = blocks
+              .filter((b) => b.type === "text")
+              .map((b) => b.text ?? "")
+              .join("");
+            return { text, assembledText, aborted };
+          } catch (error) {
+            if (error?.name === "AbortError" || controller.signal.aborted) throw error; // dispose 中止直接放行
+            if (isRateLimited(error) && attempt < retries) {
+              const delay = baseDelayMs * 2 ** attempt;
+              ctx.logger?.warn?.(
+                `dsh-mneme: 蒸馏请求过于频繁(429)，为避免限流等待 ${delay}ms 后自动重试（第 ${attempt + 1}/${retries} 次）`
+              );
+              await sleep(delay);
+              continue;
+            }
+            // 429 重试耗尽或非 429 错误：记 audit 后抛出，保持原失败路径。
+            if (audit) {
+              audit.status = "error";
+              audit.errorMessage = String(error?.message ?? error);
+            }
+            throw error;
+          }
+        }
+      }, intervalMs);
+      };
+      // Issue #315：effort 被拒收时自动去掉字段重试一次（dream/sleep/entity
+      // 同一降级策略，withEffortFallback 共享）。蒸馏的流失败以 aborted 结果
+      // 而非 throw/undefined 返回，因此甄别在这里做：effort 型失败折叠成
+      // undefined，让 withEffortFallback 走 streamFailure 甄别分支触发重试；
+      // 非 effort 的 aborted 原样返回，仍走既有的 abortedRun 路径。
+      const result = await withEffortFallback(
+        ctx,
+        summarizeEffort,
+        () => runDistill(withEffort).then((r) =>
+          (r?.aborted && EFFORT_REJECT_RE.test(streamFailure)) ? undefined : r),
+        () => runDistill(false),
+        () => streamFailure
+      );
+      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);
+      // 解析失败不推进 seq 游标，下一次 turn/end 仍会重试同一窗口。
+      if (!parsedResult.ok) {
+        // Issue #493：失败也要留证据。原先 metadata 只在成功路径赋值，失败行恒为
+        // null —— 事后无法回答「模型到底吐了什么形状」。这里只加计量、不做任何
+        // 跳过决策（raw_head 截断到 300 字符，避免把审计表撑大）。
+        const raw = text || assembledText || "";
+        const streak = bumpParseFailureStreak(session.id);
+        // Issue #493 失败护栏：同一窗口连续失败到阈值后强制消费游标跳过它。
+        // 确定性失败（finish_reason=stop、同文同温）重试收益为 0，而窗口只会随
+        // 新事件继续变大——没有出口时它会一直失败下去。默认 0 = 关闭，行为与
+        // 历史版本逐字节一致（本仓新行为一律 opt-in，见 AGENTS.md）。
+        const maxParseRetries = config.summarizeParseFailureMaxRetries ?? 0;
+        // nextSeq 必须是有限数才算真的「跳过了窗口」：没有可验证的 seq 时
+        // commitCursor 是空操作（persistCursor 早退、内存游标也不写），此时若
+        // 仍按跳过记账并清零 streak，审计会宣称「已放弃」而窗口下一轮照旧重试
+        // —— 那是最坏的一种假象：用户以为止血了，实际还在烧。
+        const skipWindow = maxParseRetries > 0 && streak >= maxParseRetries && Number.isFinite(nextSeq);
+        if (skipWindow) {
+          // 先提交游标再复位计数：窗口已放弃，下一窗从全新状态起算。
+          commitCursor(session.id, nextSeq);
+          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 = failureAudit.errorMessage;
+          audit.metadata = {
+            distillChars,
+            ...(imageCount > 0 ? { imageCount } : {}),
+            ...failureAudit.metadata,
+            streak,
+            ...(maxParseRetries > 0 ? { maxRetries: maxParseRetries } : {}),
+            ...(skipWindow ? { skipped: "parse-failure-streak" } : {})
+          };
+        }
+        return;
+      }
+      clearParseFailureStreak(session.id);
+      const parsed = parsedResult.entries;
+      // Issue #127 条数上限：0 = 不限（现状）。被截断的条数与去重命中数一并进
+      // 审计 metadata——此前产出条数完全由模型输出决定，用户无从自查。
+      const cap = config.summarizeMaxEntriesPerRun ?? 0;
+      const entries = cap > 0 ? parsed.slice(0, cap) : parsed;
+      const capped = parsed.length - entries.length;
+      const dedupeMode = config.summarizeDedupeMode ?? "off";
+      let deduped = 0;
+      let dedupeMaxSim = 0;
+      // v0.9.0（M.O. 项目记忆）：一次窗口解析一次——同一蒸馏窗口里所有条目同属一个
+      // 工作区、一个 agent 身份，逐条解析是白花钱。解析不到就落 NULL（NULL = 未标注 =
+      // 全局可见），且解析器绝不抛错（scope.js 的硬约束：记忆写入不该被作用域拖挂）。
+      // 闸门与 tools.js 的 autoStamping（2026-10-14 在 :175）同一把：关着就一个字段都不加，老行为不变。
+      const writeScope = config?.scopeEnabled === true
+        ? resolveSessionScope({ agent: { session } })
+        : null;
+      const writes = [];
+      for (const entry of entries) {
+        // Provenance: the summarizer runs on a real session (turn/end hook), so
+        // session.id is always available here — it rides the human-readable
+        // source label.
+        // 编码记忆类型（codingRetrospect）不带 tag：读取侧门控/加权靠 m.type
+        // （rejected_solution/pitfall/constraint）区分即可，tag 体系
+        // sanitizeTags 不认 `type:` 前缀反而会清空 tags 列（额外一次 UPDATE）。
+        const source = `session:${session.id}`;
+        // Issue #127 落库前去重（opt-in，默认 off = 现状）：命中则并入既有条目
+        // （saveWithDedupe 的 _mergeInto 分支），不再新造一行。作用域 = 同会话 +
+        // 时间窗；跨会话的同类事实仍交给 autoDream / sleep 的批量裁决。
+        const dup = (dedupeMode !== "off" && typeof service.findSessionDuplicate === "function")
+          ? await service.findSessionDuplicate(
+            { ...entry, source },
+            {
+              mode: dedupeMode,
+              minSim: config.summarizeDedupeMinSim ?? 0.92,
+              windowHours: config.summarizeDedupeWindowHours ?? 24,
+              source
+            }
+          )
+          : undefined;
+        if (dup) {
+          deduped++;
+          dedupeMaxSim = Math.max(dedupeMaxSim, dup.sim ?? 0);
+        }
+        writes.push({ entry, source, dup });
+      }
+      // #399：蒸馏窗口的原始公开记录 + 记忆级溯源链接，与记忆写入同事务落盘。
+      // 凭证与它的派生记忆必须同生共死：记忆写了而记录没写，溯源就断在「不知道
+      // 出自哪段原文」；记录写了而记忆没写，盘上留一份没有索引的原文。默认关
+      // （enabled !== true）时连收集都不做，一次 SQL 都不发（测试锁 5）。
+      const distilledAt = new Date(now()).toISOString();
+      const transcript = config?.distillRecords?.enabled === true
+        && typeof service.saveDistillRecords === "function"
+        ? collectTranscriptRecords(session, previousSeq, triggerSeq, distilledAt)
+        : null;
+      const writeWindow = () => {
+        const savedIds = [];
+        for (const { entry, source, dup } of writes) {
+          const outcome = service.saveWithDedupe({
+            ...entry,
+            source,
+            // 合并进既有行时不盖章，但这件事由 saveWithDedupe 的合并分支自己保证
+            // （它只认 explicit 来源升级，从不采纳这里传的 auto 字段）——调用方不能
+            // 靠「省略字段」来表达这个意图，因为省略会反向把合并也挡掉：
+            // findSessionDuplicate 只按 type+source+时间窗找候选，不看 scope；找到
+            // 候选后由 saveWithDedupe 的 scopeMatches 门决定并或不并。这里一省略，
+            // 新条目的 scope 就是 null，与已盖过章的候选不等，门必拒 → 回落新建，
+            // 而那一行同样是新行、同样该带章，却没有章可带。实测两轮蒸馏正是如此：
+            // 第二轮命中第一轮、门拒后新建，留下同题两行一行 auto 一行 NULL——
+            // 作用域隔离没做成，重复倒留下了。传字段、让合并分支按自己的口径处理，
+            // 才是「不重贴」与「新行必贴」两个要求的唯一相容解。
+            ...(writeScope ? { agent_scope: writeScope.agent_scope, agent_scope_source: "auto" } : {}),
+            ...(writeScope ? { workspace_scope: writeScope.workspace_scope, workspace_scope_source: "auto" } : {}),
+            ...(dup ? { _mergeInto: dup.memory.id } : {})
+          });
+          // created 与 merged 两条成功分支都返回 memory（含 id）；merged 时 id 是
+          // 被并入的既有记忆——本次窗口的原文确实贡献了它，链接它是诚实的。
+          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) {
+              service.saveMemoryProvenance({
+                memoryId,
+                sessionId: session.id,
+                seqStart: transcript.seqStart,
+                seqEnd: transcript.seqEnd,
+                createdAt: distilledAt,
+                // #512：链接指回产出它的那一轮。distillRecords 关着时这里本就不跑，
+                // 于是那一轮不会留下任何窗口级归因——这是诚实的（没存原文就没有
+                // 「这段原文」可指），run 行本身照落，条数与状态仍然可查。
+                distillRunId: distillRunId ?? undefined
+              });
+            }
+          }
+        }
+        persistCursor(session.id, nextSeq);
+      };
+      if (writes.length || (transcript && transcript.records.length)) {
+        // 查询去重目标可以异步执行，但记忆写入必须在同一个事务中完成。
+        // 否则第 N 条写入失败时，前 N-1 条会残留，而重试同一 seq 窗口会重复
+        // 追加它们。createService 始终提供 transaction；缺失时直接失败并保留
+        // 游标窗口，避免退回到不具备原子性的部分写入。
+        if (typeof service.transaction !== "function") {
+          throw new Error("dsh-mneme: atomic summarization writes require service.transaction");
+        }
+        service.transaction(writeWindow);
+      } else {
+        // 空数组是合法成功：没有记忆写入，但本次事件窗口仍然应被持久消费。
+        persistCursor(session.id, nextSeq);
+      }
+      // 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,
+          ...(imageCount > 0 ? { imageCount } : {}),
+          parsed: parsed.length,
+          ...(parsedResult.salvaged ? { json_salvaged: true } : {}),
+          ...(capped > 0 ? { capped } : {}),
+          ...(deduped > 0 ? { deduped, mode: dedupeMode, maxSim: Number(dedupeMaxSim.toFixed(4)) } : {})
+        };
+      }
+      // 记忆写入和解析都成功后才提交窗口；流失败、中止、解析失败或写入异常
+      // 都会在此之前退出，从而保留窗口供下一次重试。
+      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);
+      }
+      throw error;
+    } finally {
+      // Issue #127：aborted（会话关闭 / 插件 dispose）不占间隔，避免误伤该会话的
+      // 下一次蒸馏；其余情况（含失败）的打点保留，与 dreamMinIntervalMinutes 一致。
+      if (abortedRun || controller.signal.aborted) {
+        if (prevClaim === undefined) lastRunAt.delete(session.id);
+        else lastRunAt.set(session.id, prevClaim);
+        // Issue #239：aborted 同样不占 run 预算——调用没有真正发生，占了会误伤
+        // 该会话后续的蒸馏（与上面的间隔回滚同一口径）。
+        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 {
+          auditRow = service.saveLlmAudit({
+            timestamp: audit.timestamp,
+            trigger_source: "autoSummarize",
+            operation_type: "summarize_compress",
+            model_id: `${audit.route.provider}:${audit.route.model}`,
+            input_tokens: audit.inputTokens,
+            output_tokens: audit.outputTokens,
+            total_tokens: audit.inputTokens + audit.outputTokens,
+            cost_usd: 0,
+            duration_ms: Date.now() - audit.startedAt,
+            status: audit.status,
+            error_message: audit.errorMessage,
+            related_memory_ids: [],
+            // Issue #127：parsed / capped / deduped 的观测数据。零 schema 变更
+            // （llm_audit_logs.metadata 已存在），一条 SQL 即可验证节流是否生效。
+            metadata: audit.metadata
+          });
+        } catch (auditError) {
+          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);
+    }
+  }
+
+  const unsubscribe = ctx.on("session/event", (session, event) => {
+    if (disposed || event.type !== "turn/end") return;
+    // Return the summarization promise so awaiters observe the writes; the
+    // catch keeps listener dispatch from rejecting. Dispose-initiated aborts
+    // and external AbortErrors are silent.
+    return summarize(session, event).catch((error) => {
+      if (disposed || error?.name === "AbortError") return;
+      ctx.logger?.warn?.(`dsh-mneme: summarization failed: ${String(error)}`);
+    });
+  });
+
+  return {
+    dispose() {
+      if (disposed) return;
+      disposed = true;
+      unsubscribe?.();
+      for (const timer of deferredRuns.values()) clearTimer(timer);
+      deferredRuns.clear();
+      for (const controller of inFlight.values()) controller.abort();
+      inFlight.clear();
+      lastRunAt.clear();
+      lastDistilledSeq.clear();
+      parseFailureStreakFallback.clear();
+    }
+  };
+}