@modusensus/dsh-mneme 0.8.11 → 0.8.12

package/lib/summarize.js

@@ -15,10 +15,17 @@ function parseSummaryJsonResult(raw) {
   const end = text.lastIndexOf("]");
   if (start === -1 || end === -1 || end <= start) return { ok: false, entries: [] };
   let arr;
+  let salvaged = false;
   try {
     arr = JSON.parse(text.slice(start, end + 1));
   } catch {
-    return { ok: false, entries: [] };
+    // issue #339 / E8 实测：10-20% 的窗口输出了含记忆条目的完整对象，只因中段
+    // 一处语法错误被整窗 JSON.parse 拒收；而失败路径的生产行为是游标不推进 +
+    // 温度 0 重试同文同错 = 该窗口记忆静默丢失。这里做失败路径修复：括号配对
+    // 扫描截出完整的顶层对象逐个 parse，救活多少算多少；截出 0 个不视为「模型
+    // 显式说无内容」（那是 ok:true 专属于真实空数组的语义）。
+    arr = salvageArrayItems(text.slice(start, end + 1));
+    salvaged = true;
   }
   if (!Array.isArray(arr)) return { ok: false, entries: [] };
   const VALID = new Set(["preference", "project", "decision", "history", "rejected_solution", "pitfall", "constraint"]);
@@ -38,8 +45,92 @@ function parseSummaryJsonResult(raw) {
     importance: Number.isInteger(item.importance) ? Math.min(5, Math.max(1, item.importance)) : 3
   }));
   // 空数组表示模型明确判断本轮没有可沉淀内容；非空数组若全部无效，
-  // 则不能消费窗口，否则无效输出会永久推进 seq 游标。
-  return { ok: arr.length === 0 || entries.length > 0, entries };
+  // 则不能消费窗口，否则无效输出会永久推进 seq 游标。salvage 路径
+  // 没有「显式空数组」可言——ok 只看是否救回了条目。
+  return {
+    ok: salvaged ? entries.length > 0 : (arr.length === 0 || entries.length > 0),
+    entries,
+    salvaged
+  };
+}
+
+/**
+ * Salvage scanner for malformed JSON arrays (issue #339): extracts every
+ * complete top-level {...} span, parsing each independently. Two passes,
+ * merged with de-duplication:
+ *  - pass 1 is string-aware (handles valid objects whose string values
+ *    legitimately contain braces);
+ *  - pass 2 ignores string state entirely — E8 现场的坏对象带奇数个引号
+ *    （stray quote），pass 1 的奇偶失配会把后续对象的收尾 } 吞进字符串里，
+ *    盲扫按括号深度截取反而能救回它们。坏对象两种扫法都 parse 失败，自然
+ *    被丢弃；两遍的去重靠序列化键。
+ */
+function salvageArrayItems(chunk) {
+  const out = [];
+  const seen = new Set();
+  const push = (obj) => {
+    if (!obj || typeof obj !== "object" || Array.isArray(obj)) return;
+    const key = JSON.stringify(obj);
+    if (!seen.has(key)) { seen.add(key); out.push(obj); }
+  };
+  for (const obj of scanBraceSpans(chunk, true)) push(obj);
+  for (const obj of scanBraceSpans(chunk, false)) push(obj);
+  return out;
+}
+
+function scanBraceSpans(chunk, respectStrings) {
+  // 修订（CodeRabbit review on #350）：只接受「最外层数组的直接子对象」——
+  // 候选 { 必须满足 arrayDepth===1 && objDepth===0 且前一非空白 token 是 [ 或
+  // ,。否则 (a) 嵌套子数组里的对象会被误捞成顶层记忆；(b) 盲扫遇到字符串值
+  // 里的 } 会提前断 span，把属性值对象当独立记忆落库。误拦的代价只是少救回
+  // （安全侧），误捞的代价是写进假记忆。
+  const items = [];
+  let arrayDepth = 0;
+  let objDepth = 0;
+  let inString = false;
+  let escape = false;
+  let objStart = -1;
+  let prev = "";
+  for (let i = 0; i < chunk.length; i++) {
+    const ch = chunk[i];
+    if (respectStrings && inString) {
+      if (escape) escape = false;
+      else if (ch === "\\") escape = true;
+      else if (ch === '"') inString = false;
+      continue;
+    }
+    if (respectStrings && ch === '"') { inString = true; continue; }
+    if (ch === "[") {
+      arrayDepth++;
+      prev = "[";
+      continue;
+    }
+    if (ch === "]") {
+      arrayDepth = Math.max(0, arrayDepth - 1);
+      prev = "]";
+      continue;
+    }
+    if (ch === "{") {
+      if (arrayDepth === 1 && objDepth === 0 && (prev === "[" || prev === ",")) {
+        objStart = i;
+      }
+      objDepth++;
+      prev = "{";
+      continue;
+    }
+    if (ch === "}") {
+      objDepth = Math.max(0, objDepth - 1);
+      if (objDepth === 0 && objStart !== -1) {
+        try { items.push(JSON.parse(chunk.slice(objStart, i + 1))); } catch { /* 坏对象跳过 */ }
+        objStart = -1;
+      }
+      prev = "}";
+      continue;
+    }
+    if (ch === ",") { prev = ","; continue; }
+    if (!/\s/.test(ch)) prev = ch;
+  }
+  return items;
 }
 
 /** Extract a JSON array from LLM output that may contain prose around it. */
