@modusensus/dsh-mneme 0.8.11 → 0.8.12

package/README.md

@@ -5,7 +5,7 @@
 [![npm version](https://img.shields.io/npm/v/@modusensus/dsh-mneme?color=blue&label=npm)](https://www.npmjs.com/package/@modusensus/dsh-mneme)
 [![license](https://img.shields.io/badge/license-MIT-green)](LICENSE)
 [![Awesome](https://awesome-dsh-plugin.com/badge.svg)](https://github.com/awesome-dsh-plugin/awesome-dsh-plugin)
-[![tests](https://img.shields.io/badge/tests-1437%20passed-success)](https://github.com/slow-stack/mneme)
+[![tests](https://img.shields.io/badge/tests-1497%20passed-success)](https://github.com/slow-stack/mneme)
 [![CI](https://img.shields.io/github/actions/workflow/status/slow-stack/mneme/ci.yml)](https://github.com/slow-stack/mneme/actions)
 [![node](https://img.shields.io/badge/node-22%2B-blue)](https://nodejs.org)
 [![npm downloads](https://img.shields.io/npm/d18m/@modusensus/dsh-mneme.svg?color=blue&label=downloads)](https://www.npmjs.com/package/@modusensus/dsh-mneme)
@@ -253,7 +253,7 @@ v0.3.0 起新增**记忆基因**层：从记忆里抽取**命名实体**、**带
 
 ### 前置条件
 
-- [DeepSeek Harness](https://github.com/deepseek-ai/deepseek-harness)（DSH）— 兼容 DSH 0.1.x，已验证 0.1.2-rc.1（`Session.events` → `snapshotEvents()` 变更已由插件垫片兼容，新旧版本通吃；v0.7.9 确保该垫片真正进入发布产物 lib/）
+- [DeepSeek Harness](https://github.com/deepseek-ai/deepseek-harness)（DSH）— 兼容 DSH 0.1.x 与 0.2.x（三段式 peer 范围见 `package.json`）；开发与 CI 已对齐 0.2 线，`0.2.0-rc.1` / `0.2.0-rc.2` 实测全绿。旧版兼容垫片（`Session.events` → `snapshotEvents()`，v0.7.9 起确保进入发布产物 lib/）保留
 - Node 24+（`node:sqlite`）
 
 ### 安装步骤
@@ -430,7 +430,7 @@ dsh web
 | `searchSemanticDedupThreshold` | `0.95` | 语义去重相似度阈值（v0.5.0，默认 0.95，范围 0.5-1.0）：`searchSemanticDedup=true` 时生效，调整可防小模型误折叠 |
 | `memoryQualityFilter` | `{enabled:true, archiveThreshold:30, degradeThreshold:60, minContentLength:10, exemptImportance:4}` | 记忆质量过滤（v0.4.6，默认开）：写库前启发式打分 0-100，元记忆词汇/自指/过短/重复/近似重复扣分；≥60 正常存储，30-60 降权（注入排序按 importance×quality/100），<30 归档标记 `low_quality`（显式搜索仍可召回，永不自动注入；`exemptImportance` 豁免：importance ≥ 该值只降权不归档，#135） |
 | `llmAudit` | `{enabled:true, retentionDays:90}` | LLM 消耗审计（v0.4.6，默认开）：每次后台 LLM 调用（`autoDream` / `autoSummarize` / `sleep` / `entityExtract`，对应 `operation_type` 为 `dream_consolidate` / `dream_summarize` / `dream_narrative`、`summarize_compress`、`sleep_conflict` / `sleep_pattern`、`entity_extract`）写 `llm_audit_logs`（tokens/duration/status/source）；失败记 error 不阻塞；只读 API `/api/dsh-mneme/semantic/llm-audit` + `/llm-audit/stats` |
-| `scopeEnabled` | `false` | 作用域隔离总开关（v0.8.0，issue #17）：memory_save 按会话身份写入 agent / workspace 标注（agentPreset / 工作区路径，registry 反查取不到回退 header.cwd，再取不到 NULL）；去重键扩展含作用域三元——跨作用域同标题不再物理合并；检索按当前会话作用域加权（命中 ×1.25、他 scope ×0.5 保留可见）。也走 feature_flags 白名单（面板可启停） |
+| `scopeEnabled` | `false` | 作用域隔离总开关（v0.8.0，issue #17）：memory_save 按会话身份写入 agent / workspace 标注（agentPreset / 工作区路径，registry 反查取不到回退 header.cwd，再取不到 NULL）；去重键扩展含作用域三元——跨作用域同标题不再物理合并；检索与注入排序按当前会话作用域加权（命中 ×1.25、他 scope ×0.5 保留可见，issue #339 补齐注入通道）。也走 feature_flags 白名单（面板可启停） |
 | `strictScope` | `false` | 作用域硬过滤（v0.8.0 引入，v0.8.1 起只认显式声明；依赖 `scopeEnabled`）：检索 / 注入 / 列表 / 单取四路过滤，**显式声明**收窄到他者作用域的记忆完全不可见；载体自动标注只降权保留可见——真正的物理隔离请用 sensitivity。会话身份解析不到时 fail-closed 只挡显式行。关闭时全部为软隔离（降权保留可见）。也走 feature_flags 白名单 |
 | `writeAdmission` | `{enabled:false, enforce:false}` | 写入准入（issue #254，默认关）：把「这条该不该进库」前移到 LLM 之前。第 1 级是零 LLM 的确定性判据——空白 / 纯噪声 + 密钥 / PII（判据来源是 #164 A2，经 `sensitiveScan` 注入，本批只定义接口）。`enabled` 跑判据并落审计行（`llm_audit_logs` 的 `metadata.deny`），`enforce` 才真的拒（`store.save` 之前返回，`memory_save` 返回 `action:"denied"` + `reason`）；只开 `enabled` = 仅告警、写入不拦。去重键命中不进第 1 级（归 write-update 放行），G1/G2 阈值只计量。也走 feature_flags 白名单 |
 | `conflictFreezeEnabled` | `false` | 冲突冻结（v0.4.4）：dream 发现矛盾对不自动裁决，冻结进冲突队列；状态页「冲突队列」支持并排对比与人工确认（保留 A / 保留 B / 仅标记已处理，v0.8.0） |
@@ -584,7 +584,7 @@ src/
 ├── api.js            # HTTP 路由（Web 面板数据通道，含 /conflicts 冲突队列）
 └── index.js          # 插件接线
 lib/                  # src 的同步分发产物（npm run sync；发布前由 root prepack 的 check-sync.js 校验一致性；唯一手写例外 lib/client.js——Web 面板 bundle，sync 不覆盖）
-test/                 # 1431 个 node:test 测试（审计与三轴线压测不变量；src↔lib 一致性由 scripts/check-sync.js 发布闸门校验）
+test/                 # 1497 个 node:test 测试（审计与三轴线压测不变量；src↔lib 一致性由 scripts/check-sync.js 发布闸门校验）
 scripts/              # e2e-dsh.js 端到端演示 · stress-dsh.js 三轴线压测 · sync-lib.js 同步 · check-sync.js 发布闸门 · benchmark-recall.js / benchmark-embed.js / benchmark-rerank.js 基准 · sync-test-badge.mjs 测试徽章 · build-runtime-manifest.mjs 运行时清单
 ```
 
@@ -593,7 +593,7 @@ scripts/              # e2e-dsh.js 端到端演示 · stress-dsh.js 三轴线压
 ```bash
 cd dsh-mneme
 npm install        # 安装 peer 依赖（以 devDependencies 形式，用于本地测试）
-npm test           # 运行 1431 个测试
+npm test           # 运行 1497 个测试
 npm run stress     # 三轴线压测：长会话检索 / 冲突仲裁 / 多 Agent 并发（离线 mock LLM）
 npm run sync       # 把 src/ 同步到 lib/（发布时由 prepack 钩子自动执行）
 ```

package/assets/icon.svg

@@ -1,3 +1,3 @@
-<svg xmlns="http://www.w3.org/2000/svg" width="48" height="48" viewBox="0 0 16 16" fill="none" stroke="#4176e6" stroke-width="1" stroke-linecap="round" stroke-linejoin="round">
-  <path d="M4.43 12.31C2.19 10.17 2.27 6.81 4.18 4.84C6.10 2.88 9.06 2.99 10.74 4.68C12.43 6.37 12.28 8.92 10.82 10.33C9.35 11.74 7.22 11.55 6.08 10.32C4.95 9.08 5.18 7.35 6.18 6.50C6.57 6.17 7.03 5.99 7.48 5.97"/>
-</svg>
+<svg xmlns="http://www.w3.org/2000/svg" width="48" height="48" viewBox="0 0 16 16" fill="none" stroke="#4176e6" stroke-width="1" stroke-linecap="round" stroke-linejoin="round">
+  <path d="M4.43 12.31C2.19 10.17 2.27 6.81 4.18 4.84C6.10 2.88 9.06 2.99 10.74 4.68C12.43 6.37 12.28 8.92 10.82 10.33C9.35 11.74 7.22 11.55 6.08 10.32C4.95 9.08 5.18 7.35 6.18 6.50C6.57 6.17 7.03 5.99 7.48 5.97"/>
+</svg>

package/lib/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/lib/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/lib/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/lib/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/lib/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) {

package/lib/graph/anchoring.js

@@ -0,0 +1,180 @@
+// dsh-mneme/src/graph/anchoring.js
+// 图谱锚定层（issue #24 · 块1 Activation Anchoring）。
+import assert from "node:assert/strict";
+// 纯函数模块：把「查询命中实体的多路激活信号」归一化、合并成种子集、再沿
+// entity_relations 级联扩散。零数据库依赖——store 侧查询由调用方注入，
+// 本模块只做信号处理，便于单测与与其他召回通路（BM25/向量）同等对待。
+//
+// 设计输入来自 #24 合议 + heptaspirit serendipity-engine 实战（#24 评论）：
+//  - 归一化二分法：连续分（cos/PPR）走 min-max；匹配通路（精确/tag/别名）
+//    走离散级别，不用 min-max——布尔通路用 min-max 会把「中 1 个」和「中
+//    20 个」都拉平到 1.0，级别信息被压平。
+//  - 级联扩散加「跳数配额」：λ/θ 只管可及性，可见性由配额决定——直接按 hop
+//    深度打 0.5/0.3/0.2 权重，配桶内 round-robin，防深跳被 1-hop 完全压住。
+//  - graphSeedCap：防「多锚点命中 + 模糊通路」把种子集撑爆成整库。
+//  - 排序稳定：并列按实体 ID 破序（同输入两次结果不同会让 A/B 调参白做）。
+
+/** 匹配通路的离散级别（heptaspirit 建议：布尔/计数通路不用 min-max）。 */
+export const DISCRETE_LEVELS = Object.freeze({
+  exact: 1.0, // 名称精确含于查询（布尔 1.0）
+  title: 0.8, // 实体名匹配记忆标题（tag/别名层）
+  alias: 0.6,
+  tag: 0.4,   // tag 共现
+  substring: 0.2, // 子串命中（最弱，纯计数不级联）
+});
+
+/** 级联每跳的权重（跳数配额：1:2:3-hop = 0.5/0.3/0.2）。 */
+export const HOP_QUOTA = Object.freeze({ 1: 0.5, 2: 0.3, 3: 0.2 });
+
+/**
+ * 连续分 min-max 归一化（向量 cos 相似度、PPR 激活分等）。
+ * 输入 [] 或全同值时返回原样（无尺度可压平，防除零）。
+ */
+export function minMax(scores) {
+  const arr = Array.isArray(scores) ? scores : [];
+  if (arr.length === 0) return [];
+  let min = Infinity;
+  let max = -Infinity;
+  for (const v of arr) {
+    if (v < min) min = v;
+    if (v > max) max = v;
+  }
+  if (max - min < 1e-12) return arr.map(() => 1); // 平局视为满权
+  return arr.map((v) => (v - min) / (max - min));
+}
+
+/**
+ * 把一条检测通路的结果归一化成 0..1 的打分表。
+ * path 是离散通路名（exact/tag/...）→ 查 DISCRETE_LEVELS；是连续通路
+ * （continuous=true）→ min-max。返回 { byId: Map<id, score>, order: [id...] }。
+ */
+export function normalizePath(hits, { path = "exact", continuous = false } = {}) {
+  const ids = Array.isArray(hits) ? hits : [];
+  const byId = new Map();
+  if (continuous) {
+    const raw = ids.map((h) => (typeof h === "number" ? h : h?.score ?? 0));
+    const norm = minMax(raw);
+    ids.forEach((h, i) => {
+      const id = typeof h === "object" ? h.id : h;
+      byId.set(id, norm[i]);
+    });
+  } else {
+    const level = DISCRETE_LEVELS[path] ?? DISCRETE_LEVELS.substring;
+    for (const id of ids) byId.set(id, level);
+  }
+  return { byId, order: [...byId.keys()] };
+}
+
+/**
+ * 合并多路激活成种子集：每路先归一化（调用方负责通路分类），再累加。
+ * seedsCap 上限（graphSeedCap，默认 12）；封顶前按总分排序取前 N——保证
+ * 扩散的是活跃子图而非冷启动点爆整库。
+ * 返回 { id, name, score, paths: Set } 列表，按 score 降序、name 升序（稳定）。
+ */
+export function anchorSeeds({ paths = [], cap = 12 } = {}) {
+  const score = new Map();
+  const nameOf = new Map();
+  const pathSet = new Map();
+  for (const p of paths) {
+    for (const [id, s] of p.byId ?? []) {
+      score.set(id, (score.get(id) ?? 0) + s);
+      if (!pathSet.has(id)) pathSet.set(id, new Set());
+      pathSet.get(id).add(p.path ?? "?");
+      if (p.nameOf?.has?.(id)) nameOf.set(id, p.nameOf.get(id));
+    }
+  }
+  let seeds = [...score.entries()].map(([id, s]) => ({
+    id,
+    name: nameOf.get(id) ?? id,
+    score: s,
+    paths: pathSet.get(id) ?? new Set()
+  }));
+  seeds.sort((a, b) => b.score - a.score || (a.name < b.name ? -1 : a.name > b.name ? 1 : 0));
+  if (cap > 0 && seeds.length > cap) seeds = seeds.slice(0, cap);
+  return seeds;
+}
+
+/**
+ * 级联扩散：从种子实体出发沿 adjacency 走 BFS，为每个可达实体贴最短深度。
+ * depth 上界默认 2（[1,3] 配置范围）。返回 Map<entityId, minDepth>——
+ * 调用方据此取 HOP_QUOTA[minDepth] 权重 + 桶内 round-robin（见 pickByHopQuota）。
+ * adjacency 由调用方提供（store.getEntityNeighbors(id) 或全量邻接矩阵），
+ * 本模块不感知存储。
+ */
+export function cascadeDepths({ seeds, adjacencyOf, maxDepth = 2 } = {}) {
+  const depths = new Map();
+  const idOfSeeds = (seeds ?? []).map((s) => (typeof s === "object" ? s.id : s));
+  const queue = [];
+  for (const id of idOfSeeds) {
+    if (!depths.has(id)) {
+      depths.set(id, 0);
+      queue.push([id, 0]);
+    }
+  }
+  for (let i = 0; i < queue.length; i++) {
+    const [id, d] = queue[i];
+    if (d >= maxDepth) continue;
+    let neighbors = [];
+    try {
+      neighbors = typeof adjacencyOf === "function" ? adjacencyOf(id) : (adjacencyOf?.get?.(id) ?? []);
+    } catch { /* single neighbor fetch failure: keep spreading from the rest */ }
+    for (const nb of neighbors) {
+      const nid = typeof nb === "object" ? nb.id : nb;
+      if (!nid || depths.has(nid)) continue;
+      depths.set(nid, d + 1);
+      queue.push([nid, d + 1]);
+    }
+  }
+  return depths;
+}
+
+/**
+ * 跳数配额选取：候选实体按深度分层，层内按（分，ID）稳定排序后取额度。
+ * quota 形如 { 1: 0.5, 2: 0.3, 3: 0.2 }——每层最多取 ceil(depthCap * quota[d]) 个，
+ * 桶内按 score 降序（并列按 ID）。返回 { ids, scoreOf, depthOf }。
+ * 这一步把「级联可及性」与「最终可见性」解耦（heptaspirit：λ/θ 只管前者）。
+ */
+export function pickByHopQuota({
+  depths = new Map(),
+  scoreOf = () => 0,
+  maxDepth = 2,
+  depthCap = 12
+} = {}) {
+  const buckets = new Map(); // depth -> [{id, score}]
+  for (const [id, d] of depths) {
+    if (d === 0 || d > maxDepth) continue;
+    const key = Math.min(d, 3);
+    if (!buckets.has(key)) buckets.set(key, []);
+    buckets.get(key).push({ id, score: scoreOf(id) ?? 0 });
+  }
+  const picked = [];
+  for (const [d, items] of buckets) {
+    items.sort((a, b) => b.score - a.score || (a.id < b.id ? -1 : a.id > b.id ? 1 : 0));
+    const quota = HOP_QUOTA[d] ?? 0.2;
+    const n = Math.max(1, Math.floor(depthCap * quota));
+    picked.push(...items.slice(0, n).map((x) => x.id));
+  }
+  // 队内稳定序：按深度升序（1-hop 优先），保证可感知的扩散次序。
+  picked.sort((a, b) => (depths.get(a) - depths.get(b)) || (a < b ? -1 : a > b ? 1 : 0));
+  return { ids: picked, scoreOf, depthOf: depths };
+}
+
+// Lightweight self-check (ponytail: 非平凡逻辑留一个可运行断言)。
+export function _selfCheck() {
+  const exact = normalizePath(["e1", "e2"], { path: "exact" });
+  const tag = normalizePath(["e2", "e3"], { path: "tag" });
+  assert(exact.byId.get("e1") === 1.0 && exact.byId.get("e2") === 1.0, "exact level");
+  assert(tag.byId.get("e2") === 0.4 && tag.byId.get("e3") === 0.4, "tag level");
+  const seeds = anchorSeeds({ paths: [exact, tag], cap: 10 });
+  assert(seeds[0].id === "e2", "merged highest first"); // e2: 精确+tag = 1.4
+  assert(seeds[0].score >= 1.4 - 1e-9, "score accumulates");
+  const adj = new Map([
+    ["e2", ["n1", "n2"]],
+    ["n1", ["n2", "deep3"]],
+  ]);
+  const depths = cascadeDepths({ seeds, adjacencyOf: (id) => adj.get(id) ?? [], maxDepth: 2 });
+  assert(depths.get("n1") === 1 && depths.get("n2") === 1 && depths.get("deep3") === 2, "bfs depth");
+  const { ids } = pickByHopQuota({ depths, maxDepth: 2, depthCap: 12 });
+  assert(ids.includes("n1") && ids.includes("n2") && ids.includes("deep3"), "quota picks all");
+  return "anchoring self-check ok";
+}

package/lib/index.js

@@ -502,6 +502,11 @@ export const apply = (ctx, config) => {
       logger: ctx.logger,
       semantic: { embedder, vectorIndex },
       lastRunAtSeed: store.lastDreamRunAt("auto"),
+      // Issue #89（基线半边）：阈值基线同样跨重启恢复——只恢复 lastRunAt 的话，
+      // 重启后的第一条写入仍会绕过阈值（库里记忆多于阈值时 overBase 恒成立）开跑
+      // 整轮。种子取上次成功轮的库规模，口径与运行期刷新一致；读不到时调度器退回
+      // 零基线（= 升级前行为）。
+      baselineSeed: store.lastDreamBaseline("auto"),
       // Issue #239（第 4 项）镜像到巩固：高峰期不做梦，顺延到最近的高峰结束时刻。
       peakHours: cfg.dreamPeakHours ?? "",
       peakMaxDeferMinutes: cfg.dreamPeakMaxDeferMinutes ?? 120,

package/lib/inject.js

@@ -274,9 +274,14 @@ export function createInjector(ctx, service, settings, config) {
     // 日志抢同一份预算后被降级」正是本议题要修的结构缺陷。单条仍有硬顶
     // （PINNED_CONTENT_MAX），超出照旧带截断提示，不静默。
     const pinnedCount = Math.max(0, Math.min(candidates.length, pinnedStats?.shown ?? 0));
+    // #24 块3：图召回线索行（graphHint）——引导语插在第一个线索行之前（保持块头
+    // 语义：先声明「这些不是事实」）。线索行自身按 graphHintLine 渲染（线索/ 前缀
+    // 区别于普通记忆行）。
+    let graphSeen = 0;
     for (let i = 0; i < candidates.length; i++) {
       const m = candidates[i];
       const pinned = i < pinnedCount;
+      if (m.graphHint === true) graphSeen++;
       // Epistemic trust (v0.4.5): when enabled, measured observations are
       // flagged so the agent can weigh them above guesses/opinions.
       const verified = config.trustEpistemicWeighting === true && m.epistemic_status === "observation"
@@ -284,7 +289,13 @@ export function createInjector(ctx, service, settings, config) {
         : "";
       const title = STR.entryTitle[language](m.title, m.importance);
       const content = injectMemory(m, pinned ? PINNED_CONTENT_MAX : maxContent);
-      const full = STR.entryLine[language](m.type, verified, title, content);
+      const full = m.graphHint === true
+        ? STR.graphHintLine[language](m.type, title, content)
+        : STR.entryLine[language](m.type, verified, title, content);
+      // 线索行引导语插在第一个线索行之前（保持块头语义：先声明「这些不是事实」）。
+      if (m.graphHint === true && graphSeen === 1) {
+        lines.push(STR.graphHintHeader[language]);
+      }
       if (pinned) {
         // pin 不扣块预算（上面那条设计注释的落地）：pin 一条就够击穿 MAX_BLOCK
         // （PINNED_CONTENT_MAX 2000 > MAX_BLOCK 1500），照扣会把 budget 压成负数，
@@ -363,8 +374,9 @@ export function createInjector(ctx, service, settings, config) {
         const query = lastUserQuery(ctx);
         if (query) prefetchQueryVector(query);
         const queryVector = queryVectorCache.get(query);
-        // v0.8.0 A3：scope 随请求解析（strict 开启时 injectCandidates 内硬过滤；
-        // flag 关闭时解析器返回 null，注入行为不变）。
+        // v0.8.0 A3：scope 随请求解析（解析器恒返回对象，身份取不到时两维为
+        // null）；硬过滤与软加权的门控都在 injectCandidates 内——strict 看
+        // strictScope，软加权看 scopeEnabled 且至少一维可解析（issue #339）。
         const scope = resolveSessionScope(ctx);
         // Issue #205：跨轮轮换——最近 N 个查询轮次注入过的 id 本轮不再优先。
         const sessionId = ctx?.agent?.session?.id ?? "_";

package/lib/lang.js

@@ -81,6 +81,16 @@ export const STR = {
     zh: (n) => `〔约束/偏好类另有 ${n} 条未展示〕`,
     en: (n) => `[${n} more constraint/preference entries not shown]`
   },
+  // Issue #24 块3：图召回线索行的引导语——正向声明「链路信息非事实断言」，
+  // 防 LLM 单次消费把桥接召回当有依据的事实回头扩散（幻觉诱导）。
+  graphHintHeader: {
+    zh: "[检索线索] 以下为实体图搜索的链路信息，仅供定位参考，非事实断言：",
+    en: "[Retrieval hints] Entity-graph link trails below are navigation aids, not factual assertions:"
+  },
+  graphHintLine: {
+    zh: (type, title, content) => `- [线索/${type}] ${title}：${content}`,
+    en: (type, title, content) => `- [hint/${type}] ${title}: ${content}`
+  },
   userSettingsHeader: {
     zh: "[用户设置] 来自 dsh-mneme 的用户画像与规则：",
     en: "[User settings] Profile and rules from dsh-mneme:"