@modusensus/dsh-mneme 0.7.30 → 0.7.32

package/src/dream.js

@@ -1,6 +1,7 @@
 import { validateDecisions, applyDecisions } from "./dream/decisions.js";
-import { clusterMemories, findPotentialConflicts } from "./dream/clustering.js";
+import { clusterMemories, findPotentialConflicts, cosineSimilarity } from "./dream/clustering.js";
 import { createHash, randomUUID } from "node:crypto";
+import { STR, langOf } from "./lang.js";
 export { validateDecisions, applyDecisions, withEffortFallback, describeStreamFailure, resolveDreamEffort, resolveRoute };
 
 
@@ -40,52 +41,6 @@ function extractJsonArray(text) {
   }
   return null;
 }
-const SUMMARY_PROMPT = `你是记忆库摘要助手。根据整理后的记忆，生成一段 150-200 字的记忆库总览，覆盖：用户偏好、活跃项目、关键决策。之后作为会话上下文注入。只输出摘要文本，不要其他内容。`;
-
-const CONSOLIDATION_PROMPT = `你是记忆库整理助手。下面是全部记忆条目（id、类型、标题、内容、重要性、更新时间）。
-请执行记忆巩固（consolidation），输出一个决策 JSON 数组。
-
-【决策格式（必须严格遵守）】
-每个决策必须是对象，字段固定：
-- "action"：必填。取值只能是 "keep" / "merge" / "archive" / "update" / "conflict" 之一（字段名必须是 action，严禁写成 type）
-- "ids"：必填，数组，本决策涉及的记忆 id 列表
-- "reason"：可选，字符串，决策理由
-- "importance"：可选，整数 1-5
-- merge 额外字段："keepSource"（单个 id 字符串，必须是 ids 之一）+ 合并后的 "title"、"content"
-- conflict 额外字段："winner" 与 "loser"，都是【单个 id 字符串，不是数组】
-- update 额外字段：修正后的 "title" 和/或 "content"；"ids" 只能包含一个 id
-
-【决策 JSON 示例】
-[
-  { "action": "merge", "ids": ["m1", "m2"], "keepSource": "m1", "title": "合并标题", "content": "合并后的摘要内容", "importance": 4, "reason": "主题相近" },
-  { "action": "conflict", "winner": "m3", "loser": "m4", "reason": "内容矛盾，保留更新的信息" },
-  { "action": "update", "ids": ["m5"], "content": "修正后的内容", "reason": "信息过时" },
-  { "action": "archive", "ids": ["m6"], "reason": "重复或过时" }
-]
-
-【任务】
-1. 识别主题相近的条目 → merge（合并为更精炼的摘要，保留信息最完整的 id 作为 keepSource）
-2. 识别重复/过时信息 → archive
-3. 识别内容矛盾的条目 → conflict（按时间新旧、来源完整性、信息具体程度判断 winner/loser）
-4. 发现单条记忆中的信息过时、错误或遗漏 → update（直接修正内容）
-   - update 的 ids 只能包含一个 id
-   - 必须提供修正后的 title 和/或 content
-   - 仅当内容确实需要修正时才使用，不要滥用
-   - 每次整理最多输出 2 个 update
-   - 24 小时内新建的记忆不可 update
-5. 无问题的条目无需输出（未提及的条目将自动保留 keep）
-
-【硬性规则】
-- 字段名必须精确为 "action"，严禁写成 "type"；字段名统一用双引号
-- conflict 的 winner/loser、merge 的 keepSource 都是【单个 id 字符串，绝不是数组】
-- 每条记忆最多被 claim 一次：同一个 id 不能出现在多个决策中（同一 id 不能被 merge 和 conflict/archive 等重复占用）
-- 未在决策中提及的记忆将自动保留（keep），无需为每条记忆输出 keep
-- merge 的 keepSource 必须是 ids 之一
-- 仅合并同类型条目（type 相同）
-- 不要编造 ids；只使用提供的 id
-- 重要性 1-5，合并后取最高
-- 只输出 JSON 数组，不要其他文字`;
-
 function totalChars(memories) {
   return memories.reduce((sum, m) => sum + (m.title?.length ?? 0) + (m.content?.length ?? 0), 0);
 }
@@ -154,6 +109,13 @@ export function buildOutcome(decisions) {
       byId[d.loser] = "conflict-archived";
     } else if (d.action === "update") {
       for (const id of d.ids) byId[id] = "updated";
+    } else if (d.action === "supersede") {
+      // Issue #126 review（Copilot）：新动作此前在 outcome.byId 里没有 disposition，
+      // 审计行产了 receipt 却看不出这些目标被如何处置。
+      byId[d.winner] = "supersede-winner";
+      byId[d.loser] = "superseded-archived";
+    } else if (d.action === "differentiate") {
+      for (const id of d.ids ?? []) byId[id] = "differentiated";
     }
   }
   return { byId };
