@modusensus/dsh-mneme 0.14.0-beta.1 → 0.14.0-beta.2

package/src/dream/decisions.js

@@ -1,945 +1,945 @@
-import { STR, langOf } from "../lang.js";
-import { contentHashOf } from "../content-hash.js";
-
-// Issue #126：sleepActionSet="full" 时新增两个动作——supersede（演进：新版取代
-// 旧版）与 differentiate（互补：两条都留，各自保留原本的正文）。两者的校验与执行
-// 都复用既有 merge/conflict 的机制（winner/loser、casGuard、transaction、receipt）。
-// Issue #533 起 differentiate 不再改写正文，只落裁决账本——见 applyDifferentiate。
-// 调用方（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
-// = preferred. observation (measured) > inferred (derived) > subjective (guess).
-export const EPISTEMIC_PRIORITY = { observation: 3, inferred: 2, subjective: 1 };
-
-// Issue #104 方向 2：archive 类型护栏的长保留类型集合——这些类型的存在意义
-// 就是长期保存（踩坑记录、约束、用户偏好、挖掘出的模式），LLM 以「价值判断」
-// 类理由批量归档它们时误伤损失最大。conflict 裁决的败者归档不经过 archive
-// action（走 applyDecisions 的 conflict 分支），不受此护栏影响。
-const ARCHIVE_GUARDED_TYPES = new Set(["preference", "pattern", "rejected_solution", "constraint", "pitfall"]);
-// 「重复 / 过时」类理由的关键词（中英双语）。命中才允许归档长保留类型；
-// 词表宁可放宽也不误拦——护栏只跳过单条并落明细，不整单拒绝。
-const ARCHIVE_RATIONALE_RE = /重复|过时|陈旧|过期|已被取代|被取代|冗余|不再使用|旧版|废弃|stale|outdated|obsolete|dup(?:licate|licat)?|superseded|redundant|deprecated|expired|replaced/i;
-// Issue #522 评审：上面那张词表只认关键词，不认否定——「并不重复，只是主题相近」
-// 与 "not a duplicate" 都会命中「重复」/"duplicate" 子串。archive 护栏从 #104 起
-// 就带着这个洞（既有行为，改它会扩大范围，先记在这里），但 #521 给 merge 加的
-// 逃生门是本 PR 新开的口子，必须自己堵上：否定表述一票否决。第二轮评审又指出
-// 词表里「过时 / stale / outdated」同样是钥匙，只挡「重复」等于留了半边门——
-// 「并不过时，只是主题相近」照样能换到合并许可，所以否定词按整张词表铺开。
-const NEGATED_RATIONALE_RE = /(?:不|并不|不是|非)\s*(?:重复|过时|陈旧|过期|已被取代|被取代|冗余|旧版|废弃)|\b(?:not|no|isn't|is not|never)\s+(?:a\s+|an\s+)?(?:duplicat\w*|stale|outdated|obsolete|superseded|redundant|deprecated|expired|replaced)/i;
-
-// Issue #521：把 skipped[].error 归一化成可分组的原因。原样字符串不能直接
-// GROUP BY——前缀带 decision[N]: 序号，同一种原因会被拆成 N 组（#521 实测 280
-// 条被拆成 20 组），面板上看不出「一整类动作 100% 失败」。这里只剥三样东西：
-// 序号前缀、模型可控的引号文本、具体类型集合，其余措辞保持原样，好让人一眼
-// 认出是哪个判据。
-export function normalizeSkipReason(error) {
-  // 一条决策可能攒下多条错误，skipped[].error 用 "; " 把它们拼成一句（见下方
-  // skipped.push）。所以先按 decision[N]: 的边界切开、逐段归一化再拼回去——
-  // 原先的正则 ^ 锚定，只剥得掉第一个前缀，后面的 decision[1]: 会留在字符串
-  // 中间，聚合时又被拆成多组（#522 评审指出）。
-  // 抹引号必须排在切分之前：模型写的理由原文里可能正好含 "; decision[0]: "
-  // （引文、邮箱都算），先切分就会把这段自由文本切成独立的一段，而那一段不带
-  // 任何可识别的边界，后面对它无从下手。先抹掉引号里的内容，切分就只看得到
-  // 我们自己拼进去的分隔符。
-  return maskModelText(String(error ?? ""))
-    .split(/;\s*(?=decision\[\d+\]:\s*)/)
-    .map(normalizeSkipSegment)
-    .join("; ")
-    .trim();
-}
-
-// 引号内的内容一律是模型可控的：id、action 名、理由原文都由 JSON.stringify
-// 加引号，所以「引号内 = 不可信」是这里唯一的判据。成对的那段整段抹成占位符；
-// 万一剩下一个孤立引号（旧版把理由截到 60 字再拼进 error，可能正好断在字符串
-// 中间），从那里砍到结尾——宁可少一句尾巴，也不让记忆正文随 open 路由出网关。
-// 刻意不按「, got: 」这类分隔符猜边界（#522 三轮评审）：分隔符本身可能出现在
-// id 里（unknown id "a@b.c, got: x"），猜错就会把引号截断，脱敏反而失效。
-function maskModelText(text) {
-  return String(text ?? "")
-    .replace(/"(?:[^"\\]|\\.)*"/g, "\u0000")
-    .replace(/"(?:[\s\S])*$/, "\u0000")
-    .replace(/\u0000/g, '"…"');
-}
-
-// 单段归一化：剥序号前缀、丢掉已经抹空的自由文本尾巴、把具体类型集合抹成占位符。
-function normalizeSkipSegment(segment) {
-  return String(segment ?? "")
-    .replace(/^decision\[\d+\]:\s*/, "")
-    // 抹完之后「, got: "…"」是个固定字面量（maskModelText 的产物），可以整段
-    // 砍掉：它只说明「校验器当时回了一句理由」，内容已经不在字符串里了。
-    .replace(/,\s*got:\s*"…"$/, "")
-    // 类型集合同理，但单个类型名保留——「被拦的是哪一类」本身是有效信息
-    .replace(/\(([a-z_]+(?:,\s*[a-z_]+)+)\)/g, "(…)")
-    .trim();
-}
-
-// Issue #521：按归一化原因聚合 skipped，供面板直接显示。按 (action, reason)
-// 二元组计数——同一句原因在 merge 和 archive 上是两回事，混在一起会误导。
-export function summarizeSkipped(skipped) {
-  const buckets = new Map();
-  for (const item of Array.isArray(skipped) ? skipped : []) {
-    const reason = normalizeSkipReason(item?.error);
-    if (!reason) continue;
-    // #522 评审：action 也走白名单。这条聚合结果会随 open 路由出网关，放任意字符串
-    // 过去等于让上游的脏数据（或将来某个新字段）自己决定响应形状；不在枚举里的一律
-    // 归成空串，面板少显示一个动作标签，比显示一段来路不明的文本安全。
-    const action = ACTIONS.has(item?.action) ? item.action : "";
-    const key = action + "\u0000" + reason;
-    const bucket = buckets.get(key);
-    if (bucket) bucket.count += 1;
-    else buckets.set(key, { action, reason, count: 1 });
-  }
-  return [...buckets.values()].sort((a, b) => b.count - a.count || a.reason.localeCompare(b.reason));
-}
-
-/**
- * Validate a dream decision list against a snapshot of eligible memories.
- * @param decisions - LLM-produced decision list. In skipInvalid mode, invalid
- *   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}>,
- *   resolvedShortIds?: number}}
- */
-export function validateDecisions(decisions, snapshot, options = {}) {
-  const errors = [];
-  // Issue #89 回归修复（v0.6.9 / Issue #26 的 skipInvalid 路径原样移植，该路径
-  // 在 v0.7.11 重写中丢失）：skipInvalid 开启时，单条非法决策只跳过该条（记录
-  // 到 skipped、不 claim 任何 id），合法子集照常应用，调用方据此把 run 记为
-  // degraded。全局信号（update/create 上限、显式覆盖率下限）依旧整单拒绝——
-  // 刷爆上限或覆盖率不达标的输出是模型坏了，不是轻微 schema 漂移。
-  const skipped = [];
-  const survivors = [];
-  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;
-  // reflectionUpdateEnabled=false：update 在本次调用里不算合法动作。走与
-  // allowedActions 同一条单条跳过的通路（不是整单拒绝）——用户关掉的是「改写已有
-  // 记忆」这一种动作，模型多输出了几条 update 不该连带丢掉同批的 merge/archive。
-  // 与 prompt 侧后缀双闸：prompt 让模型别写，这里兜住模型仍然写了的情况。
-  const allowUpdate = options.allowUpdate !== false;
-  // 被用户开关关掉的动作单独计数：它们进 skipped（要留痕），但不该触发下面的
-  // 「全部跳过 = 模型坏了」整单拒绝——那是防幻觉 id / 截断输出的护栏，而这里是
-  // 用户自己关掉的动作。混在一起会让「只输出了 update」的一轮被判 failed、调度器
-  // 拿同一批输入重跑同一条必被拒的输出，无限循环。
-  let policySkipped = 0;
-  if (!Array.isArray(decisions)) {
-    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: [], 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()) {
-    const at = `decision[${index}]`;
-    // 单条校验错误先进 local：skipInvalid 模式下整条跳过，严格模式下才并入
-    // 全局 errors（沿用 v0.6.9 的双轨结构）。
-    const local = [];
-    let policyDisabled = false;
-    // 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 (allowedActions && !allowedActions.has(d.action)) {
-      // 动作本身合法，但不在当前档位允许的集合里（例如默认档收到 supersede）。
-      local.push(`${at}: action ${JSON.stringify(d.action)} not allowed in this mode`);
-    } else if (d.action === "update" && !allowUpdate) {
-      // reflectionUpdateEnabled=false：旧记忆永不被自动改写。这条要排在
-      // allowedActions 之后、update 字段校验之前——先判「这个动作本次不许用」，
-      // 再谈字段合不合规，否则同一条会同时报两个错、日志里读不出真实原因。
-      local.push(`${at}: update action is disabled (reflectionUpdateEnabled=false)`);
-      policyDisabled = true;
-    } else if (d.action === "conflict" || d.action === "supersede") {
-      if (!d.winner || !d.loser || d.winner === d.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 仍然必填：#533 之后
-      // 它不再写进正文，但仍是「模型确实做过分类」的唯一凭据，落进裁决账本供审计
-      // （空数组意味着模型只是偷懒输出了一条动作名，不该被记成已裁决）。
-      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,
-      // so it skips the claiming loop below; evidence is optional provenance
-      // (already filtered to real ids by the caller) and is stored in content.
-      if (typeof d.title !== "string" || !d.title.trim()) {
-        local.push(`${at}: create needs non-empty title`);
-      }
-      if (typeof d.content !== "string" || !d.content.trim()) {
-        local.push(`${at}: create needs non-empty content`);
-      }
-      if (d.importance !== undefined && (!Number.isInteger(d.importance) || d.importance < 1 || d.importance > 5)) {
-        local.push(`${at}: create importance must be an integer 1-5 when provided`);
-      }
-      if (typeof d.type !== "string" || !d.type.trim()) {
-        local.push(`${at}: create needs non-empty type`);
-      }
-    } else if (!Array.isArray(d.ids) || d.ids.length === 0) {
-      local.push(`${at}: ${d.action} needs non-empty ids`);
-    }
-    // update-specific field validation runs BEFORE claiming ids, so a failing
-    // update never pollutes the claimed set (which drives the "every id must
-    // appear in a decision" check below).
-    // Issue #104 方向 2：archive 类型护栏。长保留类型的 archive 决策必须携带
-    // 「重复 / 过时」类理由（提示词对 archive 的定义本就如此），「价值判断」类
-    // 理由（保持整洁、参考价值低……）不放行——单条跳过记 skipped（run 记
-    // degraded，明细进 dream_runs.skipped），绝不整单拒绝。未知 id 在下方通用
-    // 校验里另行报错，这里 snapshot.get 为 undefined 时跳过护栏判断。
-    if (local.length === 0 && d?.action === "archive") {
-      const guardedTypes = new Set();
-      for (const id of d.ids) {
-        const mem = snapshot.get(id);
-        if (mem && ARCHIVE_GUARDED_TYPES.has(mem.type)) guardedTypes.add(mem.type);
-      }
-      if (guardedTypes.size > 0 && !ARCHIVE_RATIONALE_RE.test(String(d.reason ?? ""))) {
-        local.push(`${at}: archive of long-retention type(s) ${[...guardedTypes].join(", ")} needs a duplicate/outdated rationale (重复/过时), got: ${JSON.stringify(String(d.reason ?? "").slice(0, 60))}`);
-      }
-    }
-    if (local.length === 0 && d?.action === "update") {
-      // 只能更新单条
-      if (!Array.isArray(d.ids) || d.ids.length !== 1) {
-        local.push(`${at}: update must target exactly one id`);
-      } else {
-        // 必须产生实际变化
-        const mem = snapshot.get(d.ids[0]);
-        const hasChange = (d.title !== undefined && d.title !== mem?.title)
-          || (d.content !== undefined && d.content !== mem?.content)
-          || (d.importance !== undefined && d.importance !== mem?.importance);
-        if (!hasChange) {
-          local.push(`${at}: update must change at least one field`);
-        } else if (mem?.type === "summary") {
-          // 不能更新 summary
-          local.push(`${at}: cannot update summary via update action`);
-        } else {
-          // 保护期：新建记忆不可立即被 update（可配置）
-          const ageHours = (Date.now() - new Date(mem?.created_at).getTime()) / 3600000;
-          if (ageHours < minAgeHours) {
-            local.push(`${at}: memory too young (< ${minAgeHours}h)`);
-          }
-        }
-      }
-    }
-    if (local.length === 0 && d && d.action !== "create") {
-      // seen 捕获同一条决策内的重复 id；claimed 只含先前存活决策的 id
-      // （被跳过的决策不 claim，其目标留给其它合法决策/隐式 keep）。
-      const seen = new Set();
-      for (const id of ids) {
-        const mem = snapshot.get(id);
-        if (!mem) {
-          local.push(`${at}: unknown id ${JSON.stringify(id)}`);
-        } else if (mem.archived || mem.type === "summary") {
-          local.push(`${at}: id ${JSON.stringify(id)} is archived or summary (not eligible)`);
-        }
-        if (claimed.has(id) || seen.has(id)) {
-          local.push(`${at}: id ${JSON.stringify(id)} claimed by multiple decisions`);
-        }
-        seen.add(id);
-      }
-      if (local.length === 0 && d.action === "merge") {
-        if (!d.keepSource || !d.ids.includes(d.keepSource)) {
-          local.push(`${at}: merge keepSource must be one of ids`);
-        }
-        if (typeof d.title !== "string" || !d.title.trim() || typeof d.content !== "string" || !d.content.trim()) {
-          local.push(`${at}: merge needs non-empty title and content`);
-        }
-        if (d.importance !== undefined && (!Number.isInteger(d.importance) || d.importance < 1 || d.importance > 5)) {
-          local.push(`${at}: merge importance must be an integer 1-5 when provided`);
-        }
-        // Merging across types would blur preference/project/decision boundaries
-        // in the injected context; the snapshot carries each entry's type.
-        // Issue #26 (P1)：默认禁止跨类型合并。用户显式开启 allowCrossTypeMerge
-        // 后放宽该检查，类型边界由用户自行承担。
-        const mergeTypes = new Set(d.ids.map((id) => snapshot.get(id)?.type));
-        if (mergeTypes.size > 1 && options.allowCrossTypeMerge !== true) {
-          local.push(`${at}: merge ids span multiple types (${[...mergeTypes].join(", ")})`);
-        }
-        // issue #339 / E8 考卷：merge 护栏（默认开，dreamMergeGuard）。巩固损耗
-        // 实测里 10/26 条被丢约束已归位 guarded 类型仍被 merge 吃掉——archive
-        // 护栏（上方）只挡 archive 不挡 merge，而 merge 的「更精炼摘要」恰是
-        // 约束失真的主通道。开启后被合并对象命中 ARCHIVE_GUARDED_TYPES 的
-        // merge 决策整条跳过（与 archive 护栏同款通道：skipInvalid 时 skipped
-        // 明细、严格模式整单拒绝）。
-        if (local.length === 0 && options.mergeGuard === true) {
-          const guardedTypes = new Set();
-          for (const id of d.ids) {
-            const mem = snapshot.get(id);
-            if (mem && ARCHIVE_GUARDED_TYPES.has(mem.type)) guardedTypes.add(mem.type);
-          }
-          // Issue #521：与上方 archive 护栏对齐——archive 早就允许「带重复/过时
-          // 理由」的长保留类型通过，merge 却一律拦死，于是一份真重复的
-          // preference 永远合不掉，而提示词还在催模型合并它们。实测（#521）46 轮
-          // 巩固里 280 条 merge 决策全被这条拦下、merge 恒为 0，模型每轮把同一
-          // 簇条目再提一次，满载 token 空转。逃生门条件与 archive 护栏同一条词表
-          // 且要求同类型（跨类型合并本就另受 allowCrossTypeMerge 约束，逃生门
-          // 不跟着放宽）。reason 只写「主题相近」不会命中词表——这是故意的：
-          // 相近不等于重复，只有确属重复/过时才值得牺牲两条独立表述。
-          const sameType = new Set(d.ids.map((id) => snapshot.get(id)?.type)).size === 1;
-          const reasonText = String(d.reason ?? "");
-          // #522 评审：词表命中还不够——「并不重复」「not a duplicate」也含关键词，
-          // 放它们过闸等于让模型用一句否认换来合并许可。否定表述直接判不重复。
-          const duplicated = !NEGATED_RATIONALE_RE.test(reasonText) && ARCHIVE_RATIONALE_RE.test(reasonText);
-          if (guardedTypes.size > 0 && !(sameType && duplicated)) {
-            local.push(`${at}: merge of long-retention type(s) ${[...guardedTypes].join(", ")} is blocked by dreamMergeGuard (needs a duplicate/outdated rationale, 重复/过时)`);
-          }
-        }
-      }
-    }
-    if (local.length > 0) {
-      if (skipInvalid) {
-        // 单条非法 → 跳过该决策，不 claim id（其目标记忆留给其它合法决策/隐式
-        // keep），并记录到 skipped 供调用方日志/审计。信息性跳过绝不写入全局
-        // errors，否则会误触发下方的整单拒绝。
-        //
-        // #534：除四键骨架外补三个「模型到底给没给」的布尔，把 skipped 从
-        // 「error 字符串」变成可计数的形状。作者实测 19 轮 17 轮整轮无效，但
-        // skipped 里只有一句错误串，事后无法判断模型是漏字段（merge 缺
-        // title/content）、还是字段给了但值不合规（has_* 为 true 仍报错）。
-        // 只加布尔不加原文：原文进 llm_audit_logs.metadata 与 dream_runs.raw_output，
-        // 这里保持每条记录足够小（skipped 会按轮累积进一行 JSON）。
-        if (policyDisabled) policySkipped++;
-        skipped.push({
-          index,
-          action: d?.action,
-          ids,
-          error: local.join("; "),
-          // true = 用户开关关掉了这个动作（不是模型输出有问题）。调用方据此区分
-          // 「这轮白跑」与「这轮输出坏了」。
-          ...(policyDisabled ? { policyDisabled: true } : {}),
-          has_keepSource: d?.keepSource !== undefined && d?.keepSource !== null,
-          has_title: typeof d?.title === "string" && d.title.trim().length > 0,
-          has_content: typeof d?.content === "string" && d.content.trim().length > 0
-        });
-      } else {
-        errors.push(...local);
-      }
-      continue;
-    }
-    if (d.action !== "create") {
-      for (const id of ids) claimed.add(id);
-    }
-    survivors.push(d);
-  }
-  // Cap update churn: too many edits in one cycle signals a runaway model.
-  // 全局信号——skipInvalid 模式下依旧整单拒绝（见函数头注释）。
-  const updateCount = survivors.filter((d) => d.action === "update").length;
-  if (updateCount > maxUpdatePerRun) {
-    errors.push(`too many update decisions: ${updateCount} > ${maxUpdatePerRun}`);
-  }
-  // Cap pattern minting per run (sleepMaxPatternPerRun passes through here).
-  const createCount = survivors.filter((d) => d.action === "create").length;
-  const maxCreatePerRun = options.maxCreatePerRun ?? 5;
-  if (createCount > maxCreatePerRun) {
-    errors.push(`too many create decisions: ${createCount} > ${maxCreatePerRun}`);
-  }
-  // Issue #104 方向 2：archive 批量上限——一次性大扫除（12 条互不相关主题被
-  // 批量归档）是失控信号，与 update 上限同一类全局闸门：skipInvalid 也不豁免，
-  // 超限整单拒绝；正常的大规模清理由用户调高 dreamMaxArchivePerRun。
-  const archiveCount = survivors.filter((d) => d.action === "archive").length;
-  const maxArchivePerRun = options.maxArchivePerRun ?? 8;
-  if (archiveCount > maxArchivePerRun) {
-    errors.push(`too many archive decisions: ${archiveCount} > ${maxArchivePerRun}`);
-  }
-  // merge 批量上限（#135 成本审计的派生护栏）。merge 是唯一**回吐正文**的动作：
-  // 每条 merge 都要求模型重新写出合并后的 content（实测 2113 条 merge 平均 550
-  // 字符/条），而 archive/keep/conflict 都不带正文——所以单轮 merge 数是「输出
-  // 里正文占比」唯一可控的杠杆（实测 dream_consolidate 的输出 token 只有约 11.8%
-  // 是决策正文，其余是推理与 JSON 骨架，那部分由 effort 决定、与本闸无关）。
-  // 与 update/create/archive 三道闸同类：全局闸门，skipInvalid 也不豁免，超限整单
-  // 拒绝。默认值取 40 的校准依据（只读探针，全库 246 轮 / 近 10 天 88 轮）：
-  // 每轮 merge 数 全库 p50 7 / p90 15 / p99 28 / max 39，近 10 天 p50 9 / p90 20 /
-  // p99 39 / max 39 —— 40 是观测分布的上沿（历史命中 0/246），与 archive 闸默认 8
-  // 恰为其 p90=max 同一校准法：这是面向未来的尾险护栏，不是成本削减工具（现有三
-  // 道闸在实测分布下命中率均为 0.0%，同一性质）。刻意不取更小的值：超限的代价
-  // 不对称——整单拒绝 = run 记 failed = 调度器不刷新 baseline（src/dream.js:905-915）
-  // = 下一次写入用同一批输入重跑，一次误伤约等于该轮成本 ×2；而探针里 merge≥15 的
-  // 大轮正文/显式决策比例都正常（10~22%），没有失控特征。想用覆盖换成本的用户可
-  // 自行调低 dreamMaxMergePerRun。
-  const mergeCount = survivors.filter((d) => d.action === "merge").length;
-  const maxMergePerRun = options.maxMergePerRun ?? 40;
-  if (mergeCount > maxMergePerRun) {
-    errors.push(`too many merge decisions: ${mergeCount} > ${maxMergePerRun}`);
-  }
-  // Issue #89 防洗白核心（#104 方向 1 重审后保留）：全部决策都被跳过、合法
-  // 子集为空时仍整单拒绝——宽容的前提是「有合法子集可应用」；模型输出整体
-  // 非法（如全部幻觉 id）是真故障，不能被隐式 keep 洗成 ok。#104 只豁免
-  // 「有合法子集但覆盖率不足」的良性挑重点（见下方 coverageShortfall）。
-  // 只把「非策略性跳过」算进这条：policySkipped 是用户关掉的动作，不是模型故障。
-  const modelSkipped = skipped.length - policySkipped;
-  if (options.skipInvalid === true && modelSkipped > 0 && survivors.length === 0 && errors.length === 0) {
-    errors.push(`all ${skipped.length} decision(s) invalid — nothing valid survived validation`);
-    return { ok: false, errors, skipped, resolvedShortIds };
-  }
-  // v0.4.4: 隐式 keep。默认（dreamImplicitKeep !== false）下，未 claim 的
-  // snapshot 记忆自动补 {action:"keep"}，而不是整体拒绝——大记忆量下 LLM 漏报
-  // 一两条就全拒（636 记忆 → 677 errors）会白白浪费整轮 run。设 false 则保留
-  // 旧的严格"全量覆盖"校验。补齐的 keep 直接 append 到 decisions，调用方
-  // （runDream/applyDecisions/audit）复用同一数组即可覆盖全部 snapshot 记忆。
-  //
-  // v0.4.4 fix（残缺输出防洗白）→ Issue #104 方向 1 重审：显式覆盖率护栏的
-  // 初衷是拦「输出截断 → 只 claim 少量 → 其余被隐式 keep 洗白」，但它无法区分
-  // 恶性截断与良性挑重点——而提示词硬性规则本身要求「无问题的条目无需输出」，
-  // 挑重点正是要求的行为。官方路由 + 强模型的实测（heptaspirit：81 轮 failed
-  // 全是 coverage，LLM 调用本身成功、applied=0）证明这是常规路径而非边角。
-  // 处置：覆盖率不足不再 ok:false 整单拒绝，改为返回 coverageShortfall 理由、
-  // 照常补齐隐式 keep——调用方把 run 记 degraded（合法子集已应用），护栏以
-  // 状态暴露而非一票否决，与 skipInvalid 同一宽容哲学。明确异常信号（create
-  // 上限等硬错误）保持整单拒绝。要恢复旧行为可设 dreamImplicitKeep:false
-  // （严格模式，缺失即 error）或 dreamMinExplicitCoverage: 0（关护栏）。
-  // 非覆盖类硬错误（create 上限溢出、严格模式缺失 id）仍然先整单拒绝——
-  // #104 方向 1 只豁免 coverage 这一个信号，防洗白语义对它们原样保留。
-  if (errors.length > 0) {
-    return { ok: false, errors, skipped, resolvedShortIds };
-  }
-  const minCoverage = options.dreamMinExplicitCoverage ?? 0.5;
-  let coverageShortfall = null;
-  if (options.dreamImplicitKeep !== false) {
-    const coverage = snapshot.size > 0 ? claimed.size / snapshot.size : 1;
-    if (coverage < minCoverage) {
-      coverageShortfall = `explicit decision coverage ${Math.round(coverage * 100)}% < minimum ${Math.round(minCoverage * 100)}%`;
-    }
-    for (const id of snapshot.keys()) {
-      if (!claimed.has(id)) survivors.push({ action: "keep", ids: [id] });
-    }
-  } else {
-    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, resolvedShortIds };
-  }
-  // 调用方下游（apply/audit）复用同一 decisions 引用：就地同步为 survivors——
-  // 在 skipInvalid 模式下去掉被跳过的非法决策；在隐式 keep 下追加补齐的 keep。
-  // 不能以 survivors.length !== decisions.length 作为是否 splice 的判据：
-  // 当"被跳过的非法决策数 == 隐式补齐的 keep 数"时长度回到相等但内容已变，
-  // 被跳过的决策会残留进 apply/audit。一律无条件 splice 最安全。
-  decisions.splice(0, decisions.length, ...survivors);
-  return { ok: true, errors, skipped, resolvedShortIds, coverageShortfall };
-}
-
-/** Marker thrown when a decision target changed since the run snapshot. */
-export class CasConflictError extends Error {
-  constructor(action, ids, reason) {
-    super(`cas conflict: ${action} targets changed since snapshot (${reason})`);
-    this.name = "CasConflictError";
-    this.action = action;
-    this.ids = ids;
-  }
-}
-
-function decisionIds(d) {
-  return d.action === "conflict" || d.action === "supersede" ? [d.winner, d.loser] : (d.ids ?? []);
-}
-
-/**
- * CAS guard (item ①): every target memory must still match what the run
- * snapshot captured — otherwise the decision was computed against stale state
- * and applying it would overwrite a concurrent edit. Snapshotless replays skip
- * the guard entirely (per-action idempotency checks handle those). Throws
- * CasConflictError on the first mismatch; the caller's transaction rolls back.
- */
-function casGuard(service, snapshot, ids) {
-  if (!snapshot) return;
-  for (const id of ids) {
-    const expect = snapshot.get(id);
-    if (!expect) continue; // not in snapshot: validated elsewhere, skip guard
-    const current = service.getById(id);
-    if (!current) {
-      throw new CasConflictError("deleted", [id], `memory ${id} was removed`);
-    }
-    const changed = expect.updated_at !== undefined
-      ? current.updated_at !== expect.updated_at
-      : current.content !== expect.content || current.title !== expect.title;
-    if (changed) {
-      throw new CasConflictError(
-        "changed",
-        [id],
-        `memory ${id} was concurrently modified (expected updated_at=${expect.updated_at}, got ${current.updated_at})`
-      );
-    }
-  }
-}
-
-/**
- * Apply a validated decision list to the service. Caller must validate first.
- * Each decision runs inside its own SQLite transaction (item ②): the multi-step
- * mutation of a decision is atomic, so a merge can never leave "keeper updated
- * but source not archived" or vice versa — a throwing sub-step rolls the whole
- * decision back.
- *
- * @param decisions - validated decision list.
- * @param service - memory service (saveWithDedupe/getById/update/setArchived/transaction).
- * @param logger - optional logger ({ warn }); per-decision failures are logged.
- * @param snapshot - optional Map<id, memory> captured before the LLM call; when
- *   provided, every decision target is CAS-checked against it and a decision
- *   computed from stale state is skipped and reported as a conflict instead of
- *   overwriting concurrent writes (item ①).
- * @param config - pipeline config; `config.mintSource` (optional string) is the
- *   provenance stamped on memories minted by `create` decisions. It is
- *   read from the CALLER, never from the decision object: the LLM authors
- *   `create` payloads and validateDecisions does not strip unknown fields, so
- *   trusting `d.source` would let a model label its own output as human-written.
- *   Absent/blank → saveWithDedupe's existing "manual" fallback (unchanged).
- * @returns {{ applied: number, conflicts: Array, failures: Array, committed: Array }}
- *   applied    - number of decisions/memories actually committed (archive counts
- *                each archived memory as one, merge/conflict/update count one).
- *   conflicts  - decisions skipped because a target changed since the snapshot.
- *   failures   - decisions that threw mid-transaction (fully rolled back).
- *   committed  - the decisions that actually landed, for outcome/receipt based
- *                on real committed sub-steps rather than the raw LLM list.
- */
-export function applyDecisions(decisions, service, logger = null, snapshot = null, config = {}) {
-  let applied = 0;
-  let merged = 0;
-  const conflicts = [];
-  const failures = [];
-  const committed = [];
-  for (const [i, d] of decisions.entries()) {
-    try {
-      // keep is a confirmed no-op: it commits nothing but still records the
-      // per-id disposition so the outcome covers every snapshot memory.
-      if (d.action === "keep") {
-        committed.push({ action: "keep", ids: d.ids });
-        continue;
-      }
-      const outcome = applyOne(d, service, snapshot, config, logger);
-      if (outcome === "skipped") continue;
-      applied += outcome.applied;
-      // `merged` counts creates that hit a same-title row instead of minting a
-      // new one. Kept apart from `applied` on purpose: a create that vanished
-      // into an existing row is not a new conclusion, and folding it in is how
-      // two different dispositions ended up looking like two minted patterns
-      // (#619 audit round 5).
-      if (outcome.merged) merged += outcome.merged;
-      committed.push(outcome.committed);
-    } catch (error) {
-      if (error instanceof CasConflictError) {
-        conflicts.push({ index: i, action: d.action, ids: error.ids, reason: error.message });
-        logger?.warn?.(`dsh-mneme dream: ${error.message}`);
-      } else {
-        failures.push({ index: i, action: d.action, ids: decisionIds(d), reason: error.message });
-        logger?.warn?.(`dsh-mneme dream: failed to apply ${d.action} at index ${i}: ${error.message}`);
-      }
-    }
-  }
-  return { applied, merged, conflicts, failures, committed };
-}
-
-function applyOne(d, service, snapshot, config = {}, logger = null) {
-  switch (d.action) {
-    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, logger);
-    default: return applyUpdate(d, service, snapshot, config);
-  }
-}
-
-/**
- * Highest-epistemic-priority UNARCHIVED id among `ids` (ties break toward
- * `preferred`). Archived memories are never eligible keepers — promoting one
- * would demote the real keepSource to a source and then hit the archived-keeper
- * guard in applyMerge, silently skipping the whole merge. When `preferred`
- * itself is archived (or missing), fall back to any unarchived candidate.
- */
-function pickBestKeeper(ids, preferred, service) {
-  let best = null;
-  let bestP = -1;
-  for (const id of ids) {
-    const mem = service.getById(id);
-    if (!mem || mem.archived) continue; // archived/missing: ineligible keeper
-    const p = EPISTEMIC_PRIORITY[mem.epistemic_status] ?? 0;
-    if (p > bestP || (p === bestP && id === preferred)) {
-      bestP = p;
-      best = id;
-    }
-  }
-  return best ?? preferred;
-}
-
-/**
- * Mint a fresh memory (pattern discovery). No existing target, so no CAS guard.
- * Evidence ids ride in the content so a pattern stays traceable to its source
- * memories. saveWithDedupe dedupes identical mints (idempotent replay-safe).
- */
-function applyCreate(d, service, config = {}, logger = null) {
-  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;
-  const type = typeof d.type === "string" ? d.type : "pattern";
-  const evidence = Array.isArray(d.evidence)
-    ? d.evidence.filter((id) => typeof id === "string")
-    : [];
-  const body = evidence.length > 0
-    ? STR.evidenceSuffix[language](content, evidence)
-    : content;
-  // mint 来源由调用方（管道）给，不从决策对象取——LLM 能自己写 d.source，
-  // 信它就等于让模型给自造条目盖「人写的」戳（见 applyDecisions 的 @param config）。
-  // 取不到就一个字段都不传，落回 saveWithDedupe 原有的兜底，行为与改前一致。
-  const mintSource = typeof config?.mintSource === "string" ? config.mintSource.trim() : "";
-  // pattern 是「整句重写」而不是「增量补充」：同一 (人, 对象, 情绪) 的标题天然
-  // 相同，saveWithDedupe 命中后若走 appendContent，重放一轮就把同一段结论再粘
-  // 一遍（实测 161 → 355 → 549 字，外加一串重复的 [证据: …] 尾巴），而 pattern
-  // 正是注入面消费的东西。`_overwrite` 是既有逃生口（bootstrap / dream summary /
-  // narrative 三处先例）：命中同题行时原地刷新而不是追加，旧文进 content_history。
-  // 只对 pattern 放开——其他类型被 create 撞上同题行时仍按合并语义走，那多半是
-  // 模型自造了不该出现的类型，把既有行整段覆盖掉比追加更危险。
-  const overwrite = type === "pattern";
-  const created = service.saveWithDedupe({
-    type,
-    title,
-    content: body,
-    importance,
-    ...(mintSource ? { source: mintSource } : {}),
-    ...(overwrite ? { _overwrite: true } : {})
-  });
-  const memory = created?.memory;
-  if (!memory) return "skipped"; // deduped/subsumed: nothing minted, clean no-op
-  // 命中同题活跃行 ⇒ saveWithDedupe 返回 action:"merged"。它确实动过库（刷新了
-  // 那一行），但**没有铸出新条目**：把它算进 applied 会让「一条真实结论被同题行
-  // 吃掉了」这种情况看起来像成功（#619 审计第五轮：两个不同对象铸出同一条
-  // pattern，applied 照样报 2）。两类结局分开报：applied 只数新铸，merged 数刷新。
-  const refreshed = created?.action !== "created";
-  // #512：这条记忆出生自哪一轮。只记 create——merge/conflict/update/supersede 对
-  // 既有行的改动已由 receipt_chain 按 (run_id, record_id) 记账，再造一份就是第二套账。
-  //
-  // #619 / Ephor 第七轮 ③：`refreshed` 也在这条规矩里。原地刷新没有铸新条目，
-  // 它改的是既有行——同一条记忆不该有两份「出生记录」。此前 create_merged 这条
-  // 新路没被上面那句规矩覆盖，于是一个 pattern 跑两轮，`memory_mints` 就有两行、
-  // run_id 各不相同，面板上显示成「这条记忆出生过两次」（`mintsFor` 由
-  // provenance-http.js 读取）。live 库当时还没显形，是因为同题刷新刚上线。
-  //
-  // 记账失败不许拖垮这次铸造：归因是审计，记忆已经落盘了。
-  try {
-    if (!refreshed && typeof service?.saveMemoryMint === "function" && config?.runId) {
-      service.saveMemoryMint({
-        memoryId: memory.id,
-        runId: config.runId,
-        runType: config.mintSource === "sleep" ? "sleep" : "dream",
-        triggerSource: config.mintSource === "sleep" ? "sleep" : "autoDream",
-        createdAt: new Date().toISOString()
-      });
-    }
-  } catch (mintError) {
-    logger?.warn?.(`dsh-mneme dream: failed to record memory mint: ${String(mintError?.message ?? mintError)}`);
-  }
-  return { applied: refreshed ? 0 : 1, merged: refreshed ? 1 : 0, committed: { action: refreshed ? "create_merged" : "create", id: memory.id, type } };
-}
-
-function applyArchive(d, service, snapshot) {
-  const targets = d.ids.filter((id) => {
-    const mem = service.getById(id);
-    return mem && !mem.archived; // existing, not-yet-archived rows only
-  });
-  if (targets.length === 0) return "skipped"; // all already archived: idempotent replay
-  service.transaction(() => {
-    casGuard(service, snapshot, d.ids);
-    for (const id of d.ids) {
-      const mem = service.getById(id);
-      if (mem && !mem.archived) service.setArchived(id, true);
-    }
-  });
-  return { applied: targets.length, committed: { action: "archive", ids: targets } };
-}
-
-function applyMerge(d, service, snapshot, config = {}) {
-  // Epistemic trust (v0.4.5): when enabled, prefer an observation keeper over a
-  // subjective/inferred one. Mutating the decision keeps the receipt + committed
-  // record aligned with the actual keeper.
-  if (config.trustEpistemicWeighting === true) {
-    const best = pickBestKeeper(d.ids, d.keepSource, service);
-    if (best && best !== d.keepSource) d.keepSource = best;
-  }
-  const sources = d.ids.filter((id) => id !== d.keepSource);
-  // Idempotent replay: if every other source is already archived, this merge
-  // already landed — skip so a replayed/concurrent decision never double-counts
-  // or re-applies (guard against duplicate merges).
-  if (sources.every((id) => service.getById(id)?.archived)) return "skipped";
-  service.transaction(() => {
-    casGuard(service, snapshot, d.ids);
-    const keeper = service.getById(d.keepSource);
-    if (!keeper || keeper.archived) return; // missing keeper: no write, still a clean commit
-    service.update(d.keepSource, {
-      title: d.title,
-      content: d.content,
-      importance: d.importance ?? Math.max(keeper.importance, ...d.ids.map((id) => service.getById(id)?.importance ?? 1))
-    });
-    for (const id of sources) {
-      const mem = service.getById(id);
-      if (mem && !mem.archived) service.setArchived(id, true);
-    }
-    // 4.3.2 迁移实体关联（opt-in）：将 loser（source）记忆关联的 entity_attrs 的
-    // memory_id 迁移到 keeper；keeper 已有同 entity+key 的当前属性时 loser 行被
-    // 失效。单个 source 迁移失败只告警，绝不能导致整个 merge 事务回滚（fail-safe）。
-    if (config.entityExtractionEnabled && typeof service.migrateAttrsToMemory === "function") {
-      for (const id of sources) {
-        try {
-          service.migrateAttrsToMemory(id, d.keepSource, new Date().toISOString());
-        } catch (error) {
-          logger?.warn?.(`dsh-mneme dream: failed to migrate attrs from ${id} to ${d.keepSource}: ${error.message}`);
-        }
-      }
-    }
-  });
-  return {
-    applied: 1,
-    committed: { action: "merge", ids: d.ids, keepSource: d.keepSource, title: d.title, content: d.content, importance: d.importance, count_before: d.ids.length, count_after: 1 }
-  };
-}
-
-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) {
-    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";
-  // Idempotent replay: an already-archived loser means the conflict was already
-  // adjudicated — skip so the provenance note is never re-appended and the loser
-  // is not re-archived.
-  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.winner, {
-      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 #641 enforce 档的 T1 处置，供 sleep/dream
- * 两条链路共用）。与冻结分支自动裁决档（#603 第 4 层，sleep.js 内联实现）同一
- * 条契约，本函数是它的共享出口：
- *   · 保留**信息量更大**的那条，不是更新的——#616 实测 55-57% 的新条反而更短
- *     （蒸馏压缩过的一版常常更新），留新条等于把更完整的那条归档掉；
- *   · 长度相同才退回 updated_at，再退回 id——三级兜底保证同一对每次判出同一个
- *     赢家（重放不翻面）；
- *   · trustEpistemicWeighting 显式关：自动处置的承诺必须是确定的，可信度换位
- *     不让结果随 epistemic_status 数据漂移；
- *   · 赢家正文一字不动——supersede 的可追溯注记落在被归档侧（#126 原设计）。
- *     E13b 证明 conflict 动作的「败者前 100 字追加进赢家」是值级泄漏通道，
- *     确定性处置一律走 supersede、不走 conflict。
- * CAS 快照 + 事务 + 幂等（败者已归档 → applied 0）全部沿用 applyDecisions，
- * 不另写第二份裁决路径。
- *
- * @param {{a: object, b: object}} p 候选对（完整记忆行：id/title/content/updated_at）
- * @returns {{applied: boolean, winnerId: string, loserId: string, winner: object, loser: object}}
- */
-export function supersedeInfoFirstPair(p, service, logger = null, config = {}) {
-  const an = p.a.content?.length ?? 0;
-  const bn = p.b.content?.length ?? 0;
-  const [winner, loser] = an !== bn
-    ? (an > bn ? [p.a, p.b] : [p.b, p.a])
-    : (p.a.updated_at ?? "") !== (p.b.updated_at ?? "")
-      ? ((p.a.updated_at ?? "") > (p.b.updated_at ?? "") ? [p.a, p.b] : [p.b, p.a])
-      : (p.a.id > p.b.id ? [p.a, p.b] : [p.b, p.a]);
-  const snapshot = new Map();
-  for (const m of [winner, loser]) {
-    snapshot.set(m.id, { updated_at: m.updated_at, content: m.content, title: m.title });
-  }
-  const { applied } = applyDecisions(
-    [{ action: "supersede", winner: winner.id, loser: loser.id }],
-    service, logger, snapshot, { ...config, trustEpistemicWeighting: false }
-  );
-  return { applied: applied > 0, winnerId: winner.id, loserId: loser.id, winner, loser };
-}
-
-/**
- * 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"）：互补型重复——两条各自成立、
- * 覆盖不同侧面，不该判输赢。双方都保留（不归档），**正文一个字节都不动**。
- *
- * 为什么不动正文（Issue #533）：#126 的原设计是「双方各追加同一段差异注记，注记
- * 进正文 → 进注入与 embedding → 下一轮就不会再被判成重复」。离线复现证伪了这个
- * 假设——两侧共享同一段后缀会让两条向量**同向靠拢**，余弦一轮比一轮高（0.876 →
- * 0.960 只用了 5 轮，把注记截到 0 字照样往上爬，因为推高相似度的是共享前缀本身而
- * 不是注记长短），于是同一对下一轮又被判成重复、又追加一段，实测单条堆到 19 段。
- * 现在的裁决落在 differentiated_pairs 账本（src/store.js）里：候选构造阶段读它，
- * 已裁决且两侧正文都没改过就不再送模型，正文保持干净。
- *
- * 幂等三层，从便宜到贵：
- *   1. 一侧已归档 → skipped（缺一条就没什么可区分的）；
- *   2. 存量兼容：两侧正文都还带着旧版注记块 → skipped（升级不清账）；
- *   3. 账本命中且两侧 content hash 与记账时一致 → skipped（真正的幂等重放）。
- * 任一侧后来被改写 → hash 对不上 → 重新裁决，宁可再判一次也不静音真的演化。
- */
-function applyDifferentiate(d, service, snapshot, config = {}) {
-  const ids = Array.isArray(d.ids) ? d.ids : [];
-  const alive = ids.filter((id) => {
-    const m = service.getById(id);
-    return m && !m.archived;
-  });
-  if (alive.length < 2) return "skipped"; // 缺一条即已处理/不可用（幂等）
-  const hashes = new Map(alive.map((id) => [id, contentHashOf(service.getById(id))]));
-  const [a, b] = alive.slice(0, 2);
-  const record = typeof service.findDifferentiatedPair === "function"
-    ? service.findDifferentiatedPair(a, b)
-    : undefined;
-  if (record) {
-    // 记账时 a/b 是按 id 排序存的，hash 也跟着换位，这里同样按排序取值比对。
-    const [ha, hb] = a <= b ? [hashes.get(a), hashes.get(b)] : [hashes.get(b), hashes.get(a)];
-    if (record.hash_a === ha && record.hash_b === hb) return "skipped";
-  } else {
-    // 存量库兼容：旧版本把注记写进了正文，那些行没有账本行。两侧都还带着注记块
-    // 才认定「已裁决过」——只有一侧有，说明另一侧后来被改写，应当重判。
-    const noted = alive.filter((id) => STR.differentiatedNoteRe.test(String(service.getById(id)?.content ?? "")));
-    if (noted.length >= 2) return "skipped";
-  }
-  // 账本缺席（人工确认路径的裸 service）就什么都不写：正文一字不动本来就是本动作
-  // 的全部副作用，没有账本就只剩「这条决策无处落地」，不是错误，也不是 applied。
-  if (typeof service.saveDifferentiatedPair !== "function") return "skipped";
-  service.transaction(() => {
-    casGuard(service, snapshot, ids);
-    const [ia, ib] = alive.slice(0, 2);
-    service.saveDifferentiatedPair({
-      run_id: config.runId,
-      memory_a: ia,
-      memory_b: ib,
-      // hash 取**执行时**的正文（不是送审时），与账本里下一次比对的口径同源。
-      hash_a: hashes.get(ia),
-      hash_b: hashes.get(ib),
-      // 模型给的差异点也落账：正文不再写注记，这些就是「当初为什么判互补」的唯一凭据。
-      distinctions: (Array.isArray(d.distinctions) ? d.distinctions : [])
-        .filter((x) => typeof x === "string" && x.trim())
-        .map((x) => x.trim())
-    });
-  });
-  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);
-  if (!mem || mem.archived) return "skipped";
-  // 幂等检查：如果字段已与目标一致则跳过
-  const same = (d.title === undefined || d.title === mem.title)
-    && (d.content === undefined || d.content === mem.content)
-    && (d.importance === undefined || d.importance === mem.importance);
-  if (same) return "skipped";
-  service.transaction(() => {
-    casGuard(service, snapshot, [id]);
-    const cur = service.getById(id);
-    if (!cur || cur.archived) return;
-    service.update(id, {
-      title: d.title ?? cur.title,
-      content: d.content ?? cur.content,
-      importance: d.importance ?? cur.importance
-    });
-  });
-  // 4.3.1 supersedes 关系（opt-in）：事务提交成功后，为该记忆关联的每条实体属性
-  // 建立自引用 supersedes 关系，表示"此属性版本已被替代"。仅记录、绝不阻断主流程
-  // （fail-safe）：记录失败只告警，update 本身照常生效。
-  if (config.entityExtractionEnabled && typeof service.saveRelation === "function" && typeof service.getAttrsByMemory === "function") {
-    try {
-      const oldAttrs = service.getAttrsByMemory(id);
-      for (const attr of oldAttrs) {
-        if (!attr.entity_id) continue;
-        service.saveRelation({
-          from_entity: attr.entity_id,
-          to_entity: attr.entity_id,
-          relation_type: "supersedes",
-          memory_id: id,
-          metadata: JSON.stringify({ attr_key: attr.attr_key, old_value: attr.attr_value })
-        });
-      }
-    } catch (error) {
-      logger?.warn?.(`dsh-mneme dream: failed to record supersedes relations for ${id}: ${error.message}`);
-    }
-  }
-  return { applied: 1, committed: { action: "update", ids: [id], title: d.title, content: d.content, importance: d.importance, count_before: 1, count_after: 1 } };
-}
+import { STR, langOf } from "../lang.js";
+import { contentHashOf } from "../content-hash.js";
+
+// Issue #126：sleepActionSet="full" 时新增两个动作——supersede（演进：新版取代
+// 旧版）与 differentiate（互补：两条都留，各自保留原本的正文）。两者的校验与执行
+// 都复用既有 merge/conflict 的机制（winner/loser、casGuard、transaction、receipt）。
+// Issue #533 起 differentiate 不再改写正文，只落裁决账本——见 applyDifferentiate。
+// 调用方（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
+// = preferred. observation (measured) > inferred (derived) > subjective (guess).
+export const EPISTEMIC_PRIORITY = { observation: 3, inferred: 2, subjective: 1 };
+
+// Issue #104 方向 2：archive 类型护栏的长保留类型集合——这些类型的存在意义
+// 就是长期保存（踩坑记录、约束、用户偏好、挖掘出的模式），LLM 以「价值判断」
+// 类理由批量归档它们时误伤损失最大。conflict 裁决的败者归档不经过 archive
+// action（走 applyDecisions 的 conflict 分支），不受此护栏影响。
+const ARCHIVE_GUARDED_TYPES = new Set(["preference", "pattern", "rejected_solution", "constraint", "pitfall"]);
+// 「重复 / 过时」类理由的关键词（中英双语）。命中才允许归档长保留类型；
+// 词表宁可放宽也不误拦——护栏只跳过单条并落明细，不整单拒绝。
+const ARCHIVE_RATIONALE_RE = /重复|过时|陈旧|过期|已被取代|被取代|冗余|不再使用|旧版|废弃|stale|outdated|obsolete|dup(?:licate|licat)?|superseded|redundant|deprecated|expired|replaced/i;
+// Issue #522 评审：上面那张词表只认关键词，不认否定——「并不重复，只是主题相近」
+// 与 "not a duplicate" 都会命中「重复」/"duplicate" 子串。archive 护栏从 #104 起
+// 就带着这个洞（既有行为，改它会扩大范围，先记在这里），但 #521 给 merge 加的
+// 逃生门是本 PR 新开的口子，必须自己堵上：否定表述一票否决。第二轮评审又指出
+// 词表里「过时 / stale / outdated」同样是钥匙，只挡「重复」等于留了半边门——
+// 「并不过时，只是主题相近」照样能换到合并许可，所以否定词按整张词表铺开。
+const NEGATED_RATIONALE_RE = /(?:不|并不|不是|非)\s*(?:重复|过时|陈旧|过期|已被取代|被取代|冗余|旧版|废弃)|\b(?:not|no|isn't|is not|never)\s+(?:a\s+|an\s+)?(?:duplicat\w*|stale|outdated|obsolete|superseded|redundant|deprecated|expired|replaced)/i;
+
+// Issue #521：把 skipped[].error 归一化成可分组的原因。原样字符串不能直接
+// GROUP BY——前缀带 decision[N]: 序号，同一种原因会被拆成 N 组（#521 实测 280
+// 条被拆成 20 组），面板上看不出「一整类动作 100% 失败」。这里只剥三样东西：
+// 序号前缀、模型可控的引号文本、具体类型集合，其余措辞保持原样，好让人一眼
+// 认出是哪个判据。
+export function normalizeSkipReason(error) {
+  // 一条决策可能攒下多条错误，skipped[].error 用 "; " 把它们拼成一句（见下方
+  // skipped.push）。所以先按 decision[N]: 的边界切开、逐段归一化再拼回去——
+  // 原先的正则 ^ 锚定，只剥得掉第一个前缀，后面的 decision[1]: 会留在字符串
+  // 中间，聚合时又被拆成多组（#522 评审指出）。
+  // 抹引号必须排在切分之前：模型写的理由原文里可能正好含 "; decision[0]: "
+  // （引文、邮箱都算），先切分就会把这段自由文本切成独立的一段，而那一段不带
+  // 任何可识别的边界，后面对它无从下手。先抹掉引号里的内容，切分就只看得到
+  // 我们自己拼进去的分隔符。
+  return maskModelText(String(error ?? ""))
+    .split(/;\s*(?=decision\[\d+\]:\s*)/)
+    .map(normalizeSkipSegment)
+    .join("; ")
+    .trim();
+}
+
+// 引号内的内容一律是模型可控的：id、action 名、理由原文都由 JSON.stringify
+// 加引号，所以「引号内 = 不可信」是这里唯一的判据。成对的那段整段抹成占位符；
+// 万一剩下一个孤立引号（旧版把理由截到 60 字再拼进 error，可能正好断在字符串
+// 中间），从那里砍到结尾——宁可少一句尾巴，也不让记忆正文随 open 路由出网关。
+// 刻意不按「, got: 」这类分隔符猜边界（#522 三轮评审）：分隔符本身可能出现在
+// id 里（unknown id "a@b.c, got: x"），猜错就会把引号截断，脱敏反而失效。
+function maskModelText(text) {
+  return String(text ?? "")
+    .replace(/"(?:[^"\\]|\\.)*"/g, "\u0000")
+    .replace(/"(?:[\s\S])*$/, "\u0000")
+    .replace(/\u0000/g, '"…"');
+}
+
+// 单段归一化：剥序号前缀、丢掉已经抹空的自由文本尾巴、把具体类型集合抹成占位符。
+function normalizeSkipSegment(segment) {
+  return String(segment ?? "")
+    .replace(/^decision\[\d+\]:\s*/, "")
+    // 抹完之后「, got: "…"」是个固定字面量（maskModelText 的产物），可以整段
+    // 砍掉：它只说明「校验器当时回了一句理由」，内容已经不在字符串里了。
+    .replace(/,\s*got:\s*"…"$/, "")
+    // 类型集合同理，但单个类型名保留——「被拦的是哪一类」本身是有效信息
+    .replace(/\(([a-z_]+(?:,\s*[a-z_]+)+)\)/g, "(…)")
+    .trim();
+}
+
+// Issue #521：按归一化原因聚合 skipped，供面板直接显示。按 (action, reason)
+// 二元组计数——同一句原因在 merge 和 archive 上是两回事，混在一起会误导。
+export function summarizeSkipped(skipped) {
+  const buckets = new Map();
+  for (const item of Array.isArray(skipped) ? skipped : []) {
+    const reason = normalizeSkipReason(item?.error);
+    if (!reason) continue;
+    // #522 评审：action 也走白名单。这条聚合结果会随 open 路由出网关，放任意字符串
+    // 过去等于让上游的脏数据（或将来某个新字段）自己决定响应形状；不在枚举里的一律
+    // 归成空串，面板少显示一个动作标签，比显示一段来路不明的文本安全。
+    const action = ACTIONS.has(item?.action) ? item.action : "";
+    const key = action + "\u0000" + reason;
+    const bucket = buckets.get(key);
+    if (bucket) bucket.count += 1;
+    else buckets.set(key, { action, reason, count: 1 });
+  }
+  return [...buckets.values()].sort((a, b) => b.count - a.count || a.reason.localeCompare(b.reason));
+}
+
+/**
+ * Validate a dream decision list against a snapshot of eligible memories.
+ * @param decisions - LLM-produced decision list. In skipInvalid mode, invalid
+ *   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}>,
+ *   resolvedShortIds?: number}}
+ */
+export function validateDecisions(decisions, snapshot, options = {}) {
+  const errors = [];
+  // Issue #89 回归修复（v0.6.9 / Issue #26 的 skipInvalid 路径原样移植，该路径
+  // 在 v0.7.11 重写中丢失）：skipInvalid 开启时，单条非法决策只跳过该条（记录
+  // 到 skipped、不 claim 任何 id），合法子集照常应用，调用方据此把 run 记为
+  // degraded。全局信号（update/create 上限、显式覆盖率下限）依旧整单拒绝——
+  // 刷爆上限或覆盖率不达标的输出是模型坏了，不是轻微 schema 漂移。
+  const skipped = [];
+  const survivors = [];
+  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;
+  // reflectionUpdateEnabled=false：update 在本次调用里不算合法动作。走与
+  // allowedActions 同一条单条跳过的通路（不是整单拒绝）——用户关掉的是「改写已有
+  // 记忆」这一种动作，模型多输出了几条 update 不该连带丢掉同批的 merge/archive。
+  // 与 prompt 侧后缀双闸：prompt 让模型别写，这里兜住模型仍然写了的情况。
+  const allowUpdate = options.allowUpdate !== false;
+  // 被用户开关关掉的动作单独计数：它们进 skipped（要留痕），但不该触发下面的
+  // 「全部跳过 = 模型坏了」整单拒绝——那是防幻觉 id / 截断输出的护栏，而这里是
+  // 用户自己关掉的动作。混在一起会让「只输出了 update」的一轮被判 failed、调度器
+  // 拿同一批输入重跑同一条必被拒的输出，无限循环。
+  let policySkipped = 0;
+  if (!Array.isArray(decisions)) {
+    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: [], 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()) {
+    const at = `decision[${index}]`;
+    // 单条校验错误先进 local：skipInvalid 模式下整条跳过，严格模式下才并入
+    // 全局 errors（沿用 v0.6.9 的双轨结构）。
+    const local = [];
+    let policyDisabled = false;
+    // 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 (allowedActions && !allowedActions.has(d.action)) {
+      // 动作本身合法，但不在当前档位允许的集合里（例如默认档收到 supersede）。
+      local.push(`${at}: action ${JSON.stringify(d.action)} not allowed in this mode`);
+    } else if (d.action === "update" && !allowUpdate) {
+      // reflectionUpdateEnabled=false：旧记忆永不被自动改写。这条要排在
+      // allowedActions 之后、update 字段校验之前——先判「这个动作本次不许用」，
+      // 再谈字段合不合规，否则同一条会同时报两个错、日志里读不出真实原因。
+      local.push(`${at}: update action is disabled (reflectionUpdateEnabled=false)`);
+      policyDisabled = true;
+    } else if (d.action === "conflict" || d.action === "supersede") {
+      if (!d.winner || !d.loser || d.winner === d.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 仍然必填：#533 之后
+      // 它不再写进正文，但仍是「模型确实做过分类」的唯一凭据，落进裁决账本供审计
+      // （空数组意味着模型只是偷懒输出了一条动作名，不该被记成已裁决）。
+      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,
+      // so it skips the claiming loop below; evidence is optional provenance
+      // (already filtered to real ids by the caller) and is stored in content.
+      if (typeof d.title !== "string" || !d.title.trim()) {
+        local.push(`${at}: create needs non-empty title`);
+      }
+      if (typeof d.content !== "string" || !d.content.trim()) {
+        local.push(`${at}: create needs non-empty content`);
+      }
+      if (d.importance !== undefined && (!Number.isInteger(d.importance) || d.importance < 1 || d.importance > 5)) {
+        local.push(`${at}: create importance must be an integer 1-5 when provided`);
+      }
+      if (typeof d.type !== "string" || !d.type.trim()) {
+        local.push(`${at}: create needs non-empty type`);
+      }
+    } else if (!Array.isArray(d.ids) || d.ids.length === 0) {
+      local.push(`${at}: ${d.action} needs non-empty ids`);
+    }
+    // update-specific field validation runs BEFORE claiming ids, so a failing
+    // update never pollutes the claimed set (which drives the "every id must
+    // appear in a decision" check below).
+    // Issue #104 方向 2：archive 类型护栏。长保留类型的 archive 决策必须携带
+    // 「重复 / 过时」类理由（提示词对 archive 的定义本就如此），「价值判断」类
+    // 理由（保持整洁、参考价值低……）不放行——单条跳过记 skipped（run 记
+    // degraded，明细进 dream_runs.skipped），绝不整单拒绝。未知 id 在下方通用
+    // 校验里另行报错，这里 snapshot.get 为 undefined 时跳过护栏判断。
+    if (local.length === 0 && d?.action === "archive") {
+      const guardedTypes = new Set();
+      for (const id of d.ids) {
+        const mem = snapshot.get(id);
+        if (mem && ARCHIVE_GUARDED_TYPES.has(mem.type)) guardedTypes.add(mem.type);
+      }
+      if (guardedTypes.size > 0 && !ARCHIVE_RATIONALE_RE.test(String(d.reason ?? ""))) {
+        local.push(`${at}: archive of long-retention type(s) ${[...guardedTypes].join(", ")} needs a duplicate/outdated rationale (重复/过时), got: ${JSON.stringify(String(d.reason ?? "").slice(0, 60))}`);
+      }
+    }
+    if (local.length === 0 && d?.action === "update") {
+      // 只能更新单条
+      if (!Array.isArray(d.ids) || d.ids.length !== 1) {
+        local.push(`${at}: update must target exactly one id`);
+      } else {
+        // 必须产生实际变化
+        const mem = snapshot.get(d.ids[0]);
+        const hasChange = (d.title !== undefined && d.title !== mem?.title)
+          || (d.content !== undefined && d.content !== mem?.content)
+          || (d.importance !== undefined && d.importance !== mem?.importance);
+        if (!hasChange) {
+          local.push(`${at}: update must change at least one field`);
+        } else if (mem?.type === "summary") {
+          // 不能更新 summary
+          local.push(`${at}: cannot update summary via update action`);
+        } else {
+          // 保护期：新建记忆不可立即被 update（可配置）
+          const ageHours = (Date.now() - new Date(mem?.created_at).getTime()) / 3600000;
+          if (ageHours < minAgeHours) {
+            local.push(`${at}: memory too young (< ${minAgeHours}h)`);
+          }
+        }
+      }
+    }
+    if (local.length === 0 && d && d.action !== "create") {
+      // seen 捕获同一条决策内的重复 id；claimed 只含先前存活决策的 id
+      // （被跳过的决策不 claim，其目标留给其它合法决策/隐式 keep）。
+      const seen = new Set();
+      for (const id of ids) {
+        const mem = snapshot.get(id);
+        if (!mem) {
+          local.push(`${at}: unknown id ${JSON.stringify(id)}`);
+        } else if (mem.archived || mem.type === "summary") {
+          local.push(`${at}: id ${JSON.stringify(id)} is archived or summary (not eligible)`);
+        }
+        if (claimed.has(id) || seen.has(id)) {
+          local.push(`${at}: id ${JSON.stringify(id)} claimed by multiple decisions`);
+        }
+        seen.add(id);
+      }
+      if (local.length === 0 && d.action === "merge") {
+        if (!d.keepSource || !d.ids.includes(d.keepSource)) {
+          local.push(`${at}: merge keepSource must be one of ids`);
+        }
+        if (typeof d.title !== "string" || !d.title.trim() || typeof d.content !== "string" || !d.content.trim()) {
+          local.push(`${at}: merge needs non-empty title and content`);
+        }
+        if (d.importance !== undefined && (!Number.isInteger(d.importance) || d.importance < 1 || d.importance > 5)) {
+          local.push(`${at}: merge importance must be an integer 1-5 when provided`);
+        }
+        // Merging across types would blur preference/project/decision boundaries
+        // in the injected context; the snapshot carries each entry's type.
+        // Issue #26 (P1)：默认禁止跨类型合并。用户显式开启 allowCrossTypeMerge
+        // 后放宽该检查，类型边界由用户自行承担。
+        const mergeTypes = new Set(d.ids.map((id) => snapshot.get(id)?.type));
+        if (mergeTypes.size > 1 && options.allowCrossTypeMerge !== true) {
+          local.push(`${at}: merge ids span multiple types (${[...mergeTypes].join(", ")})`);
+        }
+        // issue #339 / E8 考卷：merge 护栏（默认开，dreamMergeGuard）。巩固损耗
+        // 实测里 10/26 条被丢约束已归位 guarded 类型仍被 merge 吃掉——archive
+        // 护栏（上方）只挡 archive 不挡 merge，而 merge 的「更精炼摘要」恰是
+        // 约束失真的主通道。开启后被合并对象命中 ARCHIVE_GUARDED_TYPES 的
+        // merge 决策整条跳过（与 archive 护栏同款通道：skipInvalid 时 skipped
+        // 明细、严格模式整单拒绝）。
+        if (local.length === 0 && options.mergeGuard === true) {
+          const guardedTypes = new Set();
+          for (const id of d.ids) {
+            const mem = snapshot.get(id);
+            if (mem && ARCHIVE_GUARDED_TYPES.has(mem.type)) guardedTypes.add(mem.type);
+          }
+          // Issue #521：与上方 archive 护栏对齐——archive 早就允许「带重复/过时
+          // 理由」的长保留类型通过，merge 却一律拦死，于是一份真重复的
+          // preference 永远合不掉，而提示词还在催模型合并它们。实测（#521）46 轮
+          // 巩固里 280 条 merge 决策全被这条拦下、merge 恒为 0，模型每轮把同一
+          // 簇条目再提一次，满载 token 空转。逃生门条件与 archive 护栏同一条词表
+          // 且要求同类型（跨类型合并本就另受 allowCrossTypeMerge 约束，逃生门
+          // 不跟着放宽）。reason 只写「主题相近」不会命中词表——这是故意的：
+          // 相近不等于重复，只有确属重复/过时才值得牺牲两条独立表述。
+          const sameType = new Set(d.ids.map((id) => snapshot.get(id)?.type)).size === 1;
+          const reasonText = String(d.reason ?? "");
+          // #522 评审：词表命中还不够——「并不重复」「not a duplicate」也含关键词，
+          // 放它们过闸等于让模型用一句否认换来合并许可。否定表述直接判不重复。
+          const duplicated = !NEGATED_RATIONALE_RE.test(reasonText) && ARCHIVE_RATIONALE_RE.test(reasonText);
+          if (guardedTypes.size > 0 && !(sameType && duplicated)) {
+            local.push(`${at}: merge of long-retention type(s) ${[...guardedTypes].join(", ")} is blocked by dreamMergeGuard (needs a duplicate/outdated rationale, 重复/过时)`);
+          }
+        }
+      }
+    }
+    if (local.length > 0) {
+      if (skipInvalid) {
+        // 单条非法 → 跳过该决策，不 claim id（其目标记忆留给其它合法决策/隐式
+        // keep），并记录到 skipped 供调用方日志/审计。信息性跳过绝不写入全局
+        // errors，否则会误触发下方的整单拒绝。
+        //
+        // #534：除四键骨架外补三个「模型到底给没给」的布尔，把 skipped 从
+        // 「error 字符串」变成可计数的形状。作者实测 19 轮 17 轮整轮无效，但
+        // skipped 里只有一句错误串，事后无法判断模型是漏字段（merge 缺
+        // title/content）、还是字段给了但值不合规（has_* 为 true 仍报错）。
+        // 只加布尔不加原文：原文进 llm_audit_logs.metadata 与 dream_runs.raw_output，
+        // 这里保持每条记录足够小（skipped 会按轮累积进一行 JSON）。
+        if (policyDisabled) policySkipped++;
+        skipped.push({
+          index,
+          action: d?.action,
+          ids,
+          error: local.join("; "),
+          // true = 用户开关关掉了这个动作（不是模型输出有问题）。调用方据此区分
+          // 「这轮白跑」与「这轮输出坏了」。
+          ...(policyDisabled ? { policyDisabled: true } : {}),
+          has_keepSource: d?.keepSource !== undefined && d?.keepSource !== null,
+          has_title: typeof d?.title === "string" && d.title.trim().length > 0,
+          has_content: typeof d?.content === "string" && d.content.trim().length > 0
+        });
+      } else {
+        errors.push(...local);
+      }
+      continue;
+    }
+    if (d.action !== "create") {
+      for (const id of ids) claimed.add(id);
+    }
+    survivors.push(d);
+  }
+  // Cap update churn: too many edits in one cycle signals a runaway model.
+  // 全局信号——skipInvalid 模式下依旧整单拒绝（见函数头注释）。
+  const updateCount = survivors.filter((d) => d.action === "update").length;
+  if (updateCount > maxUpdatePerRun) {
+    errors.push(`too many update decisions: ${updateCount} > ${maxUpdatePerRun}`);
+  }
+  // Cap pattern minting per run (sleepMaxPatternPerRun passes through here).
+  const createCount = survivors.filter((d) => d.action === "create").length;
+  const maxCreatePerRun = options.maxCreatePerRun ?? 5;
+  if (createCount > maxCreatePerRun) {
+    errors.push(`too many create decisions: ${createCount} > ${maxCreatePerRun}`);
+  }
+  // Issue #104 方向 2：archive 批量上限——一次性大扫除（12 条互不相关主题被
+  // 批量归档）是失控信号，与 update 上限同一类全局闸门：skipInvalid 也不豁免，
+  // 超限整单拒绝；正常的大规模清理由用户调高 dreamMaxArchivePerRun。
+  const archiveCount = survivors.filter((d) => d.action === "archive").length;
+  const maxArchivePerRun = options.maxArchivePerRun ?? 8;
+  if (archiveCount > maxArchivePerRun) {
+    errors.push(`too many archive decisions: ${archiveCount} > ${maxArchivePerRun}`);
+  }
+  // merge 批量上限（#135 成本审计的派生护栏）。merge 是唯一**回吐正文**的动作：
+  // 每条 merge 都要求模型重新写出合并后的 content（实测 2113 条 merge 平均 550
+  // 字符/条），而 archive/keep/conflict 都不带正文——所以单轮 merge 数是「输出
+  // 里正文占比」唯一可控的杠杆（实测 dream_consolidate 的输出 token 只有约 11.8%
+  // 是决策正文，其余是推理与 JSON 骨架，那部分由 effort 决定、与本闸无关）。
+  // 与 update/create/archive 三道闸同类：全局闸门，skipInvalid 也不豁免，超限整单
+  // 拒绝。默认值取 40 的校准依据（只读探针，全库 246 轮 / 近 10 天 88 轮）：
+  // 每轮 merge 数 全库 p50 7 / p90 15 / p99 28 / max 39，近 10 天 p50 9 / p90 20 /
+  // p99 39 / max 39 —— 40 是观测分布的上沿（历史命中 0/246），与 archive 闸默认 8
+  // 恰为其 p90=max 同一校准法：这是面向未来的尾险护栏，不是成本削减工具（现有三
+  // 道闸在实测分布下命中率均为 0.0%，同一性质）。刻意不取更小的值：超限的代价
+  // 不对称——整单拒绝 = run 记 failed = 调度器不刷新 baseline（src/dream.js:905-915）
+  // = 下一次写入用同一批输入重跑，一次误伤约等于该轮成本 ×2；而探针里 merge≥15 的
+  // 大轮正文/显式决策比例都正常（10~22%），没有失控特征。想用覆盖换成本的用户可
+  // 自行调低 dreamMaxMergePerRun。
+  const mergeCount = survivors.filter((d) => d.action === "merge").length;
+  const maxMergePerRun = options.maxMergePerRun ?? 40;
+  if (mergeCount > maxMergePerRun) {
+    errors.push(`too many merge decisions: ${mergeCount} > ${maxMergePerRun}`);
+  }
+  // Issue #89 防洗白核心（#104 方向 1 重审后保留）：全部决策都被跳过、合法
+  // 子集为空时仍整单拒绝——宽容的前提是「有合法子集可应用」；模型输出整体
+  // 非法（如全部幻觉 id）是真故障，不能被隐式 keep 洗成 ok。#104 只豁免
+  // 「有合法子集但覆盖率不足」的良性挑重点（见下方 coverageShortfall）。
+  // 只把「非策略性跳过」算进这条：policySkipped 是用户关掉的动作，不是模型故障。
+  const modelSkipped = skipped.length - policySkipped;
+  if (options.skipInvalid === true && modelSkipped > 0 && survivors.length === 0 && errors.length === 0) {
+    errors.push(`all ${skipped.length} decision(s) invalid — nothing valid survived validation`);
+    return { ok: false, errors, skipped, resolvedShortIds };
+  }
+  // v0.4.4: 隐式 keep。默认（dreamImplicitKeep !== false）下，未 claim 的
+  // snapshot 记忆自动补 {action:"keep"}，而不是整体拒绝——大记忆量下 LLM 漏报
+  // 一两条就全拒（636 记忆 → 677 errors）会白白浪费整轮 run。设 false 则保留
+  // 旧的严格"全量覆盖"校验。补齐的 keep 直接 append 到 decisions，调用方
+  // （runDream/applyDecisions/audit）复用同一数组即可覆盖全部 snapshot 记忆。
+  //
+  // v0.4.4 fix（残缺输出防洗白）→ Issue #104 方向 1 重审：显式覆盖率护栏的
+  // 初衷是拦「输出截断 → 只 claim 少量 → 其余被隐式 keep 洗白」，但它无法区分
+  // 恶性截断与良性挑重点——而提示词硬性规则本身要求「无问题的条目无需输出」，
+  // 挑重点正是要求的行为。官方路由 + 强模型的实测（heptaspirit：81 轮 failed
+  // 全是 coverage，LLM 调用本身成功、applied=0）证明这是常规路径而非边角。
+  // 处置：覆盖率不足不再 ok:false 整单拒绝，改为返回 coverageShortfall 理由、
+  // 照常补齐隐式 keep——调用方把 run 记 degraded（合法子集已应用），护栏以
+  // 状态暴露而非一票否决，与 skipInvalid 同一宽容哲学。明确异常信号（create
+  // 上限等硬错误）保持整单拒绝。要恢复旧行为可设 dreamImplicitKeep:false
+  // （严格模式，缺失即 error）或 dreamMinExplicitCoverage: 0（关护栏）。
+  // 非覆盖类硬错误（create 上限溢出、严格模式缺失 id）仍然先整单拒绝——
+  // #104 方向 1 只豁免 coverage 这一个信号，防洗白语义对它们原样保留。
+  if (errors.length > 0) {
+    return { ok: false, errors, skipped, resolvedShortIds };
+  }
+  const minCoverage = options.dreamMinExplicitCoverage ?? 0.5;
+  let coverageShortfall = null;
+  if (options.dreamImplicitKeep !== false) {
+    const coverage = snapshot.size > 0 ? claimed.size / snapshot.size : 1;
+    if (coverage < minCoverage) {
+      coverageShortfall = `explicit decision coverage ${Math.round(coverage * 100)}% < minimum ${Math.round(minCoverage * 100)}%`;
+    }
+    for (const id of snapshot.keys()) {
+      if (!claimed.has(id)) survivors.push({ action: "keep", ids: [id] });
+    }
+  } else {
+    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, resolvedShortIds };
+  }
+  // 调用方下游（apply/audit）复用同一 decisions 引用：就地同步为 survivors——
+  // 在 skipInvalid 模式下去掉被跳过的非法决策；在隐式 keep 下追加补齐的 keep。
+  // 不能以 survivors.length !== decisions.length 作为是否 splice 的判据：
+  // 当"被跳过的非法决策数 == 隐式补齐的 keep 数"时长度回到相等但内容已变，
+  // 被跳过的决策会残留进 apply/audit。一律无条件 splice 最安全。
+  decisions.splice(0, decisions.length, ...survivors);
+  return { ok: true, errors, skipped, resolvedShortIds, coverageShortfall };
+}
+
+/** Marker thrown when a decision target changed since the run snapshot. */
+export class CasConflictError extends Error {
+  constructor(action, ids, reason) {
+    super(`cas conflict: ${action} targets changed since snapshot (${reason})`);
+    this.name = "CasConflictError";
+    this.action = action;
+    this.ids = ids;
+  }
+}
+
+function decisionIds(d) {
+  return d.action === "conflict" || d.action === "supersede" ? [d.winner, d.loser] : (d.ids ?? []);
+}
+
+/**
+ * CAS guard (item ①): every target memory must still match what the run
+ * snapshot captured — otherwise the decision was computed against stale state
+ * and applying it would overwrite a concurrent edit. Snapshotless replays skip
+ * the guard entirely (per-action idempotency checks handle those). Throws
+ * CasConflictError on the first mismatch; the caller's transaction rolls back.
+ */
+function casGuard(service, snapshot, ids) {
+  if (!snapshot) return;
+  for (const id of ids) {
+    const expect = snapshot.get(id);
+    if (!expect) continue; // not in snapshot: validated elsewhere, skip guard
+    const current = service.getById(id);
+    if (!current) {
+      throw new CasConflictError("deleted", [id], `memory ${id} was removed`);
+    }
+    const changed = expect.updated_at !== undefined
+      ? current.updated_at !== expect.updated_at
+      : current.content !== expect.content || current.title !== expect.title;
+    if (changed) {
+      throw new CasConflictError(
+        "changed",
+        [id],
+        `memory ${id} was concurrently modified (expected updated_at=${expect.updated_at}, got ${current.updated_at})`
+      );
+    }
+  }
+}
+
+/**
+ * Apply a validated decision list to the service. Caller must validate first.
+ * Each decision runs inside its own SQLite transaction (item ②): the multi-step
+ * mutation of a decision is atomic, so a merge can never leave "keeper updated
+ * but source not archived" or vice versa — a throwing sub-step rolls the whole
+ * decision back.
+ *
+ * @param decisions - validated decision list.
+ * @param service - memory service (saveWithDedupe/getById/update/setArchived/transaction).
+ * @param logger - optional logger ({ warn }); per-decision failures are logged.
+ * @param snapshot - optional Map<id, memory> captured before the LLM call; when
+ *   provided, every decision target is CAS-checked against it and a decision
+ *   computed from stale state is skipped and reported as a conflict instead of
+ *   overwriting concurrent writes (item ①).
+ * @param config - pipeline config; `config.mintSource` (optional string) is the
+ *   provenance stamped on memories minted by `create` decisions. It is
+ *   read from the CALLER, never from the decision object: the LLM authors
+ *   `create` payloads and validateDecisions does not strip unknown fields, so
+ *   trusting `d.source` would let a model label its own output as human-written.
+ *   Absent/blank → saveWithDedupe's existing "manual" fallback (unchanged).
+ * @returns {{ applied: number, conflicts: Array, failures: Array, committed: Array }}
+ *   applied    - number of decisions/memories actually committed (archive counts
+ *                each archived memory as one, merge/conflict/update count one).
+ *   conflicts  - decisions skipped because a target changed since the snapshot.
+ *   failures   - decisions that threw mid-transaction (fully rolled back).
+ *   committed  - the decisions that actually landed, for outcome/receipt based
+ *                on real committed sub-steps rather than the raw LLM list.
+ */
+export function applyDecisions(decisions, service, logger = null, snapshot = null, config = {}) {
+  let applied = 0;
+  let merged = 0;
+  const conflicts = [];
+  const failures = [];
+  const committed = [];
+  for (const [i, d] of decisions.entries()) {
+    try {
+      // keep is a confirmed no-op: it commits nothing but still records the
+      // per-id disposition so the outcome covers every snapshot memory.
+      if (d.action === "keep") {
+        committed.push({ action: "keep", ids: d.ids });
+        continue;
+      }
+      const outcome = applyOne(d, service, snapshot, config, logger);
+      if (outcome === "skipped") continue;
+      applied += outcome.applied;
+      // `merged` counts creates that hit a same-title row instead of minting a
+      // new one. Kept apart from `applied` on purpose: a create that vanished
+      // into an existing row is not a new conclusion, and folding it in is how
+      // two different dispositions ended up looking like two minted patterns
+      // (#619 audit round 5).
+      if (outcome.merged) merged += outcome.merged;
+      committed.push(outcome.committed);
+    } catch (error) {
+      if (error instanceof CasConflictError) {
+        conflicts.push({ index: i, action: d.action, ids: error.ids, reason: error.message });
+        logger?.warn?.(`dsh-mneme dream: ${error.message}`);
+      } else {
+        failures.push({ index: i, action: d.action, ids: decisionIds(d), reason: error.message });
+        logger?.warn?.(`dsh-mneme dream: failed to apply ${d.action} at index ${i}: ${error.message}`);
+      }
+    }
+  }
+  return { applied, merged, conflicts, failures, committed };
+}
+
+function applyOne(d, service, snapshot, config = {}, logger = null) {
+  switch (d.action) {
+    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, logger);
+    default: return applyUpdate(d, service, snapshot, config);
+  }
+}
+
+/**
+ * Highest-epistemic-priority UNARCHIVED id among `ids` (ties break toward
+ * `preferred`). Archived memories are never eligible keepers — promoting one
+ * would demote the real keepSource to a source and then hit the archived-keeper
+ * guard in applyMerge, silently skipping the whole merge. When `preferred`
+ * itself is archived (or missing), fall back to any unarchived candidate.
+ */
+function pickBestKeeper(ids, preferred, service) {
+  let best = null;
+  let bestP = -1;
+  for (const id of ids) {
+    const mem = service.getById(id);
+    if (!mem || mem.archived) continue; // archived/missing: ineligible keeper
+    const p = EPISTEMIC_PRIORITY[mem.epistemic_status] ?? 0;
+    if (p > bestP || (p === bestP && id === preferred)) {
+      bestP = p;
+      best = id;
+    }
+  }
+  return best ?? preferred;
+}
+
+/**
+ * Mint a fresh memory (pattern discovery). No existing target, so no CAS guard.
+ * Evidence ids ride in the content so a pattern stays traceable to its source
+ * memories. saveWithDedupe dedupes identical mints (idempotent replay-safe).
+ */
+function applyCreate(d, service, config = {}, logger = null) {
+  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;
+  const type = typeof d.type === "string" ? d.type : "pattern";
+  const evidence = Array.isArray(d.evidence)
+    ? d.evidence.filter((id) => typeof id === "string")
+    : [];
+  const body = evidence.length > 0
+    ? STR.evidenceSuffix[language](content, evidence)
+    : content;
+  // mint 来源由调用方（管道）给，不从决策对象取——LLM 能自己写 d.source，
+  // 信它就等于让模型给自造条目盖「人写的」戳（见 applyDecisions 的 @param config）。
+  // 取不到就一个字段都不传，落回 saveWithDedupe 原有的兜底，行为与改前一致。
+  const mintSource = typeof config?.mintSource === "string" ? config.mintSource.trim() : "";
+  // pattern 是「整句重写」而不是「增量补充」：同一 (人, 对象, 情绪) 的标题天然
+  // 相同，saveWithDedupe 命中后若走 appendContent，重放一轮就把同一段结论再粘
+  // 一遍（实测 161 → 355 → 549 字，外加一串重复的 [证据: …] 尾巴），而 pattern
+  // 正是注入面消费的东西。`_overwrite` 是既有逃生口（bootstrap / dream summary /
+  // narrative 三处先例）：命中同题行时原地刷新而不是追加，旧文进 content_history。
+  // 只对 pattern 放开——其他类型被 create 撞上同题行时仍按合并语义走，那多半是
+  // 模型自造了不该出现的类型，把既有行整段覆盖掉比追加更危险。
+  const overwrite = type === "pattern";
+  const created = service.saveWithDedupe({
+    type,
+    title,
+    content: body,
+    importance,
+    ...(mintSource ? { source: mintSource } : {}),
+    ...(overwrite ? { _overwrite: true } : {})
+  });
+  const memory = created?.memory;
+  if (!memory) return "skipped"; // deduped/subsumed: nothing minted, clean no-op
+  // 命中同题活跃行 ⇒ saveWithDedupe 返回 action:"merged"。它确实动过库（刷新了
+  // 那一行），但**没有铸出新条目**：把它算进 applied 会让「一条真实结论被同题行
+  // 吃掉了」这种情况看起来像成功（#619 审计第五轮：两个不同对象铸出同一条
+  // pattern，applied 照样报 2）。两类结局分开报：applied 只数新铸，merged 数刷新。
+  const refreshed = created?.action !== "created";
+  // #512：这条记忆出生自哪一轮。只记 create——merge/conflict/update/supersede 对
+  // 既有行的改动已由 receipt_chain 按 (run_id, record_id) 记账，再造一份就是第二套账。
+  //
+  // #619 / Ephor 第七轮 ③：`refreshed` 也在这条规矩里。原地刷新没有铸新条目，
+  // 它改的是既有行——同一条记忆不该有两份「出生记录」。此前 create_merged 这条
+  // 新路没被上面那句规矩覆盖，于是一个 pattern 跑两轮，`memory_mints` 就有两行、
+  // run_id 各不相同，面板上显示成「这条记忆出生过两次」（`mintsFor` 由
+  // provenance-http.js 读取）。live 库当时还没显形，是因为同题刷新刚上线。
+  //
+  // 记账失败不许拖垮这次铸造：归因是审计，记忆已经落盘了。
+  try {
+    if (!refreshed && typeof service?.saveMemoryMint === "function" && config?.runId) {
+      service.saveMemoryMint({
+        memoryId: memory.id,
+        runId: config.runId,
+        runType: config.mintSource === "sleep" ? "sleep" : "dream",
+        triggerSource: config.mintSource === "sleep" ? "sleep" : "autoDream",
+        createdAt: new Date().toISOString()
+      });
+    }
+  } catch (mintError) {
+    logger?.warn?.(`dsh-mneme dream: failed to record memory mint: ${String(mintError?.message ?? mintError)}`);
+  }
+  return { applied: refreshed ? 0 : 1, merged: refreshed ? 1 : 0, committed: { action: refreshed ? "create_merged" : "create", id: memory.id, type } };
+}
+
+function applyArchive(d, service, snapshot) {
+  const targets = d.ids.filter((id) => {
+    const mem = service.getById(id);
+    return mem && !mem.archived; // existing, not-yet-archived rows only
+  });
+  if (targets.length === 0) return "skipped"; // all already archived: idempotent replay
+  service.transaction(() => {
+    casGuard(service, snapshot, d.ids);
+    for (const id of d.ids) {
+      const mem = service.getById(id);
+      if (mem && !mem.archived) service.setArchived(id, true);
+    }
+  });
+  return { applied: targets.length, committed: { action: "archive", ids: targets } };
+}
+
+function applyMerge(d, service, snapshot, config = {}) {
+  // Epistemic trust (v0.4.5): when enabled, prefer an observation keeper over a
+  // subjective/inferred one. Mutating the decision keeps the receipt + committed
+  // record aligned with the actual keeper.
+  if (config.trustEpistemicWeighting === true) {
+    const best = pickBestKeeper(d.ids, d.keepSource, service);
+    if (best && best !== d.keepSource) d.keepSource = best;
+  }
+  const sources = d.ids.filter((id) => id !== d.keepSource);
+  // Idempotent replay: if every other source is already archived, this merge
+  // already landed — skip so a replayed/concurrent decision never double-counts
+  // or re-applies (guard against duplicate merges).
+  if (sources.every((id) => service.getById(id)?.archived)) return "skipped";
+  service.transaction(() => {
+    casGuard(service, snapshot, d.ids);
+    const keeper = service.getById(d.keepSource);
+    if (!keeper || keeper.archived) return; // missing keeper: no write, still a clean commit
+    service.update(d.keepSource, {
+      title: d.title,
+      content: d.content,
+      importance: d.importance ?? Math.max(keeper.importance, ...d.ids.map((id) => service.getById(id)?.importance ?? 1))
+    });
+    for (const id of sources) {
+      const mem = service.getById(id);
+      if (mem && !mem.archived) service.setArchived(id, true);
+    }
+    // 4.3.2 迁移实体关联（opt-in）：将 loser（source）记忆关联的 entity_attrs 的
+    // memory_id 迁移到 keeper；keeper 已有同 entity+key 的当前属性时 loser 行被
+    // 失效。单个 source 迁移失败只告警，绝不能导致整个 merge 事务回滚（fail-safe）。
+    if (config.entityExtractionEnabled && typeof service.migrateAttrsToMemory === "function") {
+      for (const id of sources) {
+        try {
+          service.migrateAttrsToMemory(id, d.keepSource, new Date().toISOString());
+        } catch (error) {
+          logger?.warn?.(`dsh-mneme dream: failed to migrate attrs from ${id} to ${d.keepSource}: ${error.message}`);
+        }
+      }
+    }
+  });
+  return {
+    applied: 1,
+    committed: { action: "merge", ids: d.ids, keepSource: d.keepSource, title: d.title, content: d.content, importance: d.importance, count_before: d.ids.length, count_after: 1 }
+  };
+}
+
+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) {
+    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";
+  // Idempotent replay: an already-archived loser means the conflict was already
+  // adjudicated — skip so the provenance note is never re-appended and the loser
+  // is not re-archived.
+  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.winner, {
+      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 #641 enforce 档的 T1 处置，供 sleep/dream
+ * 两条链路共用）。与冻结分支自动裁决档（#603 第 4 层，sleep.js 内联实现）同一
+ * 条契约，本函数是它的共享出口：
+ *   · 保留**信息量更大**的那条，不是更新的——#616 实测 55-57% 的新条反而更短
+ *     （蒸馏压缩过的一版常常更新），留新条等于把更完整的那条归档掉；
+ *   · 长度相同才退回 updated_at，再退回 id——三级兜底保证同一对每次判出同一个
+ *     赢家（重放不翻面）；
+ *   · trustEpistemicWeighting 显式关：自动处置的承诺必须是确定的，可信度换位
+ *     不让结果随 epistemic_status 数据漂移；
+ *   · 赢家正文一字不动——supersede 的可追溯注记落在被归档侧（#126 原设计）。
+ *     E13b 证明 conflict 动作的「败者前 100 字追加进赢家」是值级泄漏通道，
+ *     确定性处置一律走 supersede、不走 conflict。
+ * CAS 快照 + 事务 + 幂等（败者已归档 → applied 0）全部沿用 applyDecisions，
+ * 不另写第二份裁决路径。
+ *
+ * @param {{a: object, b: object}} p 候选对（完整记忆行：id/title/content/updated_at）
+ * @returns {{applied: boolean, winnerId: string, loserId: string, winner: object, loser: object}}
+ */
+export function supersedeInfoFirstPair(p, service, logger = null, config = {}) {
+  const an = p.a.content?.length ?? 0;
+  const bn = p.b.content?.length ?? 0;
+  const [winner, loser] = an !== bn
+    ? (an > bn ? [p.a, p.b] : [p.b, p.a])
+    : (p.a.updated_at ?? "") !== (p.b.updated_at ?? "")
+      ? ((p.a.updated_at ?? "") > (p.b.updated_at ?? "") ? [p.a, p.b] : [p.b, p.a])
+      : (p.a.id > p.b.id ? [p.a, p.b] : [p.b, p.a]);
+  const snapshot = new Map();
+  for (const m of [winner, loser]) {
+    snapshot.set(m.id, { updated_at: m.updated_at, content: m.content, title: m.title });
+  }
+  const { applied } = applyDecisions(
+    [{ action: "supersede", winner: winner.id, loser: loser.id }],
+    service, logger, snapshot, { ...config, trustEpistemicWeighting: false }
+  );
+  return { applied: applied > 0, winnerId: winner.id, loserId: loser.id, winner, loser };
+}
+
+/**
+ * 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"）：互补型重复——两条各自成立、
+ * 覆盖不同侧面，不该判输赢。双方都保留（不归档），**正文一个字节都不动**。
+ *
+ * 为什么不动正文（Issue #533）：#126 的原设计是「双方各追加同一段差异注记，注记
+ * 进正文 → 进注入与 embedding → 下一轮就不会再被判成重复」。离线复现证伪了这个
+ * 假设——两侧共享同一段后缀会让两条向量**同向靠拢**，余弦一轮比一轮高（0.876 →
+ * 0.960 只用了 5 轮，把注记截到 0 字照样往上爬，因为推高相似度的是共享前缀本身而
+ * 不是注记长短），于是同一对下一轮又被判成重复、又追加一段，实测单条堆到 19 段。
+ * 现在的裁决落在 differentiated_pairs 账本（src/store.js）里：候选构造阶段读它，
+ * 已裁决且两侧正文都没改过就不再送模型，正文保持干净。
+ *
+ * 幂等三层，从便宜到贵：
+ *   1. 一侧已归档 → skipped（缺一条就没什么可区分的）；
+ *   2. 存量兼容：两侧正文都还带着旧版注记块 → skipped（升级不清账）；
+ *   3. 账本命中且两侧 content hash 与记账时一致 → skipped（真正的幂等重放）。
+ * 任一侧后来被改写 → hash 对不上 → 重新裁决，宁可再判一次也不静音真的演化。
+ */
+function applyDifferentiate(d, service, snapshot, config = {}) {
+  const ids = Array.isArray(d.ids) ? d.ids : [];
+  const alive = ids.filter((id) => {
+    const m = service.getById(id);
+    return m && !m.archived;
+  });
+  if (alive.length < 2) return "skipped"; // 缺一条即已处理/不可用（幂等）
+  const hashes = new Map(alive.map((id) => [id, contentHashOf(service.getById(id))]));
+  const [a, b] = alive.slice(0, 2);
+  const record = typeof service.findDifferentiatedPair === "function"
+    ? service.findDifferentiatedPair(a, b)
+    : undefined;
+  if (record) {
+    // 记账时 a/b 是按 id 排序存的，hash 也跟着换位，这里同样按排序取值比对。
+    const [ha, hb] = a <= b ? [hashes.get(a), hashes.get(b)] : [hashes.get(b), hashes.get(a)];
+    if (record.hash_a === ha && record.hash_b === hb) return "skipped";
+  } else {
+    // 存量库兼容：旧版本把注记写进了正文，那些行没有账本行。两侧都还带着注记块
+    // 才认定「已裁决过」——只有一侧有，说明另一侧后来被改写，应当重判。
+    const noted = alive.filter((id) => STR.differentiatedNoteRe.test(String(service.getById(id)?.content ?? "")));
+    if (noted.length >= 2) return "skipped";
+  }
+  // 账本缺席（人工确认路径的裸 service）就什么都不写：正文一字不动本来就是本动作
+  // 的全部副作用，没有账本就只剩「这条决策无处落地」，不是错误，也不是 applied。
+  if (typeof service.saveDifferentiatedPair !== "function") return "skipped";
+  service.transaction(() => {
+    casGuard(service, snapshot, ids);
+    const [ia, ib] = alive.slice(0, 2);
+    service.saveDifferentiatedPair({
+      run_id: config.runId,
+      memory_a: ia,
+      memory_b: ib,
+      // hash 取**执行时**的正文（不是送审时），与账本里下一次比对的口径同源。
+      hash_a: hashes.get(ia),
+      hash_b: hashes.get(ib),
+      // 模型给的差异点也落账：正文不再写注记，这些就是「当初为什么判互补」的唯一凭据。
+      distinctions: (Array.isArray(d.distinctions) ? d.distinctions : [])
+        .filter((x) => typeof x === "string" && x.trim())
+        .map((x) => x.trim())
+    });
+  });
+  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);
+  if (!mem || mem.archived) return "skipped";
+  // 幂等检查：如果字段已与目标一致则跳过
+  const same = (d.title === undefined || d.title === mem.title)
+    && (d.content === undefined || d.content === mem.content)
+    && (d.importance === undefined || d.importance === mem.importance);
+  if (same) return "skipped";
+  service.transaction(() => {
+    casGuard(service, snapshot, [id]);
+    const cur = service.getById(id);
+    if (!cur || cur.archived) return;
+    service.update(id, {
+      title: d.title ?? cur.title,
+      content: d.content ?? cur.content,
+      importance: d.importance ?? cur.importance
+    });
+  });
+  // 4.3.1 supersedes 关系（opt-in）：事务提交成功后，为该记忆关联的每条实体属性
+  // 建立自引用 supersedes 关系，表示"此属性版本已被替代"。仅记录、绝不阻断主流程
+  // （fail-safe）：记录失败只告警，update 本身照常生效。
+  if (config.entityExtractionEnabled && typeof service.saveRelation === "function" && typeof service.getAttrsByMemory === "function") {
+    try {
+      const oldAttrs = service.getAttrsByMemory(id);
+      for (const attr of oldAttrs) {
+        if (!attr.entity_id) continue;
+        service.saveRelation({
+          from_entity: attr.entity_id,
+          to_entity: attr.entity_id,
+          relation_type: "supersedes",
+          memory_id: id,
+          metadata: JSON.stringify({ attr_key: attr.attr_key, old_value: attr.attr_value })
+        });
+      }
+    } catch (error) {
+      logger?.warn?.(`dsh-mneme dream: failed to record supersedes relations for ${id}: ${error.message}`);
+    }
+  }
+  return { applied: 1, committed: { action: "update", ids: [id], title: d.title, content: d.content, importance: d.importance, count_before: 1, count_after: 1 } };
+}