@modusensus/dsh-mneme 0.8.10 → 0.8.12

package/lib/service.js

@@ -11,6 +11,7 @@ import { createDocumentRegistrar } from "./document.js";
 import { createOrganizer } from "./organize.js";
 import { createBM25Index } from "./search/bm25.js";
 import { adaptiveThreshold } from "./search/adaptive.js";
+import { anchorSeeds, normalizePath, cascadeDepths, HOP_QUOTA } from "./graph/anchoring.js";
 
 const INJECT_TYPES = new Set(["preference", "project", "decision", "summary", "rejected_solution", "pitfall", "constraint"]);
 
@@ -448,30 +449,92 @@ export function createService({ store, mirror, config, onWrite, logger, document
   }
 
   /**
-   * Graph fourth recall path (issue #219). When the query text mentions a
-   * known entity name, memories linked to that entity (attrs + relations)
-   * join the fusion pool as a confirm/backfill signal — same standing as
-   * BM25, never dominating the semantic ranking. Tier scores: attr-linked
-   * 1.0 (direct evidence, same source searchByEntity trusts) > relation
-   * edge 0.9. Archived/forgotten rows never participate. Failures degrade
-   * to [] — a recall booster, never a correctness gate (same contract as
-   * bm25Recall).
+   * Graph fourth recall path (issue #219 → #24 块1 锚定层). When the query text
+   * mentions a known entity name, memories linked to that entity (attrs +
+   * relations) join the fusion pool as a confirm/backfill signal — same standing
+   * as BM25, never dominating the semantic ranking. Tier scores: attr-linked
+   * 1.0 (direct evidence, same source searchByEntity trusts) > relation edge
+   * 0.9. Archived/forgotten rows never participate. Failures degrade to [] —
+   * a recall booster, never a correctness gate (same contract as bm25Recall).
+   *
+   * #24 升级（graphAnchoringEnabled）：命中实体作为锚定种子，沿 entity_relations
+   * 级联扩散邻居（默认深度 2），邻居挂联的记忆以 hop 配额权重参与——把「关系是
+   * 用出来的」延伸成检索信号：查询命中的不只有直接挂联，还有跳跃可达的活跃子图。
+   * 邻居权重 = HOP_QUOTA[hop] × linked tier（attr 1.0 / relation 0.9），仍低于
+   * 直达种子的满权，绝不喧宾夺主。
    */
   function entityRecall(q, limit) {
     if (config?.entityRecallEnabled !== true) return [];
     try {
       const entities = store.findEntitiesMentionedIn(q);
       if (!entities.length) return [];
-      const linked = store.getLinkedMemoryIds(entities.map((e) => e.id));
-      if (!linked.size) return [];
-      const hits = [];
-      for (const [id, tier] of linked) {
-        const row = store.getById(id);
-        if (!row || row.archived || row.forgotten) continue;
-        hits.push({ ...row, score: tier === "attr" ? 1.0 : 0.9, source: "entity" });
-        if (hits.length >= limit * 2) break;
+      // 关闭锚定级联=逐字节复用 #219 单跳轴：种子裁剪/重排/截断全是 #24 新增的
+      // 行为，默认关时一条都不许漏进旧路径（graphSeedCap 也只在开启后生效——
+      // 无论 cap 调多小，关档时命中实体仍全量挂联）。
+      if (config?.graphAnchoringEnabled !== true) {
+        const linked = store.getLinkedMemoryIds(entities.map((e) => e.id));
+        if (!linked.size) return [];
+        const hits = [];
+        for (const [id, tier] of linked) {
+          const row = store.getById(id);
+          if (!row || row.archived || row.forgotten) continue;
+          hits.push({ ...row, score: tier === "attr" ? 1.0 : 0.9, source: "entity" });
+          if (hits.length >= limit * 2) break;
+        }
+        return hits;
+      }
+      // 锚定种子（精确名布尔通路——命名实体逻辑上是离散匹配，不参与 min-max）。
+      const exact = normalizePath(entities.map((e) => e.id), { path: "exact" });
+      const seeds = anchorSeeds({ paths: [exact], cap: config?.graphSeedCap ?? 12 });
+      if (!seeds.length) return [];
+      // 0-hop 直达：挂联记忆按 tier 定分（attr 1.0 / relation 0.9）——与 #219
+      // 单跳轴同分。MAX 语义：同一条记忆被多实体挂联时保留最高分。
+      const scored = new Map();
+      const push = (memId, score) => {
+        if (scored.has(memId) && scored.get(memId) >= score) return;
+        const row = store.getById(memId);
+        if (!row || row.archived || row.forgotten) return;
+        scored.set(memId, score);
+      };
+      const seedLinked = store.getLinkedMemoryIds(seeds.map((s) => s.id));
+      for (const [memId, tier] of seedLinked) {
+        push(memId, tier === "attr" ? 1.0 : 0.9);
+      }
+      // 级联：沿 entity_relations 走 BFS，邻居挂联的记忆以 hop 配额权重补位——
+      // 不覆盖种子直达分（MAX 语义保证），只填「种子里没有但邻居可达」的槽。
+      const seedIds = seeds.map((s) => s.id);
+      const adjacency = store.getEntityNeighbors(seedIds);
+      const depths = cascadeDepths({
+        seeds,
+        // 逐节点懒取邻居：初次查询只带种子那一层的邻接，BFS 走到 1-hop 节点时
+        // 必须按需再拉一层，否则 >1 跳永远拿到空邻居、graphCascadeDepth≥2 形同
+        // 虚设。节点数随图度数增长，热路径上以 graphCascadeDepth≤3 为天然上界，
+        // 真遇到大图再考虑查询配额。
+        adjacencyOf: (id) => {
+          if (!adjacency.has(id)) adjacency.set(id, store.getEntityNeighbors([id]).get(id) ?? []);
+          return adjacency.get(id);
+        },
+        maxDepth: config?.graphCascadeDepth ?? 2
+      });
+      let neighborsSeen = 0;
+      const neighborCap = (config?.graphSeedCap ?? 12) * HOP_QUOTA[1]; // 1-hop 配额即为邻居总量上界
+      for (const [nid, hop] of depths) {
+        if (hop < 1) continue;
+        if (neighborsSeen >= Math.max(1, Math.floor(neighborCap))) break;
+        neighborsSeen++;
+        const neighborLinked = store.getLinkedMemoryIds([nid]);
+        for (const [memId, tier] of neighborLinked) {
+          const tierW = tier === "attr" ? 1.0 : 0.9;
+          push(memId, HOP_QUOTA[Math.min(hop, 3)] * tierW);
+        }
       }
-      return hits;
+      const hits = [...scored.entries()]
+        .map(([id, score]) => {
+          const row = store.getById(id);
+          return { ...row, score, source: "entity" };
+        })
+        .sort((a, b) => b.score - a.score || (a.id < b.id ? -1 : a.id > b.id ? 1 : 0));
+      return hits.slice(0, limit * 2);
     } catch {
       return [];
     }
@@ -530,11 +593,28 @@ export function createService({ store, mirror, config, onWrite, logger, document
    * on the hot recall path). A touch failure must never break search/inject.
    */
   function touchRecalled(memories) {
-    if (config?.heatEnabled === false || !Array.isArray(memories) || memories.length === 0) return;
+    if (!Array.isArray(memories) || memories.length === 0) return;
+    // heatEnabled=false 只关 touchLastAccess 的热度消费（既有语义），但 #24
+    // 块4 被动确认独立于 heat——graphPassiveConfirm 开时照常 bump 关联边。
+    // graphWeightEnabled 是块2 立的演化总闸：它关着时任何触达都不该改边权，被动
+    // 确认只是它底下的一个通道（后续块还会接别的确认通道），两键同开才 bump，
+    // 否则单开通道键就等于绕过「演化默认关」的承诺。
+    // 两条路径都 best-effort，失败绝不阻断检索/注入。
+    const heatOn = config?.heatEnabled !== false;
+    const passive = config?.graphPassiveConfirm === true && config?.graphWeightEnabled === true;
+    const delta = config?.graphWeightDelta ?? 0.1;
     for (const m of memories) {
       if (!m?.id) continue;
       try {
-        store.touchLastAccess(m.id);
+        if (heatOn) store.touchLastAccess(m.id);
+        if (passive) {
+          // 正常触达=对该记忆挂联关系边的被动确认；bump 只加不减封顶 1.0，
+          // 自激回路由封顶天然遏制。「仅异常路径暴露给用户复核」的确认记录
+          // 侧在此落地，复核 UI 留后续块。
+          for (const rel of store.getRelationsByMemory(m.id)) {
+            store.bumpRelationWeight(rel.id, delta);
+          }
+        }
       } catch { /* touch is best effort */ }
     }
   }
@@ -1427,6 +1507,14 @@ export function createService({ store, mirror, config, onWrite, logger, document
       ? new Map(filtered.map((m) => [m.id, computeHeat(m, Date.now(), config)]))
       : null;
     const heatOf = (m) => (heatMap ? heatMap.get(m.id) ?? 1 : 1);
+    // v0.8.x（issue #339 / E7 实测）：A2 软加权补齐到注入通道。此前 ×0.5/×1.25
+    // 只作用于 searchMemories——E7 考卷里「explicit 标注 + 软档」的注入集与无标注
+    // 逐条相同（80/80），主泄露面上软档形同虚设。门控与检索侧同款：scopeEnabled
+    // 且当前会话至少一维可解析；strictScope 硬过滤在下方先行，硬墙开启时被滤行
+    // 不会到这里被二次降权。未激活时乘 1，排序与改动前逐字节一致。
+    const softScopeActive = config?.scopeEnabled === true && scope != null &&
+      Boolean(scope.agent_scope || scope.workspace_scope);
+    const scopeMultOf = (m) => (softScopeActive ? scopeMultiplier(m, scope) : 1);
     const items = filtered.sort((a, b) => {
         // 编码记忆在编码任务时优先于普通 decision（与 preference 同级），
         // importance 乘 codingBoostFactor 加权（封顶 5，保持 importance 语义）。
@@ -1447,8 +1535,11 @@ export function createService({ store, mirror, config, onWrite, logger, document
             : m.importance;
         const pa = priority(a);
         const pb = priority(b);
+        // 软加权乘在层内数值积上（priority 档位不动）：foreign ×0.5 后压不过
+        // 同档自己行——E7 的同 importance 档设计正是这个场景。
         return pa - pb ||
-          (effImportance(b) * qualityWeight(b) * heatOf(b)) - (effImportance(a) * qualityWeight(a) * heatOf(a));
+          (effImportance(b) * qualityWeight(b) * heatOf(b) * scopeMultOf(b)) -
+          (effImportance(a) * qualityWeight(a) * heatOf(a) * scopeMultOf(a));
       });
     let candidates = items;
     if (config.hybridInject !== false && q) {
@@ -1493,6 +1584,13 @@ export function createService({ store, mirror, config, onWrite, logger, document
             semanticItems.push(hit);
           }
         }
+        // issue #339（CodeRabbit review on #350）：首轮 BM25 兜底领跑合并池，
+        // 而 selectiveInject 相似度重排要等查询向量就绪才执行——软加权必须
+        // 在这里就位，否则 foreign 命中绕过降权直接占注入位。
+        if (softScopeActive) {
+          semanticItems.sort((a, b) =>
+            (b.score ?? 0) * scopeMultOf(b) - (a.score ?? 0) * scopeMultOf(a));
+        }
       }
       if (semanticItems.length) {
         const seen = new Set();
@@ -1523,7 +1621,13 @@ export function createService({ store, mirror, config, onWrite, logger, document
         const hits = vectorIndex.search(queryVector, { limit: 200, threshold: 0 });
         const sim = new Map(hits.map((m) => [m.id, m.score ?? 0]));
         if (sim.size) {
-          candidates = [...candidates].sort((a, b) => (sim.get(b.id) ?? -1) - (sim.get(a.id) ?? -1));
+          // 软加权作用在真实 sim 上；未命中的规则候选保持 -1 沉底（缺失项
+          // 乘乘数会让 foreign 缺失项反而排到自己的缺失项之上，故不乘）。
+          const scopedSim = (m) => {
+            const s = sim.get(m.id);
+            return s === undefined ? -1 : s * scopeMultOf(m);
+          };
+          candidates = [...candidates].sort((a, b) => scopedSim(b) - scopedSim(a));
         }
       } catch { /* topic re-rank unavailable: keep rule-based order */ }
     }
@@ -1532,6 +1636,26 @@ export function createService({ store, mirror, config, onWrite, logger, document
     if (config?.strictScope === true && scope) {
       candidates = candidates.filter((m) => isVisibleInScope(m, scope));
     }
+    // #24 块3：图召回候选打标。entityRecall 只在 entityRecallEnabled 开启时
+    // 有产出，这里为命中者贴 graphHint 标签——注入侧据此（a）graphInjectHint
+    // 开=标成 [检索线索] 前缀的线索行（独立预算），（b）关=线索行只参与排序
+    // 不改变注入块（保守档）。与检索侧共用同一图闸：块1 #341 把 entityRecall
+    // 升级成级联后，注入侧自动吃到同样的扩散信号，无需再改。只在语义/规则候选
+    // 为空时兜底检索，避免注入路径双倍候选成本。
+    if (config?.entityRecallEnabled === true && q) {
+      try {
+        const graphHits = entityRecall(q, maxItems * 2);
+        if (graphHits.length) {
+          const graphIds = new Set(graphHits.map((m) => m.id));
+          candidates = [
+            ...candidates.map((m) => graphIds.has(m.id) ? { ...m, graphHint: true } : m),
+            ...graphHits
+              .filter((m) => !candidates.some((c) => c.id === m.id))
+              .map((m) => ({ ...m, graphHint: true }))
+          ];
+        }
+      } catch { /* graph hint is best-effort */ }
+    }
     // #249 第一批：B1 pin 池。取在相关性排序之后、轮换之前——取谁按此刻的候选
     // 次序（即相关性次序），取到后从候选中摘除，于是下面的轮换重排碰不到它们
     // （验收：pin 不参与跨轮轮换）。独立预算的两层意义：pin 既不占 maxItems
@@ -1539,7 +1663,10 @@ export function createService({ store, mirror, config, onWrite, logger, document
     // 超预算的条数回报给调用方，在块内如实标注（绝不静默省略）。
     const pinnedBudget = Math.max(0, Math.min(5, Math.floor(config?.pinnedInjectBudget ?? 0)));
     // eligible 留到块外：未展示条数要等 general 槽选完才算得准（见 selected 之后）。
-    const eligible = pinnedBudget > 0 ? candidates.filter((m) => PINNED_MEMORY_TYPES.has(m.type)) : [];
+    // graphHint 行不进 pin 池：pin 是「每轮必进的约束/偏好」，而线索行按定义是
+    // 「链路信息、非事实断言」，且 pin 长在候选池遍历之前——不排除的话，保守档
+    // （graphInjectHint 关）也能从 pin 侧把它放回注入块，线索开关就被绕过去了。
+    const eligible = pinnedBudget > 0 ? candidates.filter((m) => PINNED_MEMORY_TYPES.has(m.type) && m.graphHint !== true) : [];
     let pinned = [];
     if (pinnedBudget > 0 && eligible.length > 0) {
       pinned = eligible.slice(0, pinnedBudget);
@@ -1560,9 +1687,23 @@ export function createService({ store, mirror, config, onWrite, logger, document
     // 注入块变成文档目录（#164 失败判据：批量把历史塞进上下文）。
     const documentBudget = config?.documentInjectBudget ?? 2;
     let documentSeen = 0;
+    // #24 块3：图线索行（graphHint）按独立预算 graphInjectBudget 进块；所谓
+    // 独立=既不受 document 预算约束、也不挤占 maxItems 槽位。graphInjectHint
+    // 关（默认保守档）时线索行**不进注入块**——它们只参与候选池排序（对融合无
+    // 影响，因为候选池生成的唯一用途就是注入），桥接信号不污染常驻文本；开时
+    // 才作为 [检索线索] 前缀行进入。与 document/pin 同构：预算只约束注入。
+    const hintOpen = config?.graphInjectHint === true;
+    let graphSeen = 0;
+    const graphBudget = hintOpen ? Math.max(0, Math.floor(config?.graphInjectBudget ?? 1)) : 0;
     const general = [];
     for (const m of candidates) {
-      if (general.length >= maxItems) break;
+      if (m.graphHint === true) {
+        if (!hintOpen) continue;      // 保守档：线索只排序不进块
+        if (graphSeen >= graphBudget) continue; // 独立预算内放行
+        graphSeen++;
+      } else if (general.length >= maxItems) {
+        break; // 普通候选受 maxItems 槽位上界
+      }
       if (m.type === "document") {
         if (documentSeen >= documentBudget) continue;
         documentSeen++;

package/lib/settings.js

@@ -58,6 +58,18 @@ const FEATURE_FLAG_BOOLEANS = [
   // Issue #219：图召回轴——查询命中实体名时把挂联记忆并入检索融合池
   // （默认关；依赖实体抽取产出，lightMode 强制关闭）。
   "entityRecallEnabled",
+  // Issue #24 块1：图谱锚定层级联——命中实体作种子、沿关系表向邻居扩散
+  // （默认关；依赖实体抽取产出，lightMode 强制关闭）。
+  "graphAnchoringEnabled",
+  // Issue #24 块2：边权重演化总闸——关着时任何触达都不改边权（默认关；
+  // 依赖实体抽取产出，lightMode 强制关闭）。块4 的被动确认是它底下的一个通道。
+  "graphWeightEnabled",
+  // Issue #24 块3：关联提示防幻觉——图召回线索行以「[检索线索]」标注进注入
+  // （默认关=线索只参与排序不进块；依赖实体抽取产出，lightMode 强制关闭）。
+  "graphInjectHint",
+  // Issue #24 块4：被动确认通道——正常触达即对该记忆挂联的边 bump 一格
+  // （默认关；需总闸 graphWeightEnabled 同开）。
+  "graphPassiveConfirm",
   // Issue #164：叙述条——dream 期间按 tag 主题簇合成叙述落库（source=
   // narrative，evidence 回链簇内记忆；按需检索不常驻注入；默认关）。
   "dreamNarrativeEnabled",
@@ -88,6 +100,9 @@ const FEATURE_FLAG_BOOLEANS = [
   // Issue #89：宽容校验回归（默认开）+ 跨类型合并显式放宽（默认关）。
   "dreamSkipInvalid",
   "allowCrossTypeMerge",
+  // Issue #339 / E8：guarded 类型 merge 护栏（默认关）——合并对象命中
+  // 长保留类型的 merge 决策整条跳过。
+  "dreamMergeGuard",
   // Issue #17（v0.8.0 A1）：scope 隔离存储层总开关。开启后写入标注
   // agent_scope/workspace_scope、去重键扩展（含 sensitivity）；检索侧过滤在
   // A2/A3。默认关=行为与 A1 前逐字节一致。
@@ -143,7 +158,12 @@ const FEATURE_FLAG_INT_RANGES = {
   // Issue #257：sleep 冲突/模式阶段的 LLM 输出预算（原硬编码 2048，实测不足）。
   sleepMaxTokens: [256, 131072],
   // Issue #258：总览（dream_summarize）输入条数硬上限（0 = 不设上限）。
-  dreamSummaryMaxInputs: [0, 100000]
+  dreamSummaryMaxInputs: [0, 100000],
+  // Issue #24 块1：锚定种子上限与级联深度（闭区间与 config.js 的 z.natural() 对齐）。
+  graphSeedCap: [1, 30],
+  graphCascadeDepth: [1, 3],
+  // Issue #24 块3：图线索行的独立注入预算（0 = 线索不进块）。
+  graphInjectBudget: [0, 5]
 };
 // 浮点开关的闭区间（与 config.js 的 z.number().min().max() 对齐）。与整数开关
 // 分开：面板的整数控件要求 Number.isInteger，而余弦相似度阈值必须允许小数。
@@ -151,7 +171,9 @@ const FEATURE_FLAG_NUMBER_RANGES = {
   // Issue #127：vector 去重档的并入阈值。
   summarizeDedupeMinSim: [0.5, 0.99],
   // Issue #125：hybrid 判"高相似"的阈值。
-  dreamCandidateMinSim: [0.5, 0.99]
+  dreamCandidateMinSim: [0.5, 0.99],
+  // Issue #24 块2：单次有效触达的边权抬升幅度（与 config.js 的闭区间对齐）。
+  graphWeightDelta: [0, 1]
 };
 // 自由字符串开关（与 config.js 的 z.string() 同名同型）：trim 后 ≤200 字符，
 // 空串合法（= 跟随主对话模型/默认路径，面板显示 placeholder）。

package/lib/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,