@@ -195,9 +286,14 @@ function collectMessages(session, maxChars = 8000, language = "zh", afterSeq, th
         break;
       }
       case "tool/result": {
-        const result = Array.isArray(data?.message?.content)
-          ? data.message.content.find((block) => block?.type === "tool-result")
-          : undefined;
+        // 工具结果有两种形状：旧形状把载荷与 isError 装在 content 内的
+        // `type:"tool-result"` 块上；DSH 0.2.x 起内核改为直接投递 `role:"tool"`
+        // 消息本身，content 里只有 `type:"text"` 块、isError 挂在消息上。只认
+        // 旧块形状时新形状落进 undefined 分支，工具输出与工具报错被静默丢弃。
+        const message = data?.message;
+        const blocks = Array.isArray(message?.content) ? message.content : [];
+        const legacy = blocks.find((block) => block?.type === "tool-result");
+        const result = legacy ?? (message?.role === "tool" ? message : undefined);
         const out = textOf(result?.content);
         const status = result?.isError === true ? STR.statusFail[language] : STR.statusOk[language];
         lines.push(STR.transcriptToolResult[language](status, trim(out, 500)));
@@ -678,9 +774,10 @@ export function createSummarizer(ctx, service, config, deps = {}) {
         // 空数组是合法成功：没有记忆写入，但本次事件窗口仍然应被持久消费。
         persistCursor(session.id, nextSeq);
       }
-      if (audit && (capped > 0 || deduped > 0)) {
+      if (audit && (capped > 0 || deduped > 0 || parsedResult.salvaged)) {
         audit.metadata = {
           parsed: parsed.length,
+          ...(parsedResult.salvaged ? { json_salvaged: true } : {}),
           ...(capped > 0 ? { capped } : {}),
           ...(deduped > 0 ? { deduped, mode: dedupeMode, maxSim: Number(dedupeMaxSim.toFixed(4)) } : {})
         };

package/locale/en.json

@@ -1,6 +1,6 @@
-{
-  "meta": {
-    "title": "mneme",
-    "description": "Cross-session memory: auto-distill each session into a local SQLite store, inject on demand, consolidate while idle (autoDream)."
-  }
-}
+{
+  "meta": {
+    "title": "mneme",
+    "description": "Cross-session memory: auto-distill each session into a local SQLite store, inject on demand, consolidate while idle (autoDream)."
+  }
+}

package/locale/zh.json

@@ -1,6 +1,6 @@
-{
-  "meta": {
-    "title": "mneme 记忆库",
-    "description": "跨会话记忆：自动把会话沉淀进本机 SQLite，需要时按需注入，空闲时巩固（做梦）。"
-  }
-}
+{
+  "meta": {
+    "title": "mneme 记忆库",
+    "description": "跨会话记忆：自动把会话沉淀进本机 SQLite，需要时按需注入，空闲时巩固（做梦）。"
+  }
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@modusensus/dsh-mneme",
   "description": "Cross-session memory plugin for DeepSeek Harness with autoDream consolidation: SQLite store, Markdown mirrors, 9 model tools, automatic injection, session summarization, user profile/rules, custom slash commands, vector (semantic) search, and a Web GUI panel",
-  "version": "0.8.11",
+  "version": "0.8.12",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -71,10 +71,10 @@
   },
   "devDependencies": {
     "@deepseek-ai/cordis": "^4.0.1",
-    "@deepseek-ai/dsh-host-webserver": "^0.1.0-rc.6",
-    "@deepseek-ai/dsh-llm": "^0.1.0-rc.6",
-    "@deepseek-ai/dsh-system-prompt": "^0.1.0-rc.6",
-    "@deepseek-ai/dsh-tools": "^0.1.0-rc.6",
+    "@deepseek-ai/dsh-host-webserver": "^0.2.0-rc.1",
+    "@deepseek-ai/dsh-llm": "^0.2.0-rc.1",
+    "@deepseek-ai/dsh-system-prompt": "^0.2.0-rc.1",
+    "@deepseek-ai/dsh-tools": "^0.2.0-rc.1",
     "@deepseek-ai/schemastery": "^3.18.1",
     "@huggingface/transformers": "^4.3.0",
     "c8": "^12.0.0",
@@ -104,7 +104,8 @@
     "morphicons": "^1.7.1"
   },
   "overrides": {
-    "adm-zip": "0.6.1"
+    "adm-zip": "0.6.1",
+    "brace-expansion": "5.0.12"
   },
   "allowScripts": {
     "onnxruntime-node@1.24.3": true,

package/scripts/sync-test-badge.mjs

@@ -6,7 +6,9 @@
 //   1. 跑一遍全量测试（npm test），取套件总数（`ℹ tests N` 汇总行）；
 //   2. 把双 README 的 tests 徽章（img.shields.io/badge/tests-N%20passed）与
 //      开发命令注释（# N 个测试 / # 运行 N 个测试 / # N 个 node:test 测试 /
-//      # N tests）刷成该数字；
+//      # N tests）刷成该数字——形状集合收在 scripts/test-count-sync.mjs，与发版
+//      自动路径 scripts/release-prep.mjs 共用（两条路径各存一份曾导致 v0.8.11
+//      徽章与注释不同数）；
 //   3. 有变化就写回文件（由调用方决定是否 commit/push），无变化静默退出。
 //
 // 测试失败（fail>0 或进程非零退出）时以非零退出且不改任何文件——徽章永远
@@ -16,6 +18,7 @@ import { execSync } from "node:child_process";
 import { readFileSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
+import { applyTestCount } from "./test-count-sync.mjs";
 
 const scriptDir = dirname(fileURLToPath(import.meta.url));
 const repoRoot = join(scriptDir, "..", "..");
@@ -46,18 +49,17 @@ if (!count) {
   process.exit(1);
 }
 
-// 3) 刷双 README（徽章 + 两行开发命令注释）
+// 3) 刷双 README（徽章 + 四种开发命令注释形状）
+// 形状集合与 release-prep.mjs（发版自动路径）共用，收在 scripts/test-count-sync.mjs —
+// 两条路径各自维护一份规则正是 v0.8.11 注释漂移的根因。
 const targets = [
   join(repoRoot, "README.md"),
   join(repoRoot, "dsh-mneme", "README.md")
 ];
 let changed = 0;
 for (const file of targets) {
-  let text = readFileSync(file, "utf8");
-  const next = text
-    .replace(/tests-\d+%20passed-/g, `tests-${count}%20passed-`)
-    .replace(/(#\s*(?:运行\s*)?)\d+( 个(?:\s*node:test)?\s*测试)/g, `$1${count}$2`)
-    .replace(/(#\s*)\d+( tests)/g, `$1${count}$2`);
+  const text = readFileSync(file, "utf8");
+  const next = applyTestCount(text, count);
   if (next !== text) {
     writeFileSync(file, next);
     changed += 1;

package/scripts/test-count-sync.mjs

@@ -0,0 +1,44 @@
+// 测试数在双 README 里以多种形状重复出现：shields.io 徽章 URL，以及四种 `# N …测试`
+// 注释（`# N 个测试` / `# 运行 N 个测试` / `# N 个 node:test 测试` / `# N tests`）。
+// 所有出现处必须永远报同一个数。
+//
+// 这些规则原先在两条写入路径里各存一份，且形状集合不同：
+//   - scripts/release-prep.mjs（Release Prep 工作流，自动，每次发版跑）
+//   - dsh-mneme/scripts/sync-test-badge.mjs（npm run badge:sync，手动）
+// release-prep 当时只 replace 徽章 URL，于是 v0.8.11 发版时徽章自动跳到 1437，
+// 四条注释留在 1431 —— 自动路径反而成了漂移的来源。规则收在这里共用，
+// 由 test/test-count-sync.test.js 锁住形状集合与「双 README 同数」这条不变量。
+//
+// 徽章正则刻意不带尾随 `-`：`tests-N%20passed` 既能命中 `…passed-3E63DD`（root）
+// 也能命中 `…passed-success`（包 README），将来出现无后缀写法也不会静默漏改。
+
+const BADGE = /tests-\d+%20passed/g;
+const COMMENT_CJK = /(#\s*(?:运行\s*)?)\d+( 个(?:\s*node:test)?\s*测试)/g;
+const COMMENT_EN = /(#\s*)\d+( tests)/g;
+
+/** 把一段文本里所有测试数出现处刷成 count（含徽章与四种注释形状）。 */
+export function applyTestCount(text, count) {
+  return text
+    .replace(BADGE, `tests-${count}%20passed`)
+    .replace(COMMENT_CJK, `$1${count}$2`)
+    .replace(COMMENT_EN, `$1${count}$2`);
+}
+
+/**
+ * 只读地抽出文本里所有测试数字面量及其形状，供「处处一致」断言使用。
+ * 历史版本表里的「745 测试全绿」不带 `#` 前缀，刻意不在两种口径内——那是各版本
+ * 当时的真实记录，不该被后续发版改写。
+ */
+export function readTestCounts(text) {
+  const found = [];
+  for (const m of text.matchAll(/tests-(\d+)%20passed/g)) {
+    found.push({ shape: "badge", value: Number(m[1]) });
+  }
+  for (const m of text.matchAll(/#\s*(?:运行\s*)?(\d+)\s*个(?:\s*node:test)?\s*测试/g)) {
+    found.push({ shape: "comment-cjk", value: Number(m[1]) });
+  }
+  for (const m of text.matchAll(/#\s*(\d+)\s+tests/g)) {
+    found.push({ shape: "comment-en", value: Number(m[1]) });
+  }
+  return found;
+}

package/src/config.js

@@ -281,6 +281,14 @@ export const Config = z.object({
   // 显式开启后放宽跨类型合并检查（类型边界由用户自行承担）；配合
   // dreamSkipInvalid 理解：关闭 skipInvalid 时跨类型 merge 直接整单拒绝。
   allowCrossTypeMerge: z.boolean().default(false),
+  // issue #339 / E8 考卷：merge 护栏（opt-in，默认关 = 现状）。开启后合并对象
+  // 命中长保留类型（preference/pattern/rejected_solution/constraint/pitfall，
+  // 与 archive 护栏同一张表）的 merge 决策整条跳过——E8 实测巩固损耗里
+  // 10/26 条被丢约束已归位 guarded 类型仍被 merge 吃掉，而 archive 护栏只挡
+  // archive 不挡 merge，「更精炼的摘要」恰是约束失真的主通道。skipInvalid
+  // （默认开）时被跳条目进 dream_runs.skipped、run 记 degraded；关闭
+  // skipInvalid 时整单拒绝。与 allowCrossTypeMerge 同用时长 guard 先判。
+  dreamMergeGuard: z.boolean().default(false),
   // Rule version for dream adjudication: when this bumps, older dream_runs
   // degrade to historical evidence (their receipts no longer drive live
   // decisions). Default 0 = no versioning in use yet.
@@ -463,6 +471,35 @@ export const Config = z.object({
   // 检索融合池（与 BM25 同级的确认/回填信号）。默认关=检索行为与 #219 前
   // 逐字节一致；走 feature_flags 面板可启停，lightMode 强制关闭。
   entityRecallEnabled: z.boolean().default(false),
+  // 边权重演化（issue #24 块2）：touch 门控是否把被寻回路径的边权重抬升。
+  // 默认关=边初值纯由建边来源决定（store.RELATION_SOURCE_DEFAULTS），演化
+  // 不生效；开=被激活的边经 bumpRelationWeight 上涨（只加不减、封顶 1.0）。
+  graphWeightEnabled: z.boolean().default(false),
+  // 单次有效触达的抬升幅度。
+  graphWeightDelta: z.number().min(0).max(1).default(0.1),
+  // 被动确认（issue #24 块4）：heat 触达（记忆被召回/注入=被用）即对该记忆
+  // 挂联的关系边做被动确认——bumpRelationWeight 抬一格。默认关=零行为变化；
+  // 开=正常触达演化边权，「关系是用出来的」闭环落地（异常路径复核留后续块）。
+  graphPassiveConfirm: z.boolean().default(false),
+
+  // --- 图谱锚定层（issue #24 · 块1 Activation Anchoring）-------------------
+  // entityRecallEnabled 之上再开一层：以查询命中的实体为种子，沿实体关系表
+  // 级联扩散（默认深度 2），把「邻居实体挂联的记忆」也带进融合池。种子集
+  // 上限 graphSeedCap、级联深度 graphCascadeDepth 一并下发到 anchorSeeds /
+  // cascadeDepths（见 src/graph/anchoring.js）。默认关=行为与 #219 单跳轴
+  // 逐字节一致；走 feature_flags 面板可启停，lightMode 强制关闭。
+  graphAnchoringEnabled: z.boolean().default(false),
+  graphSeedCap: z.natural().min(1).max(30).default(12),
+  graphCascadeDepth: z.natural().min(1).max(3).default(2),
+
+  // 关联提示防幻觉（issue #24 块3）：图召回的候选（查询命中实体的挂联记忆）
+  // 进注入时默认只参与排序、不改变注入块构成（graphInjectHint=false 保守档）；
+  // 开启后注入文本里以固定句式「[检索线索] …」标出，引导语说明这是链路信息
+  // 非事实断言，防 LLM 单次消费把桥接召回当有依据的事实回头扩散。
+  graphInjectHint: z.boolean().default(false),
+  // 图召回候选在注入块里的独立预算（条数上限）。与 pin/document 预算同构：
+  // 不占 maxInjectedItems 名额、只约束「桥接线索」这类低信任信息的常驻占比。
+  graphInjectBudget: z.natural().min(0).max(5).default(1),
 
   // --- sleep mode: idle-triggered deep maintenance (v0.4.0) ---------------
   // Opt-in, off by default. Unlike autoDream (threshold-triggered, lightweight)
@@ -685,7 +722,8 @@ export const Config = z.object({
   // agent_scope, workspace_scope, sensitivity)。检索侧加权/过滤在 A2/A3 落地。
   // 也走 feature_flags（FEATURE_FLAG_BOOLEANS 白名单），面板可启停=线上回滚开关。
   scopeEnabled: z.boolean().default(false),
-  // strictScope（A3）：硬过滤模式。关闭=A2 软隔离（他 scope 降权保留可见）；
+  // strictScope（A3）：硬过滤模式。关闭=A2 软隔离（他 scope 降权保留可见，
+  // 检索与注入排序同权重，issue #339 补齐注入通道）；
   // 开启后检索/注入/list/get 按 issue #17 四象限可见性公式硬过滤——带他 scope
   // 的记忆完全不可见，未标注（NULL）恒可见；当前会话某维度解析不到时该维度
   // 带标注的记忆一律不可见（fail-closed：身份不明只见全局）。依赖 scopeEnabled
@@ -712,6 +750,14 @@ const LIGHT_MODE_OFF = [
   "bm25SearchEnabled",
   // 轻量模式不开图召回轴（#219，依赖实体抽取产出；抽取本身已被关掉）。
   "entityRecallEnabled",
+  // 轻量模式不开图谱锚定层级联（#24 块1，依赖实体抽取 + 关系表，抽取已关则无边可扩）。
+  "graphAnchoringEnabled",
+  // 轻量模式不开边权重演化（#24 块2，依赖实体抽取产出；抽取关则无 v08 边可抬升）。
+  "graphWeightEnabled",
+  // 轻量模式不开关联提示标注（#24 块3，常驻注入文本多一段提示成本）。
+  "graphInjectHint",
+  // 轻量模式不开被动确认（#24 块4，依赖实体抽取产出；抽取关则无 v08 边可抬升）。
+  "graphPassiveConfirm",
   // 轻量模式不开叙述条（额外 LLM 调用；#164 对齐，opt-in）。
   "dreamNarrativeEnabled",
   // 轻量模式不开 document 指针行（#230，opt-in：注册/注入/检索增强全随闸）。

package/src/dream/decisions.js

@@ -210,6 +210,22 @@ export function validateDecisions(decisions, snapshot, options = {}) {
         if (mergeTypes.size > 1 && options.allowCrossTypeMerge !== true) {
           local.push(`${at}: merge ids span multiple types (${[...mergeTypes].join(", ")})`);
         }
+        // issue #339 / E8 考卷：merge 护栏（opt-in，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);
+          }
+          if (guardedTypes.size > 0) {
+            local.push(`${at}: merge of long-retention type(s) ${[...guardedTypes].join(", ")} is blocked by dreamMergeGuard`);
+          }
+        }
       }
     }
     if (local.length > 0) {

package/src/dream/sleep.js

@@ -373,6 +373,9 @@ async function phaseConflicts(ctx, service, config, logger, runId, semantic = nu
     minAgeHours: config.reflectionUpdateMinAgeHours,
     skipInvalid: config.dreamSkipInvalid !== false,
     allowCrossTypeMerge: config.allowCrossTypeMerge === true,
+    // issue #339 / E8：guarded 类型 merge 护栏（opt-in，dreamMergeGuard），
+    // 与 dream 主链路同一判据。
+    mergeGuard: config.dreamMergeGuard === true,
     // Issue #126 review（Copilot）：默认档必须真的只放行旧动作集——只换 prompt 挡不住
     // 模型自发输出 supersede / differentiate，那样"opt-in 零行为变化"就不成立。
     allowedActions: actionSet === "full" ? null : LEGACY_ACTIONS

package/src/dream.js

@@ -52,6 +52,26 @@ function totalChars(memories) {
   return memories.reduce((sum, m) => sum + (m.title?.length ?? 0) + (m.content?.length ?? 0), 0);
 }
 
+// 阈值口径的唯一实现：活跃记忆（未归档、非 summary/document）的条数与正文字符数。
+// 触发判定（shouldTrigger）与「成功轮把基线落库」（runDream 的 finish）都走这里——
+// 两处若各写一份过滤条件，重启播种读到的基线就会和运行期判定口径漂移（一个把
+// document 算进去、一个不算），阈值随之失真，且这种漂移只会在重启后才显形。
+function activeStoreSize(service) {
+  const memories = service.all().filter((m) => !m.archived && m.type !== "summary" && m.type !== "document");
+  return { count: memories.length, chars: totalChars(memories) };
+}
+
+// 基线的唯一合法形状：两个非负整数；其余（缺字段、负数、非整数、整个对象缺失）
+// 一律视为「没有基线」→ 调用方退回 {0,0}。播种值来自持久化列，可能是老库的 NULL
+// 或手工改坏的库，判定必须比调用点更严格，而不是相信数据库里存的一定合法。
+function toBaseline(raw) {
+  if (!raw || typeof raw !== "object") return null;
+  const count = Number.isInteger(raw.count) && raw.count >= 0 ? raw.count : null;
+  const chars = Number.isInteger(raw.chars) && raw.chars >= 0 ? raw.chars : null;
+  if (count === null || chars === null) return null;
+  return { count, chars };
+}
+
 // ---------------------------------------------------------------- audit
 
 /**
@@ -760,7 +780,7 @@ export async function maintainIndexAfterDream(decisions, service, semantic) {
 // 用户配得比这更大的 dreamMinIntervalMinutes 基数压小（见 effectiveMinIntervalMs）。
 const FAILURE_BACKOFF_CAP_MS = 30 * 60 * 1000;
 
-export function createDreamScheduler({ onRun, thresholdCount = 10, thresholdChars = 5000, delayMs = 2000, minIntervalMs = 0, failureBackoff = false, logger, semantic = null, lastRunAtSeed = 0, peakHours = "", peakMaxDeferMinutes = 120, auditPeakSkip = null, now = () => Date.now(), setTimeoutFn = setTimeout, clearTimeoutFn = clearTimeout }) {
+export function createDreamScheduler({ onRun, thresholdCount = 10, thresholdChars = 5000, delayMs = 2000, minIntervalMs = 0, failureBackoff = false, logger, semantic = null, lastRunAtSeed = 0, baselineSeed = null, peakHours = "", peakMaxDeferMinutes = 120, auditPeakSkip = null, now = () => Date.now(), setTimeoutFn = setTimeout, clearTimeoutFn = clearTimeout }) {
   let pendingTimer = null;
   // Issue #239（第 4 项）镜像到巩固：高峰顺延定时器。与 pendingTimer 分开——两者
   // 语义不同（一个是「马上要跑」，一个是「等出高峰再跑」），合成一个变量会让
@@ -768,7 +788,13 @@ export function createDreamScheduler({ onRun, thresholdCount = 10, thresholdChar
   let deferTimer = null;
   let running = false;
   let disposed = false;
-  let baseline = { count: 0, chars: 0 };
+  // Issue #89（基线半边）：阈值基线跨重启持久化。baselineSeed 由调用方从
+  // dream_runs 读上次成功轮结束时的库规模（store.lastDreamBaseline）——它只活在
+  // 闭包内存里时进程重启即归零，而库里记忆远多于阈值，重启后第一条写入就满足
+  // overBase、绕过阈值开跑整轮（#291 只补了 lastRunAt 那半边）。缺种子（新库、
+  // 升级后还没跑过成功轮）或种子非法时退回 {0,0}：不假装知道基线，行为与升级前
+  // 逐字节一致——修的是「知道却不认」，不是凭空造一个基线。
+  let baseline = toBaseline(baselineSeed) ?? { count: 0, chars: 0 };
   let inFlight = null;
   // Issue #89（请求 2）：上一次实际开跑时刻。失败/degraded 的 run 也占用
   // 最小间隔——节流的目的正是防止失败调用连发；间隔内的触发静默跳过。
@@ -792,9 +818,7 @@ export function createDreamScheduler({ onRun, thresholdCount = 10, thresholdChar
   }
 
   function shouldTrigger(service) {
-    const memories = service.all().filter((m) => !m.archived && m.type !== "summary" && m.type !== "document");
-    const count = memories.length;
-    const chars = totalChars(memories);
+    const { count, chars } = activeStoreSize(service);
     const overBase = count >= baseline.count + thresholdCount || chars >= baseline.chars + thresholdChars;
     const overAbs = count >= thresholdCount || chars >= thresholdChars;
     return { trigger: overAbs && overBase, count, chars };
@@ -881,7 +905,10 @@ export function createDreamScheduler({ onRun, thresholdCount = 10, thresholdChar
         if (result && result.ok) {
           consecutiveFailures = 0; // Issue #292：成功清零，下次触发回到基数间隔
           try {
-            baseline = shouldTrigger(service);
+            // Issue #89（基线半边）：run 自报的基线（与审计行同一份数字）优先——重启
+            // 播种读的就是它，两条路径共用唯一口径；no-op 桩不回这个字段时退回现场
+            // 计算，最小测试替身的行为逐字节不变。
+            baseline = toBaseline(result.baseline) ?? shouldTrigger(service);
           } catch (error) {
             // Store closed mid-flight: keep the last known baseline.
             logger?.warn?.(`dsh-mneme dream: baseline refresh failed: ${String(error)}`);
@@ -986,6 +1013,19 @@ export function createDreamScheduler({ onRun, thresholdCount = 10, thresholdChar
       const applied = result.applied ?? 0;
       const summaryStored = result.summary ?? false;
       const receipt = buildReceipt({ runId, status, snapshotHash, inputCount: snapshot.size, applied, summaryStored });
+      // Issue #89（基线半边）：成功轮把「本轮结束后的库规模」落进审计行 = 阈值基线的
+      // 持久化副本，重启后由 store.lastDreamBaseline 播种。判定条件必须与调度器刷新
+      // 基线的条件严格一致（result.ok）——非 ok 轮不推进基线是既有语义，若这里也落值，
+      // 重启后播种就会拿到一个「其实没推进过」的假基线，阈值反而被抬高。
+      // 取不到（库已关闭等）就落 NULL：宁可不持久化，也不写一个错的基线。
+      let baselineSnapshot = null;
+      if (result.ok) {
+        try {
+          baselineSnapshot = activeStoreSize(service);
+        } catch {
+          baselineSnapshot = null;
+        }
+      }
       try {
         service.saveDreamRun({
           id: runId,
@@ -1023,12 +1063,18 @@ export function createDreamScheduler({ onRun, thresholdCount = 10, thresholdChar
           // 而非内联进 decisions——degraded 的 decisions 是合法子集，下游按「决策
           // 数组」消费，内联标记会污染其它读者（失败轮的 _validationFailed 是整单
           // 拒绝哨兵，语义与「部分应用」不同，也不复用）。
-          skipped: result.skipped
+          skipped: result.skipped,
+          // Issue #89（基线半边）：成功的 run 才带这两个值（见上方 baselineSnapshot
+          // 的注释）。两列要么同时有值、要么同时为 NULL，读侧以「同时有值」认账。
+          store_count: baselineSnapshot?.count,
+          store_chars: baselineSnapshot?.chars
         });
       } catch (error) {
         logger?.warn?.(`dsh-mneme dream: failed to record audit run: ${String(error)}`);
       }
-      return { ...result, runId, receipt, snapshotHash };
+      // Issue #89（基线半边）：把「与审计行同一份数字」的基线回给调度器，两条路径
+      // （进程内刷新 / 跨重启播种）因此共享唯一口径；调度器拿不到时会退出现场计算。
+      return { ...result, runId, receipt, snapshotHash, baseline: baselineSnapshot ?? undefined };
     };
     if (!route) {
       logger?.warn?.("dsh-mneme dream: no llm route available");
@@ -1135,7 +1181,9 @@ export function createDreamScheduler({ onRun, thresholdCount = 10, thresholdChar
       // Issue #89：v0.6.9（Issue #26）的宽容路径在 v0.7.11 重写中丢失——单条
       // 非法决策重新只跳过该条、合法子集照常应用（run 记为 degraded）。
       skipInvalid: config.dreamSkipInvalid !== false,
-      allowCrossTypeMerge: config.allowCrossTypeMerge === true
+      allowCrossTypeMerge: config.allowCrossTypeMerge === true,
+      // issue #339 / E8：guarded 类型 merge 护栏（opt-in，dreamMergeGuard）。
+      mergeGuard: config.dreamMergeGuard === true
     });
     // Issue #135：模型把 UUID 缩写成前缀时，唯一前缀已在校验前被解析回完整 id。
     // 解析量是模型输出质量的一个直接信号（>0 意味着模型在缩写 id），记一条 info

package/src/entities/extractor.js

@@ -226,7 +226,10 @@ export async function extractEntities(memory, { store, config, callLLM, logger }
           to_entity: toId,
           relation_type: rel.type,
           memory_id: memory.id,
-          metadata: { model: options.model || "default" }
+          metadata: { model: options.model || "default" },
+          // issue #24 块2：LLM 抽取自动建边 → llm 来源（初值 0.4），区别于
+          // 人工/确认的满权边。来源进 metadata 之上的独立列，演化与审计可辨。
+          source: "llm"
         });
         savedRelations.push(saved);
       } catch (err) {