@modusensus/dsh-mneme 0.8.7 → 0.8.9

package/src/guide.js

@@ -42,3 +42,21 @@ export const TOOL_GUIDE = {
     " Save only durable, cross-session value (a preference, a decision with its rationale, an engineering constraint, " +
     "a pitfall with its root cause). Trivial single-turn work does not belong here, and when unsure, do not save."
 };
+
+/**
+ * #249 N3 的降级路径：宿主若不提供可挂钩的压缩前时机，双落点里的「注入」那一半就没
+ * 有触发者。此时不把功能算作失败，而是把规则交给 agent 自判压力（§4.4 点名的降级
+ * 形态）。落点是工具描述——常驻文本、不进每轮上下文，零注入成本。
+ *
+ * 英文单一正本，理由同 TOOL_GUIDE（见文件头）。字段名用存储与注入那一侧的口径
+ * （`current_work` / `next_step` / open question，#249 §6.2）；规格 §4.4 里的
+ * Current Work / Next Step / Critical Context 是**宿主压缩模板**的字段名，不是这里的。
+ */
+export const CONTINUITY_TOOL_RULE = {
+  memory_save:
+    " If this session's context is about to be compacted, first save a continuity note with this same tool " +
+    "(type: project, title: one stable title for this line of work, e.g. \"continuity: <topic>\"): current_work (what you " +
+    "are doing now), next_step, and any open question. Keep it to those fields, and reuse that same title for later " +
+    "updates: the store merges rows of the same type + title (the merge appends to the note instead of replacing it), " +
+    "so a fresh title each time just leaves a trail of near-duplicate project rows."
+};

package/src/index.js

@@ -7,6 +7,7 @@ import { createService } from "./service.js";
 import { createWriteAdmission } from "./write-admission.js";
 import { createTools } from "./tools.js";
 import { createInjector } from "./inject.js";
+import { createContinuityRescue } from "./continuity.js";
 import { createSummarizer } from "./summarize.js";
 import { createDreamScheduler } from "./dream.js";
 import { createSleepScheduler, runSleep } from "./dream/sleep.js";
@@ -20,7 +21,7 @@ import { createEmbedder } from "./embedding.js";
 import { createEmbedderByProvider } from "./local-embedder.js";
 import { LocalReranker } from "./reranker.js";
 import { createVectorIndex } from "./vector-index.js";
-import { Config, applyLightModePreset } from "./config.js";
+import { Config, applyLightModePreset, injectChildEnabled } from "./config.js";
 import { langOf } from "./lang.js";
 import { extractEntities } from "./entities/extractor.js";
 import { mkdirSync } from "node:fs";
@@ -490,9 +491,37 @@ export const apply = (ctx, config) => {
       thresholdChars: cfg.dreamThresholdChars,
       delayMs: cfg.dreamDelayMs,
       minIntervalMs: (cfg.dreamMinIntervalMinutes ?? 0) * 60000,
+      // Issue #292：连续失败指数退避（opt-in，默认关 = 行为不变）。
+      failureBackoff: cfg.autoDreamFailureBackoff === true,
       logger: ctx.logger,
       semantic: { embedder, vectorIndex },
       lastRunAtSeed: store.lastDreamRunAt("auto"),
+      // Issue #239（第 4 项）镜像到巩固：高峰期不做梦，顺延到最近的高峰结束时刻。
+      peakHours: cfg.dreamPeakHours ?? "",
+      peakMaxDeferMinutes: cfg.dreamPeakMaxDeferMinutes ?? 120,
+      // 跳过时的审计行在这里落地（调度器只拿到 service，拿不到 config 的
+      // llmAudit 开关与巩固模型路由）。口径与 runAuditedLlm 一致：审计关掉就
+      // 不写；写失败只 warn，绝不反噬调度（CONTRIBUTING 的 fail-safe 硬约定）。
+      auditPeakSkip: ({ count, chars }) => {
+        if (cfg?.llmAudit?.enabled === false || typeof service?.saveLlmAudit !== "function") return;
+        const modelId = cfg.dreamProvider && cfg.dreamModel ? `${cfg.dreamProvider}:${cfg.dreamModel}` : "";
+        service.saveLlmAudit({
+          timestamp: new Date().toISOString(),
+          trigger_source: "autoDream",
+          operation_type: "dream_consolidate",
+          model_id: modelId,
+          input_tokens: 0,
+          output_tokens: 0,
+          total_tokens: 0,
+          cost_usd: 0,
+          duration_ms: 0,
+          status: "skipped",
+          error_message: "peak-hours",
+          related_memory_ids: [],
+          // 观测用：跳过时窗口里积了多少（阈值继续累积，不是丢弃）。
+          metadata: JSON.stringify({ count, chars })
+        });
+      },
       onRun: () => (dream ? dream.runDream(ctx, service, cfg) : Promise.resolve({ ok: true, skipped: true }))
     });
     service.setDreamHook(() => dream.maybeSchedule(service));