@@ -226,6 +188,32 @@ function buildRecordReceipts({ runId, committed, snapshot, policyEpoch }) {
         kind: "update",
         input_digest: hashDecisionInput([at(c.ids[0])].filter(Boolean))
       });
+    } else if (c.action === "supersede") {
+      // Issue #126：演进型裁决——record 记被取代的一方。winner 正文未被改动，
+      // 不需要自己的 receipt；loser 归档并追加"已被取代"注记。
+      receipts.push({
+        ...base,
+        receipt_id: randomUUID(),
+        record_id: c.loser,
+        kind: "supersede",
+        input_digest: hashDecisionInput([at(c.winner), at(c.loser)].filter(Boolean)),
+        winner_id: c.winner,
+        loser_id: c.loser
+      });
+    } else if (c.action === "differentiate") {
+      // Issue #126：互补型裁决——两条都保留，各记一条 receipt。数量没有变化，
+      // count_before/after 固定 1/1（该记录只是被追加了差异注记）。
+      for (const id of c.ids ?? []) {
+        receipts.push({
+          ...base,
+          receipt_id: randomUUID(),
+          record_id: id,
+          kind: "differentiate",
+          input_digest: hashDecisionInput([at(id)].filter(Boolean)),
+          count_before: 1,
+          count_after: 1
+        });
+      }
     }
   }
   return receipts;
