@modusensus/dsh-mneme 0.7.31 → 0.7.32

package/src/config.js

@@ -2,6 +2,10 @@ import z from "@deepseek-ai/schemastery";
 import { TYPE_DECAY_DEFAULTS } from "./heat.js";
 
 export const Config = z.object({
+  // 记忆语言：生成记忆、注入标题与后台 LLM 提示词所用语言；'zh'（默认，
+  // 行为不变）/ 'en'。启动时读入，切换后重启生效。
+  language: z.union([z.const("zh"), z.const("en")]).default("zh")
+    .description("记忆语言：生成的记忆条目、注入标题与后台 LLM 提示词所用语言（zh=默认中文，en=英文）。"),
   memoryDir: z.string().default("~/.dsh/memory"),
   autoInject: z.boolean().default(true),
   autoSummarize: z.boolean().default(true),
@@ -14,6 +18,17 @@ export const Config = z.object({
   // 蒸馏把完整对话上下文交给 LLM 提炼，不硬裁到 8000 字就截断语义；默认
   // 24000 字符（约覆盖一整轮中等对话），需要更完整可调大。
   distillMaxChars: z.natural().min(1000).max(200000).default(24000),
+  // autoSummarize 节流、产出上限与写入端同会话去重（Issue #127，默认全 0/off =
+  // 零行为变化）。此前每个 turn/end 必跑、产出条数由模型输出决定、写入端只按
+  // 「同类型 + 标题 trim 全等」去重——本机实测单日 84 次、单会话一天 198 条、
+  // 同一事实 6 小时铸出 28+ 条。阀门交给用户按需拧，升级本身不改行为。
+  summarizeMinIntervalMinutes: z.natural().min(0).max(10080).default(0),
+  summarizeMaxEntriesPerRun: z.natural().min(0).max(50).default(0),
+  // 落库前去重档位：off（默认，等同现状）/ title（零成本，仅拦完全同名）/
+  // vector（复用已有 embedding 列做同会话语义近邻，无 LLM 调用）。
+  summarizeDedupeMode: z.union([z.const("off"), z.const("title"), z.const("vector")]).default("off"),
+  summarizeDedupeMinSim: z.number().min(0.5).max(0.99).default(0.92),
+  summarizeDedupeWindowHours: z.natural().min(0).max(168).default(24),
   // 智能调速器（429 保护，默认开）：蒸馏 LLM 调用全局串行排队，相邻请求
   // 间隔 distillRateLimitIntervalMs（默认 1s 一次）；命中 429 限流时按
   // distillRateLimitBaseDelayMs 指数退避（1s→2s→4s…）自动重试
@@ -64,25 +79,47 @@ export const Config = z.object({
   //     选用时建议配 dreamReasoningEffort 并实测；不行就换非思考模型。
   dreamProvider: z.string().description("记忆巩固专用模型的服务商（settings「巩固模型」）。巩固反复失败时，优先改用官方非思考模型的服务商（如 deepseek / glm）。"),
   dreamModel: z.string().description("记忆巩固专用模型。建议选非思考模型（如 deepseek-chat、glm-5-2 类）：思考模型可能烧光 token 预算返回空体，导致巩固失败（UNSUPPORTED_REASONING_EFFORT）。"),
-  dreamMaxTokens: z.natural().min(256).max(131072).default(32768),
-  // Pass-through reasoning effort for dream's LLM calls. 'none' (default)
-  // omits the field so the provider's own default applies; low/medium/high
-  // are forwarded verbatim. Useful to cap reasoning spend on thinking-type
-  // models that would otherwise drain the whole token budget and return an
-  // empty body ("no json array in llm output").
+  // Issue #135 建议 3：#9 只抬了 max（8192→131072），default 停在 32768。思考型
+  // 模型的推理与正文共享该预算，effort 未压低时 32768 恰好被推理烧光 → 空体
+  // （"no json array in llm output"，报告实测 146 轮因此失败）。默认抬到上限，
+  // 让默认配置也留足正文预算；流式计费按实际用量，不按上限。
+  dreamMaxTokens: z.natural().min(256).max(131072).default(131072),
+  // Pass-through reasoning effort for dream's LLM calls (Issue #135 建议 4/5).
+  // Unset (no value) resolves to the LOWEST effort the model declares before
+  // streaming: background consolidation must produce JSON, and omitting the
+  // field lets the harness substitute the model's defaultEffort (thinking-type
+  // models often default to high/max) — the reasoning then drains the whole
+  // token budget and the run dies with an empty body. Explicit 'none' still
+  // omits the field (provider default applies); off/low/medium/high are
+  // forwarded verbatim, unsupported values are remapped (v0.7.26+).
   // Caveat: on some thinking models (e.g. v4-flash-ga) the harness declares NO
   // supported effort, so even the fallback retry (field stripped) is rejected
   // again via its defaultEffort — prefer a non-reasoning dreamProvider/dreamModel.
   dreamReasoningEffort: z.union([
+    z.const("off"),
     z.const("low"),
     z.const("medium"),
     z.const("high"),
     z.const("none")
-  ]).default("none").description("巩固模型的推理档位：'none'（默认）用服务商自带默认；low/medium/high 原样传递。模型不支持的值会自动换用其支持的档位（v0.7.26+）。"),
+  ]).description("巩固模型的推理档位：未配置 = 自动取模型支持的最低档（避免思考模型用自带默认档烧光预算返回空体，#135）；显式 'none' = 不发送字段、用服务商自带默认；off/low/medium/high 原样传递。模型不支持的值会自动换用其支持的档位（v0.7.26+）。"),
   // 滑动窗口上限（v0.4.4）：autoDream 每次只对最近 dreamMaxSnapshotSize 条
   // 记忆做 consolidation。大记忆量下全量快照会把 LLM 输入撑爆（636 记忆 →
   // 677 "missing" errors、applied=0），窗口外的旧记忆不进 snapshot。
   dreamMaxSnapshotSize: z.natural().min(1).max(1000).default(200),
+  // Issue #125：候选集构造方式。"window"（默认，等同现状）只取最近
+  // dreamMaxSnapshotSize 条；"hybrid" 在此基础上并入**向量翻出的高相似组**——
+  // 本机实测 45 对「双方活跃且 sim≥0.85」里 0 对能同时进窗口（窗口覆盖率 11.7%），
+  // 纯时间窗口让"该合并的一对"几乎永远碰不到面。候选总量仍由下面的上限封顶、
+  // 与库总量解耦，这是相对"调大窗口"的核心收益：输入成本不随库增长。
+  dreamCandidateMode: z.union([
+    z.const("window"),
+    z.const("hybrid")
+  ]).default("window"),
+  // hybrid 的候选总量上限；0 = 复用 dreamMaxSnapshotSize（不迁移，需要时显式覆盖）。
+  dreamCandidateMax: z.natural().min(0).max(5000).default(0),
+  // hybrid 判"高相似"的阈值；0.85 与 sleep normal 档对齐——两个模块对"高相似"
+  // 保持同一个定义。
+  dreamCandidateMinSim: z.number().min(0.5).max(0.99).default(0.85),
   // 隐式 keep（v0.4.4）：LLM 未提及的 snapshot 记忆自动补 {action:"keep"}，
   // 避免"未覆盖即全拒"白白浪费整轮 run。设为 false 时保留旧的严格校验
   // （未覆盖即拒绝整单）。
@@ -134,6 +171,20 @@ export const Config = z.object({
   embedModelCacheDir: z.string().default(""),
   embedModelMirror: z.string().default("https://hf-mirror.com"),
 
+  // 自管运行时目录（issue #131）。空 = ~/.dsh/mneme/runtime：里面放收编或下载来的
+  // transformers + onnxruntime 闭包，插件经 src/runtime/loader.js 的三层解析加载它。
+  // 目的就是让这条重依赖不必留在宿主 profile 的依赖图里——profile 是所有插件共用的
+  // 依赖图，留在里面会让「装任何插件都要替它重走一遍这条链」。
+  runtimeDir: z.string().default(""),
+
+  // 运行时取件的两个来源（issue #131 / PR-C）。都是「克制」的默认：留空 = 不额外改变行为。
+  // - runtimeTarballDir：本地 .tgz 目录。某个包网络下不到时（例如 onnxruntime-node），
+  //   把 `npm pack <pkg>` 出来的 tgz 丢进这个目录即可离线取件；有它就优先于联网。
+  // - runtimeMirror：registry 镜像前缀，例如 https://npmmirror.com/mirrors/npm/ 。
+  //   留空则用 runtime-manifest.json 里写死的官方地址（那是随包发布的固定清单）。
+  runtimeTarballDir: z.string().default(""),
+  runtimeMirror: z.string().default(""),
+
   // Vector search tuning.
   vectorSearchTopK: z.natural().min(1).max(100).default(20),
   vectorSearchThreshold: z.number().min(0).max(1).default(0.65),
@@ -228,9 +279,9 @@ export const Config = z.object({
   // default provider/model.
   entityExtractionModel: z.string().default(""),
   // Reasoning effort for entity extraction (issue #109), mirrors
-  // dreamReasoningEffort: 'none' (default) omits the field / provider default;
-  // low/medium/high passed through. A provider that rejects the effort retries
-  // once without it, so opting in is safe to experiment with.
+  // dreamReasoningEffort pass-through: 'none' omits the field / provider
+  // default; off/low/medium/high passed through. A provider that rejects the
+  // effort retries once without it, so opting in is safe to experiment with.
   entityExtractionReasoning: z.union([
     z.const("low"),
     z.const("medium"),
@@ -265,6 +316,14 @@ export const Config = z.object({
     z.const("normal"),
     z.const("aggressive")
   ]).default("normal"),
+  // Issue #126：冲突阶段的动作集。"conflict"（默认 = 现状）只用 conflict/keep——
+  // 后台自动流程不静默扩张行为；"full" 开放六分支（merge / update / supersede /
+  // differentiate / conflict / keep），互补型与演进型重复因此有了正确出口，不再
+  // 被迫"输赢化"（实测抽样 10 对里 2 对属演进型/互补型，用 conflict 处理会丢信息）。
+  sleepActionSet: z.union([
+    z.const("conflict"),
+    z.const("full")
+  ]).default("conflict"),
   // Archival demotion tiering (days since last access):
   //   >= sleepArchiveDays  → shrink to summary, full body kept in _full_content
   //   >= sleepCompressDays → archived outright (entity relations preserved)
@@ -281,14 +340,16 @@ export const Config = z.object({
   sleepProvider: z.string().default("").description("sleep 深维护专用模型服务商，留空用巩固模型或当前模型。"),
   sleepModel: z.string().default("").description("sleep 深维护专用模型，留空用巩固模型或当前模型；建议同巩固模型选非思考模型。"),
   // Pass-through reasoning effort for sleep's LLM passes, same semantics as
-  // dreamReasoningEffort: 'none' (default) omits the field; low/medium/high
-  // are forwarded verbatim.
+  // dreamReasoningEffort (Issue #135 建议 4/5): unset resolves to the lowest
+  // effort the model declares; explicit 'none' omits the field; off/low/
+  // medium/high are forwarded verbatim.
   sleepReasoningEffort: z.union([
+    z.const("off"),
     z.const("low"),
     z.const("medium"),
     z.const("high"),
     z.const("none")
-  ]).default("none").description("同 dreamReasoningEffort：sleep 各阶段 LLM 的推理档位，'none' 用服务商默认。"),
+  ]).description("同 dreamReasoningEffort：sleep 各阶段 LLM 的推理档位，未配置 = 自动取模型支持的最低档；显式 'none' = 不发送字段、用服务商自带默认。"),
 
   // --- epistemic trust: memory source credibility (v0.4.5) -----------------
   // Distinguish memories by source: observation (measured / witnessed),
@@ -311,7 +372,12 @@ export const Config = z.object({
     enabled: z.boolean().default(true),
     archiveThreshold: z.natural().min(1).max(100).default(30),
     degradeThreshold: z.natural().min(1).max(100).default(60),
-    minContentLength: z.natural().min(1).max(1000).default(10)
+    minContentLength: z.natural().min(1).max(1000).default(10),
+    // Issue #135 附属发现 1：importance ≥ 该值的记忆不参与静默自动归档——评分
+    // 与信号标签照常写入（可观测）、注入排序照常降权，但 setArchived 跳过。
+    // 报告实测 150 条低分归档里 128 条 importance ≥ 4（51 条 = 5）。设 1 = 全部
+    // 豁免（等效关闭自动归档），设 5 = 仅最重要的豁免。
+    exemptImportance: z.natural().min(1).max(5).default(4)
   }).default({}),
 
   // --- LLM audit trail (Bug8) ------------------------------------------------

package/src/dream/decisions.js

@@ -1,4 +1,10 @@
-const ACTIONS = new Set(["keep", "merge", "archive", "conflict", "update", "create"]);
+import { STR, langOf } from "../lang.js";
+
+// Issue #126：sleepActionSet="full" 时新增两个动作——supersede（演进：新版取代
+// 旧版）与 differentiate（互补：两条都留、各追加差异注记）。两者的校验与执行都
+// 复用既有 merge/conflict 的机制（winner/loser、casGuard、transaction、receipt）。
+// 调用方（sleep）按档位派生「本档允许的动作集合」时需要读它，故导出。
+export const ACTIONS = new Set(["keep", "merge", "archive", "conflict", "update", "create", "supersede", "differentiate"]);
 
 // Epistemic trust (v0.4.5): when config.trustEpistemicWeighting is on, merge
 // keepSource and conflict winners prefer the higher-trust memory. Higher value
@@ -11,7 +17,8 @@ const EPISTEMIC_PRIORITY = { observation: 3, inferred: 2, subjective: 1 };
  *   entries are spliced out of this array in place (the caller reuses the same
  *   reference downstream for apply/audit); implicit keeps are appended here too.
  * @param snapshot - Map<id, memory> of eligible (non-archived, non-summary) entries.
- * @returns {{ok: boolean, errors: string[], skipped?: Array<{index, action, ids, error}>}}
+ * @returns {{ok: boolean, errors: string[], skipped?: Array<{index, action, ids, error}>,
+ *   resolvedShortIds?: number}}
  */
 export function validateDecisions(decisions, snapshot, options = {}) {
   const errors = [];
@@ -25,15 +32,52 @@ export function validateDecisions(decisions, snapshot, options = {}) {
   const skipInvalid = options.skipInvalid === true;
   const maxUpdatePerRun = options.maxUpdatePerRun ?? 2;
   const minAgeHours = options.minAgeHours ?? 24;
+  // Issue #126 review（Copilot）：档位白名单。sleepActionSet 默认档只换 prompt 是
+  // 不够的——ACTIONS 是两个模块共用的，模型自发出 supersede / differentiate 时校验器
+  // 照样放行，"opt-in 零行为变化"就成了空话。省略 / null = 不限制（沿用全局 ACTIONS）。
+  const allowedActions = Array.isArray(options.allowedActions) ? new Set(options.allowedActions) : null;
   if (!Array.isArray(decisions)) {
-    return { ok: false, errors: ["decision list must be an array"] };
+    return { ok: false, errors: ["decision list must be an array"], resolvedShortIds: 0 };
   }
   // 空决策 = 模型完整评估后确认无需操作（CONSOLIDATION_PROMPT 明确允许"无问题的
   // 条目无需输出"）。合法 JSON [] 不是空体（那是无输出/截断），也不是"残缺输出"
   // ——显式短路直接 ok，避免隐式 keep 的覆盖率检查把 0% 误判为模型坏了。与
   // sleep 的空模式（skipped no-op）语义对齐：下游 applied=0、audit 记 ok。
   if (decisions.length === 0) {
-    return { ok: true, errors: [], skipped: [] };
+    return { ok: true, errors: [], skipped: [], resolvedShortIds: 0 };
+  }
+  // Issue #135：模型常把 36 位 UUID 回填成前缀（实测 78/78 个 8 位前缀都能唯一
+  // 对应窗口内真实记忆，且 few-shot 示例的 "m1"/"m2" 占位符在诱导这种缩写），而
+  // 下方校验用 snapshot.get(id) 整串精确匹配 → 全部 unknown id → claimed=0 →
+  // 覆盖率闸整单拒绝，一整轮语义成果被丢。校验前先把「唯一前缀」解析回完整 id
+  // （git 短哈希式）：仅在 snapshot 内解析，有歧义或匹配不到就原样保留，仍由下
+  // 方 unknown id 校验如实报错。就地改写 ids / keepSource / winner / loser，下
+  // 游 applyDecisions 与审计拿到的同样是完整 id。
+  let resolvedShortIds = 0;
+  const resolveShortId = (value) => {
+    if (typeof value !== "string" || snapshot.has(value)) return value;
+    // 太短不猜（歧义概率高）；长度 ≥36 说明不是前缀缩写，交给校验如实报错。
+    if (value.length < 8 || value.length >= 36) return value;
+    let hit = null;
+    let matches = 0;
+    for (const id of snapshot.keys()) {
+      if (id.startsWith(value)) {
+        hit = id;
+        if (++matches > 1) return value; // 有歧义，不解析
+      }
+    }
+    if (matches === 1) {
+      resolvedShortIds++;
+      return hit;
+    }
+    return value;
+  };
+  for (const d of decisions) {
+    if (!d || typeof d !== "object") continue;
+    if (Array.isArray(d.ids)) d.ids = d.ids.map(resolveShortId);
+    if (typeof d.keepSource === "string") d.keepSource = resolveShortId(d.keepSource);
+    if (typeof d.winner === "string") d.winner = resolveShortId(d.winner);
+    if (typeof d.loser === "string") d.loser = resolveShortId(d.loser);
   }
   const claimed = new Set();
   for (const [index, d] of decisions.entries()) {
@@ -41,12 +85,26 @@ export function validateDecisions(decisions, snapshot, options = {}) {
     // 单条校验错误先进 local：skipInvalid 模式下整条跳过，严格模式下才并入
     // 全局 errors（沿用 v0.6.9 的双轨结构）。
     const local = [];
-    const ids = d && d.action === "conflict" ? [d.winner, d.loser] : (d?.ids ?? []);
+    // Issue #126：supersede 与 conflict 一样用 winner/loser 定位双方（沿用同一套
+    // 字段，校验与 receipt 逻辑因此可以直接复用）。
+    const ids = d && (d.action === "conflict" || d.action === "supersede") ? [d.winner, d.loser] : (d?.ids ?? []);
     if (!d || typeof d !== "object" || !ACTIONS.has(d.action)) {
       local.push(`${at}: invalid action ${JSON.stringify(d?.action)}`);
-    } else if (d.action === "conflict") {
+    } else if (allowedActions && !allowedActions.has(d.action)) {
+      // 动作本身合法，但不在当前档位允许的集合里（例如默认档收到 supersede）。
+      local.push(`${at}: action ${JSON.stringify(d.action)} not allowed in this mode`);
+    } else if (d.action === "conflict" || d.action === "supersede") {
       if (!d.winner || !d.loser || d.winner === d.loser) {
-        local.push(`${at}: conflict needs distinct winner and loser`);
+        local.push(`${at}: ${d.action} needs distinct winner and loser`);
+      }
+    } else if (d.action === "differentiate") {
+      // Issue #126：互补型——两条都留下、各追加差异注记。ids 必须 ≥2（随后走下方
+      // 通用 id 校验：unknown / archived / summary / 重复 claim），distinctions 必须
+      // 非空，否则会写出空注记（写了等于没写，还会污染正文）。
+      if (!Array.isArray(d.ids) || d.ids.length < 2) {
+        local.push(`${at}: differentiate needs at least two ids`);
+      } else if (!Array.isArray(d.distinctions) || !d.distinctions.some((s) => typeof s === "string" && s.trim())) {
+        local.push(`${at}: differentiate needs a non-empty distinctions array`);
       }
     } else if (d.action === "create") {
       // Mint a fresh memory (sleep pattern discovery). Claims no existing id,
@@ -170,14 +228,14 @@ export function validateDecisions(decisions, snapshot, options = {}) {
   // snapshot（claimed.size / snapshot.size < dreamMinExplicitCoverage）时整单拒绝，
   // 而不是用 keep 把绝大部分 snapshot 全部"通过"。
   if (errors.length > 0) {
-    return { ok: false, errors, skipped };
+    return { ok: false, errors, skipped, resolvedShortIds };
   }
   const minCoverage = options.dreamMinExplicitCoverage ?? 0.5;
   if (options.dreamImplicitKeep !== false) {
     const coverage = snapshot.size > 0 ? claimed.size / snapshot.size : 1;
     if (coverage < minCoverage) {
       errors.push(`explicit decision coverage ${Math.round(coverage * 100)}% < minimum ${Math.round(minCoverage * 100)}%`);
-      return { ok: false, errors, skipped };
+      return { ok: false, errors, skipped, resolvedShortIds };
     }
     for (const id of snapshot.keys()) {
       if (!claimed.has(id)) survivors.push({ action: "keep", ids: [id] });
@@ -186,7 +244,7 @@ export function validateDecisions(decisions, snapshot, options = {}) {
     for (const id of snapshot.keys()) {
       if (!claimed.has(id)) errors.push(`memory ${JSON.stringify(id)} missing from decisions`);
     }
-    if (errors.length > 0) return { ok: false, errors, skipped };
+    if (errors.length > 0) return { ok: false, errors, skipped, resolvedShortIds };
   }
   // 调用方下游（apply/audit）复用同一 decisions 引用：就地同步为 survivors——
   // 在 skipInvalid 模式下去掉被跳过的非法决策；在隐式 keep 下追加补齐的 keep。
@@ -194,7 +252,7 @@ export function validateDecisions(decisions, snapshot, options = {}) {
   // 当"被跳过的非法决策数 == 隐式补齐的 keep 数"时长度回到相等但内容已变，
   // 被跳过的决策会残留进 apply/audit。一律无条件 splice 最安全。
   decisions.splice(0, decisions.length, ...survivors);
-  return { ok: true, errors, skipped };
+  return { ok: true, errors, skipped, resolvedShortIds };
 }
 
 /** Marker thrown when a decision target changed since the run snapshot. */
@@ -208,7 +266,7 @@ export class CasConflictError extends Error {
 }
 
 function decisionIds(d) {
-  return d.action === "conflict" ? [d.winner, d.loser] : (d.ids ?? []);
+  return d.action === "conflict" || d.action === "supersede" ? [d.winner, d.loser] : (d.ids ?? []);
 }
 
 /**
@@ -297,6 +355,8 @@ function applyOne(d, service, snapshot, config = {}) {
     case "archive": return applyArchive(d, service, snapshot);
     case "merge": return applyMerge(d, service, snapshot, config);
     case "conflict": return applyConflict(d, service, snapshot, config);
+    case "supersede": return applySupersede(d, service, snapshot, config);
+    case "differentiate": return applyDifferentiate(d, service, snapshot, config);
     case "create": return applyCreate(d, service, config);
     default: return applyUpdate(d, service, snapshot, config);
   }
@@ -330,6 +390,7 @@ function pickBestKeeper(ids, preferred, service) {
  * memories. saveWithDedupe dedupes identical mints (idempotent replay-safe).
  */
 function applyCreate(d, service, config = {}) {
+  const language = langOf(config);
   const title = String(d.title ?? "").trim();
   const content = String(d.content ?? "").trim();
   const importance = Number.isInteger(d.importance) ? d.importance : 3;
@@ -338,7 +399,7 @@ function applyCreate(d, service, config = {}) {
     ? d.evidence.filter((id) => typeof id === "string")
     : [];
   const body = evidence.length > 0
-    ? `${content}\n\n[证据: ${evidence.join(", ")}]`
+    ? STR.evidenceSuffix[language](content, evidence)
     : content;
   const created = service.saveWithDedupe({ type, title, content: body, importance });
   const memory = created?.memory;
@@ -408,6 +469,7 @@ function applyMerge(d, service, snapshot, config = {}) {
 }
 
 function applyConflict(d, service, snapshot, config = {}) {
+  const language = langOf(config);
   // Epistemic trust (v0.4.5): when enabled, the observation side of a conflict
   // is preferred as winner over a subjective/inferred one.
   if (config.trustEpistemicWeighting === true) {
@@ -428,13 +490,84 @@ function applyConflict(d, service, snapshot, config = {}) {
     const loserNow = service.getById(d.loser);
     if (!winnerNow || !loserNow || loserNow.archived) return;
     service.update(d.winner, {
-      content: `${winnerNow.content}\n\n（已否决旧信息：${[...loserNow.content].slice(0, 100).join("")}）`
+      content: STR.supersededSuffix[language](winnerNow.content, [...loserNow.content].slice(0, 100).join(""))
     });
     service.setArchived(d.loser, true);
   });
   return { applied: 1, committed: { action: "conflict", winner: d.winner, loser: d.loser, count_before: 2, count_after: 1 } };
 }
 
+/**
+ * supersede（Issue #126，sleepActionSet="full"）：演进型重复——新版本取代旧版本。
+ * 与 conflict 的关键差别：**注记追加到 loser（被取代方）而不是 winner**。conflict
+ * 把"已否决旧信息"写进赢家正文，赢家因此被污染——这正是 #126 的原始抱怨；
+ * supersede 把可追溯性留在被归档的那一侧，赢家正文一字不动。
+ *
+ * 幂等：loser 已归档即视为该决策已落地（重放/并发不会重复追加注记或重复归档）。
+ */
+function applySupersede(d, service, snapshot, config = {}) {
+  const language = langOf(config);
+  // Epistemic trust（与 conflict 同款）：可信度更高的一侧优先作为取代方。
+  if (config.trustEpistemicWeighting === true) {
+    const pw = EPISTEMIC_PRIORITY[service.getById(d.winner)?.epistemic_status] ?? 0;
+    const pl = EPISTEMIC_PRIORITY[service.getById(d.loser)?.epistemic_status] ?? 0;
+    if (pl > pw) [d.winner, d.loser] = [d.loser, d.winner];
+  }
+  const winner = service.getById(d.winner);
+  const loser = service.getById(d.loser);
+  if (!winner || !loser) return "skipped";
+  if (loser.archived) return "skipped"; // 幂等重放：已经取代过了
+  service.transaction(() => {
+    casGuard(service, snapshot, [d.winner, d.loser]);
+    const winnerNow = service.getById(d.winner);
+    const loserNow = service.getById(d.loser);
+    if (!winnerNow || !loserNow || loserNow.archived) return;
+    service.update(d.loser, {
+      content: STR.supersededBySuffix[language](loserNow.content, winnerNow.title)
+    });
+    service.setArchived(d.loser, true);
+  });
+  return { applied: 1, committed: { action: "supersede", winner: d.winner, loser: d.loser, count_before: 2, count_after: 1 } };
+}
+
+/**
+ * differentiate（Issue #126，sleepActionSet="full"）：互补型重复——两条各自成立、
+ * 覆盖不同侧面，不该判输赢。双方都保留（不归档），各追加同一段差异注记；注记进
+ * 正文 → 进注入与 embedding → 下一轮不会再被判成重复（这是本动作存在的意义）。
+ *
+ * 注记由插件按 distinctions 渲染，**不让模型整段重写 content**（重写有篡改/丢失
+ * 风险）。幂等：注记已在正文里就不重复追加，否则同一决策重放会不断堆叠。
+ */
+function applyDifferentiate(d, service, snapshot, config = {}) {
+  const language = langOf(config);
+  const ids = Array.isArray(d.ids) ? d.ids : [];
+  const notes = (Array.isArray(d.distinctions) ? d.distinctions : [])
+    .filter((s) => typeof s === "string" && s.trim())
+    .map((s) => s.trim());
+  const marker = STR.differentiatedMarker[language](notes);
+  const alive = ids.filter((id) => {
+    const m = service.getById(id);
+    return m && !m.archived;
+  });
+  if (alive.length < 2) return "skipped"; // 缺一条即已处理/不可用（幂等）
+  if (alive.every((id) => String(service.getById(id)?.content ?? "").includes(marker))) {
+    return "skipped"; // 同一条决策重放：注记已存在
+  }
+  service.transaction(() => {
+    casGuard(service, snapshot, ids);
+    for (const id of ids) {
+      const m = service.getById(id);
+      if (!m || m.archived) continue;
+      if (String(m.content).includes(marker)) continue; // 单条已注记过
+      service.update(id, { content: `${m.content}${marker}` });
+    }
+  });
+  return {
+    applied: 1,
+    committed: { action: "differentiate", ids, count_before: ids.length, count_after: ids.length }
+  };
+}
+
 function applyUpdate(d, service, snapshot, config = {}) {
   const id = d.ids[0];
   const mem = service.getById(id);