@modusensus/dsh-mneme 0.8.10 → 0.8.12

package/src/store.js

@@ -52,7 +52,13 @@ CREATE TABLE IF NOT EXISTS dream_runs (
   receipt        TEXT NOT NULL,
   policy_epoch   INTEGER NOT NULL DEFAULT 0,  -- 裁决规则版本：规则升级后旧裁决降级为历史证据
   run_type       TEXT NOT NULL DEFAULT 'auto', -- auto | sleep | organize：周期审计的类别区分
-  skipped        TEXT                     -- JSON: degraded 轮被跳过的逐条明细（index/action/ids/error）
+  skipped        TEXT,                    -- JSON: degraded 轮被跳过的逐条明细（index/action/ids/error）
+  -- Issue #89（基线半边）：本轮成功刷新后的活跃记忆「条数 / 正文字符数」——阈值判定的
+  -- 基线原本只活在调度器闭包内存里，进程重启归零 → 库里记忆多于阈值时，重启后第一条
+  -- 写入就绕过阈值开跑整轮（#291 只持久化了 lastRunAt 那半边）。成功轮才落这两列，
+  -- 失败/降级不推进基线的既有语义不变；两列同时有值或同时为 NULL。
+  store_count    INTEGER,
+  store_chars    INTEGER
 );
 CREATE INDEX IF NOT EXISTS idx_dream_runs_created ON dream_runs(created_at);
 
@@ -249,7 +255,12 @@ CREATE TABLE IF NOT EXISTS entity_relations (
   relation_type TEXT NOT NULL,
   memory_id TEXT,
   created_at TEXT NOT NULL,
-  metadata TEXT
+  metadata TEXT,
+  -- issue #24 块2（权重演化）：边权重 + 建边来源。初值按 source 映射
+  -- （manual 1.0 / confirmed 保持 / tag 0.3 / llm 0.4），演化只经
+  -- bumpRelationWeight（只加不减、封顶），触达侧由 touch 门控驱动。
+  weight REAL NOT NULL DEFAULT 1.0,
+  source TEXT NOT NULL DEFAULT 'manual'
 );
 CREATE INDEX IF NOT EXISTS idx_relations_from ON entity_relations(from_entity);
 CREATE INDEX IF NOT EXISTS idx_relations_to ON entity_relations(to_entity);
@@ -482,7 +493,10 @@ function toDreamRun(row) {
     policy_epoch: row.policy_epoch ?? 0,
     run_type: row.run_type ?? "auto",
     // Issue #104：degraded 轮的逐条跳过明细（JSON 列，NULL = 该轮无跳过项）。
-    skipped: row.skipped ? JSON.parse(row.skipped) : undefined
+    skipped: row.skipped ? JSON.parse(row.skipped) : undefined,
+    // Issue #89（基线半边）：成功轮落下的阈值基线（NULL = 该轮没有推进基线）。
+    store_count: row.store_count ?? undefined,
+    store_chars: row.store_chars ?? undefined
   };
 }
 
@@ -549,6 +563,15 @@ function toRecallRun(row) {
   };
 }
 
+// issue #24 块2：建边来源 → 初值权重映射。tag 延续 LLM 偏差取低起步，
+// llm 抽取自动建边取中低，manual 全权（1.0 是满权，不含演化余量的上限）。
+export const RELATION_SOURCE_DEFAULTS = Object.freeze({
+  manual: 1.0,
+  confirmed: 1.0, // manual_confirmed：已人工确认，维持满权
+  tag: 0.3,
+  llm: 0.4
+});
+
 function toRecallEval(row) {
   if (!row) return undefined;
   let metrics;
@@ -612,6 +635,8 @@ function toRelation(row) {
     relation_type: row.relation_type,
     memory_id: row.memory_id ?? undefined,
     created_at: row.created_at,
+    weight: row.weight ?? 1.0,
+    source: row.source ?? "manual",
     metadata
   };
 }