@@ -385,11 +373,48 @@ async function withEffortFallback(ctx, effort, attempt, fallback, getStreamError
  * actually accepted — or omit the field entirely when the model declares no
  * reasoning capability at all.
  *
+ * Unset vs explicit 'none' (Issue #135 建议 4/5): these are different intents.
+ * Explicit 'none' = the user asked to omit the field (provider default
+ * applies). Unset is the out-of-the-box state — dream/sleep calls must produce
+ * JSON, and omission lets the harness substitute the model's defaultEffort
+ * (thinking-type models often default to high), which drains the token budget
+ * and returns an empty body. So unset resolves to the LOWEST effort the model
+ * declares instead of omitting; when the capability query is unavailable the
+ * field stays omitted (fail-safe, retry guard unchanged).
+ *
  * @returns a supported effort id, or null when no effort should be sent, or the
  *   configured value unchanged when the capability query is unavailable.
  */
+
+// 常识档位排序（越靠前推理开销越低）；未知档位排最后（宁可交给显式配置）。
+const EFFORT_RANK = { minimal: 0, off: 0, low: 1, medium: 2, high: 3, max: 4 };
+
+function lowestSupportedEffort(reasoning) {
+  const ids = (reasoning?.efforts ?? []).map((e) => e?.id).filter(Boolean);
+  if (ids.length === 0) return null;
+  return [...ids].sort((a, b) => (EFFORT_RANK[a] ?? 99) - (EFFORT_RANK[b] ?? 99))[0];
+}
+
 async function resolveDreamEffort(ctx, route, configuredEffort, logger) {
-  if (!configuredEffort || configuredEffort === "none") return null;
+  // 显式 'none'：用户要求省略字段（服务商自带默认生效），照旧。
+  if (configuredEffort === "none") return null;
+  if (!configuredEffort) {
+    // 未配置（开箱默认）：取模型声明的最低档，避免 defaultEffort 顶上（建议 4/5）。
+    if (typeof ctx?.llm?.resolveModelInfo !== "function") return null;
+    try {
+      const info = await ctx.llm.resolveModelInfo(route.provider, route.model);
+      const reasoning = info?.reasoning;
+      if (!reasoning) return null; // 无推理声明：省略即安全（无 defaultEffort 可顶上）
+      const lowest = lowestSupportedEffort(reasoning);
+      if (!lowest) return null;
+      logger?.info?.(`dsh-mneme dream: no reasoningEffort configured for ${route.provider}:${route.model}; using lowest supported "${lowest}" instead of the model default "${reasoning.defaultEffort ?? "n/a"}"`);
+      return lowest;
+    } catch (error) {
+      // 能力查询失败：省略字段（fail-safe），withEffortFallback 照旧兜底。
+      logger?.warn?.(`dsh-mneme dream: resolveModelInfo failed (${String(error?.message ?? error)}); omitting reasoningEffort`);
+      return null;
+    }
+  }
   // Capability query unavailable (older harness / minimal mocks): forward the
   // configured value as before — absence of the API proves nothing about the
   // model, and withEffortFallback still guards against rejection.
@@ -480,12 +505,112 @@ async function collectVectors(memories, semantic) {
   return vectors.some((v) => !v) ? null : vectors;
 }
 
+/**
+ * Issue #125：把高相似对聚成**连通分量组**——一个簇 = 一个候选单元。直接按对展开
+ * 会把同一簇拆成互相抢占的多个决策（校验器有 one-claim 规则），成组才是正确粒度
+ * （与 sleep 冲突阶段的贪心"每记忆每轮最多进一对"同理）。
+ * 组内最小相似度用于组间排序：最该处理的簇先入选。
+ */
+function similarityGroups(pairs) {
+  const parent = new Map();
+  const find = (x) => {
+    let root = x;
+    while (parent.get(root) !== root) root = parent.get(root);
+    return root;
+  };
+  for (const p of pairs) {
+    if (!parent.has(p.a.id)) parent.set(p.a.id, p.a.id);
+    if (!parent.has(p.b.id)) parent.set(p.b.id, p.b.id);
+    const ra = find(p.a.id);
+    const rb = find(p.b.id);
+    if (ra !== rb) parent.set(ra, rb);
+  }
+  const byRoot = new Map();
+  for (const p of pairs) {
+    for (const m of [p.a, p.b]) {
+      const root = find(m.id);
+      if (!byRoot.has(root)) byRoot.set(root, new Map());
+      byRoot.get(root).set(m.id, m);
+    }
+  }
+  return [...byRoot.values()].map((members) => {
+    const list = [...members.values()];
+    const ids = new Set(list.map((m) => m.id));
+    let minSim = 1;
+    for (const p of pairs) {
+      if (ids.has(p.a.id) && ids.has(p.b.id)) minSim = Math.min(minSim, p.similarity);
+    }
+    return { members: list, minSim };
+  });
+}
+
+/**
+ * Issue #125：为候选构造收集向量。与 collectVectors 的差别是**允许部分缺失**——
+ * 全量库只要有几条嵌入失败就整场返回 null，会让 hybrid 在真实库上几乎永远回落；
+ * 拿不到向量的条目只是不参与比较（cosineSimilarity 对非数组返回 0，不会误判）。
+ */
+async function collectCandidateVectors(memories, semantic, logger) {
+  const { embedder, vectorIndex } = semantic;
+  const vectors = new Array(memories.length);
+  const missing = [];
+  for (let i = 0; i < memories.length; i++) {
+    const cached = vectorIndex.getEmbedding?.(memories[i].id);
+    if (cached) vectors[i] = cached;
+    else missing.push(i);
+  }
+  if (missing.length) {
+    try {
+      const texts = missing.map((i) => [memories[i].title, memories[i].content].filter(Boolean).join("\n"));
+      const rows = await embedder.embed(texts);
+      missing.forEach((mi, j) => {
+        if (rows[j]?.length) {
+          vectors[mi] = rows[j];
+          vectorIndex.saveEmbedding?.(memories[mi].id, rows[j]);
+        }
+      });
+    } catch (error) {
+      logger?.warn?.(`[dsh-mneme] dream hybrid vector backfill failed: ${String(error)}`);
+    }
+  }
+  return vectors;
+}
+
+/**
+ * Issue #125：hybrid 候选成员，按"组内最小相似度"降序展平（高价值簇排前面，
+ * 受上限截断时先入选）。同类型比较沿用 findPotentialConflicts；仅当
+ * allowCrossTypeMerge 显式开启时再补跨类型高相似对。
+ * 任何失败都返回空数组——调用方回落纯窗口，dream 路径绝不因向量层而失败。
+ */
+async function hybridCandidateMembers(allMemories, config, semantic, logger) {
+  try {
+    const vectors = await collectCandidateVectors(allMemories, semantic, logger);
+    const minSim = config.dreamCandidateMinSim ?? 0.85;
+    const pairs = findPotentialConflicts(allMemories, vectors, minSim);
+    if (config.allowCrossTypeMerge === true) {
+      for (let i = 0; i < allMemories.length; i++) {
+        for (let j = i + 1; j < allMemories.length; j++) {
+          if (allMemories[i].type === allMemories[j].type) continue; // 同类型已由上面覆盖
+          const sim = cosineSimilarity(vectors[i], vectors[j]);
+          if (sim > minSim) pairs.push({ a: allMemories[i], b: allMemories[j], similarity: sim });
+        }
+      }
+    }
+    if (pairs.length === 0) return [];
+    return similarityGroups(pairs)
+      .sort((g1, g2) => g2.minSim - g1.minSim)
+      .flatMap((g) => g.members);
+  } catch (error) {
+    logger?.warn?.(`[dsh-mneme] dream hybrid candidate expansion failed (falling back to window): ${String(error)}`);
+    return [];
+  }
+}
+
 /**
  * Rebuild the vector index after dream decisions so the store and the index
  * stay in sync: merged-away/archived/conflict-loser rows lose their vectors,
  * the merge keeper gets a fresh one.
  */
-async function maintainIndexAfterDream(decisions, service, semantic) {
+export async function maintainIndexAfterDream(decisions, service, semantic) {
   const { embedder, vectorIndex } = semantic;
   if (!embedder || !vectorIndex || typeof embedder.embedSingle !== "function") return;
   const rebuild = new Map();
@@ -500,6 +625,18 @@ async function maintainIndexAfterDream(decisions, service, semantic) {
       }
     } else if (d.action === "archive" || d.action === "conflict") {
       for (const id of d.ids ?? [d.loser]) vectorIndex.deleteEmbedding(id);
+    } else if (d.action === "supersede") {
+      // Issue #126 review（Copilot）：被取代的一方已归档 → 移除其向量（与 conflict 的
+      // loser 同等处置）。winner 正文未变化，向量保持有效。
+      vectorIndex.deleteEmbedding(d.loser);
+    } else if (d.action === "differentiate") {
+      // Issue #126 review（Copilot）：双方正文都被追加了差异注记，而 update 在事务内
+      // 会因 txDepth>0 跳过 scheduleEmbed —— 不在这里重嵌，注记就进不了 embedding，
+      // 注释里承诺的"下一轮不再判成重复"就不成立。
+      for (const id of d.ids ?? []) {
+        const mem = service.getById(id);
+        if (mem) rebuild.set(id, [mem.title, mem.content].filter(Boolean).join("\n"));
+      }
     } else if (d.action === "update") {
       const id = d.ids[0];
       const mem = service.getById(id);
@@ -594,6 +731,7 @@ export function createDreamScheduler({ onRun, thresholdCount = 10, thresholdChar
   }
 
   async function runDream(ctx, service, config) {
+    const language = langOf(config);
     const logger = ctx.logger;
     let memories = service.all().filter((m) => !m.archived && m.type !== "summary");
     if (memories.length === 0) return { ok: true, applied: 0, skipped: true, summary: false };
@@ -601,7 +739,7 @@ export function createDreamScheduler({ onRun, thresholdCount = 10, thresholdChar
     // 窗口外的旧记忆不进 snapshot（大记忆量下全量快照会撑爆 LLM 输入，配合
     // 隐式 keep 让 run 始终可收敛）。按 updated_at 倒序取前 maxSize 条。
     const maxSize = Number.isInteger(config.dreamMaxSnapshotSize) ? config.dreamMaxSnapshotSize : 200;
-    memories = [...memories]
+    const windowMemories = [...memories]
       .sort((a, b) => {
         const ta = String(a.updated_at ?? "");
         const tb = String(b.updated_at ?? "");
@@ -610,6 +748,31 @@ export function createDreamScheduler({ onRun, thresholdCount = 10, thresholdChar
         return a.id < b.id ? -1 : a.id > b.id ? 1 : 0;
       })
       .slice(0, Math.max(1, maxSize));
+    // Issue #125：hybrid 档在窗口之外并入向量翻出的高相似组。候选**总量**仍由
+    // maxSize（或显式 dreamCandidateMax）封顶、与库总量解耦——用"按相似度取候选"
+    // 替代"调大窗口"，输入成本才不随库增长。封顶截断时向量组优先于窗口尾部，
+    // 否则"该合并的一对"仍会被时间窗挤掉。
+    let selected = windowMemories;
+    if ((config.dreamCandidateMode ?? "window") === "hybrid" && semantic?.embedder && semantic?.vectorIndex) {
+      const extra = await hybridCandidateMembers(memories, config, semantic, logger);
+      if (extra.length > 0) {
+        const cap = Math.max(
+          Math.max(1, maxSize),
+          Number.isInteger(config.dreamCandidateMax) && config.dreamCandidateMax > 0 ? config.dreamCandidateMax : 0
+        );
+        const merged = [];
+        const seen = new Set();
+        for (const m of [...extra, ...windowMemories]) {
+          if (seen.has(m.id)) continue;
+          seen.add(m.id);
+          merged.push(m);
+          if (merged.length >= cap) break;
+        }
+        selected = merged;
+        logger?.info?.(`[dsh-mneme] dream hybrid candidates: ${merged.length} (window ${windowMemories.length}, vector ${extra.length}, cap ${cap})`);
+      }
+    }
+    memories = selected;
     const snapshot = new Map(memories.map((m) => [m.id, m]));
     const route = resolveRoute(ctx, config, logger);
     const runId = randomUUID();
@@ -664,7 +827,12 @@ export function createDreamScheduler({ onRun, thresholdCount = 10, thresholdChar
           outcome: result.outcome,
           applied,
           summary_stored: summaryStored,
-          receipt
+          receipt,
+          // Issue #104：degraded（合法子集已应用）轮被跳过的决策明细。写成独立字段
+          // 而非内联进 decisions——degraded 的 decisions 是合法子集，下游按「决策
+          // 数组」消费，内联标记会污染其它读者（失败轮的 _validationFailed 是整单
+          // 拒绝哨兵，语义与「部分应用」不同，也不复用）。
+          skipped: result.skipped
         });
       } catch (error) {
         logger?.warn?.(`dsh-mneme dream: failed to record audit run: ${String(error)}`);
@@ -687,11 +855,11 @@ export function createDreamScheduler({ onRun, thresholdCount = 10, thresholdChar
           const conflictIds = new Set(conflicts.flatMap((c) => [c.a.id, c.b.id]));
           const parts = [];
           clusters.forEach((cluster, ci) => {
-            parts.push(`# 聚类 ${ci + 1}`);
+            parts.push(STR.clusterHeader[language](ci + 1));
             for (const m of cluster) {
               parts.push(
                 `id=${m.id} | type=${m.type} | importance=${m.importance} | updated=${m.updated_at} | title=${m.title} | content=${m.content}` +
-                (conflictIds.has(m.id) ? " | [潜在冲突]" : "")
+                (conflictIds.has(m.id) ? STR.conflictMark[language] : "")
               );
             }
           });
@@ -712,8 +880,8 @@ export function createDreamScheduler({ onRun, thresholdCount = 10, thresholdChar
     // winner/loser (validation requires them) but they are treated as tentative
     // candidates — the human makes the final call, not the model.
     const consolidationPrompt = freezeEnabled
-      ? CONSOLIDATION_PROMPT + `\n\n当前为「冲突冻结」模式：检测到内容矛盾的条目时，仍请输出 conflict，并以 winner/loser 作为候选、reason 说明理由；冲突不会被自动裁决，而会冻结待人工确认。`
-      : CONSOLIDATION_PROMPT;
+      ? STR.prompts.consolidation[language] + STR.prompts.freezeSuffix[language]
+      : STR.prompts.consolidation[language];
     let decisionText;
     // 加固（v0.8.1）：配置的 reasoningEffort 被 provider 拒收时回退重试一次
     // （不带该字段），避免 thinking 模型配置 low/medium 直接整单失败。解析放
@@ -764,7 +932,7 @@ export function createDreamScheduler({ onRun, thresholdCount = 10, thresholdChar
       logger?.warn?.(`dsh-mneme dream: no json array in llm output (raw length ${decisionText?.length ?? 0}; head: ${head})`);
       return finish({ ok: false, error: "no json array in llm output", summary: false });
     }
-    const { ok, errors, skipped } = validateDecisions(decisions, snapshot, {
+    const { ok, errors, skipped, resolvedShortIds } = validateDecisions(decisions, snapshot, {
       maxUpdatePerRun: config.reflectionUpdateMaxPerRun,
       minAgeHours: config.reflectionUpdateMinAgeHours,
       // v0.4.4 fix：显式透传，用户配 dreamImplicitKeep:false 时严格模式必须
@@ -776,9 +944,28 @@ export function createDreamScheduler({ onRun, thresholdCount = 10, thresholdChar
       skipInvalid: config.dreamSkipInvalid !== false,
       allowCrossTypeMerge: config.allowCrossTypeMerge === true
     });
+    // Issue #135：模型把 UUID 缩写成前缀时，唯一前缀已在校验前被解析回完整 id。
+    // 解析量是模型输出质量的一个直接信号（>0 意味着模型在缩写 id），记一条 info
+    // 便于事后从日志侧观察该行为的分布。
+    if (resolvedShortIds > 0) {
+      logger?.info?.(`[dsh-mneme] dream: resolved ${resolvedShortIds} short id prefix(es) to full ids`);
+    }
     if (!ok) {
+      // Issue #135（观测缺口）：失败轮的逐条校验明细此前既不落库也基本不可见——
+      // skipped 的 warn 写在 return 之后（失败路径到不了），dream_runs.decisions
+      // 落 NULL，上百轮失败零现场。这里把明细前置到日志，并把
+      // { _validationFailed, errors, skipped } 随失败行持久化，事后可从审计行
+      // 直接定位「模型输出了什么、为何逐条非法」。
       logger?.warn?.(`dsh-mneme dream: invalid decisions: ${errors.join("; ")}`);
-      return finish({ ok: false, error: `invalid decisions: ${errors.length} errors`, summary: false });
+      if (skipped.length > 0) {
+        logger?.warn?.(`dsh-mneme dream: ${skipped.length} invalid decision(s) skipped: ${skipped.map((s) => `decision[${s.index}]: ${s.error}`).join("; ")}`);
+      }
+      return finish({
+        ok: false,
+        error: `invalid decisions: ${errors.length} errors`,
+        summary: false,
+        decisions: [{ _validationFailed: true, errors, skipped }]
+      });
     }
     const skippedInvalid = skipped.length > 0;
     if (skippedInvalid) {
@@ -902,7 +1089,7 @@ export function createDreamScheduler({ onRun, thresholdCount = 10, thresholdChar
       maxTokens: config.dreamMaxTokens ?? 2048,
       ...(withEffort && effort ? { reasoningEffort: effort } : {}),
       messages: [
-        { role: "system", content: [{ type: "text", text: SUMMARY_PROMPT }] },
+        { role: "system", content: [{ type: "text", text: STR.prompts.dreamSummary[language] }] },
         { role: "user", content: [{ type: "text", text: service.all().filter((m) => !m.archived && m.type !== "summary").map((m) => `- ${m.title}: ${m.content}`).join("\n") }] }
       ]
     }, reportUsage, (reason) => { summaryStreamFailure = describeStreamFailure(reason); }));
@@ -920,7 +1107,7 @@ export function createDreamScheduler({ onRun, thresholdCount = 10, thresholdChar
       // must REPLACE the previous overview (not append — that would grow the
       // summary unboundedly). `_overwrite` still archives the old overview into
       // content_history before replacing it.
-      service.saveWithDedupe({ type: "summary", title: "记忆库总览", content: summaryText.trim(), importance: 5, source: "dream", _overwrite: true });
+      service.saveWithDedupe({ type: "summary", title: STR.summaryTitle[language], content: summaryText.trim(), importance: 5, source: "dream", _overwrite: true });
       summaryStored = true;
       // Re-embed the fresh summary so the index stays in sync with the store.
       if (semantic?.embedder && semantic?.vectorIndex) {
@@ -966,7 +1153,10 @@ export function createDreamScheduler({ onRun, thresholdCount = 10, thresholdChar
       conflicts,
       failures,
       frozen: frozenCount,
-      summary: summaryStored
+      summary: summaryStored,
+      // Issue #104：只有真发生跳过时才落库（degraded 也可能仅因 summary 为空），
+      // ok 轮留 NULL，避免「空数组」与「无此字段」两种假明细占据审计行。
+      skipped: skippedInvalid ? skipped : undefined
     });
   }
 

package/src/embedding.js

@@ -81,9 +81,13 @@ export function createEmbedder({ store, settings, logger, vectorIndex }) {
     } catch { /* metadata write is best-effort */ }
   }
 
+  // issue #135: 「配置是否齐备」的唯一判据 —— embed()/embedFor() 的守卫与下面
+  // ready/configured 两个 getter 共用，避免以后改一处漏一处。
+  const configComplete = (cfg) => !!(cfg?.enabled && cfg.baseUrl && cfg.apiKey && cfg.model);
+
   async function embedFor(id, title, content) {
     const cfg = settings.getVectorConfig();
-    if (!cfg?.enabled || !cfg.baseUrl || !cfg.apiKey || !cfg.model) return;
+    if (!configComplete(cfg)) return;
     const text = [title, content].filter(Boolean).join("\n");
     const vector = await embedText(cfg, text);
     if (vector) {
@@ -100,6 +104,22 @@ export function createEmbedder({ store, settings, logger, vectorIndex }) {
     // Display name for /semantic: a literal's constructor.name is "Object",
     // which the status card would render verbatim.
     name: "OpenAI",
+    /**
+     * issue #135: 这个 embedder 没有异步初始化，`"ready" in embedder` 的通用
+     * 分支会把它恒判为可用 —— 而 vector-config 四项有缺时它一条都嵌不出来。
+     * 对外报真实可用性，让 /semantic 的 ready 不再是「绿色假阳性」。
+     * 用 getter 而非快照字段：设置面板改完配置无需重启即生效（与 embed() 同源读取）。
+     */
+    get ready() {
+      return configComplete(settings.getVectorConfig());
+    },
+    /**
+     * 与 ready 同源，分开两个名字是给 /semantic 用：local/ollama 的
+     * ready=false 表示「还在初始化」，而这里的 false 表示「根本没配」。
+     */
+    get configured() {
+      return configComplete(settings.getVectorConfig());
+    },
     /** Fire-and-forget re-embed of a memory after any write. */
     schedule(memory) {
       if (!memory?.id) return;
@@ -109,7 +129,7 @@ export function createEmbedder({ store, settings, logger, vectorIndex }) {
     /** Embed one text and return its vector (null on failure/disabled). */
     async embed(query) {
       const cfg = settings.getVectorConfig();
-      if (!cfg?.enabled || !cfg.baseUrl || !cfg.apiKey || !cfg.model) return null;
+      if (!configComplete(cfg)) return null;
       const vector = await embedText(cfg, query);
       if (vector) _dimension = vector.length;
       return vector;

package/src/index.js

@@ -15,6 +15,7 @@ import { createEmbedderByProvider } from "./local-embedder.js";
 import { LocalReranker } from "./reranker.js";
 import { createVectorIndex } from "./vector-index.js";
 import { Config, applyLightModePreset } from "./config.js";
+import { langOf } from "./lang.js";
 import { extractEntities } from "./entities/extractor.js";
 import { mkdirSync } from "node:fs";
 import { join } from "node:path";
@@ -86,6 +87,44 @@ export function createEntityStreamAdapter({ llm, agentDefaultModel, logger }) {
   };
 }
 
+/**
+ * Issue #128: bounded backfill of rows still missing an embedding (active rows
+ * only — needsEmbedding filters archived/forgotten). Exported for tests.
+ *
+ * Runs regardless of the model fingerprint: the old call-site gate returned
+ * early when vector_meta already held the embedder's hash, permanently
+ * orphaning rows whose embed failed at write time (embedder not ready /
+ * provider rate limit) — one successful embed was enough to never backfill
+ * again. markModel is idempotent when the fingerprint already matches, so
+ * re-running costs nothing beyond the actually-missing rows.
+ */
+export async function backfillMissingEmbeddings({
+  store, embedder, vectorIndex, logger,
+  maxTotal = 500, batchSize = 10, rateLimitMs = 200
+}) {
+  let indexed = 0;
+  for (let done = 0; done < maxTotal;) {
+    const rows = store.needsEmbedding(batchSize);
+    if (!rows.length) break;
+    for (const row of rows) {
+      try {
+        const text = [row.title, row.content].filter(Boolean).join("\n");
+        const vector = await embedder.embedSingle(text);
+        if (vector?.length) {
+          store.setEmbedding(row.id, vector);
+          indexed++;
+        }
+      } catch { /* skip the bad row */ }
+    }
+    done += rows.length;
+    // Rate limit: space out batches so the provider is not hammered.
+    if (store.needsEmbedding(1).length) await new Promise((r) => setTimeout(r, rateLimitMs));
+  }
+  if (indexed > 0 && embedder.modelHash) vectorIndex.markModel?.(embedder.modelHash, embedder.dimension);
+  logger?.info?.(`[dsh-mneme] auto-reindex backfilled ${indexed} embeddings on boot`);
+  return indexed;
+}
+
 export const apply = (ctx, config) => {
   const rawCfg = Config(config);
 
@@ -148,7 +187,9 @@ export const apply = (ctx, config) => {
     cfg[objKey] = { ...(cfg[objKey] ?? {}), ...sub };
   }
 
-  const mirror = createMirror(memoryDir);
+  // 记忆语言（memory.language）：本实例逐层传入 inject / summarize / dream /
+  // sleep / mirror，多实例（如 agent preset 内挂载）互不影响。
+  const mirror = createMirror(memoryDir, langOf(cfg));
   const service = createService({ store, mirror, config: cfg, logger: ctx.logger });
 
   // F-NEW-03: if the mirror sync failed last run (persisted dirty state), retry
@@ -212,7 +253,18 @@ export const apply = (ctx, config) => {
     // model fingerprint after each successful embed (Bug3).
     embedder = createEmbedder({ store, settings, logger: ctx.logger, vectorIndex });
     service.setEmbedder(embedder);
-    // legacy OpenAI embedder is immediately usable
+    // issue #135: 未配置时明确告警一次。此前 legacy OpenAI embedder 恒报
+    // ready=true，向量层「绿的但全哑」可以静默存在很久（本机持续了数周）。
+    // 只记日志、不阻断启动：轻量模式与「先跑起来再补配置」都是正当用法。
+    if (embedder.configured === false) {
+      ctx.logger?.warn?.(
+        "[dsh-mneme] 向量层未配置（vector-config 的 enabled/baseUrl/apiKey/model 有缺）："
+        + "语义召回、语义去重、rerank、sleep 冲突检测将静默失效，"
+        + "dream 的语义聚类会退化为全量窗口兜底。"
+        + "请在设置面板补全 embedding 端点与模型，或把 embedProvider 改为 local/ollama。"
+      );
+    }
+    // legacy OpenAI embedder needs no async init → human edits apply right away
     applyHumanEdits();
   } else {
     try {
@@ -222,6 +274,7 @@ export const apply = (ctx, config) => {
         device: cfg.localEmbedDevice,
         batchSize: cfg.localEmbedBatchSize,
         cacheDir: cfg.embedModelCacheDir,
+        runtimeDir: cfg.runtimeDir,
         baseUrl: cfg.ollamaBaseUrl,
         logger: ctx.logger
       });
@@ -273,6 +326,7 @@ export const apply = (ctx, config) => {
         scoreThreshold: cfg.rerankScoreThreshold,
         device: cfg.localEmbedDevice,
         cacheDir: cfg.embedModelCacheDir,
+        runtimeDir: cfg.runtimeDir,
         logger: ctx.logger
       });
       service.setReranker(reranker);
@@ -287,10 +341,10 @@ export const apply = (ctx, config) => {
 
   // Bug2: lazy auto-backfill of missing embeddings on boot. When the vector API
   // is configured and rows still lack an embedding (e.g. written before vector
-  // search was enabled) AND the vector_meta fingerprint is absent or stale, the
-  // index is rebuilt in the background after a short delay. Gated on
-  // cfg.autoReindexOnBoot; rate-limited in small batches so a large backlog
-  // never floods the provider. Failures degrade silently — search stays keyword.
+  // search was enabled), the backfill runs in the background after a short
+  // delay. Gated on cfg.autoReindexOnBoot; rate-limited in small batches so a
+  // large backlog never floods the provider. Failures degrade silently —
+  // search stays keyword.
   function scheduleAutoReindex() {
     if (cfg.autoReindexOnBoot === false) return;
     const attempt = (tries) => {
@@ -303,36 +357,13 @@ export const apply = (ctx, config) => {
           return;
         }
         if (!store.needsEmbedding(1).length) return; // nothing to backfill
-        // Model fingerprint gate: vectors already produced by the same model
-        // mean there is no drift and no rebuild needed.
-        const current = embedder.modelHash;
-        if (current && vectorIndex.modelHash?.() === current) return;
-        const BATCH = 10;
-        const MAX_TOTAL = 500; // bound boot-time work
-        (async () => {
-          let indexed = 0;
-          for (let done = 0; done < MAX_TOTAL;) {
-            const rows = store.needsEmbedding(BATCH);
-            if (!rows.length) break;
-            for (const row of rows) {
-              try {
-                const text = [row.title, row.content].filter(Boolean).join("\n");
-                const vector = await embedder.embedSingle(text);
-                if (vector?.length) {
-                  store.setEmbedding(row.id, vector);
-                  indexed++;
-                }
-              } catch { /* skip the bad row */ }
-            }
-            done += rows.length;
-            // Rate limit: space out batches so the provider is not hammered.
-            if (store.needsEmbedding(1).length) await new Promise((r) => setTimeout(r, 200));
-          }
-          if (indexed > 0 && current) vectorIndex.markModel?.(current, embedder.dimension);
-          ctx.logger?.info?.(`[dsh-mneme] auto-reindex backfilled ${indexed} embeddings on boot`);
-        })().catch((error) => {
-          ctx.logger?.warn?.(`[dsh-mneme] auto-reindex failed: ${String(error)}`);
-        });
+        // Issue #128: no fingerprint gate here anymore — a matching fingerprint
+        // used to return early and permanently orphan rows whose embed failed
+        // at write time. See backfillMissingEmbeddings().
+        backfillMissingEmbeddings({ store, embedder, vectorIndex, logger: ctx.logger })
+          .catch((error) => {
+            ctx.logger?.warn?.(`[dsh-mneme] auto-reindex failed: ${String(error)}`);
+          });
       } catch (error) {
         ctx.logger?.warn?.(`[dsh-mneme] auto-reindex failed: ${String(error)}`);
       }
@@ -345,7 +376,7 @@ export const apply = (ctx, config) => {
   // on boot; add/remove re-register live through the API.
   let commands = null;
   if (ctx.commands) {
-    commands = createCommandManager({ ctx, settings, logger: ctx.logger });
+    commands = createCommandManager({ ctx, settings, logger: ctx.logger, language: langOf(cfg) });
     commands.sync();
   }