dsh-prime-memory 0.26.9 → 0.26.11

package/dist/config.js

@@ -82,6 +82,17 @@ export function liveSettingsSchema() {
         conflictFreeze: Schema.boolean().default(false),
         // 轨2 技能结晶总开关(看板可拨):默认 false。开=注册 memory_skill_* 工具 + 注入 active 技能 + skills-* 端点可用。
         skillsEnabled: Schema.boolean().default(false),
+        /**
+         * 知识图谱**投影**开关（issue #16，概览区可拨）。默认 false。
+         *
+         * 与部署 `graph.enabled` **取或**（照 keywordEnabled / validityTiering 先例）：
+         * 部署可强制开，面板只能追加开。
+         *
+         * 为什么它必须在 live：投影是**写侧派生**，关了只是不入队、不丢数据；
+         * 而它的入口以前只住 YAML，用户根本找不到（面板上那个“图谱投影”其实是蒸馏预算的
+         * 分层标签，点它改的是 token 预算）。
+         */
+        graphEnabled: Schema.boolean().default(false),
         // 存量回填/进阶功能的启用开关（概览「存量回填与整形」区可拨）：默认 false，
         // 与部署 cfg.<x>.enabled 取或（经 effectiveCfg）——部署可强制开，live 只能追加开。
         // 存在的理由：这些面都有对应按钮/端点，若开关只住 YAML，用户点了只会报“未开启”却没处翻。
@@ -184,6 +195,16 @@ export const memorySchema = Schema.object({
         // 单源扫描上限（防极端大包在事件循环里阻塞 RPC；scan 是手动触发，仍留护栏）。
         scanMaxRecords: Schema.number().min(0).max(20_000).default(5000),
     }),
+    // 重建事实源(issue #14-B)：默认 local（行为与改前一致）；drsc 需显式选，
+    // 且 collector 缺席时**报错中止**（不清库）——不静默回退本地，避免“以为用了新源其实还是旧表”。
+    rebuild: Schema.object({
+        /**
+         * 'local' = 本地 l0_conversations；'drsc' = reference-session-collector 投影。
+         *
+         * drsc 路径恒带 `redact=1`（collector 的 session 缺省是原文臂，而 capture 是写前脱敏）。
+         */
+        factSource: Schema.union(['local', 'drsc']).default('local'),
+    }),
     // 轨2 技能结晶：默认关 + allowPromote 关（先只计数不晋升）。
     skills: Schema.object({
         enabled: Schema.boolean().default(false),
@@ -210,7 +231,19 @@ export const memorySchema = Schema.object({
     }),
     /**
      * 内容路由：默认**开**（用户口径：谈到本仓/dsh 生态的记忆要归到本仓 workspace，
-     * 而不是全托底到 `<dataDir>/memories`）。默认路由表就是用户给的两条归类规则（路径可改，不需改码）。
+     * 而不是全托底到 `<dataDir>/memories`）。
+     *
+     * ⚠️ **默认路由表为空**（issue #13）。此前默认值写死了作者本机的 `E:\test\rewrite-agently`
+     * 与 `E:\test\agent-no-dsh`：装好即生效，凡正文含 `dsh`/`cordis`/`prime-memory` 等词的记忆
+     * 都被写上了别人机器上的路径。别人的机器没这个盘，于是
+     *  - `targetFor` 的护栏判定目录不存在 → 投射落点静默退回单根（日志一条 warn 而已）；
+     *  - 更严重的是 `scope: workspace` 时这些记录在**真实工作区**里按 workspace 过滤不可见，
+     *    表现为"记忆莫名其妙丢了"，而根源是默认值指向别人的机器。
+     *
+     * 默认值属于**可移植性契约**：不得含任何具体主机的绝对路径。要么由用户显式配置路由、
+     * 要么用 `$workspace` 之类的占位（由调用方在运行期替换为当前会话工作区），
+     * 要么不路由（`routes: []` → 全部落单根，行为与 `enabled:false` 等价但语义更诚实）。
+     * 想恢复旧的按内容归类，请在配置里自行写下自己的两条规则。
      */
     workspaceSource: Schema.object({
         enabled: Schema.boolean().default(true),
@@ -219,31 +252,17 @@ export const memorySchema = Schema.object({
              * 归到哪个 workspace（**workspace 根**，绝对路径；写入前过 normalizeWorkspacePath）。
              *
              * 存的不包含 `.agents/memory`：投射落点由 `targetFor` 算，它会在本值后拼上
-             * `WORKSPACE_SUBDIR = ['.agents','memory']`。旧默认值把它写成了
+             * `WORKSPACE_SUBDIR = ['.agents','memory']`。旧默认值曾把它写成
              * `E:\test\rewrite-agently\.agents`，于是落点变成 `.agents\.agents\memory\`——
              * 而 `.agents` 目录确实存在，"目录不存在则退回单根"的护栏救不了这种形状，
-             * 等于在仓里挂一棵没人认领的孤儿树。新增用例钉住这个不变式。
+             * 等于在仓里挂一棵没人认领的孤儿树。有用例钉住这个不变式。
              */
             path: Schema.string().default(''),
             /** 命中任一关键词即归此路（小写子串匹配，已 NFKC 归一）。 */
             anyOf: Schema.array(Schema.string()).default([]),
             /** 出现任一排除词则此路不命中（用于「无 dsh 才算非 dsh 项目」）。 */
             noneOf: Schema.array(Schema.string()).default([]),
-        })).default([
-            {
-                path: 'E:\\test\\rewrite-agently',
-                // 'dsh' 子串已覆盖 mine-dsh-plugins 下所有插件名；把目录名单列出来是因为
-                // 有些记忆只写了"某个插件"而没写 dsh- 前缀，那时这一项才顶用。
-                anyOf: ['dsh', 'mine-dsh-plugins', 'cordis', 'prime-memory', 'brief-sidebar', 'host farm', 'inferglow-dsh'],
-                noneOf: [],
-            },
-            {
-                path: 'E:\\test\\agent-no-dsh',
-                anyOf: ['hanako', 'hanaagent', 'openhanako', 'inferglow', 'pi-agent'],
-                // 同一段内容又谈到 dsh 时属于 dsh 生态（如 Hanako 逆向用于反推 dsh 机制），归 dsh 侧。
-                noneOf: ['dsh'],
-            },
-        ]),
+        })).default([]),
         maxRecords: Schema.number().min(1).max(10_000).default(300),
         timeBudgetMs: Schema.number().min(1000).max(1_800_000).default(120_000),
     }),

package/dist/contract.d.ts

@@ -111,6 +111,16 @@ export interface MemoryLiveSettings {
     /** 轨2 技能结晶总开关（看板可拨）:true = 注册 memory_skill_* 工具、注入 active 技能、skills-* 端点可用。
      *  默认 false（新功能默认关）；与部署 cfg.skills.enabled 取或（任一开则生效）。 */
     skillsEnabled: boolean;
+    /**
+     * 知识图谱**投影**开关（概览区可拨，issue #16）。
+     *
+     * true = 把 L1 记忆投影成 graph_nodes/graph_edges，并在启动/周期补齐存量；
+     * 与部署 `cfg.graph.enabled` **取或**（任一开则生效）。
+     *
+     * 注意与 `toolGraph` 的区别：后者封印的是**读**工具（memory_search_graph 等），
+     * 本键控的是**写**面（生成图谱）。两者同名接近，UI 文案必须分开写。
+     */
+    graphEnabled: boolean;
     /** 关键词回填启用开关（概览区可拨）:true = 放行 dsh-memory/keyword-backfill。与部署 cfg.keyword.enabled 取或。 */
     keywordEnabled: boolean;
     /** 重蒸馏整形启用开关（概览区可拨）:true = 放行 dsh-memory/redistill-backfill。与部署 cfg.redistill.enabled 取或。 */
@@ -185,6 +195,34 @@ export interface RebuildStatus {
      * null 表示尚未进入准备阶段。
      */
     preserveNote: string | null;
+    /**
+     * 本次重建**能够重蒸出来**的条数（来源全部落在 L0 快照内）。
+     *
+     * 与 `preserveCount` 一起构成"点下去会发生什么"的完整交代：
+     * 用户看得到多少条会被重造、多少条会被原样保住。
+     * null = 尚未出计划（未进入准备阶段）。
+     */
+    rederivableCount: number | null;
+    /** 本次重建**必须保留**的条数（无来源 / 来源不在快照 / 来源无从证明）。 */
+    preserveCount: number | null;
+    /**
+     * 事实源**覆盖到的时刻**（ISO；本地 L0 写停后即不再前移）。
+     *
+     * 这是给"这个按钮会不会倒退"提供可判依据的字段：重建只能重造到这个时刻
+     * 之前的正文。null = 本地 L0 一条正文都没有。
+     */
+    factWatermark: string | null;
+}
+/**
+ * 重建启动请求。
+ *
+ * `force` 只用于跨过**水位落差的二次确认**（见 `STALE_RATIO_THRESHOLD`）：
+ * L0 写停后“记忆晚于水位”是常态，把它做成硬拒会把重建永久锁死；
+ * 因此这里只要求调用方显式确认一次。
+ */
+export interface RebuildStartRequest {
+    /** true = 已确认“这批记录只保留、不重蒸”。 */
+    force?: boolean;
 }
 /** 反刍阶段。 */
 export type RuminatePhase = 'idle' | 'refreshing' | 'distilling' | 'consolidating' | 'updating' | 'relabeling' | 'done' | 'cancelled' | 'failed';
@@ -856,6 +894,8 @@ export interface SettingsSetRequest {
     memoryMutate?: boolean;
     /** §C 人工冲突裁决总开关(true = 冻结冲突对,停放到待人工裁决区)。 */
     conflictFreeze?: boolean;
+    /** 知识图谱投影开关(issue #16;与部署 cfg.graph.enabled 取或)。 */
+    graphEnabled?: boolean;
 }
 export interface SettingsSetResponse {
     ok: true;
@@ -1286,6 +1326,13 @@ export interface GraphPreviewResponse {
         jobsTotal: number;
         /** 永久失败作业数(dead),可选(零漂移先例);>0 → UI 拆成"完成/失败/排队"三档显示。 */
         deadJobs?: number;
+        /**
+         * 尚未投影的 L1 记录条数（issue #16），可选：为 0 时不写键。
+         *
+         * 首次开启投影前用它算“大概要花多少”：条数 ÷ 每批 8 条 = job 数，
+         * 每个 job 一次 LLM 抽取。
+         */
+        missing?: number;
     };
     /** mode==='full' 才出现;全图星图轻量块(可见节点×active 边,截断标记 truncated)。
      *  不带此键时响应与旧形状逐字节一致——消费方按需读 `res.full?`。 */
@@ -1868,7 +1915,7 @@ export interface DshMemoryRequestMap {
     'dsh-memory/log-tail': LogTailRequest;
     'dsh-memory/trace-tail': TraceTailRequest;
     'dsh-memory/rebuild-status': Record<string, never>;
-    'dsh-memory/rebuild-start': Record<string, never>;
+    'dsh-memory/rebuild-start': RebuildStartRequest;
     'dsh-memory/rebuild-cancel': Record<string, never>;
     'dsh-memory/ruminate-status': Record<string, never>;
     'dsh-memory/ruminate-start': Record<string, never>;

package/dist/graph/gate.d.ts

@@ -0,0 +1,17 @@
+/**
+ * 知识图谱投影的**唯一开关判据**（issue #16）。
+ *
+ * 为什么单独一个模块而不是塞进 runner：
+ * - `runner` 的五处门（启动补投影 / 周期泵 / enqueue / reproject / maybeQueue）与
+ *   `tools` 的写面门（memory_reproject / memory_migrate_relation）必须用**同一个**
+ *   判据。判据分散 = 半开态：只改 enqueue 不改泵 → 队列只涨不取；只改泵不改启动 timer
+ *   → 运行时开启后存量永不进图；只改 runner 不改工具 → 工具说"未开启"、runner 却在跑。
+ * - `tools` 不该为此拉入整个 `pipeline/runner` 的依赖图。
+ *
+ * 语义：部署 `cfg.graph.enabled` **或** 面板 `live.graphEnabled`（取或，照
+ * keywordEnabled / validityTiering 先例）。部署可以硬开、面板只能追加开 ——
+ * 反过来（取与）会让面板开关变成"只能关不能开"，而它本来就只能关到部署默认。
+ */
+import type { MemoryConfig } from '../config.js';
+import type { LiveSettingsHandle } from '../settings.js';
+export declare function graphFeatureOn(cfg: MemoryConfig, live?: LiveSettingsHandle): boolean;

package/dist/graph/gate.js

@@ -0,0 +1,11 @@
+export function graphFeatureOn(cfg, live) {
+    if (cfg.graph?.enabled === true)
+        return true;
+    try {
+        return live?.get()?.graphEnabled === true;
+    }
+    catch {
+        // live 读取失败：不能把已开的部署开关抬下来，也不能把功能卡死 → 按未开处理（零行为变化）。
+        return false;
+    }
+}

package/dist/graph/preview.d.ts

@@ -46,6 +46,11 @@ export interface PreviewOpts {
     pendingJobs?: number;
     jobsTotal?: number;
     deadJobs?: number;
+    /**
+     * 尚未投影的 L1 条数（issue #16）：面板“首次开启投影大概要花多少”的分母。
+     * 与 `queueMissing` 同一 WHERE，见 `GraphStore.countMissing`。
+     */
+    missing?: number;
 }
 /** S-2:邻接统计——active 边且两端都可见才计度(双向)。 */
 export interface DegreeMaps {

package/dist/graph/preview.js

@@ -101,6 +101,8 @@ export function buildGraphPreview(nodes, edges, opts = {}) {
         pendingJobs: opts.pendingJobs ?? 0,
         jobsTotal: opts.jobsTotal ?? 0,
         ...(opts.deadJobs != null && opts.deadJobs > 0 ? { deadJobs: opts.deadJobs } : {}),
+        // 零漂移：为 0 时不写键（旧消费方拿到的形状与改前逐字一致）。
+        ...(opts.missing != null && opts.missing > 0 ? { missing: opts.missing } : {}),
     };
     const seedLimit = Math.min(Math.max(Math.floor(opts.seedLimit ?? GRAPH_PREVIEW_SEEDS), 1), 20);
     const neighborLimit = Math.min(Math.max(Math.floor(opts.neighborLimit ?? GRAPH_PREVIEW_NEIGHBORS), 1), 40);

package/dist/index.js

@@ -399,7 +399,7 @@ export async function apply(ctx, config) {
     modes.setModeChangeHandler((sessionId, oldMode, newMode) => runner.onModeChange(sessionId, oldMode, newMode));
     // 闲置兜底:静默达标会话的未蒸馏切片自动落袋(idleSeconds=0 关闭)
     runner.startIdleTimer();
-    // 图谱周期补投影(cfg.graph.enabled 门控;30 分钟一次低速收敛)
+    // 图谱周期补投影（开关在 tick 内判：部署 graph.enabled 或面板 live.graphEnabled；30 分钟一次低速收敛）
     runner.startGraphBackfillTimer();
     // 时效标注存量回填(expiry-tiering task_6.3:tieringEnabled 门控,低频、让位蒸馏)
     runner.startValidityBackfillTimer();

package/dist/pipeline/fact-source.d.ts

@@ -0,0 +1,127 @@
+/**
+ * 重建事实源抽象（issue #14-B）。
+ *
+ * ## 为什么需要这一层
+ *
+ * 重建原先硬编码 `MemoryDb.listL0All()`：写入侧（capture）自 T8.4 起已把 L0 正文停写、
+ * 历史面交给 DRSC 投影，读侧却仍只认本地那张**冻结表**。这层把「事实源」抽成可替换的
+ * provider，让本地 L0 与 DRSC 两套实现共用同一条重建管线。
+ *
+ * ## 两个刻意的设计约束
+ *
+ * 1. **`estimate()` 必须同步**：`RebuildController.start()` 是同步 RPC，要在返回前就
+ *    给出体量与"能不能重建"的判定。DRSC 做不到同步报数，故 `FactEstimate.known=false`
+ *    表示"未知"，调用方据此**跳过**同步前置门（改在 prepare 阶段用实际结果判定）。
+ * 2. **`chunks()` 而不是"先全量再分组"**：`listL0All()` 在 3 万条量级上峰值约 88MB 且
+ *    整个重建期常驻。按会话产出块，峰值降到单会话量级。`groupL0Sessions` 仍保留为
+ *    纯函数（测试与本地实现的组装点），但生产路径按会话流式拉取。
+ *
+ * ## 不丢优先
+ *
+ * `snapshotIds()` 给 `planPreserve` 判 `post-watermark` 用。DRSC 实现**无法**枚举消息 id
+ * （id 是采集端合成的 `drsc:<sid>:<seq>`，与事实源里的 `source_message_ids` 不同域），
+ * 因此返回空集 —— 效果是**全部判为不可重蒸、全部保留**。这是安全侧失败：多保留只是多
+ * 一条待去重，丢掉是不可逆。
+ */
+import type { ConversationMessage, MemoryLogger } from '../types.js';
+import type { DrscClient } from '../clients/drsc.js';
+import type { MemoryDb } from '../store/sqlite.js';
+/** 重建分块：一个会话的全部消息（按时间升序）。 */
+export interface RebuildChunk {
+    sessionId: string;
+    messages: ConversationMessage[];
+}
+/** 事实源侧的一条消息（与 `L0MessageRecord` 结构兼容，但不带 recordedAt/turn/step）。 */
+export interface FactMessage {
+    id: string;
+    sessionId: string;
+    role: 'user' | 'assistant';
+    content: string;
+    timestamp: number;
+}
+/** 体量预估。`known=false` = 事实源无法同步报数（DRSC），字段值不可作为判定依据。 */
+export interface FactEstimate {
+    sessions: number;
+    messages: number;
+    chars: number;
+    known: boolean;
+}
+/** 事实源覆盖范围（面板"重建只覆盖到 X"的依据）。 */
+export interface FactCoverage {
+    /** 覆盖到的时刻（ISO）；null = 未知/无正文。 */
+    untilIso: string | null;
+    sessions: number;
+}
+export interface FactSourceProvider {
+    readonly kind: 'l0-local' | 'drsc';
+    /** 同步体量预估；`known=false` 时调用方不得据此做拒绝判定。 */
+    estimate(): FactEstimate;
+    /**
+     * 异步精确预估 + 内部预取（DRSC 在这里一次性枚举会话，`chunks()` 复用缓存）。
+     *
+     * 与 `estimate()` 的分工：后者是同步门（`start()` 返回前就要有结论），
+     * 前者是 prepare 阶段的真实体量（能发请求、能报准确会话数）。
+     */
+    prepare(): Promise<FactEstimate>;
+    /** 消息级流（诊断/测试用；生产走 chunks）。 */
+    snapshot(): AsyncIterable<FactMessage>;
+    /** 会话级流 —— 生产路径：单会话内存，不驻留全量正文。 */
+    chunks(): AsyncIterable<RebuildChunk>;
+    /**
+     * 本次事实源的**消息 id 集**，供 `post-watermark` 判据。
+     * 空集 = "判不出来" ⇒ 所有有来源的记录都会被保守判为不可重蒸并保留。
+     */
+    snapshotIds(): Promise<ReadonlySet<string>>;
+    coverage(): FactCoverage;
+}
+/**
+ * 把一批事实消息按会话分组（纯函数）。
+ *
+ * 保留这个签名是因为它有两个真实用途：① 本地实现按"一次全量"路径时可复用；
+ * ② 测试要能直接断言分组与排序语义而不必起 provider。生产路径用 `chunks()` 流式，
+ * 不经过这里 —— 否则又把全量正文攒回内存了。
+ *
+ * **仍然做归一 + 过滤**（与迁移前同口径）：入参允许是原始 L0 行，非法行（id 空、
+ * role 非 user/assistant、正文空）一律丢弃。过滤不能只留在 provider 里，
+ * 否则任何直接调本函数的调用方（含测试夹具）都得自己重复一遍。
+ */
+export declare function groupL0Sessions(records: Iterable<FactMessage | Readonly<Record<string, unknown>>>): RebuildChunk[];
+/** 本地 L0 事实源（默认）：已停写的冻结存量，读面走会话点查避免全量驻留。 */
+export declare class LocalL0FactSource implements FactSourceProvider {
+    private readonly db;
+    private readonly logger;
+    readonly kind: "l0-local";
+    constructor(db: MemoryDb, logger: MemoryLogger);
+    estimate(): FactEstimate;
+    prepare(): Promise<FactEstimate>;
+    coverage(): FactCoverage;
+    snapshotIds(): Promise<ReadonlySet<string>>;
+    snapshot(): AsyncIterable<FactMessage>;
+    chunks(): AsyncIterable<RebuildChunk>;
+}
+/**
+ * DRSC 事实源（实验性，默认不用）：枚举会话 → 逐会话拉全量。
+ *
+ * 顺序说明：collector 的 `op=sessions` 按 `last_time_ms` **降序**返回，这里显式反转成
+ * 升序，与本地实现的"会话按首条时间升序"对齐（上下文链的衔接方向一致）。
+ */
+export declare class DrscFactSource implements FactSourceProvider {
+    private readonly client;
+    private readonly logger;
+    /** 会话分页大小（collector 侧钳 1..500）。 */
+    private readonly pageSize;
+    readonly kind: "drsc";
+    constructor(client: DrscClient, logger: MemoryLogger, 
+    /** 会话分页大小（collector 侧钳 1..500）。 */
+    pageSize?: number);
+    estimate(): FactEstimate;
+    /** 会话枚举缓存（prepare 拉一次，chunks/snapshot 复用，不重复请求）。 */
+    private sessionsCache;
+    prepare(): Promise<FactEstimate>;
+    coverage(): FactCoverage;
+    snapshotIds(): Promise<ReadonlySet<string>>;
+    private listAllSessions;
+    private sessions;
+    snapshot(): AsyncIterable<FactMessage>;
+    chunks(): AsyncIterable<RebuildChunk>;
+}

package/dist/pipeline/fact-source.js

@@ -0,0 +1,192 @@
+import { drscRoleOf } from '../clients/drsc.js';
+/** L0 记录 → 事实消息（角色/内容过滤与 `groupL0Sessions` 同口径）。 */
+function factMessageOf(rec) {
+    const id = typeof rec.id === 'string' ? rec.id : '';
+    if (id === '')
+        return undefined;
+    const role = rec.role === 'user' || rec.role === 'assistant' ? rec.role : undefined;
+    if (role === undefined)
+        return undefined;
+    const content = typeof rec.content === 'string' ? rec.content : '';
+    if (content.trim() === '')
+        return undefined;
+    return {
+        id,
+        sessionId: typeof rec.sessionId === 'string' && rec.sessionId !== '' ? rec.sessionId : 'default',
+        role,
+        content,
+        timestamp: typeof rec.timestamp === 'number' && Number.isFinite(rec.timestamp) ? rec.timestamp : 0,
+    };
+}
+/**
+ * 把一批事实消息按会话分组（纯函数）。
+ *
+ * 保留这个签名是因为它有两个真实用途：① 本地实现按"一次全量"路径时可复用；
+ * ② 测试要能直接断言分组与排序语义而不必起 provider。生产路径用 `chunks()` 流式，
+ * 不经过这里 —— 否则又把全量正文攒回内存了。
+ *
+ * **仍然做归一 + 过滤**（与迁移前同口径）：入参允许是原始 L0 行，非法行（id 空、
+ * role 非 user/assistant、正文空）一律丢弃。过滤不能只留在 provider 里，
+ * 否则任何直接调本函数的调用方（含测试夹具）都得自己重复一遍。
+ */
+export function groupL0Sessions(
+// 入参保持宽松：原始 L0 行（多带 recordedAt/turn/step）与 FactMessage 都能喂。
+records) {
+    const bySession = new Map();
+    for (const raw of records) {
+        const msg = factMessageOf(raw);
+        if (msg === undefined)
+            continue;
+        const arr = bySession.get(msg.sessionId) ?? [];
+        arr.push({ id: msg.id, role: msg.role, content: msg.content, timestamp: msg.timestamp });
+        bySession.set(msg.sessionId, arr);
+    }
+    const chunks = [];
+    for (const [sessionId, messages] of bySession) {
+        messages.sort((a, b) => a.timestamp - b.timestamp);
+        chunks.push({ sessionId, messages });
+    }
+    // 会话按首条消息时间升序:情境链按时间顺序衔接(与原始发生顺序一致)
+    chunks.sort((a, b) => a.messages[0].timestamp - b.messages[0].timestamp);
+    return chunks;
+}
+/** 本地 L0 事实源（默认）：已停写的冻结存量，读面走会话点查避免全量驻留。 */
+export class LocalL0FactSource {
+    db;
+    logger;
+    kind = 'l0-local';
+    constructor(db, logger) {
+        this.db = db;
+        this.logger = logger;
+    }
+    estimate() {
+        const est = this.db.l0RebuildEstimate();
+        return { ...est, known: true };
+    }
+    async prepare() {
+        return this.estimate();
+    }
+    coverage() {
+        const wm = this.db.rebuildWatermark();
+        return { untilIso: wm.l0Iso, sessions: wm.l0SessionCount };
+    }
+    async snapshotIds() {
+        // 只读 record_id 列，不碰正文 —— 这是"不发 88MB 也要能判 post-watermark"的关键。
+        return this.db.l0MessageIds();
+    }
+    async *snapshot() {
+        for (const sessionId of this.db.l0SessionIds()) {
+            for (const rec of this.db.l0MessagesBySession(sessionId)) {
+                const msg = factMessageOf({ ...rec, id: rec.id });
+                if (msg !== undefined)
+                    yield msg;
+            }
+        }
+    }
+    async *chunks() {
+        const sessions = this.db.l0SessionIds();
+        this.logger.debug?.(`[memory] 重建事实源：本地 L0，${sessions.length} 个会话（按会话流式读）`);
+        for (const sessionId of sessions) {
+            const messages = [];
+            for (const rec of this.db.l0MessagesBySession(sessionId)) {
+                const msg = factMessageOf({ ...rec, id: rec.id });
+                if (msg !== undefined)
+                    messages.push({ id: msg.id, role: msg.role, content: msg.content, timestamp: msg.timestamp });
+            }
+            if (messages.length > 0)
+                yield { sessionId, messages };
+        }
+    }
+}
+/**
+ * DRSC 事实源（实验性，默认不用）：枚举会话 → 逐会话拉全量。
+ *
+ * 顺序说明：collector 的 `op=sessions` 按 `last_time_ms` **降序**返回，这里显式反转成
+ * 升序，与本地实现的"会话按首条时间升序"对齐（上下文链的衔接方向一致）。
+ */
+export class DrscFactSource {
+    client;
+    logger;
+    pageSize;
+    kind = 'drsc';
+    constructor(client, logger, 
+    /** 会话分页大小（collector 侧钳 1..500）。 */
+    pageSize = 200) {
+        this.client = client;
+        this.logger = logger;
+        this.pageSize = pageSize;
+    }
+    estimate() {
+        // 同步拿不到（要发请求）。known=false 让调用方跳过同步前置门，
+        // 真正的“空事实源”判定落在 prepare 的会话数上。
+        return { sessions: 0, messages: 0, chars: 0, known: false };
+    }
+    /** 会话枚举缓存（prepare 拉一次，chunks/snapshot 复用，不重复请求）。 */
+    sessionsCache = null;
+    async prepare() {
+        this.sessionsCache = await this.listAllSessions();
+        return { sessions: this.sessionsCache.length, messages: 0, chars: 0, known: true };
+    }
+    coverage() {
+        return { untilIso: null, sessions: 0 };
+    }
+    async snapshotIds() {
+        this.logger.warn('[memory] DRSC 事实源无法枚举消息 id（drsc:<sid>:<seq> 与 source_message_ids 不同域）——'
+            + '本轮重建会把所有有来源的记忆判为不可重蒸并原样保留（保守侧失败，不丢数据）');
+        return new Set();
+    }
+    async listAllSessions() {
+        const ids = [];
+        let offset = 0;
+        for (;;) {
+            const page = await this.client.listSessions(offset, this.pageSize);
+            for (const row of page.rows) {
+                if (typeof row.session_id === 'string' && row.session_id !== '') {
+                    ids.push({ id: row.session_id, last: row.last_time_ms });
+                }
+            }
+            offset += page.rows.length;
+            if (page.rows.length === 0 || offset >= page.total)
+                break;
+        }
+        // 反转 collector 的 last_time_ms 降序 → 升序（见类注释）
+        return ids.sort((a, b) => a.last - b.last).map((r) => r.id);
+    }
+    async sessions() {
+        if (this.sessionsCache !== null)
+            return this.sessionsCache;
+        this.sessionsCache = await this.listAllSessions();
+        return this.sessionsCache;
+    }
+    async *snapshot() {
+        for (const sessionId of await this.sessions()) {
+            for (const row of await this.client.sessionAll(sessionId)) {
+                const role = drscRoleOf(row.kind);
+                if (role === undefined)
+                    continue;
+                if (row.text.trim() === '')
+                    continue;
+                yield { id: `drsc:${sessionId}:${row.seq}`, sessionId, role, content: row.text, timestamp: row.time };
+            }
+        }
+    }
+    async *chunks() {
+        const sessions = await this.sessions();
+        this.logger.info(`[memory] 重建事实源：DRSC，${sessions.length} 个会话（逐会话拉全量，redact=1）`);
+        for (const sessionId of sessions) {
+            const rows = await this.client.sessionAll(sessionId);
+            const messages = [];
+            for (const row of rows) {
+                const role = drscRoleOf(row.kind);
+                if (role === undefined)
+                    continue;
+                if (row.text.trim() === '')
+                    continue;
+                messages.push({ id: `drsc:${sessionId}:${row.seq}`, role, content: row.text, timestamp: row.time });
+            }
+            messages.sort((a, b) => a.timestamp - b.timestamp);
+            if (messages.length > 0)
+                yield { sessionId, messages };
+        }
+    }
+}

package/dist/pipeline/rebuild-preserve.d.ts

@@ -54,8 +54,19 @@ export interface FactSourceRead {
 export type PreserveReason = 
 /** 事实源里没有 `source_message_ids` —— 不是从 L0 蒸馏来的。 */
 'no-source'
-/** 内容为空白 —— 重蒸馏不会产出空记忆,保留它也无从重造。 */
+/** 内容为空白 —— 重蒸馏不会产出空记忆，保留它也无从重造。 */
  | 'empty-content'
+/**
+ * 来源消息**不在本次 L0 快照内**。
+ *
+ * 与 `no-source` 的区别：这条记录**有**来源 id，但那些 id 指向的消息不在本次
+ * 重建的事实源里——结构上重蒸不出来，故必须保留。
+ *
+ * 典型成因是 L0 写停（T8.4 后 l0 正文三表退役）：停写之后新增的 L1 记录
+ * 全部落这一类。判据用**集合包含**而不是时间差——L1 的 `created_time` 会随
+ * 每次蒸馏前移，任何时间阈值终将被跳过，用它做门槛会把重建**永久锁死**。
+ */
+ | 'post-watermark'
 /**
  * 检索库里有、事实源里**完全没有**这一行 —— 来源无从证明。
  *
@@ -86,6 +97,14 @@ export interface PreservePlan {
 }
 /** 判定单条记录是否可由 L0 重蒸馏出来(事实源侧判据)。 */
 export declare function isRederivable(record: MemoryRecord): boolean;
+/**
+ * 来源是否**全部**落在本次快照内。
+ *
+ * `every` 而不是 `some`：只要有一张原料缺失，重蒸馏就只会产出一个缺角的新记录，
+ * 不如原样保留。无来源时返回 `false`——但那一类由 `no-source` 先行接住，
+ * 不应依赖本函数的返回值。
+ */
+export declare function sourcesCoveredBySnapshot(record: MemoryRecord, snapshotIds: ReadonlySet<string>): boolean;
 /**
  * 读取事实源目录(`<dataDir>/records/*.jsonl`)。
  *
@@ -103,7 +122,17 @@ export declare function readFactSource(recordsDir: string): Promise<FactSourceRe
  * `liveDbRecords` 由调用方从**检索库**取(它没有 `source_message_ids` 列,
  * 只用来回答"这条还在不在"),恢复时以检索库副本为准 —— 那是当前检索态。
  */
-export declare function planPreserve(factRecords: readonly MemoryRecord[], liveDbRecords: readonly MemoryRecord[]): PreservePlan;
+export interface PreserveOptions {
+    /**
+     * 本次重建事实源（L0 快照）的**消息 id 集**。
+     *
+     * 不给 = 保持旧口径（只看"有无来源"）。给了才能判 `post-watermark`，
+     * 而**给了才是安全的**：L0 已写停的库只看"有无来源"会把停写后的记录
+     * 当成可重蒸，清库后真的丢。
+     */
+    readonly snapshotIds?: ReadonlySet<string>;
+}
+export declare function planPreserve(factRecords: readonly MemoryRecord[], liveDbRecords: readonly MemoryRecord[], opts?: PreserveOptions): PreservePlan;
 /** 清空闸门的判定码。 */
 export type ClearGateCode = 
 /** 放行。 */