@modusensus/dsh-mneme 0.7.31 → 0.7.32

package/src/service.js

@@ -1,5 +1,6 @@
 import { createHash, randomUUID } from "node:crypto";
 import { TYPE_FILE } from "./mirror.js";
+import { STR, langOf } from "./lang.js";
 import { computeHeat } from "./heat.js";
 import { evaluateMemoryQuality } from "./quality-filter.js";
 import { createBM25Index } from "./search/bm25.js";
@@ -32,6 +33,11 @@ const EPISTEMIC_WEIGHTS = { observation: 1.0, inferred: 0.85, subjective: 0.7 };
 // how the version was superseded (auto_merge | human_override | overwrite).
 const CONTENT_HISTORY_MAX = 20;
 
+// Issue #135 附属发现 2：质量过滤器写下的系统信号标签（「为什么被降权/归档」的
+// 唯一审计线索）。更新路径整组替换 tags 会把它们抹掉——更新时按此清单并集保留。
+// 清单必须与 quality-filter.js 的写入端对齐（6 个，含 type 自指的 self_referential）。
+const SIGNAL_TAGS = ["low_quality", "duplicate", "meta", "repetitive", "short_content", "self_referential"];
+
 /** Prepend the previous content to a memory's content_history (FIFO capped). */
 function pushContentHistory(existing, source) {
   const history = Array.isArray(existing?.content_history) ? existing.content_history : [];
@@ -78,6 +84,7 @@ export function computeRetrievalMetrics(actualIds, expectedIds) {
 }
 
 export function createService({ store, mirror, config, onWrite, logger }) {
+  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
   // passed in the constructor). Fired on the same write events as onWrite.
@@ -865,6 +872,60 @@ export function createService({ store, mirror, config, onWrite, logger }) {
     }
   }
 
+  /**
+   * 写入端同会话语义去重（Issue #127，opt-in，默认 off）：落库前把新条目与
+   * 「同会话 + 时间窗」内已落库的记忆比对，命中即并入既有条目，不再新造一行。
+   *
+   * 分层：title 档走零成本的标题归一化；vector 档复用已有 embedding 列做近邻，
+   * 新条目的向量由 embedder 现算（embedQuery），全程无 LLM 调用。embedder 不可用
+   * 或向量缺失一律返回 undefined 回落正常写入——去重是增强，绝不能成为写入依赖。
+   *
+   * 作用域刻意限定「同会话」：跨会话的同类事实仍交给 autoDream / sleep 的批量裁决。
+   * 比对逻辑与并入动作分别复用 cosineVec 与 saveWithDedupe 的 _mergeInto 分支。
+   *
+   * @returns {{action: "merged", memory: object, sim: number}|undefined} 命中则返回
+   *          并入目标与相似度；未命中（含任何异常）返回 undefined。
+   */
+  async function findSessionDuplicate(memory, { mode = "off", minSim = 0.92, windowHours = 24, source } = {}) {
+    if (mode === "off" || !source || !memory?.title) return undefined;
+    try {
+      const sinceMs = windowHours > 0 ? Date.now() - windowHours * 3600000 : 0;
+      const inWindow = (m) => {
+        if (sinceMs <= 0) return true;
+        const t = Date.parse(m.created_at ?? "");
+        return !Number.isFinite(t) || t >= sinceMs; // 时间戳损坏时不误杀
+      };
+      const candidates = store
+        .list({ type: memory.type, source, limit: 200 })
+        .filter((m) => !m.archived && inWindow(m));
+      if (!candidates.length) return undefined;
+
+      if (mode === "title") {
+        const norm = (s) => String(s ?? "").toLowerCase().replace(/[\s\p{P}]+/gu, "");
+        const key = norm(memory.title);
+        if (!key) return undefined;
+        const hit = candidates.find((m) => norm(m.title) === key);
+        return hit ? { action: "merged", memory: hit, sim: 1 } : undefined;
+      }
+      if (mode !== "vector") return undefined;
+
+      const vecs = store.getEmbeddings(candidates.map((m) => m.id));
+      if (!vecs.size) return undefined;
+      const probe = await embedQuery([memory.title, memory.content].filter(Boolean).join("\n"));
+      if (!probe) return undefined;
+      let best;
+      for (const m of candidates) {
+        const v = vecs.get(m.id);
+        if (!v) continue; // 无向量的既有行不参与比对（无信号 = 不判定）
+        const sim = cosineVec(probe, v);
+        if (sim >= minSim && (!best || sim > best.sim)) best = { action: "merged", memory: m, sim };
+      }
+      return best;
+    } catch {
+      return undefined; // 去重失败绝不阻塞写入
+    }
+  }
+
   /**
    * Save a memory, merging into an existing one when title matches within the same type.
    *
@@ -900,9 +961,19 @@ export function createService({ store, mirror, config, onWrite, logger }) {
         });
       } catch { /* quality scoring is best-effort */ }
     }