@@ -559,6 +588,13 @@ export const apply = (ctx, config) => {
     if (cfg.autoInject) disposers.push(createInjector(promptCtx, service, settings, cfg));
   });
 
+  // #249 N3：压缩边缘双落点。触发靠宿主自己落的压缩事件（订阅 + pre-step 追加），
+  // 不需要 systemPrompt / tools 的任何能力，所以不塞进上面的 inject 回调；父／子
+  // 闸门在挂载点判一次，与 inject.js 共用同一个 injectChildEnabled 判据。
+  if (cfg.autoInject && injectChildEnabled(cfg, "continuityRescueEnabled")) {
+    disposers.push(createContinuityRescue(ctx, store));
+  }
+
   ctx.inject(["tools"], (toolsCtx) => {
     disposers.push(createTools(toolsCtx, service, cfg, embedder));
   });

package/src/peak-hours.js

@@ -0,0 +1,117 @@
+// 高峰时段（peak hours）解析与判定——纯函数模块，零依赖。
+//
+// 从 summarize.js 抽出（PR #320 review）：#316 之后 summarize.js 反向依赖
+// dream.js（withEffortFallback 复用），dream 镜像错峰时再 import summarize
+// 会成真循环。时段调度本来就不是蒸馏的私有语义，独立成模块后两侧都从这里
+// import，循环消失。re-export 兼容留在 summarize.js，调用方零改动。
+//
+// Issue #239（第 4 项，错峰队列）：高峰时段解析与判定。纯函数、可单测——排程
+// 判断不绑死真实时钟，测试才能确定性地覆盖跨零点、多段、星期过滤与非法写法。
+// spec 语法：`[<星期> ]<时段>[,<时段>...]`，星期前缀可省（省 = 每天）：
+//   "09:00-18:00"                        每天 09:00-18:00
+//   "mon-fri 08:00-12:00,14:00-18:00"    工作日两段（ISO 1=周一…7=周日，也认 mon..sun）
+//   "sat,sun 23:00-06:00"                周末跨零点段
+// 时间取宿主本地时区。任一写法非法 → 整串视为未配置（返回 null）：排程是省钱手段，
+// 绝不该因为写错格式把蒸馏/巩固停掉。
+const DAY_NAMES = { mon: 1, tue: 2, wed: 3, thu: 4, fri: 5, sat: 6, sun: 7 };
+
+function parseDayToken(token) {
+  const days = new Set();
+  const normalize = (value) => (/^\d$/.test(value) ? Number(value) : DAY_NAMES[value] ?? null);
+  for (const piece of token.split(",")) {
+    const matched = /^([a-z]{3}|\d)(?:-([a-z]{3}|\d))?$/.exec(piece.trim().toLowerCase());
+    if (!matched) return null;
+    const from = normalize(matched[1]);
+    const to = matched[2] === undefined ? from : normalize(matched[2]);
+    if (from === null || to === null || from < 1 || from > 7 || to < 1 || to > 7) return null;
+    // 支持跨周环绕（fri-mon）：从 from 起逐天推进到 to，最多绕一圈。
+    for (let day = from; ; day = (day % 7) + 1) {
+      days.add(day);
+      if (day === to) break;
+    }
+  }
+  return days.size > 0 ? [...days].sort((a, b) => a - b) : null;
+}
+
+/** JS 的 getDay() 是 0=周日…6=周六；这里统一成 ISO（1=周一…7=周日）。 */
+function isoDay(date) {
+  const day = date.getDay();
+  return day === 0 ? 7 : day;
+}
+
+export function parsePeakSpec(spec) {
+  if (typeof spec !== "string" || spec.trim() === "") return null;
+  let rest = spec.trim();
+  let days = null;
+  // 星期前缀 = 第一个空白之前的部分，但**头段含冒号就不是前缀**（那是时段本身，
+  // 例如 "09:00-12:00, 14:00-18:00" 里的逗号空格）。前缀解析失败一律按未配置处理，
+  // 不做猜测——宁可不省，也不能误停。
+  const sep = rest.search(/\s/);
+  if (sep > 0) {
+    const head = rest.slice(0, sep);
+    if (!head.includes(":")) {
+      days = parseDayToken(head);
+      if (days === null) return null;
+      rest = rest.slice(sep).trim();
+    }
+  }
+  const windows = [];
+  for (const part of rest.split(",")) {
+    const matched = /^\s*(\d{1,2}):(\d{2})\s*-\s*(\d{1,2}):(\d{2})\s*$/.exec(part);
+    if (!matched) return null;
+    const [sh, sm, eh, em] = [Number(matched[1]), Number(matched[2]), Number(matched[3]), Number(matched[4])];
+    if (sh > 23 || eh > 23 || sm > 59 || em > 59) return null;
+    const start = sh * 60 + sm;
+    const end = eh * 60 + em;
+    if (start === end) return null;
+    windows.push({ start, end });
+  }
+  return windows.length > 0 ? { days, windows } : null;
+}
+
+/**
+ * 该时刻是否落在高峰内。跨零点段（start > end）按「窗口所属的那一天」认星期：
+ * `mon-fri 23:00-06:00` 的周六 02:00 属于周五开的那个窗口，仍算高峰。
+ */
+export function isInPeakWindow(date, spec) {
+  const parsed = parsePeakSpec(spec);
+  if (!parsed) return false;
+  const minutes = date.getHours() * 60 + date.getMinutes();
+  const today = isoDay(date);
+  const yesterday = today === 1 ? 7 : today - 1;
+  const allowed = (day) => !parsed.days || parsed.days.includes(day);
+  return parsed.windows.some(({ start, end }) => {
+    if (start < end) return minutes >= start && minutes < end && allowed(today);
+    return (minutes >= start && allowed(today)) || (minutes < end && allowed(yesterday));
+  });
+}
+
+/**
+ * 高峰内则返回「距当前最近的一个高峰结束时刻」（择时补跑用），否则 null。
+ * 落在多个时段重叠处时取最早结束的那个——早跑不亏，晚跑才亏。
+ */
+export function nextOffPeakAt(date, spec) {
+  const parsed = parsePeakSpec(spec);
+  if (!parsed) return null;
+  const minutes = date.getHours() * 60 + date.getMinutes();
+  const today = isoDay(date);
+  const yesterday = today === 1 ? 7 : today - 1;
+  const allowed = (day) => !parsed.days || parsed.days.includes(day);
+  let bestDelta = null;
+  const consider = (delta) => {
+    if (bestDelta === null || delta < bestDelta) bestDelta = delta;
+  };
+  for (const { start, end } of parsed.windows) {
+    if (start < end) {
+      if (minutes >= start && minutes < end && allowed(today)) consider(end - minutes);
+      continue;
+    }
+    if (minutes >= start && allowed(today)) consider((1440 - minutes) + end);
+    else if (minutes < end && allowed(yesterday)) consider(end - minutes);
+  }
+  if (bestDelta === null) return null;
+  const at = new Date(date.getTime());
+  at.setSeconds(0, 0);
+  at.setMinutes(at.getMinutes() + bestDelta);
+  return at;
+}

