@modusensus/dsh-mneme 0.10.0 → 0.10.1

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-2660%20passed-success)](https://github.com/slow-stack/mneme)
+[![tests](https://img.shields.io/badge/tests-2681%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)
@@ -285,6 +285,7 @@ v0.3.0 起新增**记忆基因**层：从记忆里抽取**命名实体**、**带
 | **v0.9.4**（2026-10-21） | 三条链各自补上「最后一环」——东西早就造好了，只差没人能叫它：**agent 主动整理**（`memory_organize`，先 dryRun 出比对报告 → agent 判断 → apply 落库，筛除只归档不删、全程留审计回执；`organizeEnabled` 默认关，关时工具根本不注册）；**画像提取草稿**（面板按钮读活跃记忆 + 一次模型调用，产一段「助手眼中的用户」草稿，`profileExtractEnabled` 默认关）——**只出草稿**，采用是用户再点一次，手写的画像原文不会被模型改写，空库与解析失败都直接报错、绝不回空草稿冒充「没提炼出东西」；**人格寻址收口**（`default` 卡以前无条件落给所有没建卡的身份，宿主里自带身份的 bot 每帧收到两句「你是谁」；`personaStrictAddressing` 默认关，把「没建卡」与「卡被显式关掉」都收回为不注入）。同版补蒸馏的**转录围栏 + 解析失败护栏**（#494：一条会话被同一窗口卡死、重试 20 次越试越贵的根因；失败行现在恒带原始输出形状），把面板自称「注入生效文本」的只读区改成后端单源渲染（并修它从不显示人格行），评审另收掉两处「坏了却不报」：整理报告侧的存在性探测口（`strictScope` 下按调用方可见性过滤落点并重算计数）、画像保存不判 `res.ok` 却提示已保存 |
 | **v0.9.5**（2026-10-30） | 记忆能安全地递给别人，也能整包收回来：**分享包 `mneme.share/v1`**（`dsh-mneme share` / `receive` / `undo-share`，面板「⋯」里同一批三件事）只含活跃行，scope 与 home 前缀不进包，命中密钥 / PII 的行整条不进；出包先给报告再给文件，超 3 MiB 水位回 413、按 `--type` / `--tag` 分批；入包一条不合格整包拒、干跑为默认、按 `share_external_id` 幂等，整包退出走物删。「本机巩固不许改写别人导入的原文」由单一谓词 `isImportedRow` 守在汇流口与九个行池上。同版给记忆来源加了读出口 `GET /memory/provenance`（#421，@z2Ace0107 实现；409 = 用户关了、503 = 装配坏了），修掉同标题重复入库（#505）、扫描谎报「没东西可扫」（#515）、五处未围栏的巩固 prompt（#501）与 dream 合并护栏整类误拦（#521），面板新增设置页分组目录（#518） |
 | **v0.10.0**（2026-11-02） | 归因与闸门——给已经发生的事补上它自己的身份：**蒸馏有了运行身份**（窗口级 `distill_runs` 记 `ok`/`degraded`/`noop`/`failed`/`aborted` 与 `audit_id`，行级 `memory_mints` 记「这条记忆出生自哪一轮巩固」；历史行留空**不猜**，失败轮也真记一行），此前归因只到「会话区间」——那是输入的坐标不是运行的身份；**溯源补上反方向** `GET /memory/provenance?sessionId=`（两个主键互斥，`limit` 越界 400 不静默截断，撞上限带 `truncated: true`）；**会话级无痕闸门** `sessionGateEnabled`（指定会话与子代理不进不出，其余会话照常；子代理判据只认宿主委派标记，`parentSession` 不是判据——本机 641 个会话头实测会误判 3 个 fork 主会话）；**防谄媚补到写入面**（蒸馏与总览加「立场纪律」四条与「叙述纪律」，排在与时间换算的指令之前）。另修 `differentiate` 正反馈闭环（注记改落 `differentiated_pairs` 账本、正文一个字节都改不了，实测单条曾堆 19 段）、sleep 冲突相位的输入侧预算与续排（分批后不再隔夜才轮到）、面板「最近巩固」区分 organize 回执（#495）、面板首次有移动端与 481–519px 中间带断点（#542） |
+| **v0.10.1**（2026-11-03） | 打开记忆详情不再崩掉整个宿主：0.10.0 里点开侧边栏任意一条记忆的详情抽屉，渲染进程立刻抛 `ReferenceError: provenance is not defined`，整个宿主跟着重启、进行中的会话被打断，100% 复现（#553）。根因是两个隔了三千多行的组件——`MemoryDrawer` 的归因 effect 与渲染块在读 `provenance` / `setProvenance`，而那句 `useState` 落在了同文件**上一个**组件 `EntityPanel` 里，在那里是纯死代码（整个函数体除声明外对 `provenance` 零引用）。这个形状躲得过眼睛、语法检查与原有用例，所以补的不是「锁一个名字」的用例，而是按组件扫「调了 `setXxx(` 却没有声明」。同版带上 v0.10.0 之后合入的图谱锚定层收尾（#24）：Tag 与向量两路起点接线（`normalizePath` 补回通路身份、`findEntitiesByTags` 走全等匹配并按 500 分块、反查改 UNION 三源以覆盖只看关系不建 attr 行的记忆、向量路复用同一份 query 向量并滤掉 0 分种子），以及被动确认的复核出口（`GET /semantic/graph/boosted-relations` 按「合法抬升量 > 0」列出、ego 边补 `weight`/`source`、面板默认收起的审计视角） |
 
 | **v0.8.x** | 作用域隔离（agent / workspace 双维 + opt-in 硬过滤）、冲突队列人工裁决、生态化（stdio MCP server / 图召回轴 / 冷启动 / 注入截断） |
 
@@ -721,7 +722,7 @@ src/
 ├── api.js            # HTTP 路由（Web 面板数据通道，含 /conflicts 冲突队列）
 └── index.js          # 插件接线
 lib/                  # src 的同步分发产物（npm run sync，prepack 钩子在发布时自动跑；一致性由 scripts/check-sync.js 在 CI 与 release.yml 校验——它只查不同步；唯一手写例外 lib/client.js——Web 面板 bundle，sync 不覆盖）
-test/                 # 2660 个 node:test 测试（审计与三轴线压测不变量；src↔lib 一致性由 scripts/check-sync.js 发布闸门校验）
+test/                 # 2681 个 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 运行时清单
 ```
 
@@ -730,7 +731,7 @@ scripts/              # e2e-dsh.js 端到端演示 · stress-dsh.js 三轴线压
 ```bash
 cd dsh-mneme
 npm install        # 安装 peer 依赖（以 devDependencies 形式，用于本地测试）
-npm test           # 运行 2660 个测试
+npm test           # 运行 2681 个测试
 npm run stress     # 三轴线压测：长会话检索 / 冲突仲裁 / 多 Agent 并发（离线 mock LLM）
 npm run sync       # 把 src/ 同步到 lib/（发布时由 prepack 钩子自动执行）
 ```

package/lib/api.js

@@ -1438,7 +1438,57 @@ export function createApi(ctx, service, settings, commands, embedder, semantic =
             to: e.to_entity,
             relation_type: e.relation_type,
             memory_id: e.memory_id ?? null,
-            created_at: e.created_at
+            created_at: e.created_at,
+            // issue #24 块4：被动确认的复核要靠这两个字段——weight 是「用出来
+            // 的分」，source 决定它的起点（manual 1.0 / tag 0.3 / llm 0.4）。
+            // 少了它们，「这条边被抬过」在面板上根本看不出来。取不到时给
+            // 初值形状而不是 undefined，前端不必到处判空。
+            weight: e.weight ?? 1.0,
+            source: e.source ?? "manual"
+          }))
+        });
+      } catch {
+        sendJson(res, 500, { error: "internal" });
+      }
+    }
+  });
+
+  // --- graph boosted relations: the review side of passive confirmation ---
+  // issue #24 块4（被动确认）的复核出口。正常触达即 bump 边权重是安静的设计，
+  // 但「抬过哪些边」必须能看见，否则「例外管理」只剩自动确认没有例外。
+  // 判据是 gain = 现权 − 该 source 初值 > 0（见 store.listBoostedRelations），
+  // 不另设记账表：抬升是唯一会改变检索形状的动作，它自己就是证据。
+  // 只读、挂在 /semantic/graph/ 前缀下（SECURITY.md 的开放读清单已含该通配）。
+  register({
+    kind: "exact",
+    path: "/api/dsh-mneme/semantic/graph/boosted-relations",
+    policy: "open",
+    handler(req, res) {
+      try {
+        const url = new URL(req.url, "http://localhost");
+        const limit = Math.max(1, Math.min(200, Number(url.searchParams.get("limit") ?? 100) || 100));
+        const rows = service.listBoostedRelations?.({ limit }) ?? [];
+        sendJson(res, 200, {
+          count: rows.length,
+          // 提示「这张表为什么可能为空」：被确认抬升的边只在图真的被用过之后
+          // 才出现，两个相关闸默认都关。面板据此说明而不是让人以为坏了。
+          // 必须两个闸同时开才算「会继续产生新提升」——touchRecalled 里
+          // passive = graphPassiveConfirm && graphWeightEnabled，只看前者会让面板
+          // 说「会自动提升」而实际上一条都不会抬（评审指出）。
+          passiveConfirmEnabled: config?.graphPassiveConfirm === true && config?.graphWeightEnabled === true,
+          items: rows.map((r) => ({
+            id: r.id,
+            from: r.from_entity,
+            to: r.to_entity,
+            from_name: r.from_name ?? null,
+            to_name: r.to_name ?? null,
+            relation_type: r.relation_type,
+            memory_id: r.memory_id ?? null,
+            created_at: r.created_at,
+            weight: r.weight,
+            base_weight: r.base_weight,
+            gain: r.gain,
+            source: r.source
           }))
         });
       } catch {

package/lib/client.js

@@ -452,6 +452,23 @@ window.__ModuleLoader__.load({
         "memory.graph.viewInGraph": "在实体视图中打开",
         "memory.graph.loading": "加载中…",
         "memory.graph.distance": "距中心 {n} 跳",
+        // issue #24 块4：被动确认的复核面。边侧卡显示权重/来源，复核区列「抬过的边」。
+        "memory.graph.weight": "权重 {w}",
+        "memory.graph.source": "来源 {s}",
+        "memory.graph.boosted.title": "被用出来的边",
+        "memory.graph.boosted.hint": "正常触达会自动抬高边的权重，这里列出被抬过的那些——抬升是唯一会改变检索形状的动作。",
+        "memory.graph.boosted.empty": "当前筛选下没有边（只列权重已高于其来源基线的边）",
+        "memory.graph.boosted.loadFailed": "这一屏没取到数据（接口不可用），不是「没有边」——稍后重试。",
+        "memory.graph.boosted.gateOff": "被动确认当前是关的，今后不会再自动抬权；下面列的是此前已经抬过的边。",
+        "memory.graph.boosted.show": "查看被用出来的边",
+        "memory.graph.boosted.hide": "收起",
+        "memory.graph.boosted.gain": "+{g}",
+        // 边的来源（#24 块2 的 RELATION_SOURCE_DEFAULTS）：决定权重的起点，
+        // 所以复核时必须和权重一起显示，否则「0.5 比 1.0 弱」这种误读无可避免。
+        "memory.graph.src.manual": "人工建立",
+        "memory.graph.src.confirmed": "人工确认",
+        "memory.graph.src.tag": "标签共现",
+        "memory.graph.src.llm": "模型抽取",
         "memory.settings.vectorTitle": "向量搜索",
         "memory.settings.vectorHint": "搜索不再只认字面：接入任意 OpenAI 兼容的 embedding 接口后，意思相近的记忆也能被召回。",
         "memory.settings.vectorEnabled": "启用向量搜索",
@@ -1242,6 +1259,23 @@ window.__ModuleLoader__.load({
         "memory.graph.viewInGraph": "Open in entity explorer",
         "memory.graph.loading": "Loading…",
         "memory.graph.distance": "{n} hop(s) from root",
+        // issue #24 块4：被动确认的复核面。
+        "memory.graph.weight": "weight {w}",
+        "memory.graph.source": "via {s}",
+        "memory.graph.boosted.title": "Edges put to use",
+        "memory.graph.boosted.hint": "A normal touch raises an edge's weight automatically. These are the ones that rose — raising is the only action that changes what gets recalled.",
+        "memory.graph.boosted.empty": "No edges match this filter (only edges already above their source baseline are listed)",
+        "memory.graph.boosted.loadFailed": "Couldn't load this panel (endpoint unavailable) — that is not the same as \"no edges\". Try again later.",
+        "memory.graph.boosted.gateOff": "Passive confirmation is off, so nothing more will be raised; the edges below were raised earlier.",
+        "memory.graph.boosted.show": "Show edges put to use",
+        "memory.graph.boosted.hide": "Hide",
+        "memory.graph.boosted.gain": "+{g}",
+        // 边的来源（#24 块2 的 RELATION_SOURCE_DEFAULTS）：决定权重的起点，
+        // 所以复核时必须和权重一起显示，否则「0.5 比 1.0 弱」这种误读无可避免。
+        "memory.graph.src.manual": "manual",
+        "memory.graph.src.confirmed": "confirmed",
+        "memory.graph.src.tag": "tag overlap",
+        "memory.graph.src.llm": "model-extracted",
         "memory.settings.vectorTitle": "Vector Search",
         "memory.settings.vectorHint": "Match by meaning, not just wording — connect any OpenAI-compatible embeddings API.",
         "memory.settings.vectorEnabled": "Enable vector search",
@@ -2089,6 +2123,13 @@ window.__ModuleLoader__.load({
       ".mneme-relrow:hover{background:var(--dsw-alias-interactive-bg-hover)}",
       ".mneme-reltype{flex:none;font-size:11px;line-height:16px;color:var(--mneme-accent);border:1px solid color-mix(in srgb,var(--dsw-alias-state-business-primary) 35%,transparent);border-radius:6px;padding:0 6px}",
       ".mneme-relname{min-width:0;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}",
+      // issue #24 块4 复核面：抬过的边。用虚线边色（--mneme-graphic-dim 同层）
+      // 而不是新增颜色——它表达的是「同一条边，只是被用过」，不是新类别。
+      ".mneme-boosted{margin-top:6px;padding-top:6px;border-top:1px dashed var(--dsw-alias-border-l2)}",
+      ".mneme-boostedbody{margin-top:6px}",
+      ".mneme-boostedrow{cursor:default;font-size:12px;line-height:18px;padding:5px 10px}",
+      ".mneme-boostedrow:hover{background:none}",
+      ".mneme-boostedgain{font-size:11px;color:var(--mneme-accent)}",
       // --- settings: quiet stacked sections, one concern per section ---
       ".mneme-set{flex:1;min-height:0;overflow-y:auto;padding:8px 24px 48px;box-sizing:border-box}",
       ".mneme-set-inner{max-width:720px;margin:0 auto}",
@@ -2790,9 +2831,6 @@ window.__ModuleLoader__.load({
     //   ④ 关系图谱  the same ego graph the old graph-only tab drew
     function EntityPanel({ t, focusEntity, onJumpMemory }) {
       const [entities, setEntities] = useState(null);
-      // #512：这条记忆的归因——窗口级（哪一段原文蒸出来的）与行级（哪一轮铸造的）。
-      // null = 还没读到（或读失败），两者要分得开，不能被当成「没有归因」。
-      const [provenance, setProvenance] = useState(null); // null = still loading
       const [railQuery, setRailQuery] = useState("");
       const [entityName, setEntityName] = useState(focusEntity || "");
       const [depth, setDepth] = useState(1);
@@ -2801,6 +2839,10 @@ window.__ModuleLoader__.load({
       const [selected, setSelected] = useState(null); // { kind: "node"|"edge", node?|edge? }
       const [attrs, setAttrs] = useState([]);
       const [related, setRelated] = useState([]);
+      // issue #24 块4：被动确认的复核面。默认收起——它是一个「想查的时候
+      // 才查」的面，不该占实体页第一屏；展开时才去取，省一次请求。
+      const [boostedOpen, setBoostedOpen] = useState(false);
+      const [boosted, setBoosted] = useState(null); // { count, passiveConfirmEnabled, items }
       const svgRef = useRef(null);
       const posRef = useRef([]); // live simulation positions, not React state
       const dragRef = useRef(null); // { id, moved }
@@ -2866,6 +2908,21 @@ window.__ModuleLoader__.load({
         return () => { cancelled = true; };
       }, [entityName]);
 
+      // issue #24 块4 复核面：只在展开时取，收起时不发请求。
+      const loadBoosted = useCallback(async () => {
+        try {
+          const res = await apiFetch("/api/dsh-mneme/semantic/graph/boosted-relations?limit=100");
+          setBoosted(res.ok
+            ? await res.json()
+            : { count: 0, items: [], passiveConfirmEnabled: false, error: true });
+        } catch {
+          setBoosted({ count: 0, items: [], passiveConfirmEnabled: false, error: true });
+        }
+      }, []);
+      useEffect(() => {
+        if (boostedOpen) loadBoosted();
+      }, [boostedOpen, loadBoosted]);
+
       // Simulation: run in rAF against posRef, tick React only every few frames.
       // Re-seeds when data changes; dragging writes straight into posRef.
       useEffect(() => {
@@ -3096,6 +3153,17 @@ window.__ModuleLoader__.load({
               ),
               h("div", { className: "mneme-gs-meta" },
                 `${t("memory.graph.relation")} · ${formatRelativeTime(selected.edge.created_at, t)}`),
+              // issue #24 块4：复核要看得见「这条边被抬过」。weight 是当前分，
+              // source 决定它的起点（manual 1.0 / confirmed 1.0 / tag 0.3 / llm 0.4）——
+              // 只看 weight 会把「tag 边被抬到 0.5」误读成「比 manual 边弱」。
+              (selected.edge.weight !== undefined || selected.edge.source !== undefined) && h("div", { className: "mneme-gs-meta" },
+                selected.edge.weight !== undefined
+                  ? t("memory.graph.weight").replace("{w}", Number(selected.edge.weight).toFixed(2))
+                  : null,
+                selected.edge.weight !== undefined && selected.edge.source ? " · " : null,
+                selected.edge.source
+                  ? t("memory.graph.source").replace("{s}", t(`memory.graph.src.${selected.edge.source}`) || selected.edge.source)
+                  : null),
               selected.edge.memory_id && h("button", {
                 className: "mneme-footbtn",
                 onClick: () => onJumpMemory && onJumpMemory({ id: selected.edge.memory_id })
@@ -3200,7 +3268,53 @@ window.__ModuleLoader__.load({
                         h("span", { className: "mneme-reltype" }, e.relation_type),
                         h("span", { className: "mneme-relname", style: { flex: 1 } }, otherName)
                       );
-                    })
+                    }),
+                    // issue #24 块4「例外管理」的可见面。被动确认是唯一会悄悄
+                    // 改变检索形状的动作（正常触达就抬权），所以它必须有个地方
+                    // 能查——否则「自动确认」和「没人看过的自动确认」没有区别。
+                    // 默认收起：这是审计视角，不是日常视角。
+                    h("div", { className: "mneme-boosted" },
+                      h("button", {
+                        className: boostedOpen ? "mneme-chip mneme-active" : "mneme-chip",
+                        "aria-expanded": boostedOpen ? "true" : "false",
+                        onClick: () => setBoostedOpen(!boostedOpen),
+                        title: t("memory.graph.boosted.hint")
+                      }, boostedOpen ? t("memory.graph.boosted.hide") : t("memory.graph.boosted.show")),
+                      boostedOpen && h("div", { className: "mneme-boostedbody" },
+                        (() => {
+                          if (boosted === null) return h("div", { className: "mneme-hint" }, t("memory.graph.loading"));
+                          // 加载失败 ≠ 闸关：接口挂了却说「被动确认是关的」，会把人
+                          // 引去翻设置，而真正的问题是这一屏没取到数据。
+                          if (boosted.error === true) return h("div", { className: "mneme-hint" }, t("memory.graph.boosted.loadFailed"));
+                          const items = boosted.items || [];
+                          const off = boosted.passiveConfirmEnabled !== true;
+                          // 闸关 ≠ 没有数据：已经抬过的边仍然在表里，关掉闸只表示
+                          // 「今后不再自动抬」。所以先出闸关提示，再照常列历史——
+                          // 否则人永远没法复核既有的提升。
+                          // 空表提示与闸门状态无关：闸关且一条都没有时，光说「下面列的是
+                          // 此前已经抬过的边」却不给任何行，人会以为这一屏坏了。
+                          return h(react.Fragment, null,
+                            off && h("div", { className: "mneme-hint" }, t("memory.graph.boosted.gateOff")),
+                            items.length === 0
+                              ? h("div", { className: "mneme-hint" }, t("memory.graph.boosted.empty"))
+                              : h(react.Fragment, null,
+                                  h("div", { className: "mneme-hint" }, t("memory.graph.boosted.hint")),
+                                  items.map((b) => h("div", {
+                                    key: b.id,
+                                    className: "mneme-relrow mneme-boostedrow",
+                                    title: `${t("memory.graph.source").replace("{s}", t(`memory.graph.src.${b.source}`) || b.source)} · ${Number(b.weight).toFixed(2)}`
+                                  },
+                                    h("span", { className: "mneme-relname", style: { textAlign: "right", flex: 1 } }, b.from_name ?? b.from),
+                                    h("span", { className: "mneme-reltype" }, b.relation_type),
+                                    h("span", { className: "mneme-relname", style: { flex: 1 } }, `${b.to_name ?? b.to} `,
+                                      h("span", { className: "mneme-boostedgain" },
+                                        t("memory.graph.boosted.gain").replace("{g}", Number(b.gain).toFixed(2))))
+                                  ))
+                                )
+                          );
+                        })()
+                      )
+                    )
                   )
             ),
             // ② 属性 — current snapshot (valid_until IS NULL)；空层整层隐藏
@@ -6498,6 +6612,13 @@ window.__ModuleLoader__.load({
       const [saveError, setSaveError] = useState(false);
       const [copied, setCopied] = useState(false);
       const [entities, setEntities] = useState(null);
+      // #512：这条记忆的归因——窗口级（哪一段原文蒸出来的）与行级（哪一轮铸造的）。
+      // null = 还没读到（或读失败），两者要分得开，不能被当成「没有归因」。
+      // 这个 state 必须住在**读它的那个组件**里：加归因区块时它曾被误放进
+      // EntityPanel（同文件的上一个组件），于是 MemoryDrawer 的 effect 与渲染块
+      // 引用到一个不存在的绑定，一开抽屉就 ReferenceError 把整个 renderer 带走
+      // （issue #553）。同名 state 落在隔壁组件里，静态扫描与 review 都不容易看出来。
+      const [provenance, setProvenance] = useState(null); // null = still loading
       // 整包退出的两段：先干跑清点（点按钮那一发），再确认物删。撤是**物理删除**不是归档
       // （归档行仍占 share_external_id 的 UNIQUE 位，撤了会导不回来，理由在
       // src/share-import.js 的 deleteSharePack），所以这里比删除那条路多一站清点。

package/lib/graph/anchoring.js

@@ -46,7 +46,12 @@ export function minMax(scores) {
 /**
  * 把一条检测通路的结果归一化成 0..1 的打分表。
  * path 是离散通路名（exact/tag/...）→ 查 DISCRETE_LEVELS；是连续通路
- * （continuous=true）→ min-max。返回 { byId: Map<id, score>, order: [id...] }。
+ * （continuous=true）→ min-max。返回 { path, byId: Map<id, score>, order }。
+ *
+ * issue #24 块1 补充：返回值带上 `path`。anchorSeeds 用它记「这个种子被哪几路
+ * 激活」（`seeds[i].paths`），复核时据此判断一条边是被精确名、Tag 桥接还是向量
+ * 拉进来的。此前只有 { byId, order }，`p.path ?? "?"` 把每一路都记成 "?"，
+ * 通路身份在合并那一步就丢了。连续通路调用方传 `path: "vector"`（cos 相似度）。
  */
 export function normalizePath(hits, { path = "exact", continuous = false } = {}) {
   const ids = Array.isArray(hits) ? hits : [];
@@ -62,7 +67,7 @@ export function normalizePath(hits, { path = "exact", continuous = false } = {})
     const level = DISCRETE_LEVELS[path] ?? DISCRETE_LEVELS.substring;
     for (const id of ids) byId.set(id, level);
   }
-  return { byId, order: [...byId.keys()] };
+  return { path, byId, order: [...byId.keys()] };
 }
 
 /**

package/lib/service.js

@@ -560,16 +560,36 @@ export function createService({ store, mirror, config, onWrite, logger, document
    * 用出来的」延伸成检索信号：查询命中的不只有直接挂联，还有跳跃可达的活跃子图。
    * 邻居权重 = HOP_QUOTA[hop] × linked tier（attr 1.0 / relation 0.9），仍低于
    * 直达种子的满权，绝不喧宾夺主。
+   *
+   * #24 块1 补充（三路起点接线）：前半段只喂了 exact 一路，Tag 桥接与向量两路
+   * 能力在 anchoring.js 里却从未被调用。现补齐——
+   *   · exact：查询里出现实体名（布尔 1.0）；
+   *   · tag  ：查询词命中某条记忆的 tag，该记忆挂联的实体即种子（计数级别 0.4）;
+   *   · vector：查询向量近邻的记忆挂联的实体（cos 走 min-max，连续通路）。
+   * 三路在累加前各按自己的尺度归一化（离散级别 vs min-max），混加不会让高频
+   * Tag 淹没强向量命中。两路都是弱信号入口：任一路为空就少一路，全空则
+   * anchorSeeds 返回空、整个图轴让位（与加这两路之前的行为一致）。
+   * 三者共用 graphAnchoringEnabled 一个闸：默认关时仍是逐字节的 #219 单跳轴。
    */
-  function entityRecall(q, limit) {
+  function entityRecall(q, limit, { queryVector = null } = {}) {
     if (config?.entityRecallEnabled !== true) return [];
     try {
       const entities = store.findEntitiesMentionedIn(q);
-      if (!entities.length) return [];
+      // Tag 桥接与向量两路只服务锚定层：关锚定时不查（少两次库读，也守住
+      // 「关档行为逐字节不变」的承诺——见下方 if 分支）。
+      const anchoring = config?.graphAnchoringEnabled === true;
+      const tagEntities = anchoring && typeof store.findEntitiesByTags === "function"
+        ? (() => { try { return store.findEntitiesByTags(q); } catch { return []; } })()
+        : [];
+      // 早退只在**三路全无来源**时才成立。向量路的存在感恰恰在查询里没有实体名
+      // 的时候最大（「数据库迁移」说不出任何实体），若仍以「名字没命中」早退，
+      // 第二、三路就永远等不到自己被调用——接上了也等于没接。
+      const canVector = anchoring && Array.isArray(queryVector) && queryVector.length > 0 && !!vectorIndex;
+      if (!entities.length && !tagEntities.length && !canVector) return [];
       // 关闭锚定级联=逐字节复用 #219 单跳轴：种子裁剪/重排/截断全是 #24 新增的
       // 行为，默认关时一条都不许漏进旧路径（graphSeedCap 也只在开启后生效——
       // 无论 cap 调多小，关档时命中实体仍全量挂联）。
-      if (config?.graphAnchoringEnabled !== true) {
+      if (!anchoring) {
         const linked = store.getLinkedMemoryIds(entities.map((e) => e.id));
         if (!linked.size) return [];
         const hits = [];
@@ -581,9 +601,43 @@ export function createService({ store, mirror, config, onWrite, logger, document
         }
         return hits;
       }
-      // 锚定种子（精确名布尔通路——命名实体逻辑上是离散匹配，不参与 min-max）。
-      const exact = normalizePath(entities.map((e) => e.id), { path: "exact" });
-      const seeds = anchorSeeds({ paths: [exact], cap: config?.graphSeedCap ?? 12 });
+      // 三路激活信号，各自先归一化再累加（尺度不同，混加会让高频通路淹没强相关）。
+      const paths = [];
+      // 第一路：精确名（布尔通路——命名实体逻辑上是离散匹配，不参与 min-max）。
+      if (entities.length) {
+        paths.push(normalizePath(entities.map((e) => e.id), { path: "exact" }));
+      }
+      // 第二路：Tag 桥接（tag 共现，离散级别 0.4——比精确名弱、比子串强）。
+      if (tagEntities.length) {
+        paths.push(normalizePath(tagEntities.map((e) => e.id), { path: "tag" }));
+      }
+      // 第三路：向量（连续通路，cos 相似度走 min-max）。记忆 → 挂联实体反查，
+      // 同一实体被多条近邻记忆挂联时取最高分（一条更近的记忆就够证明相关）。
+      if (Array.isArray(queryVector) && queryVector.length && vectorIndex) {
+        try {
+          const near = vectorIndex.search(queryVector, { limit: limit * 2, threshold: 0 });
+          const bestOf = new Map();
+          for (const m of near) {
+            const score = m?.score ?? 0;
+            if (!(score > 0)) continue;
+            for (const eid of store.entityIdsForMemories([m.id])) {
+              if (!(bestOf.get(eid) >= score)) bestOf.set(eid, score);
+            }
+          }
+          if (bestOf.size) {
+            paths.push(normalizePath(
+              [...bestOf.entries()].map(([id, score]) => ({ id, score })),
+              { path: "vector", continuous: true }
+            ));
+          }
+        } catch { /* 向量路失败只是少一路，不拖垮整条图轴 */ }
+      }
+      if (!paths.length) return [];
+      // 激活分为 0 的种子不算种子：min-max 会把**连续通路里最弱的那条**压成 0，
+      // 可下游给种子挂联记忆的是固定满权 tier（1.0/0.9），不看种子自己的分数。
+      // 留着 0 分种子，等于让「这一路里最不像的那条」以最强的方式把记忆拉进池。
+      // 零分项在 anchorSeeds 里排最后，所以先取 cap 再滤掉不会浪费名额。
+      const seeds = anchorSeeds({ paths, cap: config?.graphSeedCap ?? 12 }).filter((s) => s.score > 0);
       if (!seeds.length) return [];
       // 0-hop 直达：挂联记忆按 tier 定分（attr 1.0 / relation 0.9）——与 #219
       // 单跳轴同分。MAX 语义：同一条记忆被多实体挂联时保留最高分。
@@ -939,6 +993,9 @@ export function createService({ store, mirror, config, onWrite, logger, document
     const keyword = rawKeyword.map((m) => ({ ...m, score: scoreKeyword(m, q), source: "keyword" }));
     const wantVector = mode === "vector" || mode === "hybrid" || (mode === "auto" && !!embedder);
     let vector = [];
+    // #24 块1：查询向量在这里算出来，图轴的向量起点要用同一份——再嵌一次既
+    // 多一次模型调用，也可能拿到不同的向量（本地模型带随机性时）。
+    let vectorQuery = null;
     if (wantVector && embedder) {
       try {
         // Legacy embedders expose embed(query); local ones expose embedSingle.
@@ -947,6 +1004,7 @@ export function createService({ store, mirror, config, onWrite, logger, document
           : embedder.embed.bind(embedder);
         const qv = await embedSingle(q);
         if (qv?.length) {
+          vectorQuery = qv;
           // Adaptive threshold (v0.5.0 1.2): the fetch runs at the loosest
           // branch floor so the head-gap rule can still re-admit the tail;
           // the final cutoff is computed against the fetched score
@@ -980,7 +1038,7 @@ export function createService({ store, mirror, config, onWrite, logger, document
     // mentioned entities pull their linked memories into the pool. Keyword
     // mode stays text-only per the mode contract, so the axis is skipped
     // there even when enabled.
-    const entity = mode === "keyword" ? [] : entityRecall(q, lim);
+    const entity = mode === "keyword" ? [] : entityRecall(q, lim, { queryVector: vectorQuery });
     // Entity axis shares BM25's backfill weight (we = wb) until #217 recall
     // data justifies a distinct entity weight.
 
@@ -1819,7 +1877,7 @@ export function createService({ store, mirror, config, onWrite, logger, document
     // 为空时兜底检索，避免注入路径双倍候选成本。
     if (config?.entityRecallEnabled === true && q) {
       try {
-        const graphHits = entityRecall(q, maxItems * 2);
+        const graphHits = entityRecall(q, maxItems * 2, { queryVector });
         if (graphHits.length) {
           const graphIds = new Set(graphHits.map((m) => m.id));
           candidates = [
@@ -2872,6 +2930,9 @@ export function createService({ store, mirror, config, onWrite, logger, document
     saveRelation: (r) => store.saveRelation(r),
     listEntities: (o) => store.listEntities(o),
     getRelations: (id) => store.getRelations(id),
+    // #24 块4 被动确认的复核出口：列出权重被 bump 抬过的边（gain = 现权 −
+    // 该 source 的初值）。纯读，不动权重——「看哪些边被用出来过」是人的动作。
+    listBoostedRelations: (o) => store.listBoostedRelations(o),
     // v0.7.0 实体热投影：实体热 = 关联记忆 heat 聚合（取 max）。无关联记忆
     // 或 heatEnabled=false 时返回 null；前端据此决定图谱节点大小/明暗。
     entityHeat: (entityId) => {

package/lib/store.js

@@ -1647,6 +1647,11 @@ export function createStore(path) {
   // 解析成本可以忽略、又永远够不到那格上限，块数只随包条数线性增长。
   const DELETE_ID_CHUNK = 500;
 
+  // Tag 锚点的 IN 列表分块。比 DELETE_ID_CHUNK 多一层顾虑：那条语句只有一处 IN，
+  // 这条有**三处**（attrs / relations.from / relations.to）共用同一个记忆 id 集合，
+  // 所以单块占用的参数是 3×chunk。取 500 后最坏 1500 个参数，离 32766 仍有二十倍余量。
+  const TAG_ID_CHUNK = 500;
+
   /**
    * 整包退出（车道 C）。删空一个不存在的包是幂等的 0，不是错误——对方点第二次「收起
    * 这个包」与「收起一个从来没导入过的包」都该是这个答案；早退也不 bump generation：
@@ -3712,6 +3717,152 @@ export function createStore(path) {
     return { migrated, invalidated };
   }
 
+  /**
+   * Tag 桥接（issue #24 · 块1 三路起点里的第二路）：查询词命中某些记忆的 tag
+   * 时，那些记忆挂联的实体本身就是「这个查询正在谈的东西」——即使查询里没有
+   * 出现它们的名字。Tag 是 LLM 打的标签，比精确名松，但比向量具体，正好填在
+   * 二者之间。
+   *
+   * 匹配口径与 findEntitiesMentionedIn 对齐（JS 侧 toLowerCase，不受 SQLite
+   * 只折 ASCII 的限制）：把查询按空白与常见中英标点切词，任一词与某个 tag
+   * 全等即算命中（不做子串——tag 通常是短词，子串匹配会让「ai」命中「mail」）。
+   * 只认未归档未遗忘的行：一条已归档记忆的 tag 不该再拉出种子。
+   * 返回 {id, name}，按命中记忆数降序、名称升序（稳定）。
+   */
+  function findEntitiesByTags(text, { limit = 5 } = {}) {
+    const words = String(text ?? "")
+      .toLowerCase()
+      .split(/[\s,，、;；:：!！?？.。()（）[\]【】"'“”‘’/|]+/u)
+      .map((w) => w.trim())
+      .filter((w) => w.length >= 2);
+    if (!words.length) return [];
+    const rows = db.prepare(
+      `SELECT id, tags FROM memories WHERE archived = 0 AND forgotten = 0`
+    ).all();
+    const memHits = new Set();
+    for (const row of rows) {
+      const tags = parseTags(row.tags).map((t) => String(t).toLowerCase());
+      if (!tags.length) continue;
+      if (words.some((w) => tags.includes(w))) memHits.add(row.id);
+    }
+    if (!memHits.size) return [];
+    // 计数必须在 SQL 里做：entityIdsForMemories 返回的是 DISTINCT entity_id，
+    // 拿它反推「命中几条记忆」永远是 1，排序就静默失效了（评审抓到的正是这个）。
+    //
+    // 两个来源都要算：只读 entity_attrs 会漏掉「记忆只通过关系挂到实体上」的情况
+    // ——phaseRelations 只写 entity_relations.memory_id、不建 attr 行，于是仅由关系
+    // 关联的记忆对关系两端一个种子都生不出来。这与 getLinkedMemoryIds 的口径一致
+    // （那边 attr 与 relation 两端同样并列）。UNION 去重的是 (实体, 记忆) 对，
+    // 所以同一条记忆的多条关联记录不会把 via 抬高。
+    //
+    // 分块理由同 DELETE_ID_CHUNK：一条语句一行一个 `?`，撞上 SQLITE_MAX_VARIABLE_NUMBER
+    // （32766）会整笔抛错，而调用方 try/catch 兜底 → 静默丢掉整条 Tag 锚点。
+    // 这里每块绑 3×TAG_ID_CHUNK 个参数（三处 IN 列表），500 仍有二十倍余量。
+    const rowsByEntity = new Map();
+    const memoryIds = [...memHits];
+    for (let offset = 0; offset < memoryIds.length; offset += TAG_ID_CHUNK) {
+      const batch = memoryIds.slice(offset, offset + TAG_ID_CHUNK);
+      const marks = batch.map(() => "?").join(",");
+      const batchRows = db.prepare(
+        `SELECT hits.id AS id, e.name AS name, COUNT(DISTINCT hits.memory_id) AS via
+         FROM (
+           SELECT entity_id AS id, memory_id FROM entity_attrs
+             WHERE memory_id IN (${marks}) AND entity_id IS NOT NULL
+           UNION
+           SELECT from_entity AS id, memory_id FROM entity_relations
+             WHERE memory_id IN (${marks}) AND from_entity IS NOT NULL
+           UNION
+           SELECT to_entity AS id, memory_id FROM entity_relations
+             WHERE memory_id IN (${marks}) AND to_entity IS NOT NULL
+         ) hits JOIN entities e ON e.id = hits.id
+         GROUP BY hits.id`
+      ).all(...batch, ...batch, ...batch);
+      for (const row of batchRows) {
+        const prev = rowsByEntity.get(row.id);
+        // 各块的记忆集合互不相交，所以 via 直接相加就是全集的 DISTINCT 计数。
+        rowsByEntity.set(row.id, { id: row.id, name: row.name, via: (prev?.via ?? 0) + Number(row.via) });
+      }
+    }
+    const rows2 = [...rowsByEntity.values()];
+    if (!rows2.length) return [];
+    return rows2
+      .map((r) => ({ id: r.id, name: r.name, via: r.via }))
+      .sort((a, b) => b.via - a.via || (a.name < b.name ? -1 : a.name > b.name ? 1 : 0))
+      .slice(0, limit)
+      .map(({ id, name }) => ({ id, name }));
+  }
+
+  /**
+   * 按记忆批量反查实体 id（Tag 桥接用）。与 entitiesForMemory 的区别是「批量 +
+   * 带 id」：那边是面板详情页的单条展示（只要 name/type），这边要的是能直接
+   * 喂给 normalizePath 的 id 列表。同一 (记忆, 实体) 只出一次。
+   *
+   * 与 findEntitiesByTags 同口径：attr 行与关系两端并列。只读 entity_attrs 时，
+   * 一条只通过关系挂到实体上的记忆在向量路里也生不出种子（phaseRelations 不建 attr）。
+   */
+  function entityIdsForMemories(memoryIds) {
+    const ids = Array.isArray(memoryIds) ? memoryIds.filter(Boolean) : [];
+    if (!ids.length) return [];
+    const placeholders = ids.map(() => "?").join(",");
+    const rows = db.prepare(
+      `SELECT entity_id FROM entity_attrs
+         WHERE memory_id IN (${placeholders}) AND entity_id IS NOT NULL
+       UNION
+       SELECT from_entity AS entity_id FROM entity_relations
+         WHERE memory_id IN (${placeholders}) AND from_entity IS NOT NULL
+       UNION
+       SELECT to_entity AS entity_id FROM entity_relations
+         WHERE memory_id IN (${placeholders}) AND to_entity IS NOT NULL`
+    ).all(...ids, ...ids, ...ids);
+    return rows.map((r) => r.entity_id);
+  }
+
+  /**
+   * 被动确认的复核出口（issue #24 · 块4）：列出「权重已经被抬过」的边。
+   *
+   * 设计口径：被动确认本身是安静的——正常触达就 bump，不打扰人。要复核的恰恰
+   * 是「抬过的那些」，因为抬升是唯一会改变检索形状的动作。判据不看有没有被
+   * bump 过（那要额外记账），看权重是否高于该 source 的初值：RELATION_SOURCE_
+   * DEFAULTS 是建边时的起点，高出去的部分只能来自 bumpRelationWeight。
+   *
+   * 显式传过 weight 的边（manual 自带权重）会被算成「抬过」，这在语义上没错
+   * ——它确实不是初值——但它是人工意图，所以把 source 一起返回，面板自己决定
+   * 怎么标。整数比较用 gain > 0 而不是 >= 0，防浮点累加的 1e-17 噪声。
+   * 返回按 gain 降序、created_at 降序，附两侧实体名（面板不必再查一遍）。
+   */
+  function listBoostedRelations({ limit = 200, minGain = 0 } = {}) {
+    const { limit: lim } = sanitizePage(limit, 1, 200);
+    const rows = db.prepare(
+      `SELECT r.*, ef.name AS from_name, et.name AS to_name
+       FROM entity_relations r
+       LEFT JOIN entities ef ON ef.id = r.from_entity
+       LEFT JOIN entities et ON et.id = r.to_entity
+       ORDER BY r.weight DESC, r.created_at DESC`
+    ).all();
+    const out = [];
+    for (const row of rows) {
+      const src = row.source ?? "manual";
+      const base = Object.hasOwn(RELATION_SOURCE_DEFAULTS, src)
+        ? RELATION_SOURCE_DEFAULTS[src]
+        : 1.0;
+      const gain = (row.weight ?? 1.0) - base;
+      if (!(gain > minGain)) continue;
+      out.push({
+        ...toRelation(row),
+        from_name: row.from_name ?? null,
+        to_name: row.to_name ?? null,
+        base_weight: base,
+        gain
+      });
+    }
+    // 排序必须在算完 gain 之后做，不能交给 SQL 的 weight DESC：不同 source 的
+    // base 不同，weight 大不等于 gain 大（llm 边 0.95 / gain 0.55 会压过
+    // tag 边 0.90 / gain 0.60）。早先在循环里按 lim 提前 break 时，被截掉的
+    // 恰恰是 gain 更大的边——面板按 limit=100 取数，截断处正是最该看见的那几条。
+    out.sort((a, b) => b.gain - a.gain || String(b.created_at).localeCompare(String(a.created_at)));
+    return out.slice(0, lim);
+  }
+
   /** Relations where the entity appears on either side (from or to). */
   function getRelations(entityId) {
     return db.prepare(
@@ -4202,6 +4353,10 @@ export function createStore(path) {
     entitiesForMemory,
     findMemoriesByAttr,
     findEntitiesMentionedIn,
+    // #24 块1 第二路（Tag 桥接）与块4 复核出口。
+    findEntitiesByTags,
+    entityIdsForMemories,
+    listBoostedRelations,
     getLinkedMemoryIds,
     saveRelation,
     bumpRelationWeight,

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, 10 model tools, automatic injection, session summarization, user profile/rules, custom slash commands, vector (semantic) search, and a Web GUI panel",
-  "version": "0.10.0",
+  "version": "0.10.1",
   "license": "MIT",
   "repository": {
     "type": "git",