dsh-prime-memory 0.26.4 → 0.26.5

package/dist/store/l1.js

@@ -9,7 +9,6 @@
 import { existsSync, mkdirSync, promises as fs, writeFileSync } from 'node:fs';
 import * as path from 'node:path';
 import { familyForType, isScopeVisible } from '../types.js';
-import { graphHitRecordIds } from '../graph/search.js';
 import { isRetired } from './supersede.js';
 import { exportThenPurge, readSnapshotManifest, readSnapshotRecords, restoreL1Snapshot, selectSnapshotTargets, snapshotDirFor, listSnapshots as listSnapshotsIn } from './l1-snapshot.js';
 import { EmbedHelper, NoopEmbeddingService } from './embedding.js';
@@ -735,14 +734,35 @@ export class L1Store {
         const vecList = vecRaw ? this.db.searchL1Vector(vecRaw, candidateK, opts?.family, opts?.workspaceId) : [];
         // 第 3 路(图谱)仅在接线时**结构性存在**:未接线不占路数名额,故既有调用方
         // 仍走 2 路、得分与改动前逐位一致(见 findings.md §12.1 的路数语义)
-        const lanes = [ftsList, vecList];
+        const lanes = [['fts', ftsList], ['vec', vecList]];
         if (this.graphLaneProvider)
-            lanes.push(this.graphLane(query, candidateK, opts?.family, opts?.workspaceId));
+            lanes.push(['graph', await this.graphLane(query, candidateK, opts?.family, opts?.workspaceId)]);
         // 第 4 路(时效)在衰减开启时**结构性存在**;关掉衰减 = 该路不存在
         if (this.decayHalfLifeDays > 0)
-            lanes.push(this.recencyLane([...ftsList, ...vecList]));
-        const merged = rrfMerge(lanes, (h) => h.id);
-        return this.postProcess(this.applyDecay(merged.map(({ rrfScore, ...h }) => ({ ...h, score: normalizeRrf(rrfScore, lanes.length) }))), opts?.type, limit);
+            lanes.push(['recency', this.recencyLane([...ftsList, ...vecList])]);
+        const laneLists = lanes.map(([, list]) => list);
+        // 路归因(与融合并行,不改 rrfMerge 本体):id → 命中路集合,按路构造序
+        // 去重追加(fts→vec→graph→recency,确定性输出)。命中对象在下方 map 里
+        // 新建(不往变回路的列表元素上写),挂 lanes 后随 postProcess/applyDecay 透传。
+        const lanesById = new Map();
+        for (const [name, list] of lanes) {
+            for (const h of list) {
+                const arr = lanesById.get(h.id);
+                if (arr) {
+                    if (!arr.includes(name))
+                        arr.push(name);
+                }
+                else {
+                    lanesById.set(h.id, [name]);
+                }
+            }
+        }
+        const merged = rrfMerge(laneLists, (h) => h.id);
+        return this.postProcess(this.applyDecay(merged.map(({ rrfScore, ...h }) => ({
+            ...h,
+            lanes: lanesById.get(h.id),
+            score: normalizeRrf(rrfScore, laneLists.length),
+        }))), opts?.type, limit);
     }
     /**
      * §D 第 4 路(时效路,hybrid 专用):把候选池按 `applyDecayWeight` 加权后的
@@ -770,36 +790,37 @@ export class L1Store {
         return this.applyDecay(deduped);
     }
     /**
-     * §D 第 3 路(图谱路径,hybrid 专用):图谱命中 → `sourceRecordIds` 回链 →
-     * L1 记录,作为第 3 条**已排序**列表参与 RRF。
+     * §D 第 3 路(图谱路径,hybrid 专用):provider 给出回链记录 id 序(路内向量种子
+     * 并集 + 1-hop 边扩展在 provider 内完成),本缝只做点查回形 + family/scope 双闸,
+     * 作为第 3 条**已排序**列表参与 RRF。
      *
      * 为什么值得:图谱是按实体/关系组织的**可重建派生投影**,能召回词法与向量
      * 都命不中的记录(同义表述、关系可达)——这正是本路相对双路的增量。
      *
      * 三条边界:
      * - **异常降级**:图谱是派生投影,不得因它失败而拖垮主检索 → 记 warn、返回空路,
-     *   融合退回双路(路数随之降为 2,分数回到既有量纲);
-     * - **族隔离**:图谱节点已按族过滤,但其来源记录可能跨族 → 这里再按 `family`
-     *   过滤一次。宁可漏不可串(与档位隔离同源,§A 的 P0 关注点);
+     *   融合退回双路(路数随之降为 2,分数回到既有量纲);await 在 try 内——
+     *   provider 的 Promise reject 与同步 throw 同路径降级;
+     * - **族隔离**:图谱节点已按族过滤(含向量种子),但 1-hop 邻居与来源记录可能跨族
+     *   → 这里再按 `family` 过滤一次。宁可漏不可串(与档位隔离同源,§A 的 P0 关注点);
      * - **墓碑边界**:图谱行可能回链到已被删除的 L1 记录 → 取不到就跳过,
      *   不补空占位(占位会在 RRF 里凭空加分)。
      */
