@modusensus/dsh-mneme 0.8.7 → 0.8.9

package/src/config.js

@@ -87,6 +87,22 @@ export const Config = z.object({
   // 父开关 `autoInject` 关闭时它不生效（闸门见 injectChildEnabled）；用户显式写进
   // feature_flags 的值永远优先于这里的默认值。
   injectGuidanceEnabled: z.boolean().default(true),
+  // #249 N3（压缩边缘双落点）：上下文即将大幅精简前抢救「正在做什么」。默认关。
+  // 触发靠宿主自己的压缩事件（`compaction/start|summary|end`，都在事件白名单里），
+  // 不自定一套阈值参数——「压缩边缘」由宿主定义，我们再校准一份只会与之漂移。
+  // 为什么是「新时机 + 新表面」因而默认关：它往对话里**追加消息**（新的注入表面，
+  // 参照实现里最容易累积成一堆历史的那类），并多写一张提案表。按 §10 判据，引入
+  // 新时机/新表面/新成本的子项独立成键、默认关；只修正既有块的（基础内容分池、
+  // 库可见性行）才随父开关默认开。`pinnedInjectBudget` 与它同批，但属前者之外：
+  // 那是既有块内的预算，不是新表面。
+  // 双落点是硬要求，不能只留一半：宿主的压缩摘要器**只看对话里的内容**，只落库不
+  // 注入，等于在摘要重建里什么都没留下；只注入不落库，则压缩一过就随旧消息一起
+  // 消失。两者都做，且落库先于注入（注入失败不该丢提案）。
+  // 祖先：`autoInject`（父关则本项不生效，闸门见 injectChildEnabled）。轻量档默认
+  // 置关（见 LIGHT_MODE_OFF）：轻量档多一份注入物是反的，与 injectGuidanceEnabled
+  // 同一取舍。注意预设只是默认值而非强制——装配时用户显式开关在它之后展开，勾了就赢
+  // （合并顺序见 index.js 装配处）。
+  continuityRescueEnabled: z.boolean().default(false),
   // #249（第一批）：B1 pin 池预算——约束/偏好类注入条目的独立小上限。约束与
   // 偏好被静默降级是本议题的立项核心（同类知识与情景日志同池同速率摘要，实测
   // 一轮压缩后仅保 53%、五轮 10%），故这两类不进相关性竞争、不参与跨轮轮换、
@@ -129,6 +145,31 @@ export const Config = z.object({
   // 起算，失败/degraded 的 run 也占用间隔；间隔内的触发请求静默跳过，下一次
   // 写入事件会重新评估。
   dreamMinIntervalMinutes: z.natural().min(0).max(10080).default(0),
+  // Issue #292（#135 派生）：autoDream 连续失败退避（opt-in，默认关 = 行为与
+  // 现状逐字节一致）。开启后调度器对连续失败做指数退避：有效最小间隔 =
+  // dreamMinIntervalMinutes × 2^连续失败数（成功一次清零恢复），封顶 30 分钟。
+  // #89 的最小间隔闸失败 run 也占用，但间隔恒定——恒定失败的模型（#135 空体
+  // 面）会按固定节奏连发刷爆配额；退避把下次重试按失败次数指数推远。基数取
+  // dreamMinIntervalMinutes：基数为 0 时无闸可翻倍，本键不自己产生间隔（先配
+  // dreamMinIntervalMinutes 再开本键）。与 dreamPeakHours / dreamMinIntervalMinutes
+  // 同族（节流阀，不新增任何 LLM 调用），故不进 LIGHT_MODE_OFF。
+  autoDreamFailureBackoff: z.boolean().default(false),
+  // Issue #239（第 4 项，错峰队列）镜像到巩固：高峰期不做梦。与
+  // summarizePeakHours 同一份时段语法（复用 src/summarize.js 的 parsePeakSpec /
+  // isInPeakWindow / nextOffPeakAt，不另写解析器）：逗号分隔、可带星期前缀、支持
+  // 跨零点。空串 = 关闭，行为与现状逐字节一致。
+  //   "09:00-18:00"                      每天 09:00-18:00
+  //   "mon-fri 08:00-12:00,14:00-18:00"  工作日两段（按高峰计费的供应商即此形态）
+  // 为什么巩固比蒸馏更该有这道闸：单次巩固的输入是整窗快照（dreamMaxSnapshotSize
+  // 条），实测一次 run 的 LLM 时长可达数分钟量级，撞上高峰时既贵又慢；而它由写入
+  // 事件触发、没有天然的「等到空闲再跑」路径。命中高峰时：不调 LLM、不刷新
+  // baseline（阈值继续累积，留到非高峰一次性巩固），登记一行 status='skipped' /
+  // error_message='peak-hours' 审计，并按下面的上限择时补跑。任一写法非法则整串
+  // 按「未配置」处理——排程是省钱手段，绝不该因为写错格式把巩固停掉。
+  dreamPeakHours: z.string().default(""),
+  // 高峰顺延上限（分钟，0 = 不设上限）：到点仍处高峰就照常跑，避免整天高峰把巩固
+  // 饿死。默认 120，与 summarizePeakMaxDeferMinutes 对齐。仅在时段串非空时生效。
+  dreamPeakMaxDeferMinutes: z.natural().min(0).max(1440).default(120),
   // 巩固模型路由（settings panel「巩固模型」/ dreamProvider+dreamModel）：
   // dream 的记忆沉淀专用 LLM 路由，显式配置优先于 agent 默认模型（config-first，
   // Issue #25）。模型分类声明：
@@ -476,6 +517,23 @@ export const Config = z.object({
     z.const("high"),
     z.const("none")
   ]).description("同 dreamReasoningEffort：sleep 各阶段 LLM 的推理档位，未配置 = 自动取模型支持的最低档；显式 'none' = 不发送字段、用服务商自带默认。"),
+  // Pass-through reasoning effort for the distill (summarize) LLM call
+  // (issue #315). Mirrors entityExtractionReasoning rather than dream: the
+  // default 'none' omits the field entirely (provider default), so current
+  // behavior is unchanged until the user opts in — no auto-lowest resolution
+  // here, distill failures are retried at the window level anyway. off/low/
+  // medium/high are forwarded verbatim; a provider that rejects the effort
+  // retries once without it (withEffortFallback), so opting in is safe to
+  // experiment with. The failure being addressed is the #9 shape on the
+  // distill path: a thinking model drains the output budget on reasoning and
+  // the summary comes back empty/truncated.
+  summarizeReasoningEffort: z.union([
+    z.const("off"),
+    z.const("low"),
+    z.const("medium"),
+    z.const("high"),
+    z.const("none")
+  ]).default("none").description("蒸馏（会话总结提炼）LLM 的推理档位：默认 'none' = 不发送字段、用服务商自带默认；off/low/medium/high 原样传递，被模型拒收时自动去掉字段重试一次（与巩固/睡眠同款降级，#315）。思考型模型建议 off/low，避免推理烧光输出预算。"),
   // Issue #257：sleep 冲突/模式两阶段的输出预算（原硬编码 2048）。实测默认档
   // 每对裁决约 90 token、24 对 2097——2048 恰好压在边界（53 次运行 48 败）；
   // full 档六分支实测约 290 token/对、24 对 6967，2048 必然截断。默认 8192
@@ -633,7 +691,12 @@ const LIGHT_MODE_OFF = [
   // 轻量模式不开 document 指针行（#230，opt-in：注册/注入/检索增强全随闸）。
   "documentMemoryEnabled",
   // 轻量模式不开热计算（heat 属于重型增强；关掉后 sleep 降级也退回纯时间分层）。
-  "heatEnabled"
+  "heatEnabled",
+  // #249 N3：轻量档默认不开压缩边缘双落点——它往对话里追加消息（新的注入表面），
+  // 轻量档（小模型 / 小上下文）最不该再多一份注入物。这是预设给的默认值、不是强制：
+  // 用户显式勾选仍然赢（合并顺序「用户开关 > 轻量预设 > bundle 配置」，同
+  // injectGuidanceEnabled）。
+  "continuityRescueEnabled"
 ];
 
 /**
@@ -670,7 +733,7 @@ export function applyLightModePreset(cfg) {
  * 是扁平键，不受这条限制。
  */
 export const INJECT_CHILD_FLAGS = Object.freeze({
-  autoInject: Object.freeze(["injectGuidanceEnabled"])
+  autoInject: Object.freeze(["injectGuidanceEnabled", "continuityRescueEnabled"])
 });
 
 /** 子开关的运行时生效值：父开关显式关（false）时恒不生效。 */

package/src/continuity.js

@@ -0,0 +1,220 @@
+import { createUserMessage } from "@deepseek-ai/dsh-llm";
+
+// #249 N3（压缩边缘双落点）：上下文即将大幅精简前，抢救「正在做什么」。
+//
+// 为什么是这个形状（#249 §4.4 / §6.2 / §11；维护者 2026-09-24 拍板「都同意，开工」）：
+//
+// 1. **必须双落点**。宿主的压缩摘要器只看对话里的内容：压缩时宿主按固定字段模板
+//    重建对话，只放系统提示段的东西不进这次重建，等于白写。所以除了落库，还要把同
+//    一条连续性快照追加成靠近序列末尾的消息。DSH 没有 in-memory 消息改写钩子
+//    （§7 已核），因此这是「注入 + 序号引用寻址」，不是改写历史。
+// 2. **落库落成提案，不落成记忆行**。边缘产出直接进 memories，长会话会攒出第 N 条
+//    同主题条目（#275 记的失败形态）；转正通道与 #254 的二次确认共用一套、阶段二才
+//    打开，本批只写 pending 行。
+// 3. **全程不调模型**。三个字段是确定性抽取 + 截断（口径见 deriveContinuity），判定
+//    也只用本地字符串比较；门控成本为零。
+// 4. **触发器就是宿主真的压缩**，不自定一套阈值。宿主在 `agent/pre-step`（压力）与
+//    `agent/request-error`（溢出）两处触发压缩，我们只订阅压缩事件
+//    （`compaction/start|summary|end`，都在 @deepseek-ai/dsh-session 的事件白名单里
+//     `lib/types/known-event-types.js:31-34`）。自定阈值会与宿主口径漂移，还多一份没
+//    人校准的参数；「压缩边缘」本来就有宿主自己下的定义。
+//
+// 落点顺序（为什么 pre-step 里挂得住）：宿主的压缩插件在它自己的 pre-step 监听器里先
+// `await compactIfNeeded(...)` 再 `return next()`，所以我们的监听器拿到 `next()` 结果
+// 时压缩事件已经落库；而我们返回的 `decision.messages` 由宿主在本步末尾以
+// `surfaceOp: "append"` 追加（`@deepseek-ai/dsh-agent-loop/lib/index.js:1046`），晚于
+// 压缩的 `surfaceOp: "replace"`（`dsh-compaction-basic/lib/index.js:649`）——落点天然
+// 在压缩之后、靠近序列末尾。两条注册顺序都成立（谁先谁后，我们的 `await next()` 都在
+// 压缩工作之后返回）。
+
+/** 提案的 kind（唯一键的一半）：一次会话里"压缩边缘"这一类只留一条。 */
+export const CONTINUITY_KIND = "compaction-edge";
+/** 注入消息的统一前缀：机械校验与「不变不重复」判重都靠它（#249 §6.3）。 */
+export const CONTINUITY_NOTICE_PREFIX = "[dsh-mneme continuity]";
+/** 单字段字符上限：抽取是截断，不是摘要（改口径不需要动调用方）。 */
+export const CONTINUITY_FIELD_MAX = 200;
+/** 整条注入消息的字符上限。比 §6.3 的 160B 单行提醒宽：它是结构化快照，不是一句话提醒。 */
+export const CONTINUITY_NOTICE_MAX = 900;
+/** 边缘表的兜底上限：只留序号、且有界——压缩完就没有下一次 pre-step 的会话不走消费路径。 */
+const MAX_TRACKED_EDGES = 50;
+
+const EDGE_EVENT_TYPES = new Set(["compaction/start", "compaction/summary", "compaction/end"]);
+
+// 与 summarize.js 的 collectMessages 同一个口径：只取公开文本块，reasoning 私有推理
+// 不进快照（快照可能被宿主重建进摘要）。刻意副本而不是导出——那边是会话蒸馏的内部
+// 细节，两边取文本的理由不同。
+function textOf(content) {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  return content
+    .map((block) => (typeof block === "string" ? block : (block?.type === "text" && typeof block.text === "string" ? block.text : "")))
+    .filter((s) => s)
+    .join("\n");
+}
+
+// DSH 0.1.2-rc.1 起 Session 用 snapshotEvents()，兼容旧版 .events。这是**全量日志**
+// （append-only，含已被 surfaceOp:"replace" 折叠出表面的旧事件）——抽取要的正是全量：
+// 被压缩折叠掉的最后一条真实用户消息，也曾是"正在做什么"。
+function sessionEvents(session) {
+  let events = typeof session?.snapshotEvents === "function" ? session.snapshotEvents() : session?.events;
+  // 与 summarize.js 的同名兼容层同形：snapshotEvents 不可用或返回非数组时退回 .events。
+  if (!Array.isArray(events)) events = session?.events;
+  return Array.isArray(events) ? events : [];
+}
+
+// 「当前表面」= `session.surface.nodes`（只存活节点的 seq，事件体在上面那份日志里）。
+// 判重必须按表面而不是全量日志：旧注入还在日志里、但已被折叠出表面，照日志判重会让
+// 这一次压缩后该补的注入被静默跳过——双落点的 ② 就空了一次，而日志里看不出发生过。
+// 宿主没有表面投影（旧版）时退回全量：宁可少追加一次，也不在表面里重复追加同一份文本。
+function surfaceEvents(session) {
+  const events = sessionEvents(session);
+  let nodes;
+  // 宿主的 `surface.nodes` 是会抛的 getter（它自己用过、之后又被移除或替换的 message
+  // projection 会让宿主内部的 `_assertProjections` 抛）。判重是锦上添花的一步：读不到就
+  // 退回全量，别让一个可选的抢救功能因为读宿主状态失败而把 agent 的这一步变失败。
+  try {
+    nodes = session?.surface?.nodes;
+  } catch {
+    return events;
+  }
+  if (!Array.isArray(nodes)) return events;
+  const inSurface = new Set(nodes);
+  return events.filter((event) => inSurface.has(event?.seq));
+}
+
+/**
+ * 抽取连续性三字段（纯函数、无 LLM、无副作用，供测试直接钉住口径）：
+ * - `currentWork`：最近一条**真实** user/message（插件注入与子代理上报不算用户指令），
+ *   取头部 CONTINUITY_FIELD_MAX 字符——"正在做什么"就是最后那条指令。
+ * - `nextStep`：最近一条 assistant/message 的**尾部**同长度——"下一步"活在末尾那
+ *   一段/最后一句里，取头会把开场白带进来。
+ * - `openQuestions`：恒 null。确定性抽取判不出「哪些问题还没解决」，硬用反引号/问号
+ *   猜会给出似是而非的字段；这个字段留给转正通道与人工补（不是所有字段都必须自动
+ *   填满——宁可空着，也不编造）。空字段在注入文本里如实标 (none)。
+ */
+export function deriveContinuity(session, fieldMax = CONTINUITY_FIELD_MAX) {
+  let currentWork = null;
+  let nextStep = null;
+  for (const event of sessionEvents(session)) {
+    const data = event?.data ?? {};
+    if (event?.type === "user/message") {
+      // 只认用户自己写的：source.kind 缺省（旧事件）或 "user"。插件消息（我们自己的
+      // 注入、其它插件）与子代理上报都不是"当前指令"。
+      const kind = data?.source?.kind;
+      if (kind !== undefined && kind !== "user") continue;
+      const text = textOf(data.content).trim();
+      if (text) currentWork = text.slice(0, fieldMax);
+    } else if (event?.type === "assistant/message") {
+      const text = textOf(data?.message?.content).trim();
+      if (text) nextStep = text.slice(-fieldMax);
+    }
+  }
+  return { currentWork, nextStep, openQuestions: null };
+}
+
+/** 单行化：字段里的换行会把「靠近末尾的一条消息」摊成多行，也破坏 §6.3 的单行约定。 */
+function oneLine(text) {
+  return typeof text === "string" ? text.replace(/\s*\n\s*/g, " ").trim() : "";
+}
+
+/** 渲染注入文本（纯函数）：统一前缀 + 三个固定字段（#249 §6.2）。 */
+export function renderContinuityNotice(fields, noticeMax = CONTINUITY_NOTICE_MAX) {
+  const body = [
+    `${CONTINUITY_NOTICE_PREFIX} Context compaction happened in this session; here is the continuity snapshot ` +
+      "recorded so it survives outside the transcript (a proposal — not yet in the memory store):",
+    `current_work: ${oneLine(fields?.currentWork) || "(none)"}`,
+    `next_step: ${oneLine(fields?.nextStep) || "(none)"}`,
+    `open_questions: ${oneLine(fields?.openQuestions) || "(none)"}`
+  ].join("\n");
+  return body.length > noticeMax ? body.slice(0, noticeMax) : body;
+}
+
+/** 表面上是否已经有同一条注入（「不变不重复」，#249 §6.5）：按前缀 + 全文比较，
+ *  不做语义判定——没有改写钩子，能做的只有"同一份文本不追加第二次"。 */
+function noticeAlreadyInSurface(session, text) {
+  return surfaceEvents(session).some((event) => {
+    if (event?.type !== "user/message") return false;
+    if (event?.data?.source?.plugin !== "dsh-mneme") return false;
+    const content = textOf(event?.data?.content);
+    return content === text;
+  });
+}
+
+/**
+ * 挂两条监听（#249 §7 的 `agent/pre-step` 触发位 + 压缩事件面），返回 { dispose }。
+ *
+ * `store` 直接注入：本模块只写提案表、不碰检索/嵌入，没有用到 service 的任何能力。
+ * 调用方负责父／子闸门（`autoInject` + `continuityRescueEnabled`）；本函数不做开关判定，
+ * 保持"挂上就是开"的单一口径。
+ */
+export function createContinuityRescue(ctx, store) {
+  // 待处理的边缘：sessionId → 压缩事件序号。压缩事件到达时置位，下一次 pre-step 消费后
+  // 删除（同一个边缘绝不注入第二次）。只留序号、不留 Session：插件在宿主进程里只 apply
+  // 一次、服务所有会话，握着 Session 就是握着它的全量日志不放——压缩完就收工、不再有
+  // pre-step 是常见路径，这些条目永远走不到消费路径上。
+  const edge = new Map();
+
+  const unsubscribe = ctx.on("session/event", (session, event) => {
+    if (!EDGE_EVENT_TYPES.has(event?.type)) return;
+    if (!session?.id) return;
+    if (!edge.has(session.id) && edge.size >= MAX_TRACKED_EDGES) {
+      // 兜底淘汰最旧的（Map 是插入序）：这里漏掉最坏也只少一次注入，不会无界增长。
+      edge.delete(edge.keys().next().value);
+    }
+    // 同一轮压缩会依次落 start/summary/end，后到的覆盖前一个：留着最后一个（更有
+    // 信息——summary 带摘要事件 seq），序号即触发证据。
+    edge.set(session.id, typeof event.seq === "number" ? event.seq : null);
+  });
+
+  const offStep = ctx.on("agent/pre-step", async (payload, next) => {
+    const decision = await next();
+    // reject 是"这一步不该发生"，往里面塞消息没有意义；未知形状原样放行。
+    if (decision?.kind !== "enter") return decision;
+    const session = payload?.agent?.session;
+    const sessionId = session?.id;
+    if (!sessionId) return decision;
+    if (!edge.has(sessionId)) return decision;
+    const edgeSeq = edge.get(sessionId);
+    edge.delete(sessionId);
+
+    // 抽取就地用 payload 上的这个 session（与置位时同一个 id），不从边缘表里握对象引用。
+    const fields = deriveContinuity(session);
+    // 落库先于注入：提案是"脱离对话独立存活"的那一半。写不进去不算宿主这一步的失败——
+    // 可选插件的可选能力把 agent 的一步带崩，比丢一次抢救严重得多（本函数的不变量）。
+    try {
+      const saved = store.saveContinuityProposal({
+        sessionId,
+        kind: CONTINUITY_KIND,
+        currentWork: fields.currentWork,
+        nextStep: fields.nextStep,
+        openQuestions: fields.openQuestions,
+        edgeSeq
+      });
+      // 弃新是"静默失效"的那一类：不报出来，运维与 §8 的触发率口径都会把它当成没触发。
+      if (saved?.dropped) {
+        ctx.logger?.warn?.(`[dsh-mneme] continuity: pending queue full, dropped the edge for session ${sessionId}`);
+      }
+    } catch (error) {
+      ctx.logger?.warn?.(`[dsh-mneme] continuity proposal not recorded: ${String(error)}`);
+    }
+
+    const text = renderContinuityNotice(fields);
+    if (noticeAlreadyInSurface(session, text)) return decision;
+    const messages = Array.isArray(decision.messages) ? decision.messages : [];
+    return {
+      ...decision,
+      messages: [
+        ...messages,
+        createUserMessage({ content: [{ type: "text", text }], source: { kind: "plugin:dsh-mneme", plugin: "dsh-mneme" } })
+      ]
+    };
+  });
+
+  return {
+    dispose() {
+      unsubscribe?.();
+      offStep?.();
+      edge.clear();
+    }
+  };
+}

package/src/dream/sleep.js

@@ -334,8 +334,8 @@ async function phaseConflicts(ctx, service, config, logger, runId, semantic = nu
     maxTokens: config.sleepMaxTokens ?? 2048,
     ...(withEffort && sleepEffort ? { reasoningEffort: sleepEffort } : {}),
     messages: [
-      { role: "system", content: [{ type: "text", text: conflictPrompt }], source: { kind: "plugin", plugin: "dsh-mneme" } },
-      { role: "user", content: [{ type: "text", text: listText }], source: { kind: "plugin", plugin: "dsh-mneme" } }
+      { role: "system", content: [{ type: "text", text: conflictPrompt }], source: { kind: "plugin:dsh-mneme", plugin: "dsh-mneme" } },
+      { role: "user", content: [{ type: "text", text: listText }], source: { kind: "plugin:dsh-mneme", plugin: "dsh-mneme" } }
     ]
   }, reportUsage, (reason) => { conflictStreamFailure = describeStreamFailure(reason); }));
   };
@@ -496,8 +496,8 @@ async function phasePatterns(ctx, service, config, logger, runId, signal = null)
     maxTokens: config.sleepMaxTokens ?? 2048,
     ...(withEffort && sleepEffort ? { reasoningEffort: sleepEffort } : {}),
     messages: [
-      { role: "system", content: [{ type: "text", text: STR.prompts.pattern[language].replace("N", String(maxPatterns)) }], source: { kind: "plugin", plugin: "dsh-mneme" } },
-      { role: "user", content: [{ type: "text", text: listText }], source: { kind: "plugin", plugin: "dsh-mneme" } }
+      { role: "system", content: [{ type: "text", text: STR.prompts.pattern[language].replace("N", String(maxPatterns)) }], source: { kind: "plugin:dsh-mneme", plugin: "dsh-mneme" } },
+      { role: "user", content: [{ type: "text", text: listText }], source: { kind: "plugin:dsh-mneme", plugin: "dsh-mneme" } }
     ]
   }, reportUsage, (reason) => { patternStreamFailure = describeStreamFailure(reason); }));
   };

