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

package/src/dream/decisions.js

@@ -11,7 +11,7 @@ export const ACTIONS = new Set(["keep", "merge", "archive", "conflict", "update"
 // 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).
-const EPISTEMIC_PRIORITY = { observation: 3, inferred: 2, subjective: 1 };
+export const EPISTEMIC_PRIORITY = { observation: 3, inferred: 2, subjective: 1 };
 
 // Issue #104 方向 2：archive 类型护栏的长保留类型集合——这些类型的存在意义
 // 就是长期保存（踩坑记录、约束、用户偏好、挖掘出的模式），LLM 以「价值判断」
@@ -119,6 +119,16 @@ export function validateDecisions(decisions, snapshot, options = {}) {
   // 不够的——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 };
   }
@@ -168,6 +178,7 @@ export function validateDecisions(decisions, snapshot, options = {}) {
     // 单条校验错误先进 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 ?? []);
@@ -176,6 +187,12 @@ export function validateDecisions(decisions, snapshot, options = {}) {
     } 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`);
@@ -328,11 +345,15 @@ export function validateDecisions(decisions, snapshot, options = {}) {
         // 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
@@ -391,7 +412,9 @@ export function validateDecisions(decisions, snapshot, options = {}) {
   // 子集为空时仍整单拒绝——宽容的前提是「有合法子集可应用」；模型输出整体
   // 非法（如全部幻觉 id）是真故障，不能被隐式 keep 洗成 ok。#104 只豁免
   // 「有合法子集但覆盖率不足」的良性挑重点（见下方 coverageShortfall）。
-  if (options.skipInvalid === true && skipped.length > 0 && survivors.length === 0 && errors.length === 0) {
+  // 只把「非策略性跳过」算进这条：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 };
   }
@@ -514,6 +537,7 @@ function casGuard(service, snapshot, ids) {
  */
 export function applyDecisions(decisions, service, logger = null, snapshot = null, config = {}) {
   let applied = 0;
+  let merged = 0;
   const conflicts = [];
   const failures = [];
   const committed = [];
@@ -528,6 +552,12 @@ export function applyDecisions(decisions, service, logger = null, snapshot = nul
       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) {
@@ -539,7 +569,7 @@ export function applyDecisions(decisions, service, logger = null, snapshot = nul
       }
     }
   }
-  return { applied, conflicts, failures, committed };
+  return { applied, merged, conflicts, failures, committed };
 }
 
 function applyOne(d, service, snapshot, config = {}, logger = null) {
@@ -597,20 +627,41 @@ function applyCreate(d, service, config = {}, logger = null) {
   // 信它就等于让模型给自造条目盖「人写的」戳（见 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 } : {})
+    ...(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 (typeof service?.saveMemoryMint === "function" && config?.runId) {
+    if (!refreshed && typeof service?.saveMemoryMint === "function" && config?.runId) {
       service.saveMemoryMint({
         memoryId: memory.id,
         runId: config.runId,
@@ -622,7 +673,7 @@ function applyCreate(d, service, config = {}, logger = null) {
   } catch (mintError) {
     logger?.warn?.(`dsh-mneme dream: failed to record memory mint: ${String(mintError?.message ?? mintError)}`);
   }
-  return { applied: 1, committed: { action: "create", id: memory.id, type } };
+  return { applied: refreshed ? 0 : 1, merged: refreshed ? 1 : 0, committed: { action: refreshed ? "create_merged" : "create", id: memory.id, type } };
 }
 
 function applyArchive(d, service, snapshot) {
@@ -715,6 +766,44 @@ function applyConflict(d, service, snapshot, config = {}) {
   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