@modusensus/dsh-mneme 0.8.6 → 0.8.8

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/recall-stats.js

@@ -5,6 +5,8 @@
 // 新内聚块从第一行就落在自己的文件里，service.js 保留 barrel 出口、调用方零改动。
 // 纯读不写，绝不触发任何 write hook。
 
+import { scopeKeyOf } from "./scope.js";
+
 /**
  * 口径（issue #217 评论 2026-09-18，锚 5bd2dab）：
  *  - Top-N：窗口内 recall_runs.candidates（最终返回集）按 id 计数，join
@@ -20,6 +22,17 @@
  *  - coverage：recallRecordDefault 开启前的窗口算不到，earliestRunAt 为
  *    null（窗口内无回执）或早于窗口起点时，前端标注可信度；扫描行数有
  *    上限，超出标 truncated（degraded 口径），不静默少算。
+ *  - archive（#275 拍板的第五指标，与上面几项同位）：
+ *    · total = 归档区现有行数；addedInWindow / perDay = 窗口内进入归档区的行数
+ *      与其日均（净增速率）。归档时刻只能取 updated_at（setArchived 翻标志位时刷
+ *      它）——这是代理口径：对已归档行做一次 memory_update，或对同一行重复调
+ *      setArchived(…, true)，都会被算成「本窗口新进归档」，perDay 因此偏高。精确
+ *      口径要一个 archived_at 列（schema 变更，属第二批题材），本版不加；真正的
+ *      「净」增本来也要跨快照比 total（物理删除落地后，差值才会由负向变化体现）。
+ *    · compressible = 可压掉行数：同 type、同 scope 三维且内容哈希完全相同的归档
+ *      行里，多出来的那些（每组留一行）。用内容哈希而不是向量近重复，是因为回收
+ *      动作本身会清掉归档行向量（clearArchivedEmbeddings）——指标不能建在它自己
+ *      的输入会被回收掉的数据上；精确重复与 #254 的计量口径同一把尺。
  *
  * @param {object} store - createStore 产物（只调用 listRecallRunsSince / all）
  * @param {{ windowDays?: number, exemptDays?: number }} [options]
@@ -36,7 +49,8 @@ export function recallStats(store, options = {}) {
   const rawSlots = Number(options.maxInjectSlots ?? 5);
   const maxInjectSlots = Number.isInteger(rawSlots) && rawSlots >= 1 ? rawSlots : 5;
   const now = Date.now();
-  const since = new Date(now - windowDays * 86400000).toISOString();
+  const sinceMs = now - windowDays * 86400000;
+  const since = new Date(sinceMs).toISOString();
 
   const { rows: runs, total } = store.listRecallRunsSince(since);
   const hits = new Map(); // id -> { count, title, source }
@@ -67,8 +81,29 @@ export function recallStats(store, options = {}) {
   let activeCount = 0;
   let zombieCount = 0;
   let exemptCount = 0;
+  // 第五指标（#275）：归档区一侧单独累计，分组键与 #254 的去重候选集同构
+  // （type + 哈希 + scope 三维）——可压掉的必须是「本来就会被判成同一件事」的行。
+  let archivedTotal = 0;
+  let archivedInWindow = 0;
+  const hashGroups = new Map();
   for (const m of memories) {
-    if (m.archived || m.forgotten) continue;
+    if (m.archived) {
+      archivedTotal += 1;
+      const archivedMs = Date.parse(m.updated_at ?? "");
+      if (Number.isFinite(archivedMs) && archivedMs >= sinceMs) archivedInWindow += 1;
+      if (m.content_hash) {
+        const key = [
+          m.type ?? "",
+          m.content_hash,
+          scopeKeyOf(m.agent_scope) ?? "",
+          scopeKeyOf(m.workspace_scope) ?? "",
+          scopeKeyOf(m.sensitivity) ?? ""
+        ].join("\u0000");
+        hashGroups.set(key, (hashGroups.get(key) ?? 0) + 1);
+      }
+      continue;
+    }
+    if (m.forgotten) continue;
     const createdMs = Date.parse(m.created_at ?? "");
     // created_at 解析不了时无法证明已过机会期 → 归入豁免，宁漏勿误伤
     if (!Number.isFinite(createdMs) || now - createdMs < EXEMPT_MS) {
@@ -98,6 +133,14 @@ export function recallStats(store, options = {}) {
     .sort((a, b) => b.count - a.count || a.id.localeCompare(b.id))
     .slice(0, 10);
 
+  let compressibleGroups = 0;
+  let compressibleRows = 0;
+  for (const n of hashGroups.values()) {
+    if (n < 2) continue;
+    compressibleGroups += 1;
+    compressibleRows += n - 1;
+  }
+
   return {
     windowDays,
     generatedAt: new Date(now).toISOString(),
@@ -113,6 +156,13 @@ export function recallStats(store, options = {}) {
       slotFillRate: injectRuns > 0 ? injectedCount / (injectRuns * maxInjectSlots) : null
     },
     topRecalled,
+    // #275 第五指标：归档净增速率 + 可压掉行数（口径见文件头）
+    archive: {
+      total: archivedTotal,
+      addedInWindow: archivedInWindow,
+      perDay: Math.round((archivedInWindow / windowDays) * 100) / 100,
+      compressible: { rows: compressibleRows, groups: compressibleGroups }
+    },
     zombie: {
       activeCount,
       zombieCount,

package/src/scope.js

@@ -34,12 +34,7 @@ export function createScopeResolver({ ctx, config, logger } = {}) {
   };
 
   return function resolveWriteScope(exec) {
-    let session = null;
-    try {
-      session = exec?.agent?.session ?? null;
-    } catch {
-      session = null;
-    }
+    const session = sessionOf(exec);
 
     // 持久化 header（issue #17 的身份契约）：session.header 是创建时冻结的
     // SessionHeader（含 agentPreset/cwd）。⚠️ 不能先读 requestHeader()——那返回
@@ -83,6 +78,39 @@ export function createScopeResolver({ ctx, config, logger } = {}) {
   };
 }
 
+/**
+ * 工具 exec 上的会话对象。宿主 ctx 是 Proxy（cordis 4），裸读未 inject 的属性会
+ * 抛错——所以取值恒包在 try 里，取不到返回 null。scope 解析与写入准入的会话键
+ * 共用这一处取值口径。
+ * @param {object} exec
+ * @returns {object|null}
+ */
+export function sessionOf(exec) {
+  try {
+    return exec?.agent?.session ?? null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * 写入准入的会话键（#254 G1 会话写入预算的计数单位）。session_id 在这里只作
+ * 「同一段对话」的标识，不作为作用域键（见文件头：记忆挂在持久化身份标签上）；
+ * 取不到会话身份（系统写入）返回 null = 不进预算。
+ * @param {object} exec
+ * @returns {string|null}
+ */
+export function sessionKeyOf(exec) {
+  // 整个取值（含 .id）都在 try 里：宿主 session 可能是会抛错的 accessor，而这个
+  // 函数在 memory_save 的保存之前被调用——抛出去就是一次工具调用直接失败。
+  try {
+    const id = sessionOf(exec)?.id;
+    return id == null ? null : String(id);
+  } catch {
+    return null;
+  }
+}
+
 /**
  * v0.8.1 底座（issue #170）：显式 scope 参数（memory_save / memory_update /
  * 面板编辑）的归一化。约定：

package/src/service.js

@@ -1,5 +1,5 @@
 import { createHash, randomUUID } from "node:crypto";
-import { TYPE_FILE } from "./mirror.js";
+import { TYPE_FILE, MIRROR_READONLY_TYPES } from "./mirror.js";
 import { updatedAtBounds } from "./store.js";
 import { normalizeExplicitScope, scopeKeyOf } from "./scope.js";
 import { STR, langOf } from "./lang.js";
@@ -29,7 +29,9 @@ const CODING_MEMORY_TYPES = new Set(["rejected_solution", "pitfall", "constraint
 // 注意 constraint 同时属于 CODING_MEMORY_TYPES，非编码任务里已被 codingGate
 // 滤掉，pin 池同样拿不到它；是否豁免该门控是待维护者拍板的口径问题，本批次
 // 不动既有门控（不放大行为面）。
-const PINNED_MEMORY_TYPES = new Set(["constraint", "preference"]);
+// 导出给写入准入（#254 的穿透口）与注入侧共用一份定义：两处各写一份 list 迟早
+// 漂移成「pin 池豁免了、预算没豁免」这类两套口径。
+export const PINNED_MEMORY_TYPES = new Set(["constraint", "preference"]);
 
 /**
  * 判断一段文本是否编码类任务（关键词匹配，codingRetrospect 读取侧门控）。
@@ -167,7 +169,7 @@ export function computeRetrievalMetrics(actualIds, expectedIds) {
   };
 }
 
-export function createService({ store, mirror, config, onWrite, logger }) {
+export function createService({ store, mirror, config, onWrite, logger, documentIndex, writeAdmission }) {
   const language = langOf(config);
   // Optional dream scheduler hook, installed via setDreamHook after creation
   // (the scheduler holds a reference back to the service, so it cannot be
@@ -876,12 +878,17 @@ export function createService({ store, mirror, config, onWrite, logger }) {
           mode,
           topK: lim,
           threshold: threshold ?? null,
+          // Per-source 信号随回执落盘（fuseRecall 本就无条件计算，此前只服务
+          // signalTransparency 展示）：复用侧查询画像（query 型 → 各路权重的
+          // 离线聚合，AssoMem arXiv 2510.10397 消融所示收益大头）需要这份原料。
+          // 纯加字段——recall_runs 无 schema 变更，旧行 candidates 缺该键照常读。
           candidates: result.map((m) => ({
             id: m.id,
             title: m.title,
             content: m.content,
             score: m.score ?? null,
-            source: m.source ?? "keyword"
+            source: m.source ?? "keyword",
+            signals: signals.get(m.id) ?? {}
           })),
           createdAt: new Date().toISOString()
         });
@@ -1243,6 +1250,17 @@ export function createService({ store, mirror, config, onWrite, logger }) {
       scheduleEmbed(result);
       return { action: "merged", memory: result };
     }
+    // #254 写入准入（第一阶段只计量）：决策恒 allow、不拦写入，只把两个闸门的
+    // 测量点算出来。放在 store.save 之前——第二阶段要在这里拦下写入，接缝先摆好。
+    // 计量是旁路：任何一环失败只 warn，绝不反噬写入（与质量打分同款容错）。
+    let admission = null;
+    if (writeAdmission) {
+      try {
+        admission = writeAdmission.evaluate({ memory, sessionKey: memory._sessionKey });
+      } catch (e) {
+        try { logger?.warn?.(`[dsh-mneme] write admission evaluate failed: ${String(e)}`); } catch { /* 不反噬 */ }
+      }
+    }
     const created = store.save({
       type: memory.type,
       title: memory.title,
@@ -1263,6 +1281,17 @@ export function createService({ store, mirror, config, onWrite, logger }) {
       ...(quality ? { quality_score: quality.score } : {})
     });
     const result = applyQualityDisposition(created, quality, qf);
+    if (admission) {
+      try {
+        writeAdmission.record({
+          sessionKey: memory._sessionKey,
+          verdict: admission,
+          memoryId: created.id
+        });
+      } catch (e) {
+        try { logger?.warn?.(`[dsh-mneme] write admission record failed: ${String(e)}`); } catch { /* 不反噬 */ }
+      }
+    }
     afterSync("write");
     notifyWrite();
     scheduleEmbed(result);
@@ -1560,6 +1589,10 @@ export function createService({ store, mirror, config, onWrite, logger }) {
    * Only content/title are taken; structure fields stay machine-owned.
    */
   function mergeHumanEdits(type, edits) {
+    // #296：只读 type 的结构性守卫。调用点（启动合并 / reconcileHumanEdits）都已
+    // 跳过它们，但这条不变量属于「人改回填」本身——将来多一个调用点不该重开这个口
+    // （指针行文本被当正文写回 document 行会污染摘要）。
+    if (MIRROR_READONLY_TYPES.has(type)) return 0;
     let applied = 0;
     for (const edit of edits) {
       if (!edit.id) continue; // corrupt/malformed edit: skip it, keep merging the rest
@@ -1787,6 +1820,26 @@ export function createService({ store, mirror, config, onWrite, logger }) {
    * non-forgotten memories are mirrored: forgotten entries must not reach the
    * human-editable file (a human "edit" could otherwise resurrect them).
    */
+  // #296 第二批：documentDir/index.md 的写后语。与注册入口共用同一个
+  // documentMemoryEnabled 闸（默认关）：闸开时只列活跃指针行（正文永远不进这个
+  // 文件），闸关时把索引删掉——document 子系统整体退出，留一份陈旧索引会列出已
+  // 归档的行，正是镜像侧 documents.md 在闸关时被删掉要避免的那种「看着还在、其实
+  // 已关」的视图。两步都只 warn：索引是机器产物，不能让触发它的业务写失败。
+  function syncDocumentIndex() {
+    if (!documentIndex) return;
+    if (config?.documentMemoryEnabled !== true) {
+      const removed = documentIndex.remove();
+      if (!removed?.ok) logger?.warn?.("document index remove failed:", removed?.error);
+      return;
+    }
+    try {
+      const result = documentIndex.sync(store.list({ type: "document", limit: null }));
+      if (!result?.ok) logger?.warn?.("document index sync failed:", result?.error);
+    } catch (error) {
+      logger?.warn?.("document index sync failed:", error);
+    }
+  }
+
   // syncMirror: 同步 mirror，并在失败/成功时持久记录 dirty 状态；保证自身不抛出。
   // v0.3.6（audit peer 4 阻断）：
   //   - 开始时 incrementGeneration 绑定本次期望轮次 gen；成功用
@@ -1796,7 +1849,12 @@ export function createService({ store, mirror, config, onWrite, logger }) {
   //   - 逐 type 用 setTypeStatus 记录部分成功/失败（type_status JSON）；
   //   - 所有 store 状态写入各自 try/catch，失败只 warn，绝不向外抛（F-NEW-03）。
   function syncMirror() {
-    if (txDepth > 0 || !mirror) return { success: true, deferred: true }; // deferred to the transaction's commit
+    if (txDepth > 0) return { success: true, deferred: true }; // deferred to the transaction's commit
+    // #296 第二批：documentDir/index.md 走同一条写后语——它与镜像一样是「从库渲染
+    // 的机器产物」，同样只在内容变化时落盘、同样自己吞掉失败。放在 !mirror 短路
+    // 之前：索引在不在，不该取决于镜像是否装配（无镜像的宿主与测试同样要有它）。
+    syncDocumentIndex();
+    if (!mirror) return { success: true, deferred: true };
     const now = new Date().toISOString();
     let gen;
     try {
@@ -1812,8 +1870,20 @@ export function createService({ store, mirror, config, onWrite, logger }) {
     // 合法的空 Set 可迭代，保证 syncMirror 自身绝不抛（fail-safe）。
     const coveredTypes = new Set();
     try {
-      // 预先获取本次要覆盖的 type 集合（只调一次 store.list）
-      const list = store.list({ limit: 500, includeForgotten: false });
+      // 预先取本次要覆盖的全部活跃行（只读一次）。这里曾经是
+      // store.list({ limit: 500 })——活跃集超过 500 时镜像会静默少掉尾部记忆，
+      // 而文件本身没有任何提示（#278 第一批）。store.list 的 limit 默认值只有
+      // 50，比原来显式传的 500 更小，所以改用 all() 并在这里做同一套过滤
+      // （forgotten/archived 都不进镜像，与 includeForgotten:false + 默认
+      // includeArchived:false 等价）。
+      // 代价是全表读，且落在每次业务写后的最热路径上（#202 自记 all() 5k 行
+      // 231ms → ~135ms）。要压这一层得换按 type 分页取，属另一批的事；
+      // 在这里退回任何截断都不行——「宣称覆盖活跃集」与静默截断不能共存。
+      const list = store.all().filter((m) => !m.forgotten && !m.archived
+        // #296 第二批：镜像里的 documents.md 与 index.md 共用 documentMemoryEnabled
+        // 闸。关掉时把 document 行也从渲染集里去掉——sync 对「空 type」的既有处理
+        // 会把陈旧的 documents.md 删掉，不留一个「看着还在、其实已关」的视图。
+        && (m.type !== "document" || config?.documentMemoryEnabled === true));
       for (const memory of list) {
         if (memory?.type && TYPE_FILE[memory.type]) {
           coveredTypes.add(memory.type);
@@ -2092,6 +2162,12 @@ export function createService({ store, mirror, config, onWrite, logger }) {
   function archiveMemory(id, f) {
     const updated = store.setArchived(id, f);
     afterSync("write");
+    // #275 B 项：归档行的向量会被手动回收清掉（检索恒带 archived = 0，按定义不可达），
+    // 还原回活跃面时补一次嵌入——否则那行只剩关键词可检索，回收就成了单程票。
+    // 判据用真值（`!f`）而不是 `f === false`：store.setArchived 自己就是按真值归一
+    // （`archived ? 1 : 0`），API/工具传 0 或空串同样会把行放回活跃面，口径必须同一把尺。
+    // 排队语义与写入路径同一处（txDepth / 未就绪由 scheduleEmbed 自己挡）。
+    if (!f) scheduleEmbed(updated);
     return updated;
   }
 
@@ -2105,6 +2181,9 @@ export function createService({ store, mirror, config, onWrite, logger }) {
     embedQuery,
     pushContentHistory,
     transaction,
+    // #275 拍板 5：升格吸收的 evidence 行随之归档，但 pinned 池（#249）永不自动归档
+    // ——注册器不 import 这个集合，方向反了会成环，所以在这里注入。
+    pinnedTypes: PINNED_MEMORY_TYPES,
     finalize: (rows) => {
       for (const row of rows) scheduleEmbed(row);
     }

package/src/settings.js

@@ -45,8 +45,12 @@ const FEATURE_FLAG_BOOLEANS = [
   "hotMemoryEnabled",
   // Issue #239 第 5 项：注入条数的查询自适应（确定性强则收缩注入条数，默认关）。
   "injectUncertaintyAdaptive",
-  // Issue #249 第一批：能力说明（工具描述判断指引 + order 150 总则段，默认关）。
+  // Issue #249：能力说明（工具描述判断指引 + order 150 总则段）。第二批起它是
+  // 注入父开关 autoInject 的子项、默认开（父关时不生效，闸门见 config.js）。
   "injectGuidanceEnabled",
+  // Issue #249 N3：压缩边缘双落点——上下文即将精简前落一条连续性提案 + 往
+  // 序列末尾追加同一份快照。默认关（新注入表面，见 config.js），父开关 autoInject。
+  "continuityRescueEnabled",
   "entityExtractionEnabled",
   // Issue #219：图召回轴——查询命中实体名时把挂联记忆并入检索融合池
   // （默认关；依赖实体抽取产出，lightMode 强制关闭）。
@@ -59,6 +63,9 @@ const FEATURE_FLAG_BOOLEANS = [
   "documentMemoryEnabled",
   "codingRetrospect",
   "autoDream",
+  // Issue #292：autoDream 连续失败退避（默认关）。基数是 dreamMinIntervalMinutes，
+  // 有效间隔 = 基数 × 2^连续失败数（成功清零），封顶 30 分钟；面板可启停。
+  "autoDreamFailureBackoff",
   "sleepModeEnabled",
   "heatEnabled",
   "hybridInject",
@@ -113,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 = 既有行为）。
@@ -155,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 防线的一部分）。
@@ -168,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 = 六分支）。