dsh-prime-memory 0.26.4 → 0.26.5-beta.0

package/dist/store/l0.js

@@ -1,121 +1,9 @@
-/**
- * L0 原始对话存储(双写架构):
- * - conversations/YYYY-MM-DD.jsonl:追加式事实源;
- * - MemoryDb(SQLite):主检索引擎——检索不再按天扫文件、现建内存索引。
- */
-import { existsSync, promises as fs } from 'node:fs';
-import * as path from 'node:path';
-import { EmbedHelper, NoopEmbeddingService } from './embedding.js';
-import { appendJsonl, dayKey, ensureDir, nowIso, readJsonl } from '../util/io.js';
-import { rrfMerge } from './search-utils.js';
-import { isZeroVector } from './sqlite.js';
-/** 官方过度召回倍数(conversation-search:limit × 3)。 */
-const CANDIDATE_MULTIPLIER = 3;
 export class L0Store {
     db;
-    dir;
-    legacyDir;
-    helper;
-    embedSvc;
-    logger;
-    constructor(dataDir, db, embed = new NoopEmbeddingService(), logger) {
+    constructor(db) {
         this.db = db;
-        this.dir = path.join(dataDir, 'conversations');
-        this.legacyDir = path.join(dataDir, 'l0');
-        this.embedSvc = embed;
-        this.helper = new EmbedHelper(embed, logger);
-        this.logger = logger;
     }
-    async init() {
-        await ensureDir(this.dir);
-        await this.importLegacy();
-    }
-    /** 旧版 l0/*.jsonl 一次性导入检索库,成功后目录改名 l0.imported/。 */
-    async importLegacy() {
-        if (!existsSync(this.legacyDir))
-            return;
-        try {
-            const files = await fs.readdir(this.legacyDir).catch(() => []);
-            let imported = 0;
-            let total = 0;
-            for (const f of files.sort()) {
-                if (!f.endsWith('.jsonl'))
-                    continue;
-                const records = await readJsonl(path.join(this.legacyDir, f));
-                // 最小有效性门(同 L1 的 importLegacy):坏行读取时丢弃,按 valid 数判迁移完成
-                const valid = records.filter((r) => r && typeof r.id === 'string' && r.content);
-                const badCount = records.length - valid.length;
-                if (badCount > 0) {
-                    this.logger?.warn(`[memory] 旧版 L0 文件 ${f} 丢弃 ${badCount} 条坏行(缺 id/content)`);
-                }
-                if (valid.length > 0) {
-                    total += valid.length;
-                    if (this.db.upsertL0Batch(valid))
-                        imported += valid.length;
-                }
-            }
-            // 只有全部批次入库成功(或目录为空)才改名,避免数据被改名带走
-            if (imported === total) {
-                const renamed = await fs
-                    .rename(this.legacyDir, `${this.legacyDir}.imported`)
-                    .then(() => true, () => false);
-                if (renamed) {
-                    this.logger?.info(`[memory] 旧版 L0 数据已导入检索库 ${imported} 条(l0/ → l0.imported/)`);
-                }
-                else {
-                    this.logger?.warn('[memory] 旧版 L0 导入完成但改名失败(l0.imported/ 已存在?),下次启动会重复导入(幂等,无害)');
-                }
-            }
-            else {
-                this.logger?.warn(`[memory] 旧版 L0 导入不完整(${imported}/${total}),保留原目录下次重试`);
-            }
-        }
-        catch (err) {
-            this.logger?.warn(`[memory] 旧版 L0 数据导入失败: ${err instanceof Error ? err.message : String(err)}`);
-        }
-    }
-    async append(sessionId, messages) {
-        if (messages.length === 0)
-            return;
-        const records = messages.map((m) => {
-            const rec = {
-                sessionId,
-                recordedAt: nowIso(),
-                id: m.id,
-                role: m.role,
-                content: m.content,
-                timestamp: m.timestamp,
-            };
-            // R7:锚点摊平到事实源与 DB 两处(事实源可跨进程重建,DB 供按坐标查询)。
-            // 无锚点时**不写键**——旧行与新增的无坐标消息保持同形。
-            if (m.anchor !== undefined) {
-                rec.turn = m.anchor.turn;
-                if (m.anchor.step !== undefined)
-                    rec.step = m.anchor.step;
-            }
-            return rec;
-        });
-        // 事实源:按天追加
-        const byDay = new Map();
-        for (const r of records) {
-            const k = dayKey(r.timestamp);
-            const arr = byDay.get(k) ?? [];
-            arr.push(r);
-            byDay.set(k, arr);
-        }
-        for (const [day, list] of byDay) {
-            await appendJsonl(path.join(this.dir, `${day}.jsonl`), list);
-        }
-        // 检索引擎:DB + 向量(嵌入失败只跳过向量,不影响元数据/FTS,backfill 补齐)。
-        // 双写失败闭环:JSONL 事实源已先行追加,DB 缺行 = 这些消息检索不可见
-        // (conversation_search / 蒸馏背景参考都查不到)——升 error 并给自愈指引。
-        const vecs = await this.helper.batch(records.map((r) => r.content));
-        if (!this.db.upsertL0Batch(records, vecs)) {
-            this.logger?.error(`[memory] L0 检索库批量写入失败(${records.length} 条,JSONL 事实源完好),` +
-                '这些消息暂不可检索;可在设置页运行「重建记忆」修复');
-        }
-    }
-    /** 今日已捕获消息数(SQL 计数,不再读整文件)。 */
+    /** 今日已捕获消息数(SQL 计数,不再读整文件;写停后归零,面板口径保留)。 */
     async countToday() {
         const d = new Date();
         return this.db.countL0Since(new Date(d.getFullYear(), d.getMonth(), d.getDate()).toISOString());
@@ -124,98 +12,4 @@ export class L0Store {
     async countBySession(sessionId) {
         return this.db.countL0BySession(sessionId);
     }
-    /** 该会话最近 n 条消息(时间升序;蒸馏背景参考用,按会话现查——ADR-0003)。 */
-    async recentBySession(sessionId, limit) {
-        return this.db.recentL0BySession(sessionId, limit);
-    }
-    /** §A 水位线:该会话 L0 已落盘的最大 turn(空会话 undefined;委托 MemoryDb)。 */
-    maxCapturedTurn(sessionId) {
-        return this.db.maxCapturedTurn(sessionId);
-    }
-    /** §A 幂等检查:该 (session, turn) 是否已有任意 L0 行(委托 MemoryDb)。 */
-    hasAnyL0Message(sessionId, turn) {
-        return this.db.hasAnyL0Message(sessionId, turn);
-    }
-    /** 检索:FTS + 向量 hybrid(RRF 融合),返回按相关性排序的消息。 */
-    async search(query, limit) {
-        const caps = this.db.getCapabilities();
-        if (!caps.ftsSearch && !caps.vectorSearch)
-            return [];
-        const candidateK = limit * CANDIDATE_MULTIPLIER;
-        if (caps.vectorSearch && this.helper.vectorReady()) {
-            const [ftsRaw, vec] = await Promise.all([
-                Promise.resolve(this.db.searchL0Fts(query, candidateK)),
-                this.helper.query(query),
-            ]);
-            const vecList = vec ? this.db.searchL0Vector(vec, candidateK) : [];
-            const merged = rrfMerge([ftsRaw, vecList], (h) => h.id);
-            return merged.map(({ rrfScore: _rrf, ...r }) => r).slice(0, limit);
-        }
-        return this.db.searchL0Fts(query, limit).map(({ score: _score, ...r }) => r);
-    }
-    /** 活切换嵌入源:同步换底层服务(嵌入源三态切换用)。 */
-    setEmbeddingService(svc) {
-        this.embedSvc = svc;
-        this.helper.setService(svc);
-    }
-    /** 向量写入能力是否就绪。`reindex` 在未就绪时**静默短路**成 0/0/0
-     *  (见本文件 `reindex` 首行),调用方必须自己问这里——否则"根本没跑"
-     *  会长得和"跑完了、零条待补"一模一样。 */
-    vectorsReady() {
-        return this.helper.vectorReady();
-    }
-    /**
-     * 增量重嵌入(同 L1Store.reindex:只补缺失向量,零向量记 skipped 并入 skip 集,
-     * 不算失败、不阻塞同步标记——保证补齐判据收敛)。onProgress/shouldCancel
-     * 供活切换的进度展示与取消。
-     */
-    async reindex(opts) {
-        if (!this.helper.vectorReady())
-            return { written: 0, failed: 0, skipped: 0 };
-        const items = this.db.getL0ForReindex(this.db.getVecSkipSet('l0'));
-        const total = items.length;
-        let done = 0;
-        let written = 0;
-        let failed = 0;
-        let skipped = 0;
-        let cancelled = false;
-        const skippedNow = [];
-        const CHUNK = 32;
-        for (let i = 0; i < items.length; i += CHUNK) {
-            if (opts?.shouldCancel?.()) {
-                cancelled = true;
-                break;
-            }
-            const chunk = items.slice(i, i + CHUNK);
-            let vecs;
-            try {
-                vecs = await this.embedSvc.embedBatch(chunk.map((c) => c.text));
-            }
-            catch {
-                failed += chunk.length;
-                done += chunk.length;
-                opts?.onProgress?.(done, total);
-                continue;
-            }
-            const pending = [];
-            chunk.forEach((c, j) => {
-                if (isZeroVector(vecs[j])) {
-                    skipped++;
-                    skippedNow.push(c.id);
-                    return;
-                }
-                pending.push({ id: c.id, embedding: vecs[j] });
-            });
-            if (pending.length > 0) {
-                const ok = this.db.updateL0VecBatch(pending, '');
-                written += ok;
-                failed += pending.length - ok;
-            }
-            done += chunk.length;
-            opts?.onProgress?.(done, total);
-        }
-        if (skippedNow.length > 0)
-            this.db.addVecSkippedIds('l0', skippedNow);
-        return { written, failed, skipped, cancelled };
-    }
 }

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/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-beta.0",
   "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",
@@ -80,7 +83,8 @@
     "@deepseek-ai/schemastery": "^3.18.4",
     "@node-rs/jieba": "^2.0.2",
     "sqlite-vec": "^0.1.7-alpha.2",
-    "undici": "^7.29.0"
+    "undici": "^7.29.0",
+    "dsh-reference-session-collector": ">=0.2.0-beta.0 <0.3.0"
   },
   "peerDependencies": {
     "@deepseek-ai/cordis": "^4.0.1",