package/src/dream.js

@@ -2,6 +2,12 @@ import { validateDecisions, applyDecisions } from "./dream/decisions.js";
 import { clusterMemories, findPotentialConflicts, cosineSimilarity } from "./dream/clustering.js";
 import { clusterByTag, intersectEvidence } from "./dream/narratives.js";
 import { scopeKeyOf } from "./scope.js";
+// Issue #239（第 4 项）镜像到巩固：错峰时段解析与「最近的高峰结束时刻」从独立的
+// 零依赖模块 peak-hours.js 取（该模块从 summarize.js 抽出，PR #320 review）——
+// 不另写一份解析器，两份实现漂移会让「同一个时段串在两处行为不同」，那比没有
+// 这个功能更糟。此前直接 import summarize.js，#316 后 summarize 反向依赖 dream
+// （withEffortFallback 复用），会成真循环，故抽模块。
+import { isInPeakWindow, nextOffPeakAt } from "./peak-hours.js";
 import { createHash, randomUUID } from "node:crypto";
 import { STR, langOf } from "./lang.js";
 export { validateDecisions, applyDecisions, withEffortFallback, describeStreamFailure, resolveDreamEffort, resolveRoute };
@@ -341,6 +347,9 @@ async function runAuditedLlm(ctx, service, config, spec, body) {
  * accepted → reasoning capped; rejected → provider default (old behavior),
  * logged so the rejection is observable.
  */
+// Issue #315：effort 拒收判别式的单一来源。summarize 的流失败以 aborted 结果
+// 返回，需在折叠成 undefined 前用同一甄别（各处手写会漂移）。
+export const EFFORT_REJECT_RE = /reasoning[\s_]*effort|UNSUPPORTED_REASONING_EFFORT/i;
 async function withEffortFallback(ctx, effort, attempt, fallback, getStreamError) {
   if (!effort || effort === "none") return attempt();
   try {
@@ -351,17 +360,20 @@ async function withEffortFallback(ctx, effort, attempt, fallback, getStreamError
       // on the chunk's failure reason here or the retry below is dead code
       // for the stream path.
       const reason = String(getStreamError?.() ?? "");
-      if (/reasoning[\s_]*effort|UNSUPPORTED_REASONING_EFFORT/i.test(reason)) {
+      if (EFFORT_REJECT_RE.test(reason)) {
         ctx.logger?.warn?.(`dsh-mneme dream: reasoningEffort "${effort}" rejected via stream (${reason}); retrying without it`);
         return fallback();
       }
     }
     return result;
   } catch (error) {
+    // dispose/取消中止直接放行，绝不能被误判成 effort 拒收而触发 fallback
+    //（取消后重打一次不带 effort 的调用是浪费，且可能掩盖真实的取消意图）。
+    if (error?.name === "AbortError") throw error;
     const message = String(error?.message ?? error);
     // matches both "reasoning effort" (natural language) and the bare
     // "UNSUPPORTED_REASONING_EFFORT" error code (underscore).
-    if (!/reasoning[\s_]*effort/i.test(message)) throw error;
+    if (!EFFORT_REJECT_RE.test(message)) throw error;
     ctx.logger?.warn?.(`dsh-mneme dream: reasoningEffort "${effort}" rejected (${message}); retrying without it`);
     return fallback();
   }
@@ -410,8 +422,8 @@ async function generateNarratives({ ctx, service, config, route, language, effor
       maxTokens: config.dreamMaxTokens ?? 2048,
       ...(withEffort && effort ? { reasoningEffort: effort } : {}),
       messages: [
-        { role: "system", content: [{ type: "text", text: STR.prompts.narrative[language] }], source: { kind: "plugin", plugin: "dsh-mneme" } },
-        { role: "user", content: [{ type: "text", text: listing }], source: { kind: "plugin", plugin: "dsh-mneme" } }
+        { role: "system", content: [{ type: "text", text: STR.prompts.narrative[language] }], source: { kind: "plugin:dsh-mneme", plugin: "dsh-mneme" } },
+        { role: "user", content: [{ type: "text", text: listing }], source: { kind: "plugin:dsh-mneme", plugin: "dsh-mneme" } }
       ]
     }, reportUsage, (reason) => { streamFailure = describeStreamFailure(reason); }));
   };
@@ -744,8 +756,16 @@ export async function maintainIndexAfterDream(decisions, service, semantic) {
   if (embedder.modelHash) vectorIndex.markModel?.(embedder.modelHash, embedder.dimension);
 }
 
-export function createDreamScheduler({ onRun, thresholdCount = 10, thresholdChars = 5000, delayMs = 2000, minIntervalMs = 0, logger, semantic = null, lastRunAtSeed = 0 }) {
+// Issue #292：连续失败退避的间隔封顶（30 分钟）。封顶只拦指数「增长」，不把
+// 用户配得比这更大的 dreamMinIntervalMinutes 基数压小（见 effectiveMinIntervalMs）。
+const FAILURE_BACKOFF_CAP_MS = 30 * 60 * 1000;
+
+export function createDreamScheduler({ onRun, thresholdCount = 10, thresholdChars = 5000, delayMs = 2000, minIntervalMs = 0, failureBackoff = false, logger, semantic = null, lastRunAtSeed = 0, peakHours = "", peakMaxDeferMinutes = 120, auditPeakSkip = null, now = () => Date.now(), setTimeoutFn = setTimeout, clearTimeoutFn = clearTimeout }) {
   let pendingTimer = null;
+  // Issue #239（第 4 项）镜像到巩固：高峰顺延定时器。与 pendingTimer 分开——两者
+  // 语义不同（一个是「马上要跑」，一个是「等出高峰再跑」），合成一个变量会让
+  // maybeSchedule 的守卫在顺延期间把新的写入触发误当成「已有待跑」而吞掉。
+  let deferTimer = null;
   let running = false;
   let disposed = false;
   let baseline = { count: 0, chars: 0 };
@@ -755,6 +775,21 @@ export function createDreamScheduler({ onRun, thresholdCount = 10, thresholdChar
   // lastRunAtSeed：调用方从 dream_runs 审计表读出的上次开跑时刻——
   // 内存变量进程重启即归零，闸门对新实例放行 → 重启后立刻连发（#89 根因）。
   let lastRunAt = lastRunAtSeed;
+  // Issue #292（#135 派生）：同会话内连续失败计数。失败（onRun 抛错或返回
+  // ok:false）+1，成功清零；无返回结果的 run（no-op 桩）视为完成且无失败，
+  // 不动计数。纯内存变量、宿主重启归零——跨重启的冷却由 lastRunAtSeed（#291）
+  // 持久化负责，两者不重叠。
+  let consecutiveFailures = 0;
+
+  // Issue #292：有效最小间隔 = 基数 × 2^连续失败数，封顶 30 分钟。退避关闭或
+  // 尚无失败时逐字节返回基数（默认关 = 行为与现状一致）。基数 0 无闸可翻倍
+  // （本键不自己产生间隔）；封顶取 max(基数, cap)，指数再大也不会把用户配的
+  // 大基数压小。2^N 溢出成 Infinity 由 Math.min 兜到 cap，无需另设上限位数。
+  function effectiveMinIntervalMs() {
+    if (!failureBackoff || consecutiveFailures <= 0) return minIntervalMs;
+    const cap = Math.max(minIntervalMs, FAILURE_BACKOFF_CAP_MS);
+    return Math.min(minIntervalMs * 2 ** consecutiveFailures, cap);
+  }
 
   function shouldTrigger(service) {
     const memories = service.all().filter((m) => !m.archived && m.type !== "summary" && m.type !== "document");
@@ -766,51 +801,115 @@ export function createDreamScheduler({ onRun, thresholdCount = 10, thresholdChar
   }
 
   function maybeSchedule(service) {
-    if (disposed || running || pendingTimer) return false;
-    // Issue #89（请求 2）：最小触发间隔闸门。
-    if (minIntervalMs > 0 && Date.now() - lastRunAt < minIntervalMs) return false;
+    if (disposed || running || pendingTimer || deferTimer) return false;
+    // Issue #89（请求 2）：最小触发间隔闸门。#292 退避开启时改用指数放大的
+    // 有效间隔：连续失败越多，下次放行越晚（恒定失败的模型不再按固定节奏连发，
+    // 只会越打越稀）。失败 run 本就占用间隔（lastRunAt 在开跑时刷新，见 #89），
+    // 这里放大的是同一道闸，不新增任何状态面。间隔内的触发静默跳过：没有调用
+    // 发生，也就没有可审计的对象（与 #89 口径一致，不写审计行）。
+    if (minIntervalMs > 0 && now() - lastRunAt < effectiveMinIntervalMs()) return false;
     const { trigger, count, chars } = shouldTrigger(service);
     if (!trigger) return false;
-    pendingTimer = setTimeout(() => {
+    // Issue #239（第 4 项，错峰队列）镜像到巩固：命中高峰就不调模型。与蒸馏的差别
+    // 在于巩固是**全局单实例**（蒸馏按会话各挂一个定时器），所以这里只需要一个
+    // deferTimer，且不需要 deferredRuns 那套按会话去重。
+    // baseline 刻意不刷新：阈值继续累积，留到非高峰一次性巩固（一次大 run 比多次
+    // 小 run 省）。审计只登记一行 skip——「为什么不再做梦了」必须对用户可观测。
+    if (isInPeakWindow(new Date(now()), peakHours)) {
+      try {
+        auditPeakSkip?.({ count, chars });
+      } catch (error) {
+        // 记账是 best-effort：写审计行失败只 warn，绝不反噬调度本身。
+        logger?.warn?.(`dsh-mneme dream: peak-hours audit failed: ${String(error)}`);
+      }
+      scheduleDeferredRun(service);
+      return false;
+    }
+    pendingTimer = setTimeoutFn(() => {
       pendingTimer = null;
-      running = true;
-      lastRunAt = Date.now();
-      // Defer the onRun invocation so a synchronous throw cannot escape the
-      // timer callback (which would crash the process) and skip the teardown.
-      // Errors are logged, never swallowed silently. inFlight lets dispose()
-      // await the running consolidation before the caller closes the store.
-      inFlight = Promise.resolve()
-        .then(() => (onRun ? onRun() : Promise.resolve({ ok: true, skipped: true })))
-        .then((result) => {
-          // Refresh the baseline only for a successful run (design §5.3: an
-          // LLM failure must not move the baseline, so the next write can
-          // immediately re-trigger a retry). A `{ok:false}` result or a throw
-          // keeps the old baseline. A run that reports nothing is treated as
-          // completed without failure (no-op hooks / minimal test doubles).
-          if (result && result.ok) {
-            try {
-              baseline = shouldTrigger(service);
-            } catch (error) {
-              // Store closed mid-flight: keep the last known baseline.
-              logger?.warn?.(`dsh-mneme dream: baseline refresh failed: ${String(error)}`);
-            }
-          }
-        })
-        .catch((error) => {
-          logger?.warn?.(`dsh-mneme dream: run failed: ${error?.message ?? error}`);
-          // Failed runs do not refresh the baseline.
-        })
-        .finally(() => {
-          running = false;
-          inFlight = null;
-        });
+      startRun(service);
     }, delayMs);
     return true;
   }
 
+  /**
+   * Issue #239：高峰内择时补跑——挂到「距当前最近的一个高峰结束时刻」，被
+   * peakMaxDeferMinutes 截断时到点照跑（bypassPeak），长高峰不会把巩固饿死。
+   * 定时器 unref：不阻止宿主退出。重复触发不叠加（deferTimer 已在 maybeSchedule
+   * 的守卫里，这里再判一次以防从其它路径进来）。
+   */
+  function scheduleDeferredRun(service) {
+    if (disposed || deferTimer) return;
+    const at = nextOffPeakAt(new Date(now()), peakHours);
+    if (!at) return;
+    const maxDeferMs = (peakMaxDeferMinutes ?? 0) * 60000;
+    let delay = Math.max(0, at.getTime() - now());
+    const capped = maxDeferMs > 0 && delay > maxDeferMs;
+    if (capped) delay = maxDeferMs;
+    deferTimer = setTimeoutFn(() => {
+      deferTimer = null;
+      if (disposed) return;
+      // 截断放行时仍在高峰：不再重新顺延（否则长高峰里会无限顺延，等于把巩固
+      // 关掉）。直接开跑，与蒸馏的 bypassPeak 同口径。
+      if (!capped && isInPeakWindow(new Date(now()), peakHours)) {
+        // 理论上到点已出高峰；时钟跳变/时段串被改小可能落回高峰内，此时再顺延一次。
+        scheduleDeferredRun(service);
+        return;
+      }
+      logger?.info?.(`dsh-mneme dream: peak-hours deferred run firing (capped=${capped}, delayMs=${delay})`);
+      startRun(service);
+    }, delay);
+    deferTimer.unref?.();
+  }
+
+  /**
+   * 真正开跑。抽出来是因为两条路径都要用：写入触发的正常路径，与高峰顺延后的
+   * 补跑路径。onRun 的调用刻意放在 Promise 里——同步抛出的异常若逃出 timer 回调
+   * 会直接崩掉进程并跳过收尾。inFlight 让 dispose() 能等完这一轮再关库。
+   */
+  function startRun(service) {
+    running = true;
+    lastRunAt = now();
+    inFlight = Promise.resolve()
+      .then(() => (onRun ? onRun() : Promise.resolve({ ok: true, skipped: true })))
+      .then((result) => {
+        // Refresh the baseline only for a successful run (design §5.3: an
+        // LLM failure must not move the baseline, so the next write can
+        // immediately re-trigger a retry). A `{ok:false}` result or a throw
+        // keeps the old baseline. A run that reports nothing is treated as
+        // completed without failure (no-op hooks / minimal test doubles).
+        if (result && result.ok) {
+          consecutiveFailures = 0; // Issue #292：成功清零，下次触发回到基数间隔
+          try {
+            baseline = shouldTrigger(service);
+          } catch (error) {
+            // Store closed mid-flight: keep the last known baseline.
+            logger?.warn?.(`dsh-mneme dream: baseline refresh failed: ${String(error)}`);
+          }
+        } else if (result) {
+          // Issue #292：ok:false（LLM 失败 / 空体 / 整单拒绝）计入连败；degraded
+          // 的 run 走 ok:true（LLM 本身成功了，只是决策被部分应用）→ 算成功、清零。
+          // 退避关闭时该计数没有消费者，行为与此前逐字节一致。
+          consecutiveFailures += 1;
+        }
+        // result 为空（no-op 桩 / 最小测试替身）＝完成且无失败：基线与连败计数都不动。
+      })
+      .catch((error) => {
+        logger?.warn?.(`dsh-mneme dream: run failed: ${error?.message ?? error}`);
+        // Failed runs do not refresh the baseline.
+        consecutiveFailures += 1; // Issue #292：抛错同样计入连败
+      })
+      .finally(() => {
+        running = false;
+        inFlight = null;
+      });
+  }
+
   async function dispose() {
     disposed = true;
-    if (pendingTimer) { clearTimeout(pendingTimer); pendingTimer = null; }
+    if (pendingTimer) { clearTimeoutFn(pendingTimer); pendingTimer = null; }
+    // Issue #239：高峰顺延定时器同样要清，否则进程关闭后仍会触发一次巩固。
+    if (deferTimer) { clearTimeoutFn(deferTimer); deferTimer = null; }
     // An in-flight run is left to complete naturally (its LLM calls are
     // already paid for and aborting would discard the work). Await it so the
     // caller can close the store only after every write has landed.
@@ -1001,8 +1100,8 @@ export function createDreamScheduler({ onRun, thresholdCount = 10, thresholdChar
       maxTokens: config.dreamMaxTokens ?? 4096,
       ...(withEffort && effort ? { reasoningEffort: effort } : {}),
       messages: [
-        { role: "system", content: [{ type: "text", text: consolidationPrompt }], source: { kind: "plugin", plugin: "dsh-mneme" } },
-        { role: "user", content: [{ type: "text", text: listText }], source: { kind: "plugin", plugin: "dsh-mneme" } }
+        { role: "system", content: [{ type: "text", text: consolidationPrompt }], source: { kind: "plugin:dsh-mneme", plugin: "dsh-mneme" } },
+        { role: "user", content: [{ type: "text", text: listText }], source: { kind: "plugin:dsh-mneme", plugin: "dsh-mneme" } }
       ]
     }, reportUsage, (reason) => { streamFailure = describeStreamFailure(reason); }));
     };
@@ -1236,8 +1335,8 @@ export function createDreamScheduler({ onRun, thresholdCount = 10, thresholdChar
       maxTokens: config.dreamMaxTokens ?? 2048,
       ...(withEffort && effort ? { reasoningEffort: effort } : {}),
       messages: [
-        { role: "system", content: [{ type: "text", text: STR.prompts.dreamSummary[language] }], source: { kind: "plugin", plugin: "dsh-mneme" } },
-        { role: "user", content: [{ type: "text", text: summaryInputs.map((m) => `- ${m.title}: ${m.content}`).join("\n") }], source: { kind: "plugin", plugin: "dsh-mneme" } }
+        { role: "system", content: [{ type: "text", text: STR.prompts.dreamSummary[language] }], source: { kind: "plugin:dsh-mneme", plugin: "dsh-mneme" } },
+        { role: "user", content: [{ type: "text", text: summaryInputs.map((m) => `- ${m.title}: ${m.content}`).join("\n") }], source: { kind: "plugin:dsh-mneme", plugin: "dsh-mneme" } }
       ]
     }, reportUsage, (reason) => { summaryStreamFailure = describeStreamFailure(reason); }));
     };

package/src/entities/extractor.js

@@ -150,8 +150,8 @@ export async function extractEntities(memory, { store, config, callLLM, logger }
     const userText = buildUserMessage(memory.content);
 
     const messages = [
-      { role: "system", content: [{ type: "text", text: systemPrompt }], source: { kind: "plugin", plugin: "dsh-mneme" } },
-      { role: "user", content: [{ type: "text", text: userText }], source: { kind: "plugin", plugin: "dsh-mneme" } }
+      { role: "system", content: [{ type: "text", text: systemPrompt }], source: { kind: "plugin:dsh-mneme", plugin: "dsh-mneme" } },
+      { role: "user", content: [{ type: "text", text: userText }], source: { kind: "plugin:dsh-mneme", plugin: "dsh-mneme" } }
     ];
 
     // Issue #109: optional provider/model override + reasoning effort are