@modusensus/dsh-mneme 0.8.6 → 0.8.8

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 开启时启用）：在通用记忆之外，额外提取
 // 三类编码专属记忆，专治重复踩坑 / 遗忘被否决方案 / 丢失工程约束。字段仍沿用
@@ -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,6 +485,11 @@ 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,
@@ -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

@@ -1,11 +1,12 @@
 import { defineTool } from "@deepseek-ai/dsh-tools";
-import { createScopeResolver, normalizeExplicitScope } from "./scope.js";
+import { createScopeResolver, normalizeExplicitScope, sessionKeyOf } from "./scope.js";
 import { describeLocalRuntime, resolveRuntimeEntry } from "./runtime/loader.js";
 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 }];
 // Per-registry tool-name registry: guards against duplicate registration on
@@ -84,11 +85,21 @@ export function createTools(ctx, service, config, embedder) {
   // flag 关闭时恒返回 null——写入不标注，检索不加权，行为与 A1 前完全一致。
   // logger 透传：registry 反查失败时 warnOnce 才有出口（否则静默降级无观测）。
   const resolveSessionScope = createScopeResolver({ ctx, config, logger: ctx.logger });
-  // #249 第一批：能力说明（injectGuidanceEnabled）开启时，给「何时用」最有歧义
-  // 的两个工具补一句判断指引。工具描述常驻、不进每轮上下文，这个位子零注入
-  // 成本；关闭时描述逐字节不变，也不动其他工具的文案。
-  const withToolGuide = (name, description) =>
-    config?.injectGuidanceEnabled === true && TOOL_GUIDE[name] ? `${description}${TOOL_GUIDE[name]}` : description;
+  // #249 能力说明（injectGuidanceEnabled）：开启时给「何时用」最有歧义的两个
+  // 工具补一句判断指引。工具描述常驻、不进每轮上下文，这个位子零注入成本；
+  // 关闭时描述逐字节不变，也不动其他工具的文案。
+  // 它是注入父开关的子项（#249 第二批）：`autoInject` 关掉时这里同样不生效——
+  // 工具描述是这个子项唯一住在注入器之外的落点，不在闸门内就漏了。
+  // #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
@@ -162,6 +173,10 @@ export function createTools(ctx, service, config, embedder) {
           ? { value: normalizeExplicitScope(args.workspace_scope), source: "explicit" }
           : autoStamping && scope ? { value: scope.workspace_scope, source: "auto" } : null;
         const { action, memory } = service.saveWithDedupe({
+          // #254 写入准入（第一阶段只计量）的计数单位：会话键作为瞬时字段随写入
+          // 传递（与 _mergeInto / _overwrite 同款约定，不落库）。缺会话身份的宿主
+          // 返回 null = 这次写入不进预算。
+          _sessionKey: sessionKeyOf(exec),
           type: args.type,
           title: args.title,
           content: args.content,
@@ -482,7 +497,11 @@ export function createTools(ctx, service, config, embedder) {
         "intersects evidence with real memory ids (all-fabricated evidence is rejected; unknown ids are dropped and the row " +
         "is tagged evidence_degraded), and dedupes: re-registering the same path or title supersedes the old row (the old " +
         "file is never touched; content_history stays traceable), while a merely near-duplicate summary of a different " +
-        "document row is rejected — update that row instead. Use for 'where is the conclusion doc for this project?' " +
+        "document row is rejected — update that row instead. On success the absorbed atomic evidence rows leave the active " +
+        "face in the same transaction (recoverable, nothing deleted); constraint/preference rows and other " +
+        "document/summary rows are never auto-archived, and keep_evidence_active: true opts out. Ids this same document " +
+        "absorbed on an earlier version still count as its evidence, so re-registering a new version is not read as " +
+        "fabricated evidence. Use for 'where is the conclusion doc for this project?' " +
         "lookups; atomic facts still go to memory_save.",
       parameters: {
         path: { type: "string", required: true, description: "Absolute path of the document file (~ is expanded); must already exist as a non-empty regular file. The full text stays agent-owned — this pipeline never touches it." },
@@ -490,7 +509,8 @@ export function createTools(ctx, service, config, embedder) {
         summary: { type: "string", required: true, description: "One-paragraph summary stored in the DB and used for injection (any language)" },
         tags: { type: "array", items: { type: "string" }, description: "Optional tags (English recommended)" },
         importance: { type: "integer", description: "1-5 (default 3); the summary row injects at the next-priority tier within documentInjectBudget when importance >= threshold" },
-        evidence: { type: "array", items: { type: "string" }, description: "Memory ids this document is grounded in; each is verified against the store (fabricated evidence is rejected; unknown/archived ids are dropped and the row is tagged evidence_degraded)" },
+        evidence: { type: "array", items: { type: "string" }, description: "Memory ids this document is grounded in (atomic facts, not other pointer rows); each is verified against the store — fabricated evidence is rejected, unknown/archived ids are dropped and the row is tagged evidence_degraded, except ids this same document absorbed on an earlier version, which stay its evidence. On success the absorbed atomic rows leave the active face unless keep_evidence_active is true." },
+        keep_evidence_active: { type: "boolean", description: "Opt out of archiving the evidence rows absorbed by this document. Default false: after a successful registration the absorbed atomic rows leave the active face (recoverable, nothing deleted; constraint/preference rows and other document/summary rows are never auto-archived)." },
         source: { type: "string", description: "Optional provenance" },
         sensitivity: { type: "string", description: "Optional sensitivity label (free-form, e.g. personal). Part of the supersede matching key — same path/title with a different sensitivity stays a separate document." },
         agent_scope: { type: "string", description: "Optional explicit agent-scope declaration (issue #170): 'global' or '*' makes this document visible to every agent; any other value narrows it to that label. Overrides the automatic carrier label for this write; honored even when automatic scope labeling is disabled." },
@@ -506,12 +526,13 @@ export function createTools(ctx, service, config, embedder) {
             superseded_id: { type: "string" },
             evidence_kept: { type: "integer", required: true },
             evidence_dropped: { type: "integer", required: true },
+            evidence_archived: { type: "integer", required: true },
             degraded: { type: "boolean", required: true }
           }
         },
         render: (_args, value) => {
           const sup = value.superseded_id ? ` (supersedes ${value.superseded_id})` : "";
-          const ev = ` | evidence: ${value.evidence_kept} kept, ${value.evidence_dropped} dropped${value.degraded ? " [degraded]" : ""}`;
+          const ev = ` | evidence: ${value.evidence_kept} kept, ${value.evidence_dropped} dropped, ${value.evidence_archived} archived${value.degraded ? " [degraded]" : ""}`;
           return TEXT_OUTPUT(`document ${value.action}: ${value.id}${sup}${ev}`);
         }
       },
@@ -550,13 +571,18 @@ export function createTools(ctx, service, config, embedder) {
           ...(args.sensitivity !== undefined ? { sensitivity: args.sensitivity } : {}),
           ...(agentLabel ? { agent_scope: agentLabel.value, agent_scope_source: agentLabel.source } : {}),
           ...(workspaceLabel ? { workspace_scope: workspaceLabel.value, workspace_scope_source: workspaceLabel.source } : {})
-        }, { hiddenEvidenceIds: hiddenEvidence });
+        }, {
+          hiddenEvidenceIds: hiddenEvidence,
+          // 默认开着归档（#275 拍板 5）；agent 显式要保留活跃面时走 keep_evidence_active。
+          archiveEvidence: args.keep_evidence_active !== true
+        });
         return {
           action: result.action,
           id: result.memory.id,
           ...(result.superseded ? { superseded_id: result.superseded.id } : {}),
           evidence_kept: result.evidence_kept,
           evidence_dropped: result.evidence_dropped,
+          evidence_archived: result.evidence_archived,
           degraded: result.degraded
         };
       }

package/src/write-admission.js

@@ -0,0 +1,259 @@
+// #254 写入准入（第一阶段：只计量，不拦截）。
+//
+// 为什么先只计量：会话写入预算的 N 与同话题冷却的 X 在没有真实分布时拍任何数字
+// 都是误杀面（维护者 2026-09-23 拍板「先记录不拦，由遥测定」）。所以这一阶段只把
+// 两个闸门的原始测量点写进 llm_audit_logs（status='skipped'、metadata.gate='g1'
+// 且同话题重复时附 metadata.g2），不做判定、不改任何写入行为；第二阶段把拦截打开
+// 时才引入阈值与二次确认（memory_save({confirm:true})）。
+//
+// 为什么复用 llm_audit_logs：它是仓库既有的「后台动作回执」表（bookkeeping，不
+// 触发写钩子，见 store.js 的表注释）。第二阶段落地时「第一次 skipped/gate →
+// 第二次 confirm:true 放行」在审计里成对出现，因果可回放。
+//
+// 一行一个新建行（不是一行一个信号）：这样「会话内新建条数」就是按 session_key
+// 的直接计数，不需要任何 JSON 解析；g2 命中时作为该行的 metadata.g2 附带，不做第
+// 二行。测量点只取在新行上——并入已有行是去重机制在正常工作，既不进预算也不记行。
+// 会话身份来自工具 exec（scope.js › sessionKeyOf）：没有会话身份的写入（dream /
+// summarize / import / organize）不进预算，预算管的是「一次对话里写飞了」。
+//
+// 穿透口（与 #275 拍板 5 的 pinned 豁免同口径）：constraint / preference 是 #249
+// 第一批立的逐字保真池，永不进预算；仍记一行审计（metadata.exempt='pinned'）以便
+// 观察穿透频率。穿透行既不参与 g2 判定，也不推进同话题的时间基准——它整个不在闸门
+// 里，成为下一次比较的基准会把 g2 的样本混进穿透流量。
+//
+// 内容哈希（exact duplicate，第三类测量点，维护者 2026-09-24 拍板）：归一化口径定在
+// content-hash.js，命中即「同一内容又被写了一次」。判据用哈希而不是相似度——相似度
+// 阈值在同一件事换个说法 / 不同的事共享话题词之间来回挪，只会换一种错法。候选集先按
+// type 与 scope 三维等值收窄再比哈希（不是全表扫），并把归档行一并纳入：「出口止体积、
+// 不止重复」，被质量闸归档的同一个事实不在 saveWithDedupe 的候选集里（store.list 默认
+// 排除归档），同样的内容再写一次就是一条新行，这正是这条信号要量的穿透。两个穿透口与
+// pinned 豁免同口径：pinned 在这里返回得更早，连候选集查询都不发。
+//
+// 信号跟着同一行审计走，所以内容哈希与 g1/g2 覆盖同一批写入（会话内新建行）；无会话
+// 身份的系统写入（dream / summarize / import / organize）要另立行形状，不在本批。
+//
+// 与 llmAudit.enabled 的关系：那个开关同时关掉审计行的启动期清理（index.js 的
+// deleteOldLlmAudits），所以关掉时本模块一行都不写，否则就是在无保留期的表里做
+// 按写入频次增长。
+import { PINNED_MEMORY_TYPES } from "./service.js";
+import { contentHashOf } from "./content-hash.js";
+
+// 审计口径（llm_audit_logs 的既有列）：trigger_source = 组件名，operation_type =
+// 动作名，status='skipped' = 本行没有产生任何 LLM 花费（与 summarize 的间隔门、
+// 尖峰门同款读法）。
+export const ADMISSION_TRIGGER_SOURCE = "writeAdmission";
+export const ADMISSION_OPERATION_TYPE = "write_admission";
+export const ADMISSION_GATE_SESSION_BUDGET = "g1";
+
+// 首次见到某会话时的回填深度：话题表由审计行重建，只回填最近这么多行。更早的
+// 话题会漏（测量口径可接受），换来的是一次查询与有界的常驻内存。
+export const TOPIC_LOOKBACK_ROWS = 200;
+
+// 话题锚只收机械可判的两类：issue/PR 引用与文件路径。两条都带前缀或分隔符，误报
+// 面小；自由文本里看不出确定性的「同话题」，硬判只会把误杀面提前引进来（#254 已
+// 定：计量信号用确定性锚，不用相似度阈值——同一件事换个说法就掉下去，不同的事
+// 共享话题词又顶上来，阈值怎么挪都是在两种误判之间来回）。
+// 两处收紧都来自误报样本：`(?<![#\w])` 挡掉 Markdown 标题 `###1` 与紧跟标识符的
+// 井号；扩展名要求首字符是字母，挡掉 `3.5/2.0` 这类比值（否则一个算式就成了话题）。
+const ISSUE_REF = /(?<![#\w])#\d{1,7}\b/g;
+const FILE_PATH = /(?:[\w.-]+[\\/])+[\w.-]+\.[A-Za-z][A-Za-z0-9]{0,5}\b/g;
+
+/**
+ * 写入文本里的确定性话题锚：小写归一 + 路径分隔符统一为 `/` + 去重 + 排序。
+ * 同一话题在不同轮次必须逐字节相等，才能用等值比较而不是相似度比较——所以
+ * `src\service.js` 与 `src/service.js` 必须归到同一个锚。
+ * @param {{title?: string, content?: string, tags?: string[]}} memory
+ * @returns {string[]} 排序后的话题锚
+ */
+export function extractTopicKeys(memory) {
+  const text = [memory?.title, memory?.content, ...(Array.isArray(memory?.tags) ? memory.tags : [])]
+    .filter((s) => typeof s === "string")
+    .join("\n");
+  const keys = new Set();
+  const add = (raw) => keys.add(raw.toLowerCase().replace(/\\/g, "/"));
+  for (const m of text.matchAll(ISSUE_REF)) add(m[0]);
+  for (const m of text.matchAll(FILE_PATH)) add(m[0]);
+  return [...keys].sort();
+}
+
+/**
+ * 写入准入（#254）。返回的两个方法就是三个消费方共用的那份接口：
+ *   evaluate 给出决策形状（阶段一恒 allow），record 把测量点写成审计行。
+ * 阶段二在 evaluate 里引入阈值与 confirm 分支；#249 的注入提示与 #275 的水位计数
+ * 都读同一份 decision/审计行，而不是各写一套判定。
+ *
+ * @param {object} deps
+ * @param {object} deps.store 存储层（listLlmAudits / saveLlmAudit）
+ * @param {object} [deps.config] 已解析配置（读 llmAudit.enabled）
+ * @param {object} [deps.logger]
+ * @param {() => number} [deps.now] 时钟注入（测试用）
+ */
+export function createWriteAdmission({ store, config, logger, now = Date.now } = {}) {
+  // sessionKey → Map<话题锚, 最近一次新建行时刻(ms)>。真相源是审计行，这里只是它的
+  // 增量视图：进程重启后按需回填。FIFO 上限防长驻进程内存无界（同 store.js 的
+  // embedding 解析缓存口径）。
+  const topicTables = new Map();
+  const SESSION_CACHE_MAX = 200;
+
+  const warn = (msg) => {
+    // 计量是旁路：任何一环失败都不能影响写入，日志自身故障也一样。
+    try {
+      logger?.warn?.(msg);
+    } catch { /* ignore */ }
+  };
+
+  /** 某会话的话题表（首见时从审计行回填，之后走内存增量）。 */
+  function topicTable(sessionKey) {
+    const cached = topicTables.get(sessionKey);
+    if (cached) return cached;
+    const table = new Map();
+    try {
+      const rows = store?.listLlmAudits?.({ sessionKey, limit: TOPIC_LOOKBACK_ROWS }) ?? [];
+      for (const row of rows) {
+        const metadata = row?.metadata;
+        if (!metadata || typeof metadata !== "object" || !Array.isArray(metadata.topics)) continue;
+        // 穿透行（pinned）整个不在闸门里，也就不该进基准表——只挡内存路径不挡回填，
+        // 重启后口径就变了（同一个话题会因为一条穿透行而被判成重复）。
+        if (metadata.exempt) continue;
+        const at = Date.parse(row.timestamp);
+        // 坏时间戳跳过：落到 0 会让 gap 变成几十年，一个离群值就能带偏按分位定的 X。
+        if (!Number.isFinite(at)) continue;
+        for (const topic of metadata.topics) {
+          // 审计行按时间倒序返回，先到的那条就是该话题最近一次写入——后来的不覆盖。
+          if (!table.has(topic)) table.set(topic, at);
+        }
+      }
+    } catch (e) {
+      // 回填失败降级为「本会话此前的话题不可见」：漏一个 g2 测量点，不影响写入。
+      warn(`[dsh-mneme] write admission topic backfill failed: ${String(e)}`);
+    }
+    if (topicTables.size >= SESSION_CACHE_MAX && !topicTables.has(sessionKey)) {
+      topicTables.delete(topicTables.keys().next().value);
+    }
+    topicTables.set(sessionKey, table);
+    return table;
+  }
+
+  /**
+   * 内容哈希候选集查询（#254 第三类测量点）。失败降级为「没命中」：漏一个测量点，
+   * 不影响写入，也不让计量反噬。
+   * 多条命中时的取舍（活区优先）：有活跃/未遗忘的命中就报它（判据是「去重候选集本该
+   * 拦住」），只有归档/遗忘行命中才报它们。store 侧已把活跃行排在窗口头部，这里的 find
+   * 是防御性重复：排序口径将来再变，本判据也不跟着变。
+   * archived 与 forgotten 分开回：两者都是「出口」，但穿透含义不同——只命中已遗忘行时
+   * 若只回 archived=false，读审计的人会以为库里有活跃重复；而 saveWithDedupe 的候选集
+   * 本来就排除遗忘行（store.list 默认 includeForgotten=false），这类命中同样是穿透。
+   * @returns {{memory_id: string, archived: boolean, forgotten: boolean}|null}
+   */
+  function lookupContentDup(memory) {
+    try {
+      const hash = contentHashOf(memory);
+      if (!hash) return null;
+      const hits = store?.findContentHashMatches?.({
+        type: memory?.type,
+        hash,
+        agent_scope: memory?.agent_scope,
+        workspace_scope: memory?.workspace_scope,
+        sensitivity: memory?.sensitivity
+      }) ?? [];
+      const hit = hits.find((h) => !h.archived && !h.forgotten) ?? hits[0];
+      return hit ? { memory_id: hit.id, archived: hit.archived === true, forgotten: hit.forgotten === true } : null;
+    } catch (e) {
+      warn(`[dsh-mneme] write admission content hash lookup failed: ${String(e)}`);
+      return null;
+    }
+  }
+
+  /**
+   * 阶段一决策：恒 allow（本模块里没有阈值），只算出三个闸门的测量点。返回形状一次
+   * 定死，阶段二只往里加分支、不改字段：
+   *   decision — "allow" | "confirm"（阶段一只可能 allow）
+   *   gate     — "g1" | null（null = 这次写入不进预算，不记行）
+   *   topics   — 本次写入的确定性话题锚
+   *   repeat   — {topic, gapMs} | null（g2 的命中面）
+   *   dup      — {memory_id, archived, forgotten} | null（内容哈希的命中面）
+   *   exempt   — null | "pinned"
+   * @param {{memory: object, sessionKey?: string|null}} input
+   */
+  function evaluate({ memory, sessionKey } = {}) {
+    const verdict = { decision: "allow", gate: null, topics: [], repeat: null, dup: null, exempt: null };
+    // 无会话身份 = 系统写入（dream / summarize / import / organize），不进预算。
+    if (!sessionKey) return verdict;
+    // 审计关掉时不记行、也不推进话题表（见文件头：那个开关连启动期清理一起关掉）。
+    if (config?.llmAudit?.enabled === false) return verdict;
+    const topics = extractTopicKeys(memory);
+    const pinned = PINNED_MEMORY_TYPES.has(String(memory?.type ?? ""));
+    if (pinned) return { ...verdict, gate: ADMISSION_GATE_SESSION_BUDGET, topics, exempt: "pinned" };
+    const dup = lookupContentDup(memory);
+    const table = topicTable(sessionKey);
+    const at = now();
+    let repeat = null;
+    for (const topic of topics) {
+      if (!table.has(topic)) continue;
+      const gapMs = Math.max(0, at - table.get(topic));
+      // 同一行可能命中多个锚：取最近的那次（间隔最短＝最有价值的那次重复）。
+      if (!repeat || gapMs < repeat.gapMs) repeat = { topic, gapMs };
+    }
+    return { ...verdict, gate: ADMISSION_GATE_SESSION_BUDGET, topics, repeat, dup };
+  }
+
+  /**
+   * 把测量点落成审计行（一行一个新建行）。三个信号的读法：
+   *   g1 会话写入预算：`GROUP BY session_key` 计数即得「会话内新建条数」分布；要剔
+   *      掉穿透行（pinned 不进预算）就加 `json_extract(metadata,'$.exempt') IS NULL`。
+   *   g2 同话题冷却：`json_extract(metadata,'$.g2.gap_ms')` 即得「同话题新建行间隔」
+   *      分布。间隔算的是同一话题两次**新建行**之间——标题命中走并入的那次不在这里
+   *      （并入正是冷却要做的事，已经做到了）。
+   *   dup 内容哈希：`json_extract(metadata,'$.dup.memory_id')` 非空即「这条新行的内容
+   *      与某条既有行归一化后逐字节相同」；`$.dup.archived` 区分命中那条在活区还是
+   *      归档区——归档区命中就是去重候选集漏掉的那一类穿透。
+   * 计量绝不影响写入：任何异常只 warn。
+   * @returns {object[]} 落下的审计行（无测量点或失败时为空数组）
+   */
+  function record({ sessionKey, verdict, memoryId } = {}) {
+    if (!sessionKey || !verdict || verdict.gate == null) return [];
+    const at = now();
+    const topics = Array.isArray(verdict.topics) ? verdict.topics : [];
+    const rows = [];
+    try {
+      rows.push(store.saveLlmAudit({
+        timestamp: new Date(at).toISOString(),
+        trigger_source: ADMISSION_TRIGGER_SOURCE,
+        operation_type: ADMISSION_OPERATION_TYPE,
+        // 不是模型调用，但该列 NOT NULL——用显式占位串，免得被当成某条路由的
+        // 花费来源统计进去。
+        model_id: "-",
+        status: "skipped",
+        related_memory_ids: memoryId ? [memoryId] : [],
+        session_key: sessionKey,
+        metadata: {
+          gate: verdict.gate,
+          topics,
+          ...(verdict.exempt ? { exempt: verdict.exempt } : {}),
+          ...(verdict.repeat ? { g2: { topic: verdict.repeat.topic, gap_ms: verdict.repeat.gapMs } } : {}),
+          // dup 两个出口分字段落盘：archived 与 forgotten 是两类不同的穿透，合成一个布尔
+          // 会让「只剩遗忘行命中」读起来像「库里有活跃重复」（见 lookupContentDup 注释）。
+          ...(verdict.dup
+            ? { dup: {
+              memory_id: verdict.dup.memory_id,
+              archived: verdict.dup.archived === true,
+              forgotten: verdict.dup.forgotten === true
+            } }
+            : {})
+        }
+      }));
+    } catch (e) {
+      // 审计失败只 warn（同 saveLlmAudit 的调用惯例），写入本身照常完成。
+      warn(`[dsh-mneme] write admission audit failed: ${String(e)}`);
+    }
+    // 只有真正落库、且不是穿透口的行才推进话题表：审计写失败时内存视图不能跑在审计
+    // 前面（重启回填会得到另一条时间线），pinned 写入整个不在闸门里。
+    if (rows.length > 0 && !verdict.exempt) {
+      const table = topicTable(sessionKey);
+      for (const topic of topics) table.set(topic, at);
+    }
+    return rows;
+  }
+
+  return { evaluate, record };
+}

package/test/api.test.js

@@ -663,12 +663,16 @@ test("GET /api/dsh-mneme/features returns empty overrides and effective config d
   // issue #257 新增 sleepMaxTokens、issue #258 新增总览路由两键与
   // dreamSummaryMaxInputs、issue #230 新增 documentMemoryEnabled/
   // documentInjectBudget、issue #249 第一批新增 injectGuidanceEnabled/
-  // pinnedInjectBudget，v0.8.5 新增 disableMemorySearch/disableMemoryArchive，
-  // 本地嵌入池化新增 localEmbedPooling）
-  assert.equal(Object.keys(data.effective).length, 59 + 3 + 2 + 1 + 2 + 2 + 2 + 1);
+  // pinnedInjectBudget、issue #249 N3 新增 continuityRescueEnabled，
+  // v0.8.5 新增 disableMemorySearch/disableMemoryArchive，
+  // 本地嵌入池化新增 localEmbedPooling，issue #315 新增 summarizeReasoningEffort，
+  // issue #239 第 4 项镜像到巩固新增 dreamPeakHours/dreamPeakMaxDeferMinutes，
+  // issue #292 新增 autoDreamFailureBackoff）
+  assert.equal(Object.keys(data.effective).length, 59 + 3 + 2 + 1 + 2 + 2 + 2 + 1 + 1 + 1 + 2 + 1);
   assert.equal(data.effective.dreamSkipInvalid, true);
   assert.equal(data.effective.allowCrossTypeMerge, false);
   assert.equal(data.effective.dreamMinIntervalMinutes, 0);
+  assert.equal(data.effective.autoDreamFailureBackoff, false);
   assert.equal(data.effective.dreamMaxTokens, 131072);
   assert.equal(data.effective.sleepProvider, "");
   assert.equal(data.effective.sleepModel, "");
@@ -695,6 +699,8 @@ test("GET /api/dsh-mneme/features returns empty overrides and effective config d
   assert.equal(data.effective.entityExtractionProvider, "");
   assert.equal(data.effective.entityExtractionModel, "");
   assert.equal(data.effective.entityExtractionReasoning, "none");
+  // issue #315：蒸馏思考强度（默认 none = 不发送字段，行为不变）
+  assert.equal(data.effective.summarizeReasoningEffort, "none");
   // issue #127：summarize 节流五键（均有默认值，故计入 effective 计数）
   assert.equal(data.effective.summarizeMinIntervalMinutes, 0);
   assert.equal(data.effective.summarizeMaxEntriesPerRun, 0);
@@ -1010,6 +1016,18 @@ test("GET /api/dsh-mneme/export markdown feeds straight back through import", as
   const md = res.body;
   assert.ok(md.includes("- **ID**: `" + a.memory.id + "`"), "anchor line present (readHumanEdits-compatible)");
 
+  // 导出是一个文档（#278 审查 F1/F3）：frontmatter 只能有一份并在最前，分节不带
+  // 各自的文件头；而且它的覆盖声明必须与正文条目数一致——「说一套写一套」比没有
+  // 这个字段更糟，外部工具会照着它聚合。
+  assert.equal([...md.matchAll(/^type: /gm)].length, 1, "只有一个 frontmatter 的 type 键");
+  assert.match(md, /^type: memory-export$/m);
+  assert.match(md, /^coverage: all$/m, "导出含归档/已遗忘行，声明要说实话");
+  assert.equal(
+    Number(md.match(/^covered: (\d+)$/m)[1]),
+    (md.match(/^- \*\*ID\*\*: /gm) ?? []).length,
+    "covered 必须等于实际导出的条目数"
+  );
+
   // 黄金用例：导出文本原样导入 → 解析出全部条目，且字段无漂移
   const back = new FakeRes();
   await importRoute.handler(req("/api/dsh-mneme/import", "POST", { type: "preference", markdown: md }), back);