package/src/settings.js

@@ -48,6 +48,9 @@ const FEATURE_FLAG_BOOLEANS = [
   // Issue #249：能力说明（工具描述判断指引 + order 150 总则段）。第二批起它是
   // 注入父开关 autoInject 的子项、默认开（父关时不生效，闸门见 config.js）。
   "injectGuidanceEnabled",
+  // Issue #249 N3：压缩边缘双落点——上下文即将精简前落一条连续性提案 + 往
+  // 序列末尾追加同一份快照。默认关（新注入表面，见 config.js），父开关 autoInject。
+  "continuityRescueEnabled",
   "entityExtractionEnabled",
   // Issue #219：图召回轴——查询命中实体名时把挂联记忆并入检索融合池
   // （默认关；依赖实体抽取产出，lightMode 强制关闭）。
@@ -60,6 +63,9 @@ const FEATURE_FLAG_BOOLEANS = [
   "documentMemoryEnabled",
   "codingRetrospect",
   "autoDream",
+  // Issue #292：autoDream 连续失败退避（默认关）。基数是 dreamMinIntervalMinutes，
+  // 有效间隔 = 基数 × 2^连续失败数（成功清零），封顶 30 分钟；面板可启停。
+  "autoDreamFailureBackoff",
   "sleepModeEnabled",
   "heatEnabled",
   "hybridInject",
@@ -114,6 +120,8 @@ const FEATURE_FLAG_INT_RANGES = {
   summarizeMaxRunsPerSession: [0, 1000],
   // Issue #239 第 4 项：高峰顺延上限（分钟，0 = 不设上限）。
   summarizePeakMaxDeferMinutes: [0, 1440],
+  // Issue #239 第 4 项镜像到巩固：同一口径（分钟，0 = 不设上限）。
+  dreamPeakMaxDeferMinutes: [0, 1440],
   // Issue #125：hybrid 候选量上限（0 = 复用 dreamMaxSnapshotSize）。
   dreamCandidateMax: [0, 5000],
   // Issue #164①：注入单条正文截断上限（默认 300 = 既有行为）。
@@ -156,7 +164,9 @@ const FEATURE_FLAG_STRINGS = [
   "localEmbedModel",
   "ollamaModel",
   // Issue #239 第 4 项：高峰时段串（"09:00-18:00"，空串 = 关闭）。
-  "summarizePeakHours"
+  "summarizePeakHours",
+  // Issue #239 第 4 项镜像到巩固：同一份时段语法，空串 = 关闭（行为与现状一致）。
+  "dreamPeakHours"
 ];
 // URL 字符串开关：trim 后必须为空或合法 http/https URL（new URL() 校验协议，
 // 拒绝其余协议——这是 SSRF 防线的一部分）。
@@ -169,6 +179,9 @@ const FEATURE_FLAG_ENUMS = {
   recallFusion: ["blend", "rrf", "minmax"],
   // 实体抽取思考强度（issue #109）：与 dreamReasoningEffort 枚举对齐。
   entityExtractionReasoning: ["low", "medium", "high", "none"],
+  // 蒸馏思考强度（issue #315）：与 entityExtractionReasoning 枚举对齐，
+  // 多一个 off（显式关思考，思考型模型蒸馏防推理烧预算）。
+  summarizeReasoningEffort: ["off", "low", "medium", "high", "none"],
   // Issue #127：落库前去重档位（off 默认，等同现状）。
   summarizeDedupeMode: ["off", "title", "vector"],
   // Issue #126：sleep 冲突阶段的动作集（conflict 默认 = 现状；full = 六分支）。

package/src/store.js

@@ -276,6 +276,28 @@ CREATE TABLE IF NOT EXISTS mirror_state (
   applied_generation INTEGER NOT NULL DEFAULT 0 CHECK (applied_generation >= 0 AND applied_generation <= 9007199254740991 AND applied_generation = CAST(applied_generation AS INTEGER)), -- 已成功应用的轮次
   type_status TEXT                               -- JSON: 逐 type 状态 {type: {dirty, applied_gen, last_error}}
 );
+
+-- #249 N3（压缩边缘双落点）：连续性提案。压缩边缘只落**提案**行，不进 memories
+-- ——边缘产出若直接进记忆库，一个长会话就会攒出第 N 条同主题条目，正是 #275 记的
+-- 失败形态；转正通道与 #254 的二次确认共用一套，阶段二才打开，本批只写 pending。
+-- 唯一键 (session_id, kind) 就是形态约定里的「同一会话同一类只留一条」：再次触发
+-- 是刷新同一行，不是新增一行。status 为转正通道预留（pending → promoted/discarded）：
+-- 「实际触发率」= 提案行数、「采纳率」= promoted/总数，都能就地统计（#249 §8）。
+-- 时间戳是 ISO（与 memories 同款），created_at 在刷新时不动，updated_at 记最近边缘。
+CREATE TABLE IF NOT EXISTS continuity_proposals (
+  id             TEXT PRIMARY KEY,
+  session_id     TEXT NOT NULL,
+  kind           TEXT NOT NULL,
+  current_work   TEXT,
+  next_step      TEXT,
+  open_questions TEXT,
+  status         TEXT NOT NULL DEFAULT 'pending',
+  edge_seq       INTEGER,            -- 触发本次刷新的压缩事件 seq（证据/复现用）
+  created_at     TEXT NOT NULL,
+  updated_at     TEXT NOT NULL
+);
+CREATE UNIQUE INDEX IF NOT EXISTS idx_continuity_session_kind ON continuity_proposals(session_id, kind);
+CREATE INDEX IF NOT EXISTS idx_continuity_status ON continuity_proposals(status, updated_at);
 `;
 
 // Exported for API-layer type validation (standalone API POST /memories and
@@ -286,6 +308,12 @@ export const TYPES = new Set(["preference", "project", "decision", "history", "s
   // （registerDocument）——saveWithDedupe/updateMemory 另有守卫拒绝旁路铸造。
   "document"]);
 
+// #249 N3：连续性提案的 pending 队列上限。「队列满则弃新」是形态约定的一半——满时丢
+// 掉本次触发，**不是**淘汰旧行：旧行是别的会话还没转正的活状态，用"更近的边缘"把它挤
+// 掉，等于让长会话的噪音吃掉短会话的真实工作状态。这个数是存储侧策略，与抽取/注入的
+// 截断上限（continuity.js）是两件事。
+const MAX_CONTINUITY_PENDING = 200;
+
 // Epistemic status: what kind of evidence a memory rests on. Defaults to
 // 'subjective' so legacy rows (and rows without any signal) stay compatible.
 const EPISTEMIC_STATUSES = new Set(["observation", "subjective", "inferred"]);
@@ -2645,6 +2673,60 @@ export function createStore(path) {
    *  Otherwise wrap in BEGIN/COMMIT so a memory write and its desired-generation
    *  bump commit together: a crash between them can never leave a mutated store
    *  with generation == applied (audit peer blocker 1, "crash window"). */
+  // --- #249 N3：压缩边缘的连续性提案（唯一写入口 = 压缩边缘监听器） -------------
+  /** Upsert one continuity proposal. (session_id, kind) is the形态约定「同一会话同一类
+   *  只留一条」：命中即刷新（created_at 不动、updated_at 记最近边缘），不新增行。
+   *  Queue full → drop the new one and say so (dropped: true) instead of throwing: an edge
+   *  that cannot be recorded must not break the host's step. Returns {id, created, dropped}. */
+  function saveContinuityProposal({
+    sessionId, kind, currentWork = null, nextStep = null, openQuestions = null, edgeSeq = null,
+    maxPending = MAX_CONTINUITY_PENDING
+  } = {}) {
+    if (!sessionId || !kind) throw new TypeError("continuity proposal needs sessionId and kind");
+    const now = new Date().toISOString();
+    const existing = db.prepare("SELECT id FROM continuity_proposals WHERE session_id = ? AND kind = ?").get(sessionId, kind);
+    if (!existing) {
+      const pending = db.prepare("SELECT COUNT(*) AS c FROM continuity_proposals WHERE status = 'pending'").get().c;
+      if (pending >= maxPending) return { id: null, created: false, dropped: true };
+    }
+    // 写入本身是一条 UPSERT：唯一索引 (session_id, kind) 是并发的裁决者。两个宿主共用
+    // memoryDir 时（AGENTS.md 的多进程 WAL 场景）先查后插会有一个撞 SQLITE_CONSTRAINT，
+    // 而这里只该有一条语句决定成不成功。上面的 SELECT 只用于「队列满」与 created 标记。
+    // created_at 与 status 刻意不在 SET 里：命中只刷新内容与最近边缘时刻，不把已转正的行打回 pending。
+    const id = randomUUID();
+    db.prepare(`
+      INSERT INTO continuity_proposals (id, session_id, kind, current_work, next_step, open_questions, status, edge_seq, created_at, updated_at)
+      VALUES (?, ?, ?, ?, ?, ?, 'pending', ?, ?, ?)
+      ON CONFLICT(session_id, kind) DO UPDATE SET
+        current_work = excluded.current_work,
+        next_step = excluded.next_step,
+        open_questions = excluded.open_questions,
+        edge_seq = excluded.edge_seq,
+        updated_at = excluded.updated_at
+    `).run(id, sessionId, kind, currentWork, nextStep, openQuestions, edgeSeq, now, now);
+    const row = db.prepare("SELECT id FROM continuity_proposals WHERE session_id = ? AND kind = ?").get(sessionId, kind);
+    return { id: row?.id ?? id, created: !existing, dropped: false };
+  }
+
+  /** The single proposal for (session, kind), or null. */
+  function getContinuityProposal(sessionId, kind) {
+    return db.prepare("SELECT * FROM continuity_proposals WHERE session_id = ? AND kind = ?").get(sessionId, kind) ?? null;
+  }
+
+  /** Newest-first proposals, optionally filtered by status (转正通道的读侧预置)。 */
+  function listContinuityProposals({ status, limit = 50 } = {}) {
+    const bounded = Number.isSafeInteger(limit) && limit > 0 ? limit : 50;
+    return status
+      ? db.prepare("SELECT * FROM continuity_proposals WHERE status = ? ORDER BY updated_at DESC, id LIMIT ?").all(status, bounded)
+      : db.prepare("SELECT * FROM continuity_proposals ORDER BY updated_at DESC, id LIMIT ?").all(bounded);
+  }
+
+  function countContinuityProposals({ status } = {}) {
+    return status
+      ? db.prepare("SELECT COUNT(*) AS c FROM continuity_proposals WHERE status = ?").get(status).c
+      : db.prepare("SELECT COUNT(*) AS c FROM continuity_proposals").get().c;
+  }
+
   function runAtomically(fn) {
     if (db.isTransaction) return fn();
     db.exec("BEGIN");
@@ -2769,6 +2851,11 @@ export function createStore(path) {
     setTypeStatus,
     getTypeStatus,
     incrementGeneration,
+    // #249 N3：压缩边缘的连续性提案（落提案、转正才进 memories）。
+    saveContinuityProposal,
+    getContinuityProposal,
+    listContinuityProposals,
+    countContinuityProposals,
     close() {
       db.close();
     }

package/src/summarize.js

@@ -1,5 +1,9 @@
 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";
 
 // 编码记忆蒸馏 prompt（codingRetrospect 开启时启用）：在通用记忆之外，额外提取
 // 三类编码专属记忆，专治重复踩坑 / 遗忘被否决方案 / 丢失工程约束。字段仍沿用
@@ -216,7 +220,7 @@ function collectMessages(session, maxChars = 8000, language = "zh", afterSeq, th
   }, undefined);
   return {
     messages: lines.length
-      ? [createUserMessage({ content: [{ type: "text", text: trimTranscript(lines.join("\n"), maxChars) }], source: { kind: "plugin", plugin: "dsh-mneme" } })]
+      ? [createUserMessage({ content: [{ type: "text", text: trimTranscript(lines.join("\n"), maxChars) }], source: { kind: "plugin:dsh-mneme", plugin: "dsh-mneme" } })]
       : [],
     hasEvents: events.length > 0,
     lastSeq
@@ -256,117 +260,14 @@ function enqueueDistill(task, intervalMs = 0) {
   return run;
 }
 
-// Issue #239（第 4 项，错峰队列）：高峰时段解析与判定。纯函数、可单测——排程判断
-// 不绑死真实时钟，测试才能确定性地覆盖跨零点、多段、星期过滤与非法写法。
-// spec 语法：`[<星期> ]<时段>[,<时段>...]`，星期前缀可省（省 = 每天）：
-//   "09:00-18:00"                        每天 09:00-18:00
-//   "mon-fri 08:00-12:00,14:00-18:00"    工作日两段（ISO 1=周一…7=周日，也认 mon..sun）
-//   "sat,sun 23:00-06:00"                周末跨零点段
-// 时间取宿主本地时区。任一写法非法 → 整串视为未配置（返回 null）：排程是省钱手段，
-// 绝不该因为写错格式把蒸馏停掉。
-const DAY_NAMES = { mon: 1, tue: 2, wed: 3, thu: 4, fri: 5, sat: 6, sun: 7 };
-
-function parseDayToken(token) {
-  const days = new Set();
-  const normalize = (value) => (/^\d$/.test(value) ? Number(value) : DAY_NAMES[value] ?? null);
-  for (const piece of token.split(",")) {
-    const matched = /^([a-z]{3}|\d)(?:-([a-z]{3}|\d))?$/.exec(piece.trim().toLowerCase());
-    if (!matched) return null;
-    const from = normalize(matched[1]);
-    const to = matched[2] === undefined ? from : normalize(matched[2]);
-    if (from === null || to === null || from < 1 || from > 7 || to < 1 || to > 7) return null;
-    // 支持跨周环绕（fri-mon）：从 from 起逐天推进到 to，最多绕一圈。
-    for (let day = from; ; day = (day % 7) + 1) {
-      days.add(day);
-      if (day === to) break;
-    }
-  }
-  return days.size > 0 ? [...days].sort((a, b) => a - b) : null;
-}
-
-/** JS 的 getDay() 是 0=周日…6=周六；这里统一成 ISO（1=周一…7=周日）。 */
-function isoDay(date) {
-  const day = date.getDay();
-  return day === 0 ? 7 : day;
-}
-
-export function parsePeakSpec(spec) {
-  if (typeof spec !== "string" || spec.trim() === "") return null;
-  let rest = spec.trim();
-  let days = null;
-  // 星期前缀 = 第一个空白之前的部分，但**头段含冒号就不是前缀**（那是时段本身，
-  // 例如 "09:00-12:00, 14:00-18:00" 里的逗号空格）。前缀解析失败一律按未配置处理，
-  // 不做猜测——宁可不省，也不能误停。
-  const sep = rest.search(/\s/);
-  if (sep > 0) {
-    const head = rest.slice(0, sep);
-    if (!head.includes(":")) {
-      days = parseDayToken(head);
-      if (days === null) return null;
-      rest = rest.slice(sep).trim();
-    }
-  }
-  const windows = [];
-  for (const part of rest.split(",")) {
-    const matched = /^\s*(\d{1,2}):(\d{2})\s*-\s*(\d{1,2}):(\d{2})\s*$/.exec(part);
-    if (!matched) return null;
-    const [sh, sm, eh, em] = [Number(matched[1]), Number(matched[2]), Number(matched[3]), Number(matched[4])];
-    if (sh > 23 || eh > 23 || sm > 59 || em > 59) return null;
-    const start = sh * 60 + sm;
-    const end = eh * 60 + em;
-    if (start === end) return null;
-    windows.push({ start, end });
-  }
-  return windows.length > 0 ? { days, windows } : null;
-}
-
-/**
- * 该时刻是否落在高峰内。跨零点段（start > end）按「窗口所属的那一天」认星期：
- * `mon-fri 23:00-06:00` 的周六 02:00 属于周五开的那个窗口，仍算高峰。
- */
-export function isInPeakWindow(date, spec) {
-  const parsed = parsePeakSpec(spec);
-  if (!parsed) return false;
-  const minutes = date.getHours() * 60 + date.getMinutes();
-  const today = isoDay(date);
-  const yesterday = today === 1 ? 7 : today - 1;
-  const allowed = (day) => !parsed.days || parsed.days.includes(day);
-  return parsed.windows.some(({ start, end }) => {
-    if (start < end) return minutes >= start && minutes < end && allowed(today);
-    return (minutes >= start && allowed(today)) || (minutes < end && allowed(yesterday));
-  });
-}
-
-/**
- * 高峰内则返回「距当前最近的一个高峰结束时刻」（择时补跑用），否则 null。
- * 落在多个时段重叠处时取最早结束的那个——早跑不亏，晚跑才亏。
- */
-export function nextOffPeakAt(date, spec) {
-  const parsed = parsePeakSpec(spec);
-  if (!parsed) return null;
-  const minutes = date.getHours() * 60 + date.getMinutes();
-  const today = isoDay(date);
-  const yesterday = today === 1 ? 7 : today - 1;
-  const allowed = (day) => !parsed.days || parsed.days.includes(day);
-  let bestDelta = null;
-  const consider = (delta) => {
-    if (bestDelta === null || delta < bestDelta) bestDelta = delta;
-  };
-  for (const { start, end } of parsed.windows) {
-    if (start < end) {
-      if (minutes >= start && minutes < end && allowed(today)) consider(end - minutes);
-      continue;
-    }
-    if (minutes >= start && allowed(today)) consider((1440 - minutes) + end);
-    else if (minutes < end && allowed(yesterday)) consider(end - minutes);
-  }
-  if (bestDelta === null) return null;
-  const at = new Date(date.getTime());
-  at.setSeconds(0, 0);
-  at.setMinutes(at.getMinutes() + bestDelta);
-  return at;
-}
-
+// 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 = {}) {
   if (!config.autoSummarize) return { dispose: () => {} };
 
@@ -584,12 +485,17 @@ export function createSummarizer(ctx, service, config, deps = {}) {
         };
       }
 
+      // Issue #315：蒸馏思考强度。'none'/未配置都不发送字段（服务商默认生效，
+      // 行为与历史版本一致）；off/low/medium/high 原样传递。
+      const summarizeEffort = config.summarizeReasoningEffort;
+      const withEffort = typeof summarizeEffort === "string" && summarizeEffort !== "none";
+
       const options = {
         provider: route.provider,
         model: route.model,
         purpose: "summarization",
         messages: [
-          { role: "system", content: [{ type: "text", text: config.codingRetrospect ? STR.prompts.codingSummary[langOf(config)] : STR.prompts.summary[langOf(config)] }], source: { kind: "plugin", plugin: "dsh-mneme" } },
+          { role: "system", content: [{ type: "text", text: config.codingRetrospect ? STR.prompts.codingSummary[langOf(config)] : STR.prompts.summary[langOf(config)] }], source: { kind: "plugin:dsh-mneme", plugin: "dsh-mneme" } },
           ...messages
         ],
         signal: controller.signal
@@ -597,15 +503,30 @@ export function createSummarizer(ctx, service, config, deps = {}) {
       // 智能调速器：整段蒸馏 LLM 调用进全局串行队列，按间隔分批放行；429 时
       // 指数退避自动重试，全程对用户透明，不把 429 错误码直接抛出去。
       const intervalMs = config.distillRateLimitIntervalMs ?? 1000;
-      const { text, assembledText, aborted } = await enqueueDistill(async () => {
+      // 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(options)) {
+            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 ?? "";
@@ -627,6 +548,9 @@ export function createSummarizer(ctx, service, config, deps = {}) {
                   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}`;
@@ -666,6 +590,21 @@ export function createSummarizer(ctx, service, config, deps = {}) {
           }
         }
       }, 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;
         return;

package/src/tools.js

@@ -5,7 +5,7 @@ import { defaultRuntimeDir } from "./runtime/layout.js";
 import { hostModulesDir, loadRuntimeManifest, provisionRuntime } from "./runtime/provision.js";
 import { matchesPlatform } from "./runtime/closure.js";
 import { verifyPayload } from "./runtime/verify.js";
-import { TOOL_GUIDE } from "./guide.js";
+import { TOOL_GUIDE, CONTINUITY_TOOL_RULE } from "./guide.js";
 import { injectChildEnabled } from "./config.js";
 
 const TEXT_OUTPUT = (text) => [{ type: "text", text }];
@@ -90,8 +90,16 @@ export function createTools(ctx, service, config, embedder) {
   // 关闭时描述逐字节不变，也不动其他工具的文案。
   // 它是注入父开关的子项（#249 第二批）：`autoInject` 关掉时这里同样不生效——
   // 工具描述是这个子项唯一住在注入器之外的落点，不在闸门内就漏了。
-  const withToolGuide = (name, description) =>
-    injectChildEnabled(config, "injectGuidanceEnabled") && TOOL_GUIDE[name] ? `${description}${TOOL_GUIDE[name]}` : description;
+  // #249 N3 降级路径（continuityRescueEnabled）：宿主若不提供可挂钩的压缩前时机，
+  // 双落点里的注入那一半就没有触发者，这时把规则交给 agent 自判（见 CONTINUITY_TOOL_RULE）。
+  // 与能力说明各自独立：任一开关关闭时描述逐字节不变。
+  // 本批不做宿主能力探测（没有可靠的探测口），所以子开关打开时这条规则常驻，与自动双落点并存。
+  const withToolGuide = (name, description) => {
+    let text = description;
+    if (injectChildEnabled(config, "injectGuidanceEnabled") && TOOL_GUIDE[name]) text += TOOL_GUIDE[name];
+    if (injectChildEnabled(config, "continuityRescueEnabled") && CONTINUITY_TOOL_RULE[name]) text += CONTINUITY_TOOL_RULE[name];
+    return text;
+  };
 
   // 复核项 4（issue #170）：strictScope 下他 scope（explicit）的行对工具侧按
   // 「不存在」处理——update/delete 与 memory_get 同款无存在性泄漏。strictScope