@@ -751,6 +776,10 @@ export function createStore(path) {
   // 老库打开时 SCHEMA 的 CREATE TABLE 对既有表不生效，列还不存在，把索引写进 SCHEMA
   // 会直接报 no such column（与下方 llm_audit_logs.session_key 同理）。
   addColumn("memories", "content_hash", "ALTER TABLE memories ADD COLUMN content_hash TEXT");
+  // issue #24 块2（权重演化）：entity_relations 加 weight + source。存量关系
+  // 行缺列 → 默认 manual 1.0（最保守：既有语义不因迁移而变弱）。
+  addColumn("entity_relations", "weight", "ALTER TABLE entity_relations ADD COLUMN weight REAL NOT NULL DEFAULT 1.0");
+  addColumn("entity_relations", "source", "ALTER TABLE entity_relations ADD COLUMN source TEXT NOT NULL DEFAULT 'manual'");
   // 列序是 content_hash 打头：哈希几乎唯一，等值 seek 就已收窄到候选行，type 只当同
   // 一次 seek 里的第二列过滤；反过来（type 打头）下面的存量回填就得全表扫——每次打开
   // 都要把全部正文读一遍。
@@ -780,6 +809,11 @@ export function createStore(path) {
   // Issue #104：degraded（合法子集已应用）轮被跳过的决策明细。此前只进 logger.warn，
   // 离线回放 dream_runs 无法定位 degraded 成因（跨类型 merge / update 保护期 / unknown id）。
   addColumn("dream_runs", "skipped", "ALTER TABLE dream_runs ADD COLUMN skipped TEXT");
+  // Issue #89（基线半边）：阈值基线跨重启持久化。存量行两列皆 NULL——历史行反推不出
+  // 「那轮结束时库有多大」（input_count 是窗口条数，不是库规模），所以升级后第一次
+  // 成功轮之前播种端拿不到基线，行为与升级前一致；跑过一轮之后闸门即跨重启生效。
+  addColumn("dream_runs", "store_count", "ALTER TABLE dream_runs ADD COLUMN store_count INTEGER");
+  addColumn("dream_runs", "store_chars", "ALTER TABLE dream_runs ADD COLUMN store_chars INTEGER");
 
   // Legacy mirror_state without v0.3.6 generation columns → add each missing
   // column idempotently (old DBs open cleanly, no data loss).
@@ -1605,17 +1639,26 @@ export function createStore(path) {
     // Issue #104：degraded 轮的跳过明细（JSON）。与 decisions/outcome 同为可选
     // 载荷，未提供时落 NULL（而不是 "[]"），审计行只记真实发生过的跳过。
     const skipped = run.skipped !== undefined ? JSON.stringify(run.skipped) : null;
+    // Issue #89（基线半边）：只有成功刷新过基线的 run 才带这两个值。非法/缺失一律落
+    // NULL——播种端以「两列同时有值」为唯一认账条件，半个基线（只有条数没有字符数）
+    // 会让阈值按 0 字符起算，比不认还糟。
+    const baselineKnown =
+      Number.isInteger(run.store_count) && run.store_count >= 0 &&
+      Number.isInteger(run.store_chars) && run.store_chars >= 0;
+    const storeCount = baselineKnown ? run.store_count : null;
+    const storeChars = baselineKnown ? run.store_chars : null;
     db.prepare(
       `INSERT INTO dream_runs (id, created_at, status, error, provider, model, snapshot_hash,
-        input_count, input, decisions, outcome, applied, summary_stored, receipt, policy_epoch, run_type, skipped)
-       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        input_count, input, decisions, outcome, applied, summary_stored, receipt, policy_epoch, run_type, skipped,
+        store_count, store_chars)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
        ON CONFLICT(id) DO UPDATE SET
          created_at=excluded.created_at, status=excluded.status, error=excluded.error,
          provider=excluded.provider, model=excluded.model, snapshot_hash=excluded.snapshot_hash,
          input_count=excluded.input_count, input=excluded.input, decisions=excluded.decisions,
          outcome=excluded.outcome, applied=excluded.applied, summary_stored=excluded.summary_stored,
          receipt=excluded.receipt, policy_epoch=excluded.policy_epoch, run_type=excluded.run_type,
-         skipped=excluded.skipped`
+         skipped=excluded.skipped, store_count=excluded.store_count, store_chars=excluded.store_chars`
     ).run(
       id,
       run.created_at ?? now,
@@ -1633,7 +1676,9 @@ export function createStore(path) {
       run.receipt,
       policyEpoch,
       runType,
-      skipped
+      skipped,
+      storeCount,
+      storeChars
     );
     return getDreamRun(id);
   }
@@ -1667,6 +1712,27 @@ export function createStore(path) {
     return Number.isFinite(ms) ? ms : 0;
   }
 
+  // Issue #89（基线半边）：上次成功刷新后的阈值基线（活跃条数 / 正文字符数）。与
+  // lastDreamRunAt 同源——审计表就是事实源，不另开一份状态；差别只在只认「推进过
+  // 基线」的行（两列同时非 NULL = 那一轮是 ok）。按 run_type 隔离：sleep/organize
+  // 的轮次不参与 auto 的阈值判定，混用会让其余模块的库规模假扮成巩固基线。
+  // 认不出行时返回 null，调用方退回零基线（= 升级前行为），绝不假装知道基线。
+  function lastDreamBaseline(runType = null) {
+    const where = "store_count IS NOT NULL AND store_chars IS NOT NULL";
+    const row = runType
+      ? db.prepare(
+          `SELECT store_count, store_chars FROM dream_runs
+            WHERE run_type = ? AND ${where}
+            ORDER BY created_at DESC, id LIMIT 1`
+        ).get(runType)
+      : db.prepare(
+          `SELECT store_count, store_chars FROM dream_runs
+            WHERE ${where} ORDER BY created_at DESC, id LIMIT 1`
+        ).get();
+    if (!row) return null;
+    return { count: row.store_count, chars: row.store_chars };
+  }
+
   /**
    * Latest ruling-rule version seen on the audit trail. policy_epoch is a config
    * value stamped onto each run by the caller; reading the newest row's epoch
@@ -2402,8 +2468,13 @@ export function createStore(path) {
   /**
    * Record a typed relation between two entities. metadata (optional) is a
    * free-form JSON blob describing the relation. Relations are append-only.
+   *
+   * issue #24 块2（权重演化）：source 决定边初值——manual 1.0 / confirmed
+   * 保持 / tag 0.3 / llm 0.4；显式传入 weight 时优先于 source 映射（manual
+   * 建边可自带权重）。哲学「关系是用出来的，不是建出来的」：初值只反映来源
+   * 偏见，真正的抬升留给 bumpRelationWeight（touch 门控驱动）。
    */
-  function saveRelation({ from_entity, to_entity, relation_type, memory_id, metadata }) {
+  function saveRelation({ from_entity, to_entity, relation_type, memory_id, metadata, weight, source }) {
     const id = randomUUID();
     const now = nowIso();
     const metaStr = metadata === undefined
@@ -2411,13 +2482,36 @@ export function createStore(path) {
       : typeof metadata === "string"
         ? metadata
         : JSON.stringify(metadata);
+    const src = source ?? "manual";
+    // 只认映射表的自有键：src="constructor"/"toString" 会命中原型链上的函数，直接查表
+    // 拿到的是函数而非权重（绑进 SQL 就是整条写入抛错），必须回退默认 1.0。
+    const w = weight ?? (Object.hasOwn(RELATION_SOURCE_DEFAULTS, src) ? RELATION_SOURCE_DEFAULTS[src] : 1.0);
     db.prepare(
-      `INSERT INTO entity_relations (id, from_entity, to_entity, relation_type, memory_id, created_at, metadata)
-       VALUES (?, ?, ?, ?, ?, ?, ?)`
-    ).run(id, from_entity, to_entity, relation_type, memory_id ?? null, now, metaStr);
+      `INSERT INTO entity_relations (id, from_entity, to_entity, relation_type, memory_id, created_at, metadata, weight, source)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`
+    ).run(id, from_entity, to_entity, relation_type, memory_id ?? null, now, metaStr, w, src);
     return toRelation(db.prepare("SELECT * FROM entity_relations WHERE id = ?").get(id));
   }
 
+  /**
+   * 边权重演化（issue #24 块2）。只加不减、封顶 1.0——权重只能靠「被用」抬升、
+   * 不能靠被人为敲低，封顶防触达过频把边吹到无意义大。
+   * 下界守在这里而不是调用方：增量为负/非有限数一律拒绝（返回 false）。限幅只留
+   * 上界、把「只加不减」托付给配置范围，等于把存储接口的契约挂在调用方自觉上。
+   * 读改写合并成单条 UPDATE（MIN(1.0, weight + ?)）：memoryDir 可被多进程共用，
+   * 先 SELECT 再 UPDATE 会丢并发增量，还会拿旧值把别人已抬升的权重压回去。
+   * 幂等（缺行 changes=0 → false）；delta 默认 0.1，由调用方（touch 门控）决定
+   * 何时算一次有效触达。**作用在关系行**，与 memories 的 last_accessed_at 是两码
+   * 事：这条是针对「这条边被激活了」的演化。
+   */
+  function bumpRelationWeight(id, delta = 0.1) {
+    if (!Number.isFinite(delta) || delta < 0) return false;
+    const result = db.prepare(
+      "UPDATE entity_relations SET weight = MIN(1.0, weight + ?) WHERE id = ?"
+    ).run(delta, id);
+    return result.changes > 0;
+  }
+
   /**
    * Re-point every attr row whose memory_id is fromMemoryId to toMemoryId
    * (autoDream merge migration, v0.3.0 Phase 4 / 4.3.2). When the keeper
@@ -2459,6 +2553,52 @@ export function createStore(path) {
     ).all(entityId, entityId).map(toRelation);
   }
 
+  /**
+  /**
+   * 批量邻接（issue #24 · 块1 锚定层级联）：给定多条实体 id，一并取全部关系行
+   * 并归并成「每个实体 → 相邻实体 id 去重列表」的邻接表。供 anchoring.js 的
+   * cascadeDepths 使用——多实体一族只需要一次 SQL（IN 查询），比逐实体调
+   * getRelations 的 N 次往返省。邻接是无向的（from/to 双向），往返不重复。
+   * 返回 Map<entityId, Array<entityId>>；未命中的实体缺省为 absent（级联视为
+   * 无邻居，Map 里不放键同行，null 同等对待）。
+   */
+  function getEntityNeighbors(entityIds) {
+    const out = new Map();
+    const ids = Array.isArray(entityIds) ? entityIds.filter(Boolean) : [];
+    if (!ids.length) return out;
+    const placeholders = ids.map(() => "?").join(",");
+    const rows = db.prepare(
+      `SELECT from_entity, to_entity FROM entity_relations
+       WHERE from_entity IN (${placeholders}) OR to_entity IN (${placeholders})`
+    ).all(...ids, ...ids);
+    for (const r of rows) {
+      addNeighbor(out, r.from_entity, r.to_entity, ids);
+      addNeighbor(out, r.to_entity, r.from_entity, ids);
+    }
+    return out;
+  }
+
+  function addNeighbor(out, anchor, neighbor, queryIds) {
+    if (!queryIds.includes(anchor)) return; // 只以查询过的实体为锚
+    if (neighbor === anchor) return;        // 自环不构成扩散边
+    if (!out.has(anchor)) out.set(anchor, []);
+    const list = out.get(anchor);
+    if (!list.includes(neighbor)) list.push(neighbor);
+  }
+
+  /**
+   * 按记忆反查关联边（issue #24 块4 被动确认）：一条记忆被召回/注入（触达）
+   * 时，挂在同一记忆上的关系行即「这条关系被用过了」的证据——正常触达视为
+   * 被动确认，调用方据此 bumpRelationWeight。返回 toRelation 行（含 weight/
+   * source）。索引 idx_relations_memory 已建（#219）。
+   */
+  function getRelationsByMemory(memoryId) {
+    if (!memoryId) return [];
+    return db.prepare(
+      "SELECT * FROM entity_relations WHERE memory_id = ?"
+    ).all(memoryId).map(toRelation);
+  }
+
   /** All entities (optionally name-filtered, newest first). Used by sleep phase 4
    *  orphan detection: an entity with zero relations is a candidate for relation
    *  completion. */
@@ -2788,6 +2928,7 @@ export function createStore(path) {
     searchVector,
     saveDreamRun,
     lastDreamRunAt,
+    lastDreamBaseline,
     getDreamRun,
     listDreamRuns,
     getLatestPolicyEpoch,
@@ -2840,8 +2981,11 @@ export function createStore(path) {
     findEntitiesMentionedIn,
     getLinkedMemoryIds,
     saveRelation,
+    bumpRelationWeight,
     migrateAttrsToMemory,
     getRelations,
+    getEntityNeighbors,
+    getRelationsByMemory,
     setMirrorState,
     getMirrorState,
     markMirrorDirty,

package/src/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/test/api.test.js

@@ -669,10 +669,15 @@ test("GET /api/dsh-mneme/features returns empty overrides and effective config d
   // issue #239 第 4 项镜像到巩固新增 dreamPeakHours/dreamPeakMaxDeferMinutes，
   // issue #292 新增 autoDreamFailureBackoff、
   // issue #254 新增 writeAdmission.enabled/writeAdmission.enforce，
-  // issue #34 恢复（#333）新增 injectTimePrefix）
-  assert.equal(Object.keys(data.effective).length, 59 + 3 + 2 + 1 + 2 + 2 + 2 + 1 + 1 + 1 + 2 + 1 + 2 + 1);
+  // issue #34 恢复（#333）新增 injectTimePrefix、
+  // issue #24 块1 新增 graphAnchoringEnabled/graphSeedCap/graphCascadeDepth、
+  // 块2 新增 graphWeightEnabled/graphWeightDelta、块3 新增 graphInjectHint/graphInjectBudget、
+  // 块4 新增 graphPassiveConfirm、
+  // issue #339 新增 dreamMergeGuard）
+  assert.equal(Object.keys(data.effective).length, 59 + 3 + 2 + 1 + 2 + 2 + 2 + 1 + 1 + 1 + 2 + 1 + 2 + 1 + 3 + 2 + 2 + 1 + 1);
   assert.equal(data.effective.dreamSkipInvalid, true);
   assert.equal(data.effective.allowCrossTypeMerge, false);
+  assert.equal(data.effective.dreamMergeGuard, false);
   assert.equal(data.effective.dreamMinIntervalMinutes, 0);
   assert.equal(data.effective.autoDreamFailureBackoff, false);
   assert.equal(data.effective.dreamMaxTokens, 131072);