@modusensus/dsh-mneme 0.7.31 → 0.8.0

package/src/dream/decisions.js

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

package/src/dream/sleep.js

@@ -1,3 +1,4 @@
+import { STR, langOf } from "../lang.js";
 // System-level sleep (v0.4.0): an idle-triggered, LLM-assisted deep pass over
 // the memory store. Four independent, fail-safe phases:
 //   1. conflict resolution — high-similarity same-type pairs are either parked
@@ -15,11 +16,16 @@
 // abortable via an AbortController signal (user activity) — phases check the
 // signal between batches so a running cycle yields promptly.
 import { randomUUID, createHash } from "node:crypto";
-import { validateDecisions, applyDecisions } from "./decisions.js";
-import { findPotentialConflicts } from "./clustering.js";
-import { buildReceipt, describeStreamFailure, resolveDreamEffort, withEffortFallback } from "../dream.js";
+import { validateDecisions, applyDecisions, ACTIONS } from "./decisions.js";
+import { findPotentialConflicts, cosineSimilarity } from "./clustering.js";
+import { buildReceipt, describeStreamFailure, resolveDreamEffort, withEffortFallback, maintainIndexAfterDream } from "../dream.js";
 import { computeHeat } from "../heat.js";
 
+// Issue #126 review（Copilot）：默认档（sleepActionSet="conflict"）允许的动作 = 全局
+// ACTIONS 去掉 #126 新增的两个。从 ACTIONS 派生而非硬编码，将来再扩动作集时自动跟随。
+// 只换 prompt 挡不住模型自发输出新动作，必须由校验器按档位收口。
+const LEGACY_ACTIONS = [...ACTIONS].filter((a) => a !== "supersede" && a !== "differentiate");
+
 const SUMMARY_MAX = 120;
 // Conflict similarity threshold per strictness level (v0.4.0):
 //   gentle     only high-confidence pairs (0.92) — first-time users
@@ -27,26 +33,6 @@ const SUMMARY_MAX = 120;
 //   aggressive low-confidence pairs too (0.75) — bloated stores
 const CONFLICT_THRESHOLDS = { gentle: 0.92, normal: 0.85, aggressive: 0.75 };
 
