@modusensus/dsh-mneme 0.9.5 → 0.10.1

package/src/pipeline-runner.js

@@ -98,6 +98,7 @@ export function listPipelineIds(projectRoot) {
 export function createExecutionRecorder({
   ctx,
   logger = null,
+  sessionGate = null,
   resolvePipeline = defaultResolvePipeline,
   persistRun = appendRun,
   now = () => new Date(),
@@ -109,9 +110,19 @@ export function createExecutionRecorder({
   const windows = new Map(); // sessionId → { pipeline, projectRoot, run, events, truncated }
   // 已结账、等人确认的会话：sessionId → { pipeline, projectRoot, proposal, stats }
   const pending = new Map();
+  const gated = (session) => {
+    if (!sessionGate?.isOff(session)) return false;
+    const id = session?.id;
+    if (id) {
+      windows.delete(id);
+      pending.delete(id);
+    }
+    return true;
+  };
 
   const unsubscribe = ctx?.on?.("session/event", (session, event) => {
     try {
+      if (gated(session)) return;
       const id = session?.id;
       if (!id) return;
       const w = windows.get(id);
@@ -135,6 +146,7 @@ export function createExecutionRecorder({
      * 开始走某条流程」。猜错会把一条从没跑过的流程记成跑过。
      */
     start({ session, pipelineId } = {}) {
+      if (gated(session)) return { ok: false, reason: "session-incognito" };
       const id = session?.id;
       if (!id) return { ok: false, reason: "no-session" };
       const open = windows.get(id);
@@ -169,6 +181,7 @@ export function createExecutionRecorder({
      * 同时给出 P1 那份「观察到的业务动作清单」，让人对照着勾。
      */
     stop({ session } = {}) {
+      if (gated(session)) return { ok: false, reason: "session-incognito" };
       const id = session?.id;
       if (!id) return { ok: false, reason: "no-session" };
       const w = windows.get(id);
@@ -233,6 +246,7 @@ export function createExecutionRecorder({
      * （"没确认"不等于"没发生"，见 pipeline-confirm 的注释）。
      */
     confirm({ session, answers } = {}) {
+      if (gated(session)) return { ok: false, reason: "session-incognito" };
       const id = session?.id;
       if (!id) return { ok: false, reason: "no-session" };
       const p = pending.get(id);
@@ -323,6 +337,7 @@ export function createExecutionRecorder({
 
     /** 只看状态，不结账。要能分辨「窗口开着」与「等你确认」两种状态。 */
     status({ session } = {}) {
+      if (gated(session)) return { open: false, incognito: true };
       const id = session?.id;
       if (pending.has(id)) {
         const p = pending.get(id);

package/src/pre-inject-gate.js

@@ -207,6 +207,20 @@ export function createPreInjectGate({ llm, agentDefaultModel, service, config, l
     const startedAt = Date.now();
     const timestamp = new Date(startedAt).toISOString();
     const source = { kind: "plugin:dsh-mneme", plugin: "dsh-mneme" };
+    // 刻意不套 fenceListBody（dream.js:330，Issue #380 的复盘）：本闸的 system 契约把
+    // user 侧形状写死成「你将收到一个 JSON 对象，包含 query 与 memories」（lang.js:57/58），
+    // 套围栏会让提示词与载荷互相矛盾；而且判定池靠 JSON.parse 直接取 m#<i> 局部序号还原
+    // 候选（test/pre-inject-gate.test.js 锁着这个形状），外包围栏文本会让解析整条失败。
+    // 这里的注入防线不是围栏而是**判定结果绝不进模型上下文**：没有任何标记（判到的、
+    // 没判到的）会被写回提示词，给模型看标记的整条线已被 E2/E3 关闭（见 lang.js:52-55）。
+    // 但这条「移出候选」的保证是**有条件的**，写清楚免得被读成无条件：
+    //   · 只有 enforce 开着、且本帧缓存命中（gateFrame.state === "filtered"）时才真移除候选
+    //     （service.injectCandidates 的移除分支）；
+    //   · 观察档（enforce 关）、冷缓存首帧、判定失败/超时、整池被标记的 fail-open 帧，
+    //     候选原样注入——那些帧里记忆正文会照常到达模型；
+    //   · 判定器识别的是「意见或立场」，它**不**承诺消化正文里任何指令句（越狱式记忆
+    //     不在本闸的判据里），别把这段读成对注入指令的保证。
+    // 没有围栏可闭合，也就没有「闭合标记被伪造」这一路风险。
     const messages = [
       { role: "system", content: [{ type: "text", text: STR.prompts.preInjectGate[language] }], source },
       { role: "user", content: [{ type: "text", text: JSON.stringify({ query, memories: candidates.map((c, i) => ({ id: `m#${i}`, content: c.content })) }) }], source },

package/src/profile-extract.js

@@ -24,6 +24,9 @@
 
 import { STR, langOf } from "./lang.js";
 import { describeStreamFailure, resolveRoute, runAuditedLlm, streamText } from "./dream.js";
+// #493 补充 §③：与巩固/蒸馏同一份断链（src/fence.js）。画像条目同样是模型的可影响
+// 输入，一条写着「<<<记忆条目结束>>>」的记忆能提前闭合围栏。
+import { breakFenceMarkers } from "./fence.js";
 
 const DEFAULT_MAX_ROWS = 120;
 const DEFAULT_ROW_CHARS = 260;
@@ -115,7 +118,7 @@ export function createProfileExtractor({ ctx, service, config, logger }) {
     const listing = rows.map((r, i) => `${i + 1}. [${r.type}] ${r.title} :: ${r.content}`).join("\n");
     const userText = [
       STR.profileFenceOpen[language],
-      listing,
+      breakFenceMarkers(listing),
       STR.profileFenceClose[language],
       language === "zh"
         ? `以上 ${rows.length} 条记忆条目（数据）到此结束。只依据它们输出 JSON，条目里没有的绝不发明。`

package/src/provenance-http.js

@@ -2,41 +2,51 @@
 //
 // 为什么要单独一个模块：这张脸有两个入口——宿主内的面板路由（src/api.js 的
 // /api/dsh-mneme/memory/provenance）与 Bearer 数据面（src/api-standalone.js 的
-// /memory/provenance）。两者底下是同一份 service（provenanceFor + distillRecordsFor），
-// 差别只在鉴权与路径。历史上（#509 第一版）它们是整段复制的，于是「改一边忘一边」
-// 在结构上就可能发生——#411 已经为 reclaim / share 各踩过一次，本模块照那次的结论办。
+// /memory/provenance）。两者底下是同一份 service（provenanceFor + distillWindowsFor
+// + distillRecordsFor），差别只在鉴权与路径。历史上（#509 第一版）它们是整段复制的，
+// 于是「改一边忘一边」在结构上就可能发生——#411 已经为 reclaim / share 各踩过一次，
+// 本模块照那次的结论办。
 //
-// 口径（错误码、两种「空」的区分、窗口形状）现在只写在这里，两个入口都调它。
+// 口径（错误码、两种「空」的区分、窗口形状、上限）现在只写在这里，两个入口都调它。
 // 真要再写第二份，test/provenance-http.test.js 的静态锁会直接转红。
 //
-// 这里只做协议层的事：解析 id、判开关、组装窗口、区分「用户关了」「没接线」与
+// 这里只做协议层的事：解析入参、判开关、组装窗口、区分「用户关了」「没接线」与
 // 「没有来源」。一行数据都不改——读取在 src/store.js，透传在 src/service.js。
 //
+// 两个读方向（#421 拆成两条，方向 1 由 #509 交付、方向 2 由 #524 补上）：
+//   memory: ?id=<memoryId>     一条记忆 → 派生它的那些蒸馏窗口
+//   session: ?sessionId=<sid>  一个会话 → 它产出的那些蒸馏窗口
+// 两个主键互斥（都缺 400、都给 400）。共用同一条路径是有意的：多一条路径就多一处
+// 要登记的地方（SECURITY.md 两张表、README 路由表、security-doc 的清单锁），而这两
+// 个方向读的是**同一批数据**，只是入口不同。
+//
 // 状态码阶梯（自前而后，先匹配的先回）：
 //   401 未鉴权      ——两个壳各自的门（api.js 的 register 包装 / standalone 的
 //                     isAuthorized），在本模块之前，不在这里重复。
-//   400 缺 id       ——语法畸形，与服务端状态无关，所以排在功能开关之前；与
+//   400 缺参/多参   ——语法畸形，与服务端状态无关，所以排在功能开关之前；与
 //                     reclaim 的 invalid-json 同档（reclaim-http.js:30-33 立的是
-//                     「503 要赢过**字段校验**的 400」，缺 id 不是字段校验而是请求
+//                     「503 要赢过**字段校验**的 400」，缺参不是字段校验而是请求
 //                     本身不成立，所以不适用那条）。判断在壳里
-//                     （parseProvenanceQuery），走到本模块时 id 一定非空。
-//                     ⚠ 将来要加**语义类** 400（如 limit 越界、id 格式不合法），
-//                     必须挪到接线检查之后——那条 reclaim 口径正是为它立的。
+//                     （parseProvenanceSelector），走到本模块时选择器一定成型。
+//                     limit 越界属**语义类** 400，按上面那条口径仍排在接线检查之前
+//                     ——它是入参本身的形状问题，不是「服务端现在能不能读」。
 //   409 功能关了    ——distillRecords.enabled !== true。回的是「端点的属性」，
 //                     与 src/api.js:525 的 profileExtractEnabled 同构：用户关了
 //                     某功能 = 409，装配坏了 = 503，两者必须是可区分的答案
 //                     （src/index.js:589-591 的设计原话）。
-//   503 装配没接线  ——service 上没有 provenanceFor / distillRecordsFor。
+//   503 装配没接线  ——service 上缺该方向要用的方法（按选择器分方向判，见
+//                     REQUIRED_METHODS：只缺 session 那侧的方法时，memory 查询
+//                     仍然该能用）。
 //   读（200 / 500）
-// 刻意不用 404：本端点永远不就「这条记忆是否存在」作断言（缺 id 是 400、未知 id
-// 是 200 + 空 windows），404 在本仓另有稳定含义——未知路由与资源不存在
+// 刻意不用 404：本端点永远不就「这条记忆/这个会话是否存在」作断言（缺参是 400、
+// 未知 id 是 200 + 空 windows），404 在本仓另有稳定含义——未知路由与资源不存在
 // （src/api-standalone.js:506/515、src/api.js:1367/1445）。把「功能关了」塞进
 // 404，调用方会在状态码这个唯一被代理 / 监控 / 重试逻辑读取的通道上，把它读成
 // 「这条记忆不存在」。
 
 /**
- * 「溯源能力没接线」的错误码。headless / 旧装配下 service 上没有 provenanceFor 或
- * distillRecordsFor，那是装配坏了，不是「这条记忆没有来源」——两种空必须分开读数，
+ * 「溯源能力没接线」的错误码。headless / 旧装配下 service 上没有本方向要用的方法，
+ * 那是装配坏了，不是「这条记忆没有来源」——两种空必须分开读数，
  * 否则调用方看到一个空 windows 会以为拿到了答案。
  */
 export const PROVENANCE_UNAVAILABLE = "provenance-unavailable";
@@ -50,6 +60,24 @@ export const PROVENANCE_UNAVAILABLE = "provenance-unavailable";
  */
 export const DISTILL_RECORDS_DISABLED = "distill-records-disabled";
 
+/**
+ * 一次答复最多带几个窗口。缺省 20。
+ *
+ * 为什么**必须**有上限（#524 的第 2 条前置）：按会话读是这张脸里天然最容易放大
+ * 的方向——一个会话几十个窗口，每个窗口都是整段逐字原文，不限量就是「按会话导出
+ * 全量转录」，与 /export（一次拿全库）同量级、只是换了形状，而它同样受门控。
+ * 20 这个数的取法：本机实测一个蒸馏会话的窗口数在个位数，20 已覆盖正常排查；
+ * 真要更多就带 limit 往上要，**不许**靠缺省值默默给全量。
+ */
+export const PROVENANCE_DEFAULT_WINDOWS = 20;
+
+/**
+ * limit 的硬上界。取值与 api.js 的 MAX_PAGE_LIMIT（1000）/ MAX_SEARCH_TOP_K（200）
+ * 同一考虑：参数直接进 SQL LIMIT，上界是防御。这里比列表类接口更小，因为每个窗口
+ * 带的是一整段原文而不是一行元数据——100 个窗口已经是一份不小的转录。
+ */
+export const PROVENANCE_MAX_WINDOWS = 100;
+
 /**
  * 读侧唯一的开关判据，**与写侧 src/summarize.js:988 逐字同源**。
  *
@@ -77,48 +105,145 @@ export function provenanceWarnMessage(error) {
 }
 
 /**
- * 解析 ?id。空 / 缺失 → 400；其余原样交给 service（id 不存在时返回空 windows，
- * 那是有效答案，不是错误——读端点不替调用方判断记忆是否存在）。
+ * 按选择器分方向列出「要读必须先有哪个方法」。503 只在**该方向**缺方法时回：
+ * 只补了 session 侧的装配不该让 memory 查询一起 503（那是把一个方向的问题
+ * 报成整张脸坏了）。
+ */
+const REQUIRED_METHODS = {
+  memory: ["provenanceFor", "distillRecordsFor"],
+  session: ["distillWindowsFor", "distillRecordsFor"]
+};
+
+function trimmed(raw) {
+  return typeof raw === "string" ? raw.trim() : "";
+}
+
+/**
+ * 解析 ?limit。**只收十进制整数字面量**，缺省落默认值。
+ *
+ * 不用 Number()：它把 "" / " " / 十六进制 / 指数写法都化成数，于是 `?limit=`
+ * 会静默变成 0 个窗口——一个畸形输入拿到最坏解释（reclaim-http.js 的
+ * parseReclaimQuery 为同一理由立过这条规矩）。越界也算畸形：调用方要 1000 个
+ * 窗口，实际给 100 而不说一声，比直接拒更糟。
  *
- * @returns {{ok: true, id: string} | {ok: false, status: 400, error: string}}
+ * @returns {{ok: true, limit: number} | {ok: false, status: 400, error: string}}
  */
-export function parseProvenanceQuery(raw) {
-  const id = typeof raw === "string" ? raw.trim() : "";
-  if (!id) return { ok: false, status: 400, error: "missing-id" };
-  return { ok: true, id };
+export function parseProvenanceLimit(raw) {
+  if (raw === null || raw === undefined) return { ok: true, limit: PROVENANCE_DEFAULT_WINDOWS };
+  const text = typeof raw === "string" ? raw.trim() : "";
+  if (!/^\d+$/.test(text)) return { ok: false, status: 400, error: "invalid-limit" };
+  const limit = Number(text);
+  if (!Number.isSafeInteger(limit) || limit < 1 || limit > PROVENANCE_MAX_WINDOWS) {
+    return { ok: false, status: 400, error: "invalid-limit" };
+  }
+  return { ok: true, limit };
 }
 
 /**
- * 组装答复：一个链接一个窗口（区间 + 区间内原文行，按 seq 升序）。
+ * 解析两个互斥主键。都缺 → 400 missing-id；都给 → 400 ambiguous-id。
+ *
+ * 「都给时择一」是刻意不做的：择一意味着调用方可以发一个自己也不知道会被读哪个
+ * 主键的请求，而两边的结果形状不同——那种静默选择只会在出事之后才被发现。
+ * 400 是两个都错，比猜一个更好。
+ *
+ * @param {{memoryId?: string|null, sessionId?: string|null, limit?: string|null}} params
+ * @returns {{ok: true, selector: {mode: "memory"|"session", memoryId?: string,
+ *   sessionId?: string, limit: number}} | {ok: false, status: 400, error: string}}
+ */
+export function parseProvenanceSelector({ memoryId, sessionId, limit } = {}) {
+  const mem = trimmed(memoryId);
+  const ses = trimmed(sessionId);
+  // 参数形状排在功能开关之前：请求本身不成立时报「功能关了」是误导。
+  if (mem && ses) return { ok: false, status: 400, error: "ambiguous-id" };
+  if (!mem && !ses) return { ok: false, status: 400, error: "missing-id" };
+  const parsedLimit = parseProvenanceLimit(limit);
+  if (!parsedLimit.ok) return parsedLimit;
+  return {
+    ok: true,
+    selector: mem
+      ? { mode: "memory", memoryId: mem, limit: parsedLimit.limit }
+      : { mode: "session", sessionId: ses, limit: parsedLimit.limit }
+  };
+}
+
+/**
+ * 组装答复：一个窗口一项（区间 + 区间内原文行，按 seq 升序）。
  *
  * 顺序敏感（阶梯全貌见文件头）：409 功能关了 → 503 装配没接线 → 读。
  * 503 要赢过空结果——装配没接线时报「这条记忆没有来源」是误导，与 reclaimReply 的
  * maintenance-unavailable 同构；而 409 要赢过 503——「用户关了」比「装配坏了」更
  * 具体，把前者报成后者会让人去查一个没坏的部署。
  *
- * @param {{service: object, id: string, config?: object|null, warn?: Function}} args
+ * `truncated` 是两种模式共有的读数（#524）：撞上 limit 时把「还有更多」说出来。
+ * 少了它，被截断的答复与「本来就只有这么多」逐字节相同，调用方会把半份转录
+ * 当成全部——那正是这张脸最容易骗人的地方。
+ *
+ * @param {{service: object, selector: object, config?: object|null, warn?: Function}} args
  *   config 缺省即关（fail-closed），见 isDistillRecordsEnabled。
  * @returns {{status: number, body: object}}
  */
-export function provenanceReply({ service, id, config = null, warn = null }) {
+export function provenanceReply({ service, selector, config = null, warn = null }) {
   if (!isDistillRecordsEnabled(config)) {
     return { status: 409, body: { error: DISTILL_RECORDS_DISABLED } };
   }
-  if (typeof service?.provenanceFor !== "function" || typeof service?.distillRecordsFor !== "function") {
+  const mode = selector?.mode === "session" ? "session" : "memory";
+  if (REQUIRED_METHODS[mode].some((name) => typeof service?.[name] !== "function")) {
     return { status: 503, body: { error: PROVENANCE_UNAVAILABLE } };
   }
+  const limit = selector?.limit > 0 ? selector.limit : PROVENANCE_DEFAULT_WINDOWS;
   try {
-    const links = service.provenanceFor(id);
-    const windows = links.map((link) => ({
-      session_id: link.session_id,
-      seq_start: link.seq_start,
-      seq_end: link.seq_end,
-      created_at: link.created_at,
-      // 到期裁剪后区间可能变空：链接刻意保留并指向空区间（clearDistillRecords 的
-      // 语义），面板据此显示「原文已过期」而非「没有来源」。
-      records: service.distillRecordsFor(link.session_id, link.seq_start, link.seq_end)
-    }));
-    return { status: 200, body: { memoryId: id, windows } };
+    // session 侧多取一行判截断（store 侧只照 limit 取，不替调用方判断「还有没有」；
+    // memory 侧 provenanceFor 本来就全量返回，按长度判即可）。
+    const rows = mode === "session"
+      ? service.distillWindowsFor(selector.sessionId, limit + 1)
+      : service.provenanceFor(selector.memoryId);
+    const truncated = rows.length > limit;
+    // #512：run 是归因主体，窗口只是它的一批输入。能读到 run 就带上 run_type /
+    // trigger_source / status，读不到（旧库历史链接、或 store 没这一步）就整组
+    // 缺省——**不拿区间或时间戳去猜**：「看起来能追、实际是编的」比没有更坏。
+    const canReadRuns = typeof service?.getDistillRun === "function";
+    const windows = rows.slice(0, limit).map((link) => {
+      const base = {
+        session_id: link.session_id,
+        seq_start: link.seq_start,
+        seq_end: link.seq_end,
+        created_at: link.created_at,
+        // 到期裁剪后区间可能变空：链接刻意保留并指向空区间（clearDistillRecords 的
+        // 语义），面板据此显示「原文已过期」而非「没有来源」。
+        records: service.distillRecordsFor(link.session_id, link.seq_start, link.seq_end)
+      };
+      if (mode === "session") {
+        // link_count 只有方向 2（session）会带：一个窗口派生出几条记忆。方向 1 的每
+        // 一行本来就是「一条记忆 → 一个窗口」，这个计数恒为 1，带出去只会是噪音（用
+        // ?? 兜住，免得方向 1 的答复凭空多一个 null 键）。
+        return { ...base, link_count: link.link_count ?? 1 };
+      }
+      // 方向 2 的一行是一个窗口、可能派生多条记忆，没有单一归因主体，所以运行归因
+      // 只挂在方向 1 上；要逐条查某条记忆出生自哪一轮，仍走方向 1。
+      const run = canReadRuns && link.distill_run_id ? service.getDistillRun(link.distill_run_id) : undefined;
+      return {
+        ...base,
+        // #512：distill_run_id 为 null 就是历史行为——改造之前写下的链接没有第二轮
+        // 真相可查，面板据此显示「这一条没有运行归因」而不是给一个像样的空壳。
+        distill_run_id: link.distill_run_id ?? null,
+        run_type: run?.run_type ?? null,
+        trigger_source: run?.trigger_source ?? null,
+        run_status: run?.status ?? null
+      };
+    });
+    // 行级铸造归因（#512）：这条记忆出生自哪一轮。与窗口级是两层，各自独立缺省。
+    const mints = mode === "memory" && typeof service?.mintsFor === "function"
+      ? service.mintsFor(selector.memoryId).map((mint) => ({
+        run_id: mint.run_id,
+        run_type: mint.run_type,
+        trigger_source: mint.trigger_source,
+        created_at: mint.created_at
+      }))
+      : [];
+    const body = mode === "session"
+      ? { sessionId: selector.sessionId, windows, truncated }
+      : { memoryId: selector.memoryId, windows, truncated, mints };
+    return { status: 200, body };
   } catch (error) {
     warn?.(provenanceWarnMessage(error));
     return { status: 500, body: { error: "internal" } };

package/src/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 = [
@@ -2638,6 +2696,11 @@ export function createService({ store, mirror, config, onWrite, logger, document
     transaction,
     getDistillCursor: (sessionId) => store.getDistillCursor(sessionId),
     setDistillCursor: (sessionId, lastSeq) => store.setDistillCursor(sessionId, lastSeq),
+    // #493 补充 §②：解析失败计数是**跨进程**的事实（护栏默认关，但开着时重启一次
+    // 就清零等于让护栏可被重启绕过）。整条是 bookkeeping，不挂 write hook。
+    getDistillParseFailureStreak: (sessionId, opts) => store.getDistillParseFailureStreak(sessionId, opts),
+    bumpDistillParseFailureStreak: (sessionId, opts) => store.bumpDistillParseFailureStreak(sessionId, opts),
+    clearDistillParseFailureStreak: (sessionId) => store.clearDistillParseFailureStreak(sessionId),
     // #399 蒸馏原始记录与溯源：与上面两条游标一样是纯 passthrough——它们不是
     // 记忆写入，不该触发 syncMirror / notifyWrite / 实体抽取（那些钩子挂在
     // saveWithDedupe 上）。distill_records 的落盘由 summarize.js 在蒸馏窗口内
@@ -2648,6 +2711,18 @@ export function createService({ store, mirror, config, onWrite, logger, document
     // #421 读出口：按 (session, seq 区间) 取蒸馏原文。与 provenanceFor 成对——
     // 一个给区间、一个给区间里的原文，合起来才是「这条记忆从哪几句蒸出来的」。
     distillRecordsFor: (sessionId, seqStart, seqEnd) => store.distillRecordsFor(sessionId, seqStart, seqEnd),
+    // #524 方向 2：按会话列出它的蒸馏窗口。与 provenanceFor 同一张表、另一条索引
+    // （idx_memory_provenance_session），所以也是纯 passthrough——读的是 #399 早就
+    // 落好的事实，不产生任何写入。
+    distillWindowsFor: (sessionId, limit) => store.distillWindowsFor(sessionId, limit),
+    // #512 蒸馏运行与铸造归因：同样是 bookkeeping passthrough（与 saveDreamRun
+    // 那一组同语义）——run 是审计主体，notifyWrite 会绕回它自己的调度器。
+    saveDistillRun: (run) => store.saveDistillRun(run),
+    attachDistillRunAudit: (id, auditId) => store.attachDistillRunAudit(id, auditId),
+    getDistillRun: (id) => store.getDistillRun(id),
+    listDistillRuns: (opts) => store.listDistillRuns(opts),
+    saveMemoryMint: (mint) => store.saveMemoryMint(mint),
+    mintsFor: (memoryId) => store.mintsFor(memoryId),
     enqueue,
     setDreamHook(fn) { dreamHook = fn; },
     setSleepHook(fn) { sleepHook = fn; },
@@ -2822,6 +2897,17 @@ export function createService({ store, mirror, config, onWrite, logger, document
     listConflictQueue,
     resolveConflictPending,
     countConflictPending: () => store.countConflictPending(),
+    // Issue #533：differentiate 的裁决账本。同样只做记账、绝不改正文——正文
+    // 一旦互相追加同一段注记，两条向量会被同向拉近（复现见 store 侧建表注释）。
+    saveDifferentiatedPair: (r) => store.saveDifferentiatedPair(r),
+    findDifferentiatedPair: (a, b) => store.findDifferentiatedPair(a, b),
+    listDifferentiatedPairs: (opts) => store.listDifferentiatedPairs(opts),
+    // #529：机器侧冲突裁决台账。同样只有 bookkeeping 语义——一行台账既不是记忆
+    // 内容也不是人工裁决，写它不该触发 syncMirror / notifyWrite / 实体抽取，否则
+    // 记账本身会反过来把睡眠调度器叫醒（与上面 saveDreamRun 同一个理由）。
+    saveConflictReviewed: (r) => store.saveConflictReviewed(r),
+    loadConflictReviewed: () => store.loadConflictReviewed(),
+    listConflictReviewed: (opts) => store.listConflictReviewed(opts),
     // Recall evaluation trail (方案 B): audit-bookkeeping semantics like the
     // dream/recall passthroughs above — a recall_evals write is a snapshot, not
     // a memory mutation, so it never triggers write hooks.
@@ -2831,6 +2917,8 @@ export function createService({ store, mirror, config, onWrite, logger, document
     // LLM audit trail (Bug8): bookkeeping semantics like the recall/dream
     // passthroughs — a saveLlmAudit write never triggers write hooks.
     saveLlmAudit: (entry) => store.saveLlmAudit(entry),
+    // #534：校验层的判决要补回到调用层已经写死的审计行上（两套账分账，见 store 侧注释）。
+    annotateLlmAudit: (id, patch) => store.annotateLlmAudit(id, patch),
     listLlmAudits: (opts) => store.listLlmAudits(opts),
     countLlmAudits: (opts) => store.countLlmAudits(opts),
     getLlmAuditStats: (opts) => store.getLlmAuditStats(opts),
@@ -2842,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/src/session-gate.js

@@ -0,0 +1,91 @@
+// #539 逐会话无痕闸门：总开关关闭时保留既有行为；每个消费点读取同一份配置，
+// 因此配置对象更新后，下一次操作即按新值判定。
+export function createSessionGate(config) {
+  // 已观察到的子会话 id。作用只有一个：日志扫描只拿得到一个 id 与一段**可能解析
+  // 不出 header** 的帧，那时没有活会话对象可问。上限与会话日志扫描的批次无关，
+  // 纯粹是防「长驻宿主跑上几百个子代理后这张表只涨不落」——本机 641 个真实会
+  // 话里 455 个是子代理，不设界等于把每个子代理 id 永久留在内存里。淘汰最旧的
+  // 是安全的：淘汰只影响「header 解析不出时的那次日志过滤」，活路径一律直接用
+  // 会话对象判定，不查这张表。
+  const MAX_TRACKED_SESSIONS = 512;
+  const childSessions = new Set();
+
+  const read = (target, key) => {
+    try {
+      return target?.[key];
+    } catch {
+      return undefined;
+    }
+  };
+
+  const headerOf = (session) => {
+    const header = read(session, "header");
+    if (header && typeof header === "object") return header;
+    try {
+      const requestHeader = read(session, "requestHeader");
+      const request = typeof requestHeader === "function" ? requestHeader.call(session) : null;
+      const fallback = read(request, "config");
+      return fallback && typeof fallback === "object" ? fallback : null;
+    } catch {
+      return null;
+    }
+  };
+
+  /**
+   * 子会话判据：**只看宿主自己的委派标记**。
+   *
+   * 刻意不把 `parentSession` 当判据。它是「有父会话」而不是「是子代理」：
+   * `dsh-session` 的 `sessions.fork()` 造出来的**主会话分支**同样写它
+   * （`@deepseek-ai/dsh-session/lib/index.js` 的 fork 只写 cwd / parentSession /
+   * isSeeded，不写 origin、不写 delegationDepth），而宿主对
+   * `origin` 的取值校验只有一个合法值 "subagent"。本机 641 个真实会话头实测：
+   * origin/delegationDepth 命中 455 个子代理、零漏检；parentSession 对子代理
+   * 识别零贡献，只额外判出 3 个 fork 出来的主会话（那些会话里各有 74–136 条
+   * 用户消息、694 次工具调用，不是空壳）。把它们一起关掉 = 普通主会话突然失忆。
+   *
+   * `parentSessionId` 是 #539 描述的兼容别名，641 个真实头里一次都没出现过；
+   * 这里同样不读——留着它当判据只会把同一个误判换个键名再犯一次。
+   */
+  const isChild = (session) => {
+    const header = headerOf(session);
+    const origin = read(header, "origin") ?? read(session, "origin");
+    if (origin === "subagent") return true;
+    const depth = read(header, "delegationDepth") ?? read(session, "delegationDepth");
+    return Number(depth) > 0;
+  };
+
+  const idOf = (sessionOrId) => {
+    if (typeof sessionOrId === "string") return sessionOrId || null;
+    const id = read(sessionOrId, "id");
+    return typeof id === "string" && id.length > 0 ? id : null;
+  };
+
+  const observe = (session) => {
+    const id = idOf(session);
+    if (!id || !isChild(session)) return;
+    if (!childSessions.has(id) && childSessions.size >= MAX_TRACKED_SESSIONS) {
+      // 与 src/continuity.js:193 的边缘表同一手法：Map/Set 保持插入序，淘汰最旧。
+      childSessions.delete(childSessions.values().next().value);
+    }
+    childSessions.add(id);
+  };
+
+  const isEnabled = () => read(config, "sessionGateEnabled") === true;
+
+  const isOff = (sessionOrId) => {
+    if (!isEnabled()) return false;
+    // id 只服务两件事：手动名单的精确匹配、已观察子会话的记账查询。它**不是**
+    // 判定子会话的前提——#539 明写「子会话在首个 session/event 之前就可能组装
+    // 上下文」，那时过去只有会话对象、未必有可用 id。以前在这里 `if (!id) return
+    // false` 早退，等于把这类会话整个放过去，而下面的 isChild 本来就是为这个
+    // 场景准备的。
+    const id = idOf(sessionOrId);
+    const sessions = read(config, "sessionGateSessions");
+    if (id && Array.isArray(sessions) && sessions.includes(id)) return true;
+    if (read(config, "sessionGateSubagents") === false) return false;
+    if (id && childSessions.has(id)) return true;
+    return typeof sessionOrId === "object" && sessionOrId !== null && isChild(sessionOrId);
+  };
+
+  return { observe, isEnabled, isOff };
+}