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

package/dist/hooks/recall.js

@@ -64,6 +64,20 @@ export function ownInjectionFromEvent(ev) {
         chars,
     };
 }
+/**
+ * 会话事件统一读形状（issue #8）：旧宿主 `session.events` 是数组属性；
+ * 0.2.x 宿主已删该属性，官方访问器是 `snapshotEvents()`（全量日志，seq 与日志
+ * 位置对齐，含 fork 前缀——与旧属性同口径）。两者都拿不到时返回 undefined，
+ * 由调用点的既有退路处置（粗标记 / 存储回填）；不假设形状，不抛。
+ * 导出供双形状单测钉住。
+ */
+export function readSessionEvents(session) {
+    if (Array.isArray(session.events))
+        return session.events;
+    if (typeof session.snapshotEvents === 'function')
+        return session.snapshotEvents();
+    return undefined;
+}
 export function buildRecallQuery(messages, tailMessages = RECALL_QUERY_TAIL_MESSAGES, maxChars = RECALL_QUERY_MAX_CHARS) {
     const tail = messages.slice(-tailMessages);
     let text = tail.map((m) => blocksToText(m.content)).join(' ').trim();
@@ -572,14 +586,18 @@ usage) {
             return false;
         try {
             // 可选服务一律走 ctx.get() 的宽容路径（属性访问对未 inject 的服务会抛）
+            // events 形状双面：旧宿主数组属性 / 0.2.x snapshotEvents() 方法（issue #8）
             const sessions = ctx.get?.('sessions');
             const session = typeof sessions?.get === 'function' ? sessions.get(sessionId) : undefined;
             if (session === undefined)
                 return false;
+            const events = readSessionEvents(session);
+            if (events === undefined)
+                return false; // 事件面不可得：调用方回退粗标记
             const visibleSeqs = new Set(session.surface.nodes);
             const visibleIds = new Set();
             const knownIds = new Set();
-            for (const ev of session.events) {
+            for (const ev of events) {
                 const own = ownInjectionFromEvent(ev);
                 if (own === undefined || own.id.length === 0)
                     continue;
@@ -633,12 +651,17 @@ usage) {
         try {
             // cordis 属性访问(ctx.sessions)对未 inject 的服务抛 "without inject";
             // 可选服务一律走 ctx.get() 的宽容路径
+            // events 形状双面：旧宿主数组属性 / 0.2.x snapshotEvents() 方法（issue #8）
             const sessions = ctx.get?.('sessions');
             const session = typeof sessions?.get === 'function' ? sessions.get(sessionId) : undefined;
             if (session) {
+                const events = readSessionEvents(session);
+                // 事件形状不可得：与「不在 live store」同一退路，走存储回填，不再静默归 null
+                if (events === undefined)
+                    return estimateRecallFromStorage(sessionId);
                 const visible = new Set(session.surface.nodes);
                 let total = 0;
-                for (const ev of session.events) {
+                for (const ev of events) {
                     const own = ownInjectionFromEvent(ev);
                     // 无 seq = 无法证明它可见，就不能算进份额（与原行为一致：原来它必须 visible.has(seq)）。
                     if (own === undefined || own.chars === 0 || own.seq === undefined || !visible.has(own.seq))

package/dist/index.js

@@ -50,6 +50,7 @@ import { makeFileSyncHook } from './store/memory-md-sync.js';
 import { ObsoleteNoticeStore } from './store/obsolete-notices.js';
 import { registerSlotsProjection } from './projection/slots.js';
 import { registerRecallProjection } from './projection/recall.js';
+import { DrscClient } from './clients/drsc.js';
 import { errDetail, withFileLog } from './util/filelog.js';
 import { buildRouteChain, resolveModelRoute, invalidateEffortCache } from './llm.js';
 import { effectiveCfg } from './pipeline/runner.js';
@@ -57,6 +58,30 @@ import { pendingPathFor } from './store/pending.js';
 import { initTokenCost, resetTokenCost } from './token-cost.js';
 import { initTraceStore } from './store/trace.js';
 export const name = 'dsh-memory-plugin';
+/**
+ * webStartup(0.2.1-a.2 起更名自 webRuntime)的 best-effort 读取:trustedHosts
+ * 供 DrscClient 同源基址解析。宿主服务缺席/未声明 inject 时属性读会抛
+ * (cordis Proxy 面),双名回退链 + 两层 try,安全返回 undefined(→ 缺省 8080 口)。
+ */
+function readStartupTrustedHosts(ctx) {
+    for (const name of ['webStartup', 'webRuntime']) {
+        try {
+            const direct = ctx[name];
+            const svc = (direct !== undefined
+                ? direct
+                : typeof ctx.get === 'function'
+                    ? ctx.get(name)
+                    : undefined);
+            if (svc !== null && typeof svc === 'object' && Array.isArray(svc.trustedHosts)) {
+                return svc.trustedHosts;
+            }
+        }
+        catch {
+            /* 未声明服务的属性读抛:落下一名/缺省 */
+        }
+    }
+    return undefined;
+}
 /**
  * 硬依赖:蒸馏要用 llm,工具注册要用 tools,召回注入要用 systemPrompt。
  * 0.1.5 起 connection.rpc.handle() 把 /rpc 路由登记到 webServer 时按**调用方
@@ -172,7 +197,10 @@ export async function apply(ctx, config) {
     }
     const stores = {
         usage: undefined, // 装配于下方(依赖 dataDir 就绪)
-        l0: new L0Store(dataDir, db, embed, logger),
+        // DRSC 客户端(T8.4 读切):蒸馏背景窗 + conversation_search 工具面的历史供给。
+        // 硬依赖无本地回退(l0 表退役);trustedHosts 惰性读取(webStartup 可能晚到)。
+        drsc: new DrscClient({ trustedHosts: () => readStartupTrustedHosts(ctx) }),
+        l0: new L0Store(db),
         l1: new L1Store(dataDir, db, embed, config.recall.strategy, logger, config.recall.decayHalfLifeDays, 
         // §D 第 3 路:图谱回链。图谱不可用时 searchNodes 自带 no-op,不影响双路。
         (query, limit, family) => db.graphStore.searchNodes(query, limit, family ? [family] : undefined), 
@@ -210,7 +238,6 @@ export async function apply(ctx, config) {
     if (storageOk) {
         try {
             await Promise.all([
-                stores.l0.init(),
                 stores.l1.init(),
                 stores.scenes.chat.init(),
                 stores.scenes.work.init(),
@@ -255,18 +282,18 @@ export async function apply(ctx, config) {
                         // 增量:配置变化路径向量表已被 drop,全部记录均"缺失",等效全量;
                         // 活切换发起时让路(swap 会 drop 表,并发跑只是白烧嵌入调用)
                         const shouldCancel = () => disposed || !!embedManagerRef?.isBusy();
+                        // T8.4:l0 向量腿随写停退役(表清空后无缺失,无需重建)
                         const r1 = await stores.l1.reindex({ shouldCancel });
-                        const r0 = await stores.l0.reindex({ shouldCancel });
                         // missing 复查:嵌入服务未就绪时 reindex 短路 0/0/0——那是"没跑"不是"成功",
                         // 不得标记 meta(否则启动链不再补,补齐被无限推迟到 backfill)
-                        const missingAfter = db.countL1VecMissing(db.getVecSkipSet('l1')) + db.countL0VecMissing(db.getVecSkipSet('l0'));
-                        if (r1.failed === 0 && r0.failed === 0 && missingAfter === 0) {
+                        const missingAfter = db.countL1VecMissing(db.getVecSkipSet('l1'));
+                        if (r1.failed === 0 && missingAfter === 0) {
                             db.markEmbeddingSynced(currentProviderInfo() ?? info);
-                            const skipNote = r1.skipped + r0.skipped > 0 ? `,跳过不可嵌入 ${r1.skipped + r0.skipped} 条` : '';
-                            logger.info(`[memory] 向量重建完成:L1 ${r1.written} 条,L0 ${r0.written} 条${skipNote}(原因:${dbInit.reason ?? '配置变化'})`);
+                            const skipNote = r1.skipped > 0 ? `,跳过不可嵌入 ${r1.skipped} 条` : '';
+                            logger.info(`[memory] 向量重建完成:L1 ${r1.written} 条${skipNote}(原因:${dbInit.reason ?? '配置变化'})`);
                         }
                         else {
-                            logger.warn(`[memory] 向量重建未完成(L1 失败 ${r1.failed},L0 失败 ${r0.failed},剩缺 ${Math.max(missingAfter, 0)} 条),下次启动/补齐周期重试`);
+                            logger.warn(`[memory] 向量重建未完成(L1 失败 ${r1.failed},剩缺 ${Math.max(missingAfter, 0)} 条),下次启动/补齐周期重试`);
                         }
                     }
                     catch (err) {
@@ -302,19 +329,18 @@ export async function apply(ctx, config) {
                         if (embedManagerRef?.isBusy())
                             return;
                         const l1Missing = db.countL1VecMissing(db.getVecSkipSet('l1')) > 0;
-                        const l0Missing = db.countL0VecMissing(db.getVecSkipSet('l0')) > 0;
-                        if (!l1Missing && !l0Missing)
+                        if (!l1Missing)
                             return;
                         const shouldCancel = () => disposed || !!embedManagerRef?.isBusy();
+                        // T8.4:l0 向量腿随写停退役
                         const r1 = await stores.l1.reindex({ shouldCancel });
-                        const r0 = await stores.l0.reindex({ shouldCancel });
-                        const missingAfter = db.countL1VecMissing(db.getVecSkipSet('l1')) + db.countL0VecMissing(db.getVecSkipSet('l0'));
-                        if (r1.failed === 0 && r0.failed === 0 && missingAfter === 0) {
+                        const missingAfter = db.countL1VecMissing(db.getVecSkipSet('l1'));
+                        if (r1.failed === 0 && missingAfter === 0) {
                             db.markEmbeddingSynced(infoNow);
-                            logger.info(`[memory] 向量补齐完成:L1 ${r1.written} 条,L0 ${r0.written} 条(跳过不可嵌入 ${r1.skipped + r0.skipped} 条)`);
+                            logger.info(`[memory] 向量补齐完成:L1 ${r1.written} 条(跳过不可嵌入 ${r1.skipped} 条)`);
                         }
-                        else if (r1.failed > 0 || r0.failed > 0) {
-                            logger.warn(`[memory] 向量补齐未完成(L1 失败 ${r1.failed},L0 失败 ${r0.failed}),下个周期重试`);
+                        else if (r1.failed > 0) {
+                            logger.warn(`[memory] 向量补齐未完成(L1 失败 ${r1.failed}),下个周期重试`);
                         }
                     }
                     catch (err) {
@@ -342,7 +368,6 @@ export async function apply(ctx, config) {
             dataDir,
             cfg: config,
             db,
-            l0: stores.l0,
             l1: stores.l1,
             sourceStore,
             installer,
@@ -388,7 +413,7 @@ export async function apply(ctx, config) {
         : undefined;
     let flushL0;
     if (storageOk) {
-        flushL0 = registerCapture(ctx, config, runner, stores.l0, logger, live, modes);
+        flushL0 = registerCapture(ctx, config, runner, db.l0Watermark, logger, live, modes);
     }
     // 召回使用统计(进 topN 才算 used;热路径只碰内存,去抖落盘)
     const recallUsage = new RecallUsageStore(dataDir, logger);

package/dist/pipeline/runner.d.ts

@@ -14,8 +14,8 @@
 import type { Context } from '@deepseek-ai/cordis';
 import { type MemoryConfig } from '../config.js';
 import type { LiveSettingsHandle } from '../settings.js';
+import type { DrscClient } from '../clients/drsc.js';
 import type { GraphStore } from '../store/graph-store.js';
-import type { L0Store } from '../store/l0.js';
 import type { L1Store } from '../store/l1.js';
 import type { PersonaStore } from '../store/persona.js';
 import type { SceneStore } from '../store/scenes.js';
@@ -23,7 +23,11 @@ import type { StateStore } from '../store/state.js';
 import type { ConversationMessage, ExtractMode, MemoryFamily, MemoryLogger } from '../types.js';
 import type { FamilyStates } from './l1.js';
 export interface MemoryStores {
-    l0: L0Store;
+    /**
+     * DRSC 客户端(T8.4 读切):蒸馏背景窗的历史供给面(op=session&tail&redact=1)。
+     * 缺席(测试缝/未装配)时背景窗为空数组;拉取失败空窗降级,不抛穿管线。
+     */
+    drsc?: DrscClient;
     l1: L1Store;
     scenes: Record<MemoryFamily, SceneStore>;
     persona: Record<MemoryFamily, PersonaStore>;
@@ -171,10 +175,19 @@ export declare class MemoryRunner {
      *  蒸馏尝试时反复整量序列化落盘(多 MB 级 IO);重建轮豁免维持。 */
     private persistPending;
     private runTurn;
+    /**
+     * 蒸馏背景窗(T8.4 读切,task_19):DRSC 会话尾窗(redact 臂)→ ConversationMessage。
+     * - 形状映射:segment 行 → 消息(drscRowToConversationMessage;非 user/assistant 段跳过);
+     * - 坐标剔除:切片自身轮次整轮剔除(尾窗在 DRS 30s interval 同步后会含刚捕获
+     *   的 turn——旧 l0 读面按消息 id 剔除,跨系统 id 不同构,按坐标等价替身);
+     * - 报错口径:collector 缺席/超时 → warn 后空窗降级,**不抛穿蒸馏管线**
+     *   (工具面 conversation_search 的显式报错口径在 tools 层分清,spec R7)。
+     */
+    private drscBackground;
     /**
      * 抽取并消费一个会话切片:成功才把切片移出桶并推进爬坡阈值;失败保留切片待重试。
-     * 调用方已保证切片达到生效阈值(或 force)。背景参考按会话从 L0 现查并剔除切片
-     * 自身(ADR-0003:会话间互不污染、重启不丢背景)。
+     * 调用方已保证切片达到生效阈值(或 force)。背景参考按会话从 DRSC 尾窗现查并
+     * 剔除切片自身轮次(ADR-0003:会话间互不污染、重启不丢背景)。
      */
     private extractSessionSlice;
 }

package/dist/pipeline/runner.js

@@ -1,10 +1,11 @@
 import { resolveDataDir } from '../config.js';
 import { GRAPH_PRIORITY_NEW } from '../graph/types.js';
+import { drscRowToConversationMessage } from '../clients/drsc.js';
 import { trace } from '../store/trace.js';
 import { emptyPending, freshWarmup, groupPendingBySession, loadPending, PENDING_MODES, pendingPathFor, savePending, } from '../store/pending.js';
 import { errDetail } from '../util/filelog.js';
 import { sessionWorkspaceIdOf } from '../workspace.js';
-import { advanceWarmupThreshold, effectiveExtractThreshold, extractionBackoffMs, idleSessionsToFlush, modeSwitchAction, pickSessionBackground, } from './trigger.js';
+import { advanceWarmupThreshold, effectiveExtractThreshold, extractionBackoffMs, idleSessionsToFlush, modeSwitchAction, } from './trigger.js';
 import { runExtraction } from './l1.js';
 import { buildAnchorMap } from './anchors.js';
 import { runGraphProjection } from './graph.js';
@@ -666,10 +667,34 @@ export class MemoryRunner {
         this.afterRun?.();
         return newRecords.length;
     }
+    /**
+     * 蒸馏背景窗(T8.4 读切,task_19):DRSC 会话尾窗(redact 臂)→ ConversationMessage。
+     * - 形状映射:segment 行 → 消息(drscRowToConversationMessage;非 user/assistant 段跳过);
+     * - 坐标剔除:切片自身轮次整轮剔除(尾窗在 DRS 30s interval 同步后会含刚捕获
+     *   的 turn——旧 l0 读面按消息 id 剔除,跨系统 id 不同构,按坐标等价替身);
+     * - 报错口径:collector 缺席/超时 → warn 后空窗降级,**不抛穿蒸馏管线**
+     *   (工具面 conversation_search 的显式报错口径在 tools 层分清,spec R7)。
+     */
+    async drscBackground(sessionId, n, sliceTurns) {
+        if (n <= 0)
+            return [];
+        try {
+            const rows = await this.stores.drsc.sessionTail(sessionId, n);
+            return rows
+                .map((r) => drscRowToConversationMessage(r, sessionId))
+                .filter((m) => m !== undefined)
+                .filter((m) => m.anchor === undefined || !sliceTurns.has(m.anchor.turn))
+                .slice(-n);
+        }
+        catch (err) {
+            this.logger.warn(`[memory] 蒸馏背景窗拉取失败(DRSC),本轮空窗降级: ${errDetail(err)}`);
+            return [];
+        }
+    }
     /**
      * 抽取并消费一个会话切片:成功才把切片移出桶并推进爬坡阈值;失败保留切片待重试。
-     * 调用方已保证切片达到生效阈值(或 force)。背景参考按会话从 L0 现查并剔除切片
-     * 自身(ADR-0003:会话间互不污染、重启不丢背景)。
+     * 调用方已保证切片达到生效阈值(或 force)。背景参考按会话从 DRSC 尾窗现查并
+     * 剔除切片自身轮次(ADR-0003:会话间互不污染、重启不丢背景)。
      */
     async extractSessionSlice(sessionId, mode, cfg, effectiveThreshold, opts) {
         const bucket = this.pending[mode];
@@ -678,9 +703,11 @@ export class MemoryRunner {
             return [];
         const rest = bucket.filter((m) => m.sessionId !== sessionId);
         try {
-            // 背景参考:该会话最近消息(多取切片条数补偿被剔除者),剔除切片自身
-            const background = this.stores.l0
-                ? pickSessionBackground(await this.stores.l0.recentBySession(sessionId, cfg.extract.backgroundMessages + slice.length), new Set(slice.map((m) => m.id)), cfg.extract.backgroundMessages)
+            // 背景参考(T8.4 读切):DRSC 会话尾窗(redact 臂)按会话现查(ADR-0003 等价),
+            // 剔除切片自身轮次(切片消息可能已进 DRS 尾窗——30s interval 同步后)。
+            // 多取切片条数补偿被剔除者,与旧 l0 读面同口径。
+            const background = this.stores.drsc
+                ? await this.drscBackground(sessionId, cfg.extract.backgroundMessages + slice.length, new Set(slice.map((m) => m.anchor?.turn).filter((t) => typeof t === 'number')))
                 : [];
             const t = Date.now();
             // R7:锚点映射同时收切片与背景——模型偶尔会引用背景消息的 id,收了它

package/dist/store/embedding-source.d.ts

@@ -1,7 +1,6 @@
 import type { MemoryConfig } from '../config.js';
 import type { MemoryLogger } from '../types.js';
 import type { EmbeddingProviderInfo, EmbeddingService } from './embedding.js';
-import type { L0Store } from './l0.js';
 import type { L1Store } from './l1.js';
 import { LocalEmbeddingService } from './local-embedding.js';
 import { ModelDownloadQueue } from './download-queue.js';
@@ -74,7 +73,6 @@ export interface EmbeddingManagerDeps {
      *  否则设置页里的编辑即时生效不到活切换。 */
     getEff?: () => MemoryConfig;
     db: MemoryDb;
-    l0: L0Store;
     l1: L1Store;
     sourceStore: EmbeddingSourceStore;
     installer: RuntimeInstaller;
@@ -155,7 +153,7 @@ export declare class EmbeddingManager {
      * 门槛全部前置,且**宁可拒绝也不谎报**:以下四种情况直接抛错而非"成功受理":
      *
      * - 插件已卸载 / 重嵌已在跑 / 嵌入源切换占着锁:并发语义,重复触发无意义;
-     * - 嵌入服务未就绪:`L1Store.reindex` / `L0Store.reindex` 会**静默短路**成
+     * - 嵌入服务未就绪:`L1Store.reindex` 会**静默短路**成
      *   `0/0/0`,受理了就等于告诉用户"重建成功、零条待补"——而真相是它根本没开始。
      *
      * 用抛错而不是返回 `{accepted:false, error}`:与 `embedding-model-delete` 等既有

package/dist/store/embedding-source.js

@@ -8,7 +8,7 @@
  *   embedding.allowLocalModels 上限约束;
  * - 活切换链(后台执行,RPC 立即返回 accepted,进度靠轮询):
  *   安装运行时(首次本地)→ 预热加载 → 换服务 + swapProvider(维度变化 drop 向量表)
- *   → 后台全量重嵌(L1/L0 计数进度,可取消)→ 持久化状态。
+ *   → 后台全量重嵌(L1 计数进度,可取消;l0 计数进度字段随契约保留恒 0)→ 持久化状态。
  *   失败语义:异常(安装失败/模型加载失败/db 拒绝)→ 状态不持久化,重启回到旧源;
  *   重嵌取消/部分失败 → 已切换(物理表即新维度,meta 已同步),缺失向量由周期
  *   backfill 补齐——不回滚(回滚需要再 drop 一次表,得不偿失)。
@@ -330,7 +330,7 @@ export class EmbeddingManager {
      * 门槛全部前置,且**宁可拒绝也不谎报**:以下四种情况直接抛错而非"成功受理":
      *
      * - 插件已卸载 / 重嵌已在跑 / 嵌入源切换占着锁:并发语义,重复触发无意义;
-     * - 嵌入服务未就绪:`L1Store.reindex` / `L0Store.reindex` 会**静默短路**成
+     * - 嵌入服务未就绪:`L1Store.reindex` 会**静默短路**成
      *   `0/0/0`,受理了就等于告诉用户"重建成功、零条待补"——而真相是它根本没开始。
      *
      * 用抛错而不是返回 `{accepted:false, error}`:与 `embedding-model-delete` 等既有
@@ -345,7 +345,7 @@ export class EmbeddingManager {
             throw new Error('嵌入源切换进行中，请稍后再试');
         if (!this.currentInfo)
             throw new Error('嵌入源已关闭，重建无意义（请先启用嵌入）');
-        if (!this.deps.l1.vectorsReady() || !this.deps.l0.vectorsReady()) {
+        if (!this.deps.l1.vectorsReady()) {
             throw new Error('嵌入服务未就绪（模型加载中或推理运行时未安装），请稍后再试');
         }
         void this.reindexNow()
@@ -435,7 +435,6 @@ export class EmbeddingManager {
             const oldLocal = this.localSvc;
             this.localSvc = next.source === 'local' ? svc : null;
             this.current = svc;
-            this.deps.l0.setEmbeddingService(svc);
             this.deps.l1.setEmbeddingService(svc);
             oldLocal?.close();
             let pendingNote = '';
@@ -510,15 +509,9 @@ export class EmbeddingManager {
                 shouldCancel: () => this.reindexCancel,
             });
             failedTotal += r1.failed;
-            const r0 = await this.deps.l0.reindex({
-                onProgress: (done, total) => {
-                    this.reindex.l0Done = done;
-                    this.reindex.l0Total = total;
-                },
-                shouldCancel: () => this.reindexCancel,
-            });
-            failedTotal += r0.failed;
-            const cancelled = !!(r1.cancelled || r0.cancelled);
+            // T8.4:l0 向量腿随写停退役(表清空后无缺失,无需重建);契约的
+            // l0Done/l0Total 字段保留恒 0,client 进度面零改动。
+            const cancelled = !!r1.cancelled;
             this.reindex.cancelled = cancelled;
             this.reindex.running = false;
             this.invalidateVecCache(); // 收尾:计数必须立刻反映重建结果(TTL 可能还压着 1s 旧值)

package/dist/store/l0-watermark.d.ts

@@ -0,0 +1,46 @@
+/**
+ * L0 水位表(T8.4 l0 写停,drsc-redact-memory-wiring task_16)。
+ *
+ * capture 停写 l0_conversations/l0_fts/l0_vec 三表后,§A 崩溃恢复的幂等判据
+ * (maxCapturedTurn / hasAnyL0Message)失去数据源——本小表接住:每会话一行,
+ * 只存 (max_turn, last_step),几十 KB 量级。正文改由 DRSC 投影供读(历史面),
+ * 水位只服务「重启不重放旧 turn」的自检,不再承载任何文本。
+ *
+ * 语义对齐被退役的 SQL 口径:
+ * - `maxTurn(sid)`  ≡ 退役前 `MAX(turn)`;只前进不回退(重放/乱序登记无害);
+ * - `hasAny(sid, t)` ≡ 退役前 `t <= MAX(turn)` 的存在性判定——恢复窗口
+ *   (foldRecoverableTurns 只产出 turn > 水位 的括号)内恒 false,行为与
+ *   MAX 口径等价;写停后正文无「部分写残行」,逐 turn 点查的原始动机消失。
+ *
+ * 基线物化:写停生效前已存在的 l0_conversations 行由 {@link ensureBaseline}
+ * 一次性灌入(INSERT OR IGNORE,存量水位行不覆盖)——没有它,升级后的首次
+ * resume 会把水位当空、重放旧 turn 重复蒸馏。每次 init 幂等重跑(空表扫描
+ * 零成本;task_22 存量清退删表后同样安静)。
+ *
+ * 与 CostLedger/GraphStore 同款纪律:独立职责类,唯一耦合是共享 node:sqlite
+ * 连接;未 init / 降级时全部方法安全 no-op。
+ */
+import type { DatabaseSync } from 'node:sqlite';
+import type { MemoryLogger } from '../types.js';
+export declare const L0_WATERMARK_DDL = "\nCREATE TABLE IF NOT EXISTS l0_watermark (\n  session_id TEXT PRIMARY KEY,\n  max_turn INTEGER NOT NULL DEFAULT 0,\n  last_step INTEGER,\n  updated_at TEXT DEFAULT (datetime('now'))\n)\n";
+export declare class L0WatermarkStore {
+    private db;
+    private logger;
+    init(db: DatabaseSync, logger?: MemoryLogger): void;
+    close(): void;
+    /**
+     * 基线物化:从现存 l0_conversations 把每会话最大 turn 灌进水位表。
+     * INSERT OR IGNORE = 已有水位行(活捕获已推进)一律不覆盖;旧行文与
+     * 水位并存期两侧取大者由 record 的单调语义兜底。
+     */
+    ensureBaseline(): void;
+    /**
+     * 登记一个已捕获轮次(写停后 capture 的唯一落盘点)。单调:turn 更小/相等的
+     * 登记不回退水位(恢复对账与乱序事件都安全);step 取该轮已知最大 step。
+     */
+    record(sessionId: string, turn: number, step?: number): void;
+    /** §A 水位线:该会话已捕获的最大 turn(空会话/未 init 返回 undefined)。 */
+    maxTurn(sessionId: string): number | undefined;
+    /** §A 幂等检查:该 (session, turn) 是否已捕获(≡ 退役前 hasAnyL0Message)。 */
+    hasAny(sessionId: string, turn: number): boolean;
+}

package/dist/store/l0-watermark.js

@@ -0,0 +1,93 @@
+export const L0_WATERMARK_DDL = `
+CREATE TABLE IF NOT EXISTS l0_watermark (
+  session_id TEXT PRIMARY KEY,
+  max_turn INTEGER NOT NULL DEFAULT 0,
+  last_step INTEGER,
+  updated_at TEXT DEFAULT (datetime('now'))
+)
+`;
+export class L0WatermarkStore {
+    db = null;
+    logger;
+    init(db, logger) {
+        this.db = db;
+        this.logger = logger;
+        db.exec(L0_WATERMARK_DDL);
+        this.ensureBaseline();
+    }
+    close() {
+        this.db = null;
+    }
+    /**
+     * 基线物化:从现存 l0_conversations 把每会话最大 turn 灌进水位表。
+     * INSERT OR IGNORE = 已有水位行(活捕获已推进)一律不覆盖;旧行文与
+     * 水位并存期两侧取大者由 record 的单调语义兜底。
+     */
+    ensureBaseline() {
+        if (!this.db)
+            return;
+        try {
+            this.db.exec(`
+        INSERT OR IGNORE INTO l0_watermark (session_id, max_turn, last_step)
+        SELECT session_id, MAX(turn), NULL
+        FROM l0_conversations
+        WHERE turn IS NOT NULL
+        GROUP BY session_id
+      `);
+        }
+        catch (err) {
+            // l0_conversations 可能已被存量清退(task_22)删除:表缺 = 无基线可灌,安静跳过
+            this.logger?.debug?.(`[memory] L0 水位基线物化跳过: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    /**
+     * 登记一个已捕获轮次(写停后 capture 的唯一落盘点)。单调:turn 更小/相等的
+     * 登记不回退水位(恢复对账与乱序事件都安全);step 取该轮已知最大 step。
+     */
+    record(sessionId, turn, step) {
+        if (!this.db || !sessionId || !Number.isFinite(turn))
+            return;
+        try {
+            this.db
+                .prepare(`INSERT INTO l0_watermark (session_id, max_turn, last_step, updated_at)
+           VALUES (?, ?, ?, datetime('now'))
+           ON CONFLICT(session_id) DO UPDATE SET
+             max_turn = MAX(l0_watermark.max_turn, excluded.max_turn),
+             last_step = CASE WHEN excluded.max_turn > l0_watermark.max_turn
+                              THEN excluded.last_step ELSE l0_watermark.last_step END,
+             updated_at = excluded.updated_at`)
+                .run(sessionId, turn, typeof step === 'number' && Number.isFinite(step) ? step : null);
+        }
+        catch (err) {
+            this.logger?.warn(`[memory] L0 水位登记失败(幂等自检可能重放): ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    /** §A 水位线:该会话已捕获的最大 turn(空会话/未 init 返回 undefined)。 */
+    maxTurn(sessionId) {
+        if (!this.db || !sessionId)
+            return undefined;
+        try {
+            const row = this.db
+                .prepare('SELECT max_turn FROM l0_watermark WHERE session_id = ?')
+                .get(sessionId);
+            return typeof row?.max_turn === 'number' ? row.max_turn : undefined;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    /** §A 幂等检查:该 (session, turn) 是否已捕获(≡ 退役前 hasAnyL0Message)。 */
+    hasAny(sessionId, turn) {
+        if (!this.db || !sessionId || !Number.isFinite(turn))
+            return false;
+        try {
+            const row = this.db
+                .prepare('SELECT 1 FROM l0_watermark WHERE session_id = ? AND max_turn >= ? LIMIT 1')
+                .get(sessionId, turn);
+            return row !== undefined;
+        }
+        catch {
+            return false;
+        }
+    }
+}

package/dist/store/l0.d.ts

@@ -1,48 +1,18 @@
-import type { ConversationMessage, L0MessageRecord, MemoryLogger } from '../types.js';
-import { type EmbeddingService } from './embedding.js';
-import { type MemoryDb } from './sqlite.js';
+/**
+ * L0 存量计数门面(T8.4 l0 写路径退役后)。
+ *
+ * capture 已停写 l0 正文三表与 JSONL 事实源(见 hooks/capture.ts 与
+ * store/l0-watermark.ts),历史读面(recentBySession / search)改经
+ * `clients/drsc.ts` 的 DrscClient(硬依赖,无本地回退)——本类只剩状态
+ * 面板的两个只读计数(今日捕获 / 按会话累计)。task_22 存量清退后表为
+ * 空壳,计数自然归零,读路径无需判空。
+ */
+import type { MemoryDb } from './sqlite.js';
 export declare class L0Store {
     private readonly db;
-    private readonly dir;
-    private readonly legacyDir;
-    private readonly helper;
-    private embedSvc;
-    private readonly logger?;
-    constructor(dataDir: string, db: MemoryDb, embed?: EmbeddingService, logger?: MemoryLogger);
-    init(): Promise<void>;
-    /** 旧版 l0/*.jsonl 一次性导入检索库,成功后目录改名 l0.imported/。 */
-    private importLegacy;
-    append(sessionId: string, messages: ConversationMessage[]): Promise<void>;
-    /** 今日已捕获消息数(SQL 计数,不再读整文件)。 */
+    constructor(db: MemoryDb);
+    /** 今日已捕获消息数(SQL 计数,不再读整文件;写停后归零,面板口径保留)。 */
     countToday(): Promise<number>;
     /** 该会话累计已捕获消息数(session-stats 数据源;索引 COUNT)。 */
     countBySession(sessionId: string): Promise<number>;
-    /** 该会话最近 n 条消息(时间升序;蒸馏背景参考用,按会话现查——ADR-0003)。 */
-    recentBySession(sessionId: string, limit: number): Promise<ConversationMessage[]>;
-    /** §A 水位线:该会话 L0 已落盘的最大 turn(空会话 undefined;委托 MemoryDb)。 */
-    maxCapturedTurn(sessionId: string): number | undefined;
-    /** §A 幂等检查:该 (session, turn) 是否已有任意 L0 行(委托 MemoryDb)。 */
-    hasAnyL0Message(sessionId: string, turn: number): boolean;
-    /** 检索:FTS + 向量 hybrid(RRF 融合),返回按相关性排序的消息。 */
-    search(query: string, limit: number): Promise<L0MessageRecord[]>;
-    /** 活切换嵌入源:同步换底层服务(嵌入源三态切换用)。 */
-    setEmbeddingService(svc: EmbeddingService): void;
-    /** 向量写入能力是否就绪。`reindex` 在未就绪时**静默短路**成 0/0/0
-     *  (见本文件 `reindex` 首行),调用方必须自己问这里——否则"根本没跑"
-     *  会长得和"跑完了、零条待补"一模一样。 */
-    vectorsReady(): boolean;
-    /**
-     * 增量重嵌入(同 L1Store.reindex:只补缺失向量,零向量记 skipped 并入 skip 集,
-     * 不算失败、不阻塞同步标记——保证补齐判据收敛)。onProgress/shouldCancel
-     * 供活切换的进度展示与取消。
-     */
-    reindex(opts?: {
-        onProgress?: (done: number, total: number) => void;
-        shouldCancel?: () => boolean;
-    }): Promise<{
-        written: number;
-        failed: number;
-        skipped: number;
-        cancelled?: boolean;
-    }>;
 }