-const CONFLICT_PROMPT = `你是记忆库冲突仲裁助手。下面是检测到的高相似度记忆对，可能内容矛盾或重复。
-对每一对输出一个 decision 对象：
-- 两条确实矛盾/重复 → { "action": "conflict", "winner": <保留的id>, "loser": <归档的id>, "reason": "理由" }
-- 两条只是主题相近、并无矛盾 → { "action": "keep", "ids": [<两个id>] }
-规则：
-- winner 应为信息更完整、更新或更可信的一条
-- 只使用提供的 id，不要编造
-- 每对必须输出一个 decision
-- 只输出 JSON 数组，不要其他文字`;
-
-const PATTERN_PROMPT = `你是记忆库模式发现助手。下面是最近的记忆条目（id、类型、标题、内容）。
-请发现跨条目的稳定模式：用户偏好的规律、反复出现的主题、可复用的工作流或项目规律。
-对每个模式输出一个 create decision：
-{ "action": "create", "type": "pattern", "title": "模式一句话标题", "content": "模式详细描述（2-4句）", "importance": 1-5, "evidence": ["支持该模式的记忆id"] }
-规则：
-- 只输出有据可依的模式，宁缺毋滥
-- evidence 必须是列表中真实存在的 id
-- 最多输出 N 个模式
-- 只输出 JSON 数组，不要其他文字`;
-
 function parseJsonArray(text) {
   if (typeof text !== "string") return undefined;
   const start = text.indexOf("[");
@@ -109,6 +95,7 @@ function makeSummary(m) {
  * each pair → winner kept / loser archived. Returns a per-run summary.
  */
 async function phaseConflicts(ctx, service, config, logger, runId, semantic = null, signal = null) {
+  const language = langOf(config);
   const embedder = semantic?.embedder;
   const vectorIndex = semantic?.vectorIndex;
   if (!embedder || !vectorIndex || typeof embedder.embed !== "function") {
@@ -150,7 +137,24 @@ async function phaseConflicts(ctx, service, config, logger, runId, semantic = nu
   const usableMemories = usable.map((i) => memories[i]);
   const usableVectors = usable.map((i) => vectors[i]);
 
+  // Issue #126：动作集档位既要决定 prompt，也要决定**校验器允许的动作集合**（见下方
+  // allowedActions），并且在候选构造阶段就要知道——full 档需要补跨类型对。因此在这里
+  // 解析，而不是等到拼 prompt 时。
+  const actionSet = config.sleepActionSet ?? "conflict";
   const pairs = findPotentialConflicts(usableMemories, usableVectors, threshold);
+  if (actionSet === "full") {
+    // Issue #126 review（Copilot）：findPotentialConflicts 只看同类型，而 full 档的
+    // prompt 明确宣传 differentiate 用于互补型——互补本来就常跨类型（同一事实的项目侧
+    // 与偏好侧）。不补这一遍，那条路径永远选不到。merge 的类型守卫不受影响：它拦在
+    // validateDecisions 里（allowCrossTypeMerge），不在候选生成。
+    for (let i = 0; i < usableMemories.length; i++) {
+      for (let j = i + 1; j < usableMemories.length; j++) {
+        if (usableMemories[i].type === usableMemories[j].type) continue;
+        const sim = cosineSimilarity(usableVectors[i], usableVectors[j]);
+        if (sim > threshold) pairs.push({ a: usableMemories[i], b: usableMemories[j], similarity: sim });
+      }
+    }
+  }
   if (pairs.length === 0) return { status: "skipped", reason: "no conflicts found" };
 
   // Dedupe: each memory participates in at most one pair, highest similarity
@@ -170,7 +174,7 @@ async function phaseConflicts(ctx, service, config, logger, runId, semantic = nu
     let frozen = 0;
     for (const p of selected) {
       try {
-        service.saveConflictPending({ run_id: runId, memory_a: p.a.id, memory_b: p.b.id, reason: `相似度 ${p.similarity.toFixed(2)}` });
+        service.saveConflictPending({ run_id: runId, memory_a: p.a.id, memory_b: p.b.id, reason: STR.similarityReason[language](p.similarity.toFixed(2)) });
         frozen++;
       } catch (error) {
         logger?.warn?.(`dsh-mneme sleep: failed to freeze conflict ${p.a.id}/${p.b.id}: ${String(error)}`);
@@ -188,10 +192,13 @@ async function phaseConflicts(ctx, service, config, logger, runId, semantic = nu
     snapshot.set(p.b.id, p.b);
   }
   const listText = selected.map((p) =>
-    `候选冲突：\nid=${p.a.id} | type=${p.a.type} | title=${p.a.title}\n${p.a.content}\n---\nid=${p.b.id} | type=${p.b.type} | title=${p.b.title}\n${p.b.content}\n（相似度 ${p.similarity.toFixed(2)}）`
+    STR.candidateConflicts[language](p)
   ).join("\n\n");
   const sleepEffort = await resolveDreamEffort(ctx, route, config.sleepReasoningEffort, logger);
   let conflictStreamFailure = "";
+  // actionSet 已在候选构造前解析（跨类型候选需要它），这里只按档位选 prompt：
+  // 默认档保持只有 conflict/keep 的窄 prompt，"full" 才开放六分支。
+  const conflictPrompt = actionSet === "full" ? STR.prompts.conflictFull[language] : STR.prompts.conflict[language];
   const runConflict = (withEffort) => {
     conflictStreamFailure = "";
     return streamText(ctx, {
@@ -201,7 +208,7 @@ async function phaseConflicts(ctx, service, config, logger, runId, semantic = nu
     maxTokens: 2048,
     ...(withEffort && sleepEffort ? { reasoningEffort: sleepEffort } : {}),
     messages: [
-      { role: "system", content: [{ type: "text", text: CONFLICT_PROMPT }] },
+      { role: "system", content: [{ type: "text", text: conflictPrompt }] },
       { role: "user", content: [{ type: "text", text: listText }] }
     ]
   }, (reason) => { conflictStreamFailure = describeStreamFailure(reason); });
@@ -218,7 +225,10 @@ async function phaseConflicts(ctx, service, config, logger, runId, semantic = nu
   // 预填作为防御性双保险——漏判读作"未裁决冲突"而非"冲突阶段整体失败"。
   const covered = new Set();
   for (const d of decisions) {
-    if (d?.action === "conflict") {
+    // Issue #126 review（Copilot）：supersede 同样用 winner/loser 定位（没有 ids），
+    // 此前只认 conflict → 它的两个目标都没进 covered → 被补成 implicit keep → 与
+    // supersede 的 claim 冲突：严格模式整单拒绝，宽容模式把合成的 keep 记成 skipped。
+    if (d?.action === "conflict" || d?.action === "supersede") {
       if (typeof d?.winner === "string") covered.add(d.winner);
       if (typeof d?.loser === "string") covered.add(d.loser);
     } else if (Array.isArray(d?.ids)) {
@@ -228,15 +238,43 @@ async function phaseConflicts(ctx, service, config, logger, runId, semantic = nu
   for (const id of snapshot.keys()) {
     if (!covered.has(id)) decisions.push({ action: "keep", ids: [id] });
   }
-  const { ok, errors } = validateDecisions(decisions, snapshot, {});
-  if (!ok) return { status: "failed", error: `invalid decisions: ${errors.join("; ")}` };
+  // Issue #126：sleep 是多对批量裁决，严格模式"一票否决"太脆（一对非法就丢掉整轮
+  // 成果）→ 与 dream 对齐透传 skipInvalid：非法的那一对只跳过自己，合法子集照常
+  // 应用，run 记 degraded。update 上限与保护期同样取 dream 的同一组配置，保证两个
+  // 模块对"什么算合法"的判据一致。
+  const { ok, errors, skipped } = validateDecisions(decisions, snapshot, {
+    maxUpdatePerRun: config.reflectionUpdateMaxPerRun,
+    minAgeHours: config.reflectionUpdateMinAgeHours,
+    skipInvalid: config.dreamSkipInvalid !== false,
+    allowCrossTypeMerge: config.allowCrossTypeMerge === true,
+    // Issue #126 review（Copilot）：默认档必须真的只放行旧动作集——只换 prompt 挡不住
+    // 模型自发输出 supersede / differentiate，那样"opt-in 零行为变化"就不成立。
+    allowedActions: actionSet === "full" ? null : LEGACY_ACTIONS
+  });
+  if (!ok) return { status: "failed", error: `invalid decisions: ${errors.join("; ")}`, skipped };
   const { applied, failures, conflicts } = applyDecisions(decisions, service, logger, snapshot, config);
+  // Issue #126 review（Copilot）：事务内 service.update 会跳过 scheduleEmbed（txDepth>0），
+  // 而 sleep 路径此前没有 dream 那样的 post-apply 索引维护——differentiate 的差异注记与
+  // supersede 的归档都反映不到缓存向量，"注记进 embedding 防再判重复"就是空承诺。
+  if (applied > 0 && semantic?.embedder && semantic?.vectorIndex) {
+    try {
+      await maintainIndexAfterDream(decisions, service, semantic);
+    } catch (error) {
+      logger?.warn?.(`dsh-mneme sleep: index maintenance failed: ${String(error)}`);
+    }
+  }
+  // Issue #126 review（Copilot）：有决策被跳过时不能报 ok——与 dream 的 degraded 契约
+  // 对齐（"合法子集已应用"是 degraded 而非 ok），否则消费方分不清整轮与残轮。
+  const degraded = skipped.length > 0;
   return {
-    status: applied > 0 ? "ok" : failures.length ? "failed" : "noop",
+    status: applied > 0 ? (degraded ? "degraded" : "ok") : failures.length ? "failed" : "noop",
     pairs: selected.length,
     applied,
     failures,
-    conflicts
+    conflicts,
+    // Issue #126：#104 同向——被跳过的逐对明细要进审计行，否则事后无法判断
+    // 是哪一对、因何被跳过（此前只进 logger.warn，splice 后就地消失）。
+    skipped
   };
 }
 
@@ -295,6 +333,7 @@ function phaseDemotion(service, config, logger, runId, signal = null) {
  * "every id claimed" invariant is trivially satisfied for pure-create lists.
  */
 async function phasePatterns(ctx, service, config, logger, runId, signal = null) {
+  const language = langOf(config);
   const route = resolveSleepRoute(ctx, config, logger);
   if (!route) return { status: "skipped", reason: "no llm route" };
   const limit = config.sleepPatternMinMemories ?? 100;
@@ -320,7 +359,7 @@ async function phasePatterns(ctx, service, config, logger, runId, signal = null)
     maxTokens: 2048,
     ...(withEffort && sleepEffort ? { reasoningEffort: sleepEffort } : {}),
     messages: [
-      { role: "system", content: [{ type: "text", text: PATTERN_PROMPT.replace("N", String(maxPatterns)) }] },
+      { role: "system", content: [{ type: "text", text: STR.prompts.pattern[language].replace("N", String(maxPatterns)) }] },
       { role: "user", content: [{ type: "text", text: listText }] }
     ]
   }, (reason) => { patternStreamFailure = describeStreamFailure(reason); });
@@ -417,7 +456,11 @@ function deriveStatus(phases) {
   const list = Object.values(phases);
   if (list.length === 0) return "noop";
   const anyError = list.some((p) => p.status === "failed" || p.status === "error");
-  const anyWork = list.some((p) => p.status === "ok");
+  // Issue #126 review（Copilot）：phase 自身可以是 degraded（合法子集已应用但有条目被
+  // 跳过），它同样算"有产出"——否则整轮会被误判成 noop，把真实变更报成空轮。
+  const anyWork = list.some((p) => p.status === "ok" || p.status === "degraded");
+  const anyDegraded = list.some((p) => p.status === "degraded");
+  if (anyDegraded) return "degraded";
   if (anyWork && anyError) return "degraded";
   if (anyError) return "failed";
   if (anyWork) return "ok";
@@ -449,6 +492,12 @@ export async function runSleep(ctx, service, config, logger, semantic = null, si
   const status = deriveStatus(phases);
   const route = resolveSleepRoute(ctx, config, logger);
   const totalApplied = Object.values(phases).reduce((n, p) => n + (Number.isInteger(p?.applied) ? p.applied : 0), 0);
+  // Issue #126（与 #104 同向）：把各 phase 的跳过明细汇总成一行审计数据，带 phase
+  // 名（同一次 run 里 conflicts 与 patterns 都可能产出 skipped）。全空时写 NULL，
+  // 不落空数组——审计行只记真实发生过的跳过。
+  const skippedDetail = Object.entries(phases).flatMap(([phase, p]) =>
+    Array.isArray(p?.skipped) ? p.skipped.map((s) => ({ phase, ...s })) : []
+  );
   const snapshotHash = createHash("sha256").update(JSON.stringify(phases)).digest("hex");
   const receipt = buildReceipt({
     runId,
@@ -473,7 +522,8 @@ export async function runSleep(ctx, service, config, logger, semantic = null, si
       summary_stored: false,
       receipt,
       policy_epoch: config.policyEpoch ?? 0,
-      run_type: "sleep"
+      run_type: "sleep",
+      skipped: skippedDetail.length ? skippedDetail : undefined
     });
   } catch (error) {
     logger?.warn?.(`dsh-mneme sleep: failed to record audit run: ${String(error)}`);