-    const existing = store
-      .list({ type: memory.type, limit: 100 })
-      .find((m) => m.title.trim() === String(memory.title).trim());
+    // dream 总览按 source 身份去重，而非本地化标题：memory.language 切换后
+    // 标题变化，若仍按 (type, title) 匹配会出现两个活跃的 summary 同时注入。
+    // 其余类型维持 (type, title) 匹配不变。
+    const candidates = store.list({ type: memory.type, limit: 100 });
+    // Issue #127：写入端语义去重命中时，调用方用 _mergeInto 指定并入目标——复用
+    // 下面这段并入逻辑（appendContent + content_history + 质量处置），不另写第二份
+    // 实现。目标已被并发删除时回落到常规匹配。
+    const existing = memory._mergeInto
+      ? store.getById(memory._mergeInto)
+      : (memory.type === "summary" && memory.source === "dream")
+        ? (candidates.find((m) => m.source === "dream")
+          ?? candidates.find((m) => m.title.trim() === String(memory.title).trim()))
+        : candidates.find((m) => m.title.trim() === String(memory.title).trim());
     if (existing) {
       const newContent = String(memory.content ?? "");
       if (!newContent.trim()) {
@@ -956,6 +1027,12 @@ export function createService({ store, mirror, config, onWrite, logger }) {
    * (importance × score/100). Best-effort: a disposition write failure must
    * never fail the save. Returns the (possibly refreshed) memory row so callers
    * see the archived/tagged state, not the pre-disposition snapshot.
+   *
+   * Issue #135 附属发现 1：importance ≥ memoryQualityFilter.exemptImportance
+   * （默认 4）的记忆不参与静默自动归档——评分与信号标签照常写入（可观测），
+   * 注入排序照常按 importance × score/100 降权，但 setArchived 跳过。报告实测
+   * 150 条低分归档里 128 条 importance ≥ 4（51 条 = 5）：一条被显式标为重要的
+   * 记忆不该被规则分静默归档、无感知无豁免。
    */
   function applyQualityDisposition(memory, quality, qf) {
     if (!quality || qf?.enabled !== true) return memory;
@@ -963,14 +1040,21 @@ export function createService({ store, mirror, config, onWrite, logger }) {
     // Signal tags (meta / repetitive / duplicate / short_content / low_quality)
     // are merged onto the stored row in every assessed band so the verdict is
     // observable, not just the numeric score. Below the archive threshold the
-    // memory is additionally archived (still explicitly searchable).
+    // memory is additionally archived (still explicitly searchable) — unless
+    // its importance reaches the exemption floor (kept active, demoted only).
     const tags = [...new Set([...(memory.tags ?? []), ...(quality.tags ?? [])])];
-    if (tags.length === (memory.tags?.length ?? 0) && quality.score >= archiveThreshold) {
+    const exemptImportance = qf.exemptImportance ?? 4;
+    const importanceExempt = Number.isInteger(memory.importance) && memory.importance >= exemptImportance;
+    if (tags.length === (memory.tags?.length ?? 0) && (quality.score >= archiveThreshold || importanceExempt)) {
       return memory; // no tag drift and not archived → nothing extra to write
     }
     try {
       store.update(memory.id, { tags, quality_score: quality.score });
-      if (quality.score < archiveThreshold) store.setArchived(memory.id, true);
+      if (quality.score < archiveThreshold && !importanceExempt) {
+        store.setArchived(memory.id, true);
+      } else if (quality.score < archiveThreshold) {
+        logger?.info?.(`[dsh-mneme] quality filter: memory ${memory.id} scored ${quality.score} < ${archiveThreshold} but importance ${memory.importance} >= exemptImportance ${exemptImportance}; demoted, not archived`);
+      }
       return store.getById(memory.id);
     } catch {
       return memory;
@@ -1195,7 +1279,8 @@ export function createService({ store, mirror, config, onWrite, logger }) {
         // （保留现有 storeChanged 逻辑）
         const storeChanged = edit.updated_at !== undefined && m.updated_at !== edit.updated_at;
         if (storeChanged) {
-          const marker = `\n\n> ⚠️ 并发冲突：人工编辑 vs 记忆库并发更新（${m.updated_at}）\n> 记忆库版本：${m.content}`;
+          // 三方合并保留双方时的冲突批注：随实例语言，写进记忆正文。
+          const marker = STR.serviceConflictMarker[language](m.updated_at, m.content);
           store.update(m.id, { title: edit.title, content: `${edit.content}${marker}` });
         } else {
           store.update(m.id, { title: edit.title, content: edit.content });
@@ -1467,6 +1552,7 @@ export function createService({ store, mirror, config, onWrite, logger }) {
     setRecallRecorder(fn) { recallRecorder = fn; },
     searchMemories,
     embedQuery,
+    findSessionDuplicate,
     evaluateRetrieval,
     computeRetrievalMetrics,
     // passthroughs used by tools and api layers; mutations keep the mirror in sync
@@ -1484,7 +1570,15 @@ export function createService({ store, mirror, config, onWrite, logger }) {
     },
     update: (id, p, ctx = {}) => {
       const old = store.getById(id);
-      const updated = store.update(id, p);
+      // Issue #135 附属发现 2：质量过滤器把「为什么被降权/归档」写在系统信号标签
+      // 上（SIGNAL_TAGS，applyQualityDisposition 以并集写入），而这里整组替换
+      // tags——任何带 tags 的更新都会抹掉这条唯一的审计线索（报告实测 150 条低分
+      // 记忆里恰好缺的 2 条就是被 update 过的，并因此误判过归档来源）。把 existing
+      // 的系统信号标签并集保留；用户自传的标签照常生效。
+      const patch = (p && Array.isArray(p.tags) && old && Array.isArray(old.tags))
+        ? { ...p, tags: [...new Set([...p.tags, ...old.tags.filter((t) => SIGNAL_TAGS.includes(t))])] }
+        : p;
+      const updated = store.update(id, patch);
       // Record a user correction when any meaningful field changed and the
       // reflection failure tracker is enabled. expected = what it became,
       // actual = what it was before; query (when provided) captures the

package/src/settings.js

@@ -78,7 +78,21 @@ const FEATURE_FLAG_INT_RANGES = {
   distillMaxChars: [1000, 200000],
   codingBoostFactor: [1, 5],
   dreamMinIntervalMinutes: [0, 10080],
-  dreamMaxTokens: [256, 131072]
+  dreamMaxTokens: [256, 131072],
+  // Issue #127：autoSummarize 节流三键（0 = 零行为变化，等同现状）。
+  summarizeMinIntervalMinutes: [0, 10080],
+  summarizeMaxEntriesPerRun: [0, 50],
+  summarizeDedupeWindowHours: [0, 168],
+  // Issue #125：hybrid 候选量上限（0 = 复用 dreamMaxSnapshotSize）。
+  dreamCandidateMax: [0, 5000]
+};
+// 浮点开关的闭区间（与 config.js 的 z.number().min().max() 对齐）。与整数开关
+// 分开：面板的整数控件要求 Number.isInteger，而余弦相似度阈值必须允许小数。
+const FEATURE_FLAG_NUMBER_RANGES = {
+  // Issue #127：vector 去重档的并入阈值。
+  summarizeDedupeMinSim: [0.5, 0.99],
+  // Issue #125：hybrid 判"高相似"的阈值。
+  dreamCandidateMinSim: [0.5, 0.99]
 };
 // 自由字符串开关（与 config.js 的 z.string() 同名同型）：trim 后 ≤200 字符，
 // 空串合法（= 跟随主对话模型/默认路径，面板显示 placeholder）。
@@ -106,7 +120,13 @@ const FEATURE_FLAG_ENUMS = {
   // rank/scale-aware alternatives selected by the panel.
   recallFusion: ["blend", "rrf", "minmax"],
   // 实体抽取思考强度（issue #109）：与 dreamReasoningEffort 枚举对齐。
-  entityExtractionReasoning: ["low", "medium", "high", "none"]
+  entityExtractionReasoning: ["low", "medium", "high", "none"],
+  // Issue #127：落库前去重档位（off 默认，等同现状）。
+  summarizeDedupeMode: ["off", "title", "vector"],
+  // Issue #126：sleep 冲突阶段的动作集（conflict 默认 = 现状；full = 六分支）。
+  sleepActionSet: ["conflict", "full"],
+  // Issue #125：dream 候选集构造方式（window 默认 = 现状；hybrid 并入向量组）。
+  dreamCandidateMode: ["window", "hybrid"]
 };
 const FEATURE_FLAG_STRING_MAX = 200;
 
@@ -114,6 +134,7 @@ const FEATURE_FLAG_STRING_MAX = 200;
 export const FEATURE_FLAG_SPEC = {
   booleans: FEATURE_FLAG_BOOLEANS,
   ints: FEATURE_FLAG_INT_RANGES,
+  numbers: FEATURE_FLAG_NUMBER_RANGES,
   strings: FEATURE_FLAG_STRINGS,
   urls: FEATURE_FLAG_URLS,
   enums: FEATURE_FLAG_ENUMS
@@ -145,6 +166,14 @@ function validateFlag(key, value) {
     }
     return value;
   }
+  const numRange = FEATURE_FLAG_NUMBER_RANGES[key];
+  if (numRange) {
+    const [min, max] = numRange;
+    if (typeof value !== "number" || !Number.isFinite(value) || value < min || value > max) {
+      throw new TypeError(`feature flag "${key}" must be a number in [${min}, ${max}]`);
+    }
+    return value;
+  }
   if (FEATURE_FLAG_STRINGS.includes(key)) {
     if (typeof value !== "string") {
       throw new TypeError(`feature flag "${key}" must be a string`);
@@ -185,6 +214,11 @@ function sanitizeFlags(raw) {
   for (const [key, [min, max]] of Object.entries(FEATURE_FLAG_INT_RANGES)) {
     if (Number.isInteger(raw[key]) && raw[key] >= min && raw[key] <= max) out[key] = raw[key];
   }
+  for (const [key, [min, max]] of Object.entries(FEATURE_FLAG_NUMBER_RANGES)) {
+    if (typeof raw[key] === "number" && Number.isFinite(raw[key]) && raw[key] >= min && raw[key] <= max) {
+      out[key] = raw[key];
+    }
+  }
   for (const key of FEATURE_FLAG_STRINGS) {
     if (typeof raw[key] === "string" && raw[key].trim().length <= FEATURE_FLAG_STRING_MAX) {
       out[key] = raw[key].trim();

package/src/store.js

@@ -43,7 +43,8 @@ CREATE TABLE IF NOT EXISTS dream_runs (
   summary_stored INTEGER NOT NULL DEFAULT 0,
   receipt        TEXT NOT NULL,
   policy_epoch   INTEGER NOT NULL DEFAULT 0,  -- 裁决规则版本：规则升级后旧裁决降级为历史证据
-  run_type       TEXT NOT NULL DEFAULT 'auto'  -- auto | sleep：睡眠周期的审计区分
+  run_type       TEXT NOT NULL DEFAULT 'auto', -- auto | sleep：睡眠周期的审计区分
+  skipped        TEXT                     -- JSON: degraded 轮被跳过的逐条明细（index/action/ids/error）
 );
 CREATE INDEX IF NOT EXISTS idx_dream_runs_created ON dream_runs(created_at);
 
@@ -371,7 +372,9 @@ function toDreamRun(row) {
     summary_stored: row.summary_stored === 1,
     receipt: row.receipt,
     policy_epoch: row.policy_epoch ?? 0,
-    run_type: row.run_type ?? "auto"
+    run_type: row.run_type ?? "auto",
+    // Issue #104：degraded 轮的逐条跳过明细（JSON 列，NULL = 该轮无跳过项）。
+    skipped: row.skipped ? JSON.parse(row.skipped) : undefined
   };
 }
 
@@ -597,6 +600,9 @@ export function createStore(path) {
   // Legacy dream_runs without policy_epoch → backfill with the default epoch.
   addColumn("dream_runs", "policy_epoch", "ALTER TABLE dream_runs ADD COLUMN policy_epoch INTEGER NOT NULL DEFAULT 0");
   addColumn("dream_runs", "run_type", "ALTER TABLE dream_runs ADD COLUMN run_type TEXT NOT NULL DEFAULT 'auto'");
+  // Issue #104：degraded（合法子集已应用）轮被跳过的决策明细。此前只进 logger.warn，
+  // 离线回放 dream_runs 无法定位 degraded 成因（跨类型 merge / update 保护期 / unknown id）。
+  addColumn("dream_runs", "skipped", "ALTER TABLE dream_runs ADD COLUMN skipped TEXT");
 
   // Legacy mirror_state without v0.3.6 generation columns → add each missing
   // column idempotently (old DBs open cleanly, no data loss).
@@ -1031,11 +1037,18 @@ export function createStore(path) {
     ).get().c;
   }
 
-  /** Candidate rows still missing an embedding, for incremental re-indexing. */
+  /**
+   * Candidate rows still missing an embedding, for incremental re-indexing.
+   * Issue #128: active rows only — archived/forgotten rows never participate in
+   * recall or dream clustering, so backfill quota must not be eaten by them
+   * (report measured 25/50 reindex slots landing on archived rows while 88
+   * active rows stayed un-embedded). Same 口径 as embeddedCount()/count().
+   */
   function needsEmbedding(limit = 50) {
     return db.prepare(
       `SELECT id, title, content FROM memories
-       WHERE embedding IS NULL OR embedding = ''
+       WHERE (embedding IS NULL OR embedding = '')
+         AND forgotten = 0 AND archived = 0
        ORDER BY updated_at DESC LIMIT ?`
     ).all(limit);
   }
@@ -1119,16 +1132,20 @@ export function createStore(path) {
     const now = nowIso();
     const policyEpoch = Number.isInteger(run.policy_epoch) ? run.policy_epoch : 0;
     const runType = run.run_type ?? "auto";
+    // Issue #104：degraded 轮的跳过明细（JSON）。与 decisions/outcome 同为可选
+    // 载荷，未提供时落 NULL（而不是 "[]"），审计行只记真实发生过的跳过。
+    const skipped = run.skipped !== undefined ? JSON.stringify(run.skipped) : null;
     db.prepare(
       `INSERT INTO dream_runs (id, created_at, status, error, provider, model, snapshot_hash,
-        input_count, input, decisions, outcome, applied, summary_stored, receipt, policy_epoch, run_type)
-       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        input_count, input, decisions, outcome, applied, summary_stored, receipt, policy_epoch, run_type, skipped)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
        ON CONFLICT(id) DO UPDATE SET
          created_at=excluded.created_at, status=excluded.status, error=excluded.error,
          provider=excluded.provider, model=excluded.model, snapshot_hash=excluded.snapshot_hash,
          input_count=excluded.input_count, input=excluded.input, decisions=excluded.decisions,
          outcome=excluded.outcome, applied=excluded.applied, summary_stored=excluded.summary_stored,
-         receipt=excluded.receipt, policy_epoch=excluded.policy_epoch, run_type=excluded.run_type`
+         receipt=excluded.receipt, policy_epoch=excluded.policy_epoch, run_type=excluded.run_type,
+         skipped=excluded.skipped`
     ).run(
       id,
       run.created_at ?? now,
@@ -1145,7 +1162,8 @@ export function createStore(path) {
       run.summary_stored ? 1 : 0,
       run.receipt,
       policyEpoch,
-      runType
+      runType,
+      skipped
     );
     return getDreamRun(id);
   }

package/src/summarize.js

@@ -1,22 +1,9 @@
 import { BlockAssembler, createUserMessage } from "@deepseek-ai/dsh-llm";
-
-const SUMMARY_PROMPT = `你是记忆库提炼助手。根据下面的会话内容，提炼值得跨会话记住的原子记忆。
-原子记忆原则：每条记忆只装一个独立事实/偏好/决策，短小、自带完整上下文（把数字、名字、路径、结论等原始细节保留在 content 里，不要抽象概括）；宁可拆成多条也绝不合并丢细节。信息量一般提 2-4 条，信息密集的对话可提 4-8 条。
-只输出 JSON 数组，每项形如 {"type":"preference|project|decision|history","title":"简短标题","content":"保留原始细节的一句话","importance":1-5}。
-不要输出任何其他文字。`;
+import { STR, langOf } from "./lang.js";
 
 // 编码记忆蒸馏 prompt（codingRetrospect 开启时启用）：在通用记忆之外，额外提取
 // 三类编码专属记忆，专治重复踩坑 / 遗忘被否决方案 / 丢失工程约束。字段仍沿用
 // title/content 单列结构（store 无结构化字段），信息浓缩进 content。
-const CODING_SUMMARY_PROMPT = `你是记忆库提炼助手。根据下面的会话内容（含用户输入、助手回答、工具调用与结果），提炼值得跨会话记住的原子记忆。
-原子记忆原则：每条记忆只装一个独立事实/偏好/决策，短小、自带完整上下文（把数字、报错信息、命令、路径、结论等原始细节保留在 content 里，不要抽象概括）；宁可拆成多条也绝不合并丢细节。信息量一般提 2-4 条，信息密集的对话可提 4-8 条。
-只输出 JSON 数组，每项形如 {"type":"preference|project|decision|history|rejected_solution|pitfall|constraint","title":"简短标题","content":"保留原始细节的一句话","importance":1-5}。
-若对话涉及编码/调试，可额外提取编码类记忆：
-- rejected_solution：被否决/废弃的实现方案（content 含方案简述 + 被否决原因 + 最终采用方案）
-- pitfall：调试踩坑记录（content 含现象/报错 + 根因 + 解决/规避方法）
-- constraint：项目工程约束（content 含约束描述 + 来源）
-普通闲聊、临时无关对话一律不提取编码类记忆。不要输出任何其他文字。`;
-
 /** Extract a JSON array from LLM output that may contain prose around it. */
 export function parseSummaryJson(raw) {
   const text = String(raw ?? "");
@@ -101,7 +88,7 @@ function toProtocolChunk(chunk) {
 // Privacy: assistant `reasoning` (private thought) blocks are deliberately NOT
 // collected — distilled memories must never sink private reasoning chains.
 // Only public text blocks (type "text") reach the summarizer.
-function collectMessages(session, maxChars = 8000) {
+function collectMessages(session, maxChars = 8000, language = "zh") {
   // DSH 0.1.2-rc.1 起 Session 改用 snapshotEvents()，兼容旧版 .events
   const events = session.snapshotEvents?.() ?? session.events ?? [];
   const lines = [];
@@ -123,14 +110,14 @@ function collectMessages(session, maxChars = 8000) {
       case "user/message": {
         if (kind !== undefined && kind !== "user") break;
         const text = textOf(data?.content);
-        if (text.trim()) lines.push(`用户：${text}`);
+        if (text.trim()) lines.push(STR.transcriptUser[language](text));
         break;
       }
       case "assistant/message": {
         const msg = data?.message;
         const blocks = Array.isArray(msg?.content) ? msg.content : [];
         const text = textOf(blocks);
-        if (text.trim()) lines.push(`助手：${text}`);
+        if (text.trim()) lines.push(STR.transcriptAssistant[language](text));
         // 私有推理块（reasoning）刻意不采集：蒸馏记忆不得沉淀模型私有思考链。
         break;
       }
@@ -138,19 +125,19 @@ function collectMessages(session, maxChars = 8000) {
         const args = typeof data.arguments === "string"
           ? data.arguments
           : data.arguments ? JSON.stringify(data.arguments) : "";
-        lines.push(`工具调用：${data.name ?? "?"}(${trim(args, 300)})`);
+        lines.push(STR.transcriptToolCall[language](data.name ?? "?", trim(args, 300)));
         break;
       }
       case "tool/result": {
         const out = typeof data.output === "string" ? data.output : data.output ? JSON.stringify(data.output) : "";
-        const status = data.ok === false ? "失败" : "成功";
-        lines.push(`工具结果（${status}）：${trim(out, 500)}`);
+        const status = data.ok === false ? STR.statusFail[language] : STR.statusOk[language];
+        lines.push(STR.transcriptToolResult[language](status, trim(out, 500)));
         break;
       }
       case "tool/code-dispatch": {
         const out = typeof data.output === "string" ? data.output : data.output ? JSON.stringify(data.output) : "";
-        const status = data.ok === false ? "失败" : "成功";
-        lines.push(`代码执行（${status}）：${trim(out, 500)}`);
+        const status = data.ok === false ? STR.statusFail[language] : STR.statusOk[language];
+        lines.push(STR.transcriptCode[language](status, trim(out, 500)));
         break;
       }
       default:
@@ -197,10 +184,54 @@ export function createSummarizer(ctx, service, config) {
   if (!config.autoSummarize) return { dispose: () => {} };
 
   const inFlight = new Map();
+  // Issue #127：per-session 上一次实际开跑时刻（最小间隔闸门用）。与 inFlight
+  // 同生命周期，dispose 时一并清空。
+  const lastRunAt = new Map();
   let disposed = false;
 
+  /** 写一条 autoSummarize 的 LLM 审计行（审计失败绝不阻塞蒸馏本身）。 */
+  function writeAudit(entry) {
+    if (config?.llmAudit?.enabled === false || typeof service.saveLlmAudit !== "function") return;
+    try {
+      service.saveLlmAudit({
+        trigger_source: "autoSummarize",
+        operation_type: "summarize_compress",
+        related_memory_ids: [],
+        ...entry
+      });
+    } catch (auditError) {
+      ctx.logger?.warn?.(`dsh-mneme: llm audit write failed: ${String(auditError)}`);
+    }
+  }
+
   async function summarize(session) {
     if (disposed || inFlight.has(session.id)) return;
+
+    const header = session.requestHeader?.()?.config;
+    // Config override takes priority, then session header, then nothing.
+    const route = (config.summarizeProvider && config.summarizeModel)
+      ? { provider: config.summarizeProvider, model: config.summarizeModel }
+      : (header?.provider && header?.model)
+        ? { provider: header.provider, model: header.model }
+        : undefined;
+
+    // Issue #127 间隔门：同一会话两次蒸馏之间的最小间隔（0 = 现状，不限）。进入
+    // 即打点——失败/degraded 的 run 也占用间隔，与 dreamMinIntervalMinutes 语义
+    // 一致，防止失败连发。被挡下的 turn/end 静默跳过，但留一行 status='skipped'
+    // 审计，否则「这一轮为什么没蒸馏」对用户完全不可观测。
+    const gapMs = (config.summarizeMinIntervalMinutes ?? 0) * 60000;
+    const prevClaim = lastRunAt.get(session.id);
+    if (gapMs > 0 && Date.now() - (prevClaim ?? 0) < gapMs) {
+      writeAudit({
+        timestamp: new Date().toISOString(),
+        model_id: route ? `${route.provider}:${route.model}` : "unknown",
+        status: "skipped",
+        error_message: "min-interval"
+      });
+      return;
+    }
+    lastRunAt.set(session.id, Date.now());
+
     const controller = new AbortController();
     inFlight.set(session.id, controller);
     // audit state for the compression call. null = no audit for this run
@@ -209,18 +240,12 @@ export function createSummarizer(ctx, service, config) {
     // so a failed/aborted stream still leaves a status='error' trail without
     // ever blocking the summarization itself.
     let audit = null;
+    let abortedRun = false;
     try {
-      const header = session.requestHeader?.()?.config;
-      // Config override takes priority, then session header, then nothing.
-      const route = (config.summarizeProvider && config.summarizeModel)
-        ? { provider: config.summarizeProvider, model: config.summarizeModel }
-        : (header?.provider && header?.model)
-          ? { provider: header.provider, model: header.model }
-          : undefined;
       if (!route) return;
       // 完整转录（Codex 式）：蒸馏把整轮对话交给 LLM 提炼原子记忆，不再硬裁
       // 8000 字截断语义；上限由 distillMaxChars 控制（默认 24000，可调大）。
-      const messages = collectMessages(session, config.distillMaxChars ?? 24000);
+      const messages = collectMessages(session, config.distillMaxChars ?? 24000, langOf(config));
       if (!messages.length) return;
 
       if (config?.llmAudit?.enabled !== false && typeof service.saveLlmAudit === "function") {
@@ -240,7 +265,7 @@ export function createSummarizer(ctx, service, config) {
         model: route.model,
         purpose: "summarization",
         messages: [
-          { role: "system", content: [{ type: "text", text: config.codingRetrospect ? CODING_SUMMARY_PROMPT : SUMMARY_PROMPT }] },
+          { role: "system", content: [{ type: "text", text: config.codingRetrospect ? STR.prompts.codingSummary[langOf(config)] : STR.prompts.summary[langOf(config)] }] },
           ...messages
         ],
         signal: controller.signal
@@ -314,8 +339,19 @@ export function createSummarizer(ctx, service, config) {
           }
         }
       }, intervalMs);
-      if (aborted) return;
-      const entries = parseSummaryJson(text || assembledText);
+      if (aborted) {
+        abortedRun = true;
+        return;
+      }
+      const parsed = parseSummaryJson(text || assembledText);
+      // Issue #127 条数上限：0 = 不限（现状）。被截断的条数与去重命中数一并进
+      // 审计 metadata——此前产出条数完全由模型输出决定，用户无从自查。
+      const cap = config.summarizeMaxEntriesPerRun ?? 0;
+      const entries = cap > 0 ? parsed.slice(0, cap) : parsed;
+      const capped = parsed.length - entries.length;
+      const dedupeMode = config.summarizeDedupeMode ?? "off";
+      let deduped = 0;
+      let dedupeMaxSim = 0;
       for (const entry of entries) {
         // Provenance: the summarizer runs on a real session (turn/end hook), so
         // session.id is always available here — it rides the human-readable
@@ -323,12 +359,45 @@ export function createSummarizer(ctx, service, config) {
         // 编码记忆类型（codingRetrospect）不带 tag：读取侧门控/加权靠 m.type
         // （rejected_solution/pitfall/constraint）区分即可，tag 体系
         // sanitizeTags 不认 `type:` 前缀反而会清空 tags 列（额外一次 UPDATE）。
+        const source = `session:${session.id}`;
+        // Issue #127 落库前去重（opt-in，默认 off = 现状）：命中则并入既有条目
+        // （saveWithDedupe 的 _mergeInto 分支），不再新造一行。作用域 = 同会话 +
+        // 时间窗；跨会话的同类事实仍交给 autoDream / sleep 的批量裁决。
+        const dup = (dedupeMode !== "off" && typeof service.findSessionDuplicate === "function")
+          ? await service.findSessionDuplicate(
+            { ...entry, source },
+            {
+              mode: dedupeMode,
+              minSim: config.summarizeDedupeMinSim ?? 0.92,
+              windowHours: config.summarizeDedupeWindowHours ?? 24,
+              source
+            }
+          )
+          : undefined;
+        if (dup) {
+          deduped++;
+          dedupeMaxSim = Math.max(dedupeMaxSim, dup.sim ?? 0);
+        }
         service.saveWithDedupe({
           ...entry,
-          source: `session:${session.id}`
+          source,
+          ...(dup ? { _mergeInto: dup.memory.id } : {})
         });
       }
+      if (audit && (capped > 0 || deduped > 0)) {
+        audit.metadata = {
+          parsed: parsed.length,
+          ...(capped > 0 ? { capped } : {}),
+          ...(deduped > 0 ? { deduped, mode: dedupeMode, maxSim: Number(dedupeMaxSim.toFixed(4)) } : {})
+        };
+      }
     } finally {
+      // Issue #127：aborted（会话关闭 / 插件 dispose）不占间隔，避免误伤该会话的
+      // 下一次蒸馏；其余情况（含失败）的打点保留，与 dreamMinIntervalMinutes 一致。
+      if (abortedRun || controller.signal.aborted) {
+        if (prevClaim === undefined) lastRunAt.delete(session.id);
+        else lastRunAt.set(session.id, prevClaim);
+      }
       if (audit) {
         try {
           service.saveLlmAudit({
@@ -343,7 +412,10 @@ export function createSummarizer(ctx, service, config) {
             duration_ms: Date.now() - audit.startedAt,
             status: audit.status,
             error_message: audit.errorMessage,
-            related_memory_ids: []
+            related_memory_ids: [],
+            // Issue #127：parsed / capped / deduped 的观测数据。零 schema 变更
+            // （llm_audit_logs.metadata 已存在），一条 SQL 即可验证节流是否生效。
+            metadata: audit.metadata
           });
         } catch (auditError) {
           ctx.logger?.warn?.(`dsh-mneme: llm audit write failed: ${String(auditError)}`);
@@ -371,6 +443,7 @@ export function createSummarizer(ctx, service, config) {
       unsubscribe?.();
       for (const controller of inFlight.values()) controller.abort();
       inFlight.clear();
+      lastRunAt.clear();
     }
   };
 }