-    graphLane(query, limit, family, workspaceId) {
+    async graphLane(query, limit, family, workspaceId) {
         const provider = this.graphLaneProvider;
         if (!provider)
             return [];
-        let hits;
+        let ids;
         try {
-            hits = provider(query, limit, family);
+            ids = await provider(query, limit, family);
         }
         catch (err) {
             this.logger?.warn(`[memory] 图谱路检索失败,本轮退回双路: ${err instanceof Error ? err.message : String(err)}`);
             return [];
         }
-        const ids = graphHitRecordIds(hits);
         if (ids.length === 0)
             return [];
-        const byId = new Map(this.db.getL1ByIds(ids).map((r) => [r.id, r]));
+        const byId = new Map(this.db.getL1ByIds([...ids]).map((r) => [r.id, r]));
         const out = [];
         for (const id of ids) {
             const r = byId.get(id);

package/dist/store/session-recalled.d.ts

@@ -1,4 +1,4 @@
-import type { MemoryLogger } from '../types.js';
+import type { MemoryLogger, RecallLane } from '../types.js';
 export declare class SessionRecalledStore {
     private readonly logger?;
     private readonly file;
@@ -12,8 +12,9 @@ export declare class SessionRecalledStore {
     constructor(dataDir: string, logger?: MemoryLogger | undefined);
     revision(): number;
     private init;
-    /** 记入本 sessionKey 本轮实际注入的记录 id（写穿；插入序淘汰最旧）。 */
-    add(sessionKey: string, recordIds: readonly string[], injectionId?: string): void;
+    /** 记入本 sessionKey 本轮实际注入的记录 id（写穿；插入序淘汰最旧）。
+     *  laneById 只带真正有归因的条目（hybrid 融合才挂 lanes；单路/旧路不传）。 */
+    add(sessionKey: string, recordIds: readonly string[], injectionId?: string, laneById?: ReadonlyMap<string, readonly RecallLane[]>): void;
     /**
      * 标为受保护（判过时/软退场）：条目留在列表里，且不受上限淘汰与压缩清理影响。
      * id 不在本会话列表里时忽略（不凭这个调用新建条目）。
@@ -34,6 +35,11 @@ export declare class SessionRecalledStore {
      * 未出现过取代的会话返回共享空集，不每次新建）。
      */
     supersededOf(sessionKey: string): ReadonlySet<string>;
+    /**
+     * 本会话的路归因表（record id → 管道串；只读共享，投影/端点用）。
+     * 不在表里 = 无从归因（单路检索/旧文件条目），展示层不渲染徽标。
+     */
+    lanesOf(sessionKey: string): ReadonlyMap<string, string>;
     /**
      * 用会话日志的可见性事实**对账**取代标记（Phase 0B）。
      *

package/dist/store/session-recalled.js

@@ -23,9 +23,12 @@ import { SESSION_RECALLED_FILE_VERSION } from './file-versions.js';
 import { RECALL_DEDUPE_IDS_CAP, RECALL_DEDUPE_SESSION_CAP } from './recall-dedupe.js';
 /** 共享空集（未出现过取代的会话重复取用，不必每次新建）。 */
 const EMPTY_SET = new Set();
+/** 共享空归因表（同 EMPTY_SET 口径）。 */
+const EMPTY_LANES = new Map();
 /**
- * 读 `injectedBy` 的宽容解析：非对象/值非字符串一律丢弃。
- * 宁可让那条记录“无从判”（对账不动它），也不把脏值喂给可见性判定——
+ * 读 `Record<string, string>` 型字段的宽容解析（injectedBy/lanes 共用）：
+ * 非对象/值非字符串一律丢弃。
+ * 宁可让那条记录“无从判”（对账不动它/徽标不渲染），也不把脏值喂给下游判定——
  * 一个错的 message id 会把仍在本上下文里的正文误标成“已被摘要取代”。
  */
 function toIdMap(raw) {
@@ -93,17 +96,19 @@ export class SessionRecalledStore {
                 protectedIds: new Set(Array.isArray(entry.protectedIds) ? entry.protectedIds : []),
                 supersededIds: new Set(Array.isArray(entry.supersededIds) ? entry.supersededIds : []),
                 injectedBy: toIdMap(entry.injectedBy),
+                laneOf: toIdMap(entry.lanes),
                 updatedAt: entry.updatedAt ?? now,
             });
         }
     }
-    /** 记入本 sessionKey 本轮实际注入的记录 id（写穿；插入序淘汰最旧）。 */
-    add(sessionKey, recordIds, injectionId) {
+    /** 记入本 sessionKey 本轮实际注入的记录 id（写穿；插入序淘汰最旧）。
+     *  laneById 只带真正有归因的条目（hybrid 融合才挂 lanes；单路/旧路不传）。 */
+    add(sessionKey, recordIds, injectionId, laneById) {
         if (!sessionKey || recordIds.length === 0)
             return;
         let entry = this.entries.get(sessionKey);
         if (!entry) {
-            entry = { ids: new Set(), protectedIds: new Set(), supersededIds: new Set(), injectedBy: new Map(), updatedAt: 0 };
+            entry = { ids: new Set(), protectedIds: new Set(), supersededIds: new Set(), injectedBy: new Map(), laneOf: new Map(), updatedAt: 0 };
             this.entries.set(sessionKey, entry);
         }
         const stamp = typeof injectionId === 'string' && injectionId.length > 0 ? injectionId : undefined;
@@ -114,6 +119,11 @@ export class SessionRecalledStore {
             // 记下这次注入落在哪条消息上：没有它，对账就无从判“这条正文还在不在”。
             if (stamp !== undefined)
                 entry.injectedBy.set(id, stamp);
+            // 路归因：最后一次注入赢；本轮无归因时**不清旧值**（徽标宁可残留一轮
+            // 也不要闪无——真实路集在下一次带归因注入时自然覆盖）。
+            const laneArr = laneById?.get(id);
+            if (laneArr !== undefined && laneArr.length > 0)
+                entry.laneOf.set(id, laneArr.join('|'));
             // 淘汰只能淘汰**没被判过时的**：受保护条目数本身超顶时宁可超顶，也不能把人的裁决
             // 凭证挤掉（那等于“因为后面又召回了几条，所以之前那条的判定历史丢了”）。
             while (entry.ids.size > RECALL_DEDUPE_IDS_CAP) {
@@ -124,6 +134,7 @@ export class SessionRecalledStore {
                 entry.protectedIds.delete(oldest);
                 entry.supersededIds.delete(oldest);
                 entry.injectedBy.delete(oldest);
+                entry.laneOf.delete(oldest);
             }
         }
         entry.updatedAt = Date.now();
@@ -197,6 +208,13 @@ export class SessionRecalledStore {
     supersededOf(sessionKey) {
         return this.entries.get(sessionKey)?.supersededIds ?? EMPTY_SET;
     }
+    /**
+     * 本会话的路归因表（record id → 管道串；只读共享，投影/端点用）。
+     * 不在表里 = 无从归因（单路检索/旧文件条目），展示层不渲染徽标。
+     */
+    lanesOf(sessionKey) {
+        return this.entries.get(sessionKey)?.laneOf ?? EMPTY_LANES;
+    }
     /**
      * 用会话日志的可见性事实**对账**取代标记（Phase 0B）。
      *
@@ -302,6 +320,7 @@ export class SessionRecalledStore {
                 ...(e.protectedIds.size > 0 ? { protectedIds: [...e.protectedIds] } : {}),
                 ...(e.supersededIds.size > 0 ? { supersededIds: [...e.supersededIds] } : {}),
                 ...(e.injectedBy.size > 0 ? { injectedBy: Object.fromEntries(e.injectedBy) } : {}),
+                ...(e.laneOf.size > 0 ? { lanes: Object.fromEntries(e.laneOf) } : {}),
                 updatedAt: e.updatedAt,
             };
         }

package/dist/store/sqlite.d.ts

@@ -12,6 +12,7 @@ export interface StoreCapabilities {
 }
 import { CostLedger } from './cost-ledger.js';
 import type { BucketRow, CostAggregate, CostByLayer } from './cost-ledger.js';
+import { L0WatermarkStore } from './l0-watermark.js';
 export type { BucketRow, CostAggregate, CostByLayer } from './cost-ledger.js';
 import type { CostByModel } from '../contract.js';
 import { GraphStore } from './graph-store.js';
@@ -57,6 +58,8 @@ export declare class MemoryDb {
     readonly costLedger: CostLedger;
     /** 图谱存储(graph_* 表族;init 独立 try/catch,失败仅图谱 no-op)。 */
     readonly graphStore: GraphStore;
+    /** L0 水位表(T8.4 写停;§A 恢复幂等判据的数据源,init 内建表+基线物化)。 */
+    readonly l0Watermark: L0WatermarkStore;
     private stmtUpsertL0;
     private stmtGetL0;
     private stmtL0Exists;

package/dist/store/sqlite.js

@@ -45,6 +45,8 @@ function retiredL1Sql(alias) {
 // 成本账本(token_cost 表族)独立职责,此处 re-export 不断裂既有引用;
 // MemoryDb 的四个公开方法为一行委托。
 import { CostLedger } from './cost-ledger.js';
+// L0 水位表(T8.4 写停后 §A 恢复幂等的唯一数据源;正文三表退役,见 l0-watermark.ts)
+import { L0WatermarkStore } from './l0-watermark.js';
 // 图谱存储(graph_* 表族)同为独立职责类;init 失败仅图谱 no-op,不传染主库降级
 import { GraphStore } from './graph-store.js';
 import { RECEIPTS_MAX_RUNS, RECEIPTS_QUERY_LIMIT_MAX } from './receipts.js';
@@ -88,6 +90,8 @@ export class MemoryDb {
     costLedger = new CostLedger();
     /** 图谱存储(graph_* 表族;init 独立 try/catch,失败仅图谱 no-op)。 */
     graphStore = new GraphStore();
+    /** L0 水位表(T8.4 写停;§A 恢复幂等判据的数据源,init 内建表+基线物化)。 */
+    l0Watermark = new L0WatermarkStore();
     stmtUpsertL0;
     stmtGetL0;
     stmtL0Exists;
@@ -547,6 +551,8 @@ export class MemoryDb {
         this.prepareL0VecStatements();
         // ── token_cost:蒸馏成本明细表(成本账本自治) ──
         this.costLedger.init(this.db, this.logger);
+        // ── l0_watermark:写停后的 §A 恢复水位(建表 + 从存量 l0_conversations 基线物化) ──
+        this.l0Watermark.init(this.db, this.logger);
         // ── graph_*:知识图谱投影表族(GraphStore.init 自带 try/catch,失败仅图谱 no-op) ──
         // §F 节点向量列的维度**复用既有探测结果**（`vecLoaded` / `dimensions` 由
         // `prepareL1VecStatements` 之前的探测决定），不新增一套能力探测。探测未通过 →
@@ -2657,6 +2663,7 @@ export class MemoryDb {
         }
     }
     close() {
+        this.l0Watermark.close();
         try {
             this.db.close();
         }

package/dist/tools/index.d.ts

@@ -3,7 +3,7 @@ import type { MemoryConfig } from '../config.js';
 import type { LiveSettingsHandle } from '../settings.js';
 import type { RuminateController } from '../pipeline/ruminate.js';
 import type { GraphStore } from '../store/graph-store.js';
-import type { L0Store } from '../store/l0.js';
+import type { DrscClient } from '../clients/drsc.js';
 import type { L1Store } from '../store/l1.js';
 import type { PersonaStore } from '../store/persona.js';
 import type { SceneStore } from '../store/scenes.js';
@@ -20,7 +20,8 @@ export interface ToolSealRegistry {
     reg(group: string, make: () => () => void): void;
 }
 export declare function registerMemoryTools(ctx: Context, cfg: MemoryConfig, stores: {
-    l0: L0Store;
+    /** DRSC 客户端(T8.4 读切):conversation_search 的历史供给面;缺席=显式报错。 */
+    drsc?: DrscClient;
     l1: L1Store;
     scenes: Record<MemoryFamily, SceneStore>;
     persona: Record<MemoryFamily, PersonaStore>;

package/dist/tools/index.js

@@ -14,6 +14,7 @@
 import { createHash } from 'node:crypto';
 import { defineTool } from '@deepseek-ai/dsh-tools';
 import { DOWNGRADE_TARGET, familyOf, isKnownType, typeEnumSep } from '../memory-types.js';
+import { drscRoleOf } from '../clients/drsc.js';
 import { RECEIPTS_QUERY_LIMIT_MAX, dimensionOf, toReceiptView } from '../store/receipts.js';
 import { listConflictPairs, renderConflictResolution, renderConflicts, resolveConflictPair } from '../conflict-service.js';
 import { WING_CATALOG, WING_FALLBACK, normPersistence, normScope, resolveRecordScope } from '../types.js';
@@ -399,7 +400,7 @@ roomRegistry) {
     // ── conversation_search: L0 原始对话 ──
     ctx.tools.register(defineTool({
         name: 'conversation_search',
-        description: '搜索原始对话历史(L0)。返回带时间戳的原始消息,适用于查找具体消息原文、时间线、上下文细节。',
+        description: '搜索原始对话历史。返回带时间戳的原始消息节选(已脱敏),适用于查找具体消息原文、时间线、上下文细节。',
         parameters: {
             query: { type: 'string', required: true, description: '搜索查询文本' },
             limit: { type: 'number', description: '最大返回条数(默认 5)' },
@@ -433,15 +434,31 @@ roomRegistry) {
             if (familyOfCaller(exec) === null)
                 return { items: [], notice: blockNoticeOf(exec) };
             const limit = Math.min(Math.max(args.limit ?? 5, 1), 20);
-            const records = await stores.l0.search(args.query, limit);
-            return {
-                items: records.map((r) => ({
-                    session_id: r.sessionId,
-                    role: r.role,
-                    content: r.content,
-                    timestamp: r.timestamp,
-                })),
-            };
+            // T8.4 读切(spec R7):检索命中走 DRSC 原文 fts,返回文本取 redact=1 脱敏列。
+            // 硬依赖无本地回退(l0 本地检索已退役)——collector 缺席/故障显式报错给模型,
+            // 与「空结果」口径分清,不抛穿主流程。
+            const drsc = stores.drsc;
+            if (!drsc) {
+                return { items: [], notice: '历史对话检索不可用:DRSC collector 未装配(本地 L0 检索已退役,无回退)。' };
+            }
+            try {
+                const hits = await drsc.search(args.query, limit);
+                return {
+                    items: hits
+                        .map((h) => ({ h, role: drscRoleOf(h.kind) }))
+                        .filter((e) => e.role !== undefined)
+                        .map(({ h, role }) => ({
+                        session_id: h.session_id,
+                        role,
+                        content: h.snippet,
+                        timestamp: h.time,
+                    })),
+                };
+            }
+            catch (err) {
+                const detail = err instanceof Error ? err.message : String(err);
+                return { items: [], notice: `历史对话检索暂不可用(DRSC collector: ${detail})。` };
+            }
         },
     }));
     // ── memory_read_scene: 读取 L2 场景块 / L3 画像 ──

package/dist/types.d.ts

@@ -258,6 +258,13 @@ export interface SceneSummary {
     summary: string;
     heat: number;
 }
+/**
+ * 召回路标识(§D hybrid 多路归因):hybrid 融合时记录每条命中**来自哪几路**，
+ * 供面板/回捞展示层渲染徽标。与路数语义同源:未接线的路不存在,不会出现在
+ * 本联合的取值里(如图谱路未注入 provider 时无 'graph')。
+ * 单路检索分支(纯 fts/纯 vec)不挂归因——无歧义可归,lanes 保持 undefined。
+ */
+export type RecallLane = 'fts' | 'vec' | 'graph' | 'recency';
 /** L1 检索命中。 */
 export interface L1Hit {
     id: string;
@@ -267,6 +274,8 @@ export interface L1Hit {
     score: number;
     priority?: number;
     family?: MemoryFamily;
+    /** hybrid 融合命中的来源路集合(可选;缺省=未归因,序列化面零漂移)。 */
+    lanes?: RecallLane[];
 }
 /**
  * dsh-llm ≥0.1.7-rc.1(会话格式 v4)的 producer-owned source kind 登记。

package/dsh.plugin.json

@@ -1,7 +1,7 @@
 {
   "id": "dsh-prime-memory",
   "name": "dsh-prime-memory",
-  "version": "0.26.4",
+  "version": "0.26.5-beta.0",
   "description": {
     "en": "Layered distilled memory plugin (L0 capture → L1 atomic memory → L2 scenes → L3 persona) with automatic recall injection before each model step.",
     "zh": "L0~L3 分层蒸馏记忆插件:自动捕获对话、抽取原子记忆、整合场景块、蒸馏核心画像,并在模型步骤前自动召回注入。"

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "dsh-prime-memory",
-  "version": "0.26.4",
+  "version": "0.26.5",
   "publishConfig": {
     "registry": "https://registry.npmjs.org",
     "access": "public",
-    "tag": "latest"
+    "tag": "beta"
   },
   "description": "L0~L3 分层蒸馏记忆插件 for DeepSeek Harness：自动捕获对话（L0）、抽取原子记忆（L1）、整合场景块（L2）、蒸馏核心画像/团队方法论（L3），并在模型步骤前自动召回注入。移植自 MemoryCore (TencentDB Agent Memory) 的管线设计。",
   "type": "module",
@@ -27,7 +27,10 @@
         "@deepseek-ai/dsh-client-ui-primitives"
       ],
       "platform": "web"
-    }
+    },
+    "pluginDependencies": [
+      "dsh-reference-session-collector"
+    ]
   },
   "files": [
     "dist",
@@ -79,6 +82,7 @@
   "dependencies": {
     "@deepseek-ai/schemastery": "^3.18.4",
     "@node-rs/jieba": "^2.0.2",
+    "dsh-reference-session-collector": ">=0.2.0-beta.0 <0.3.0",
     "sqlite-vec": "^0.1.7-alpha.2",
     "undici": "^7.29.0"
   },
@@ -124,6 +128,7 @@
     }
   },
   "devDependencies": {
+    "@antv/g6": "5.1.1",
     "@deepseek-ai/cordis": "^4.0.4",
     "@deepseek-ai/cordis-plugin-loader": "^1.0.5",
     "@deepseek-ai/cosmokit": "1.8.5",