dsh-prime-memory 0.26.9 → 0.26.11

package/dist/pipeline/rebuild-preserve.js

@@ -44,6 +44,19 @@ export function isRederivable(record) {
     const src = record.source_message_ids;
     return Array.isArray(src) && src.length > 0;
 }
+/**
+ * 来源是否**全部**落在本次快照内。
+ *
+ * `every` 而不是 `some`：只要有一张原料缺失，重蒸馏就只会产出一个缺角的新记录，
+ * 不如原样保留。无来源时返回 `false`——但那一类由 `no-source` 先行接住，
+ * 不应依赖本函数的返回值。
+ */
+export function sourcesCoveredBySnapshot(record, snapshotIds) {
+    const src = record.source_message_ids;
+    if (!Array.isArray(src) || src.length === 0)
+        return false;
+    return src.every((id) => snapshotIds.has(id));
+}
 /**
  * 读取事实源目录(`<dataDir>/records/*.jsonl`)。
  *
@@ -89,16 +102,7 @@ export async function readFactSource(recordsDir) {
     }
     return { ok: true, records: [...byId.values()], files: names.length };
 }
-/**
- * 出保留计划。纯函数:输入事实源记录 + 检索库现存记录,输出要保留什么。
- *
- * 两个方向都保守:事实源说"这条没来源"要留,**检索库里查不到出处**也要留
- * (`unprovenanced`)—— 判据缺失时留,而不是丢。
- *
- * `liveDbRecords` 由调用方从**检索库**取(它没有 `source_message_ids` 列,
- * 只用来回答"这条还在不在"),恢复时以检索库副本为准 —— 那是当前检索态。
- */
-export function planPreserve(factRecords, liveDbRecords) {
+export function planPreserve(factRecords, liveDbRecords, opts = {}) {
     const live = new Map();
     for (const r of liveDbRecords)
         if (r && typeof r.id === 'string')
@@ -112,6 +116,21 @@ export function planPreserve(factRecords, liveDbRecords) {
             continue;
         seen.add(f.id);
         if (isRederivable(f)) {
+            // 顺序纪律：「外部可重蒸」必须在「post-watermark 保留」**之后**判。
+            // 停写后新增的记录 `source_message_ids` 非空，但指向的消息在本地
+            // `l0_conversations` 已查不到 —— 清库后蒸不出来，等于丢失；
+            // 而按旧口径（只看非空）它们恰好会被归进 `rederivable` 然后被清掉。
+            if (opts.snapshotIds && !sourcesCoveredBySnapshot(f, opts.snapshotIds)) {
+                const current = live.get(f.id);
+                // 已退场的不复活（与 no-source 分支同口径）
+                if (current) {
+                    preserved.push({
+                        record: current,
+                        reason: String(current.content ?? '').trim() ? 'post-watermark' : 'empty-content',
+                    });
+                }
+                continue;
+            }
             // 有来源但已退场(合并掉了)的不必计数——重建会按 L0 再造。
             if (live.has(f.id))
                 rederivable++;
@@ -175,8 +194,8 @@ export function gateClear(read, plan) {
         allowed: true,
         code: 'ok',
         note: keep > 0
-            ? `保留 ${keep} 条无 L0 来源的记忆(导入/手工写入),重建只重造 ${plan.rederivable} 条有来源的记忆`
-            : `无无来源记忆需要保留,重建重造 ${plan.rederivable} 条有来源的记忆`,
+            ? `保留 ${keep} 条不可重蒸的记忆(导入/手工写入/来源不在本次快照),重建只重造 ${plan.rederivable} 条有来源的记忆`
+            : `无不可重蒸记忆需要保留,重建重造 ${plan.rederivable} 条有来源的记忆`,
     };
 }
 /**
@@ -195,12 +214,19 @@ export async function restorePreserved(l1, plan) {
     const missing = ids.filter((id) => !back.has(id));
     return { attempted: ids.length, restored: ids.length - missing.length, missing };
 }
+/** reason → 中文标签（日志/状态栏直接给人看，不再打印英文枚举）。 */
+const REASON_LABEL = {
+    'no-source': '无来源',
+    'empty-content': '内容为空',
+    unprovenanced: '来源无从证明',
+    'post-watermark': '来源不在本次快照',
+};
 /** 面向日志/状态栏的一行摘要。 */
 export function describePlan(plan) {
     const byReason = new Map();
     for (const p of plan.preserved)
         byReason.set(p.reason, (byReason.get(p.reason) ?? 0) + 1);
-    const parts = [...byReason].map(([r, n]) => `${r} ${n}`);
-    return (`保留 ${plan.preserved.length} 条无来源记忆${parts.length ? `(${parts.join(' / ')})` : ''};` +
+    const parts = [...byReason].map(([r, n]) => `${REASON_LABEL[r] ?? r} ${n}`);
+    return (`保留 ${plan.preserved.length} 条不可重蒸记忆${parts.length ? `(${parts.join(' / ')})` : ''};` +
         `可重蒸馏 ${plan.rederivable} 条;事实源 ${plan.factCount} 条(其中无来源但已退场 ${plan.retiredNoSource} 条,不恢复)`);
 }

package/dist/pipeline/rebuild.d.ts

@@ -6,24 +6,36 @@ import type { SceneStore } from '../store/scenes.js';
 import type { StateStore } from '../store/state.js';
 import type { MemoryDb } from '../store/sqlite.js';
 import type { LiveSettingsHandle } from '../settings.js';
-import type { ConversationMessage, L0MessageRecord, MemoryFamily, MemoryLogger } from '../types.js';
+import type { MemoryFamily, MemoryLogger } from '../types.js';
 import { type MemoryRunner } from './runner.js';
+import type { DrscClient } from '../clients/drsc.js';
+export type { FactCoverage, FactEstimate, FactMessage, FactSourceProvider, RebuildChunk } from './fact-source.js';
+export { DrscFactSource, groupL0Sessions, LocalL0FactSource } from './fact-source.js';
 /** 重建所需的存储子集(l0 不需要——快照直接走 db)。 */
 export interface RebuildStores {
     l1: L1Store;
     scenes: Record<MemoryFamily, SceneStore>;
     persona: Record<MemoryFamily, PersonaStore>;
     state: StateStore;
+    /**
+     * DRSC 客户端（issue #14-B）：仅当 `rebuild.factSource === 'drsc'` 时用到。
+     * 缺席时选 drsc 会**显式中止**，不静默回退本地表。
+     */
+    drsc?: DrscClient;
 }
 import type { RebuildStatus } from '../contract.js';
 export type { RebuildPhase, RebuildStatus } from '../contract.js';
-export interface RebuildChunk {
-    sessionId: string;
-    messages: ConversationMessage[];
-}
-export declare function groupL0Sessions(records: L0MessageRecord[]): RebuildChunk[];
 /** 抽取调用数下界估算(与 l1.ts 的 perChunk 同式;会话数与字符预算取大)。 */
 export declare function estimateCalls(sessions: number, messages: number, chars: number, maxInputChars: number): number;
+/**
+ * 水位落差**提示**阀值：检索库里晚于 L0 水位的占比超过此值，就要求二次确认。
+ *
+ * 为什么叫“提示阀值”而不是“拒绝阀值”：L0 写停后这个比例只会单调上升，
+ * 拿它做硬门槛等于把重建**永久锁死**（issue #14 原提案的致命缺陷）。
+ * 所以它只负责“提醒你正在做什么”，放行靠 `force`；真正的**不丢**由
+ * `planPreserve` 的集合判据（`post-watermark`）结构性保证。
+ */
+export declare const STALE_RATIO_THRESHOLD = 0.5;
 export declare class RebuildController {
     private readonly ctx;
     private readonly cfg;
@@ -33,22 +45,44 @@ export declare class RebuildController {
     private readonly logger;
     private readonly live;
     private status;
-    private chunks;
+    /**
+     * 会话级事实源迭代器（issue #14-B）：不再把全量 L0 正文驻留内存。
+     * null = 尚未进入蒸馏 / 已收尾。
+     */
+    private chunkIter;
     private cancelRequested;
     /** 快照时刻(收尾时按它区分重建产物与重建后新对话的记录)。 */
     private rebuildStartMs;
     constructor(ctx: Context, cfg: MemoryConfig, stores: RebuildStores, db: MemoryDb, runner: Pick<MemoryRunner, 'enqueueRebuildTask' | 'runRebuildTurn' | 'states'>, logger: MemoryLogger, live: LiveSettingsHandle);
-    /** 状态快照(idle 时附带实时 L0 预估,供确认弹窗显示成本)。 */
+    /** 状态快照(idle 时附带实时预估与事实源水位,供确认弹窗讲清"会发生什么")。 */
     getStatus(): RebuildStatus;
-    /** 内存中尚未处理的会话快照块数(收尾后应为 0——快照即弃,诊断/冒烟用)。 */
+    /** 尚未处理的会话块数（流式下为估算 `total - done`；未运行时为 0，诊断/冒烟用）。 */
     get chunkCount(): number;
-    /** 启动重建(校验后入队准备任务;真正的清库/归档在管线队列里串行执行,避开并发竞态)。 */
-    start(): RebuildStatus;
+    /**
+     * 按 `cfg.rebuild.factSource` 选事实源（issue #14-B）。
+     *
+     * 选 drsc 但客户端未装配时**显式抛错**，不静默回退本地表 —— “以为用了新源其实还是旧表”
+     * 会让用户拿重建结果去判断 DRSC 数据是否完整，那是最坏的误判。
+     */
+    private provider;
+    /**
+     * 启动重建(校验后入队准备任务;真正的清库/归档在管线队列里串行执行,避开并发竞态)。
+     *
+     * `force` 只用于跨过**提示门槛**（水位落差超过 `STALE_RATIO_THRESHOLD` 时的二次确认），
+     * 不能跨过唯一那条硬拒：「L0 一条消息都没有、检索库却有记录」—— 那种形状下重建
+     * 只会清空、一条也重造不出来，属于纯亏。
+     */
+    start(force?: boolean): RebuildStatus;
     /** 请求取消:当前块完成后停止,已重建部分保留并照常收尾 L2/L3。 */
     requestCancel(): RebuildStatus;
     private prepare;
-    /** 分块链:一次只挂一个重建块,跑完再挂下一块——正常轮次可随时插队。 */
-    private scheduleChunk;
+    /**
+     * 分块链:一次只挂一个重建块,跑完再挂下一块——正常轮次可随时插队。
+     *
+     * 流式版（issue #14-B）：从事实源迭代器拉下一个会话，不再按下标从内存数组取。
+     * 内存峰值从"全量正文"降到"单会话"。
+     */
+    private scheduleNext;
     private finalize;
     /**
      * 收集重建窗口内某族的记录:重建产物全部是新插入(updated==created),

package/dist/pipeline/rebuild.js

@@ -26,29 +26,9 @@ import { runSceneConsolidation } from './l2.js';
 import { runPersona } from './l3.js';
 import { describePlan, gateClear, planPreserve, readFactSource, restorePreserved } from './rebuild-preserve.js';
 import { effectiveCfg } from './runner.js';
-export function groupL0Sessions(records) {
-    const bySession = new Map();
-    for (const r of records) {
-        if (!r || typeof r.id !== 'string' || typeof r.content !== 'string')
-            continue;
-        if (r.role !== 'user' && r.role !== 'assistant')
-            continue;
-        if (!r.content.trim())
-            continue;
-        const key = r.sessionId || 'default';
-        const arr = bySession.get(key) ?? [];
-        arr.push({ id: r.id, role: r.role, content: r.content, timestamp: r.timestamp ?? 0 });
-        bySession.set(key, 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;
-}
+import { DrscFactSource, LocalL0FactSource, } from './fact-source.js';
+export { DrscFactSource, groupL0Sessions, LocalL0FactSource } from './fact-source.js';
+// `RebuildChunk` 与 `groupL0Sessions` 已迁到 pipeline/fact-source.ts（上面已转出）。
 /** 抽取调用数下界估算(与 l1.ts 的 perChunk 同式;会话数与字符预算取大)。 */
 export function estimateCalls(sessions, messages, chars, maxInputChars) {
     if (messages === 0)
@@ -56,6 +36,15 @@ export function estimateCalls(sessions, messages, chars, maxInputChars) {
     const perChunk = Math.max(20_000, maxInputChars - 42_000);
     return Math.max(sessions, Math.ceil((chars + 64 * messages) / perChunk));
 }
+/**
+ * 水位落差**提示**阀值：检索库里晚于 L0 水位的占比超过此值，就要求二次确认。
+ *
+ * 为什么叫“提示阀值”而不是“拒绝阀值”：L0 写停后这个比例只会单调上升，
+ * 拿它做硬门槛等于把重建**永久锁死**（issue #14 原提案的致命缺陷）。
+ * 所以它只负责“提醒你正在做什么”，放行靠 `force`；真正的**不丢**由
+ * `planPreserve` 的集合判据（`post-watermark`）结构性保证。
+ */
+export const STALE_RATIO_THRESHOLD = 0.5;
 function idleStatus() {
     return {
         running: false,
@@ -72,6 +61,9 @@ function idleStatus() {
         error: null,
         archiveNote: null,
         preserveNote: null,
+        rederivableCount: null,
+        preserveCount: null,
+        factWatermark: null,
     };
 }
 /** 时间戳后缀(归档命名,秒级防撞)。 */
@@ -88,7 +80,11 @@ export class RebuildController {
     logger;
     live;
     status = idleStatus();
-    chunks = [];
+    /**
+     * 会话级事实源迭代器（issue #14-B）：不再把全量 L0 正文驻留内存。
+     * null = 尚未进入蒸馏 / 已收尾。
+     */
+    chunkIter = null;
     cancelRequested = false;
     /** 快照时刻(收尾时按它区分重建产物与重建后新对话的记录)。 */
     rebuildStartMs = 0;
@@ -101,32 +97,88 @@ export class RebuildController {
         this.logger = logger;
         this.live = live;
     }
-    /** 状态快照(idle 时附带实时 L0 预估,供确认弹窗显示成本)。 */
+    /** 状态快照(idle 时附带实时预估与事实源水位,供确认弹窗讲清"会发生什么")。 */
     getStatus() {
         if (this.status.phase === 'idle') {
-            const est = this.db.l0RebuildEstimate();
-            return {
-                ...this.status,
-                sessionCount: est.sessions,
-                messageCount: est.messages,
-                estCalls: estimateCalls(est.sessions, est.messages, est.chars, effectiveCfg(this.cfg, this.live).llm.maxInputChars),
-            };
+            try {
+                const provider = this.provider();
+                const est = provider.estimate();
+                const cov = provider.coverage();
+                return {
+                    ...this.status,
+                    sessionCount: est.sessions,
+                    messageCount: est.messages,
+                    estCalls: estimateCalls(est.sessions, est.messages, est.chars, effectiveCfg(this.cfg, this.live).llm.maxInputChars),
+                    factWatermark: cov.untilIso,
+                };
+            }
+            catch {
+                // 事实源未就绪（如选了 drsc 但 collector 未装配）：面板不能因此整块挂，
+                // 只把水位置空；真正的错误留给 start() 显式报。
+                return { ...this.status, factWatermark: null };
+            }
         }
         return { ...this.status };
     }
-    /** 内存中尚未处理的会话快照块数(收尾后应为 0——快照即弃,诊断/冒烟用)。 */
+    /** 尚未处理的会话块数（流式下为估算 `total - done`；未运行时为 0，诊断/冒烟用）。 */
     get chunkCount() {
-        return this.chunks.length;
+        return this.status.running ? Math.max(0, this.status.total - this.status.done) : 0;
     }
-    /** 启动重建(校验后入队准备任务;真正的清库/归档在管线队列里串行执行,避开并发竞态)。 */
-    start() {
+    /**
+     * 按 `cfg.rebuild.factSource` 选事实源（issue #14-B）。
+     *
+     * 选 drsc 但客户端未装配时**显式抛错**，不静默回退本地表 —— “以为用了新源其实还是旧表”
+     * 会让用户拿重建结果去判断 DRSC 数据是否完整，那是最坏的误判。
+     */
+    provider() {
+        if (this.cfg.rebuild?.factSource === 'drsc') {
+            const drsc = this.stores.drsc;
+            if (!drsc) {
+                throw new Error('重建事实源配置为 drsc，但 collector 客户端未装配 —— 已中止且**未动任何数据**。'
+                    + '请先启用 reference-session-collector，或把 rebuild.factSource 改回 local。');
+            }
+            return new DrscFactSource(drsc, this.logger);
+        }
+        return new LocalL0FactSource(this.db, this.logger);
+    }
+    /**
+     * 启动重建(校验后入队准备任务;真正的清库/归档在管线队列里串行执行,避开并发竞态)。
+     *
+     * `force` 只用于跨过**提示门槛**（水位落差超过 `STALE_RATIO_THRESHOLD` 时的二次确认），
+     * 不能跨过唯一那条硬拒：「L0 一条消息都没有、检索库却有记录」—— 那种形状下重建
+     * 只会清空、一条也重造不出来，属于纯亏。
+     */
+    start(force = false) {
         if (this.status.running)
             throw new Error('重建已在进行中');
-        const est = this.db.l0RebuildEstimate();
-        if (est.messages === 0)
+        // drsc 但客户端未装配 → provider() 在这里显式抛（未动任何数据）
+        const provider = this.provider();
+        const est = provider.estimate();
+        const wm = this.db.rebuildWatermark();
+        // 同步门只对“能同步报数”的事实源成立（本地 L0）。DRSC 要发请求才知道会话数，
+        // known=false 时必须跳过 —— 否则会把“未知”当成“空”直接拒掉。
+        if (est.known && est.messages === 0) {
+            if (wm.l1Total > 0) {
+                throw new Error(`本地 L0 一条消息都没有,而检索库有 ${wm.l1Total} 条记忆 ——`
+                    + 'L0 正文自 T8.4 起已停写,用它重建只会清空检索库、一条也重造不出来。'
+                    + '已中止重建且**未动任何数据**。若确实需要以其他事实源重建,请先把该事实源接上后重试。');
+            }
             throw new Error('L0 无任何消息,无需重建');
+        }
+        // 水位落差**只做提示**:L0 停写后这个比例会单调上升，硬拒等于永久锁死重建。
+        // 真正的“不丢”由 planPreserve 的集合判据结构性保证，这里只负责让用户看清楚。
+        if (est.known && !force && wm.l1Total > 0) {
+            const ratio = wm.l1After / wm.l1Total;
+            if (ratio > STALE_RATIO_THRESHOLD) {
+                const pct = Math.round(ratio * 100);
+                throw new Error(`检索库有 ${wm.l1Total} 条记忆，其中 ${wm.l1After} 条(${pct}%)晚于本地 L0 水位`
+                    + `${wm.l0Iso ? ` ${wm.l0Iso}` : '(L0 为空)'} —— 这些记忆的原材料已不在本次快照里，`
+                    + '重建会把它们**原样保留但不再重蒸馏**(不会丢，只是不重造)。'
+                    + '确认要继续请带 force 重试。');
+            }
+        }
         this.cancelRequested = false;
-        this.chunks = [];
+        this.chunkIter = null;
         this.status = {
             ...idleStatus(),
             running: true,
@@ -135,9 +187,12 @@ export class RebuildController {
             messageCount: est.messages,
             estCalls: estimateCalls(est.sessions, est.messages, est.chars, effectiveCfg(this.cfg, this.live).llm.maxInputChars),
             startedAt: Date.now(),
+            factWatermark: provider.coverage().untilIso,
         };
         this.runner.enqueueRebuildTask(() => this.prepare());
-        this.logger.info(`[memory] 重建开始:${est.sessions} 个会话 / ${est.messages} 条 L0 消息(预计 ≥${this.status.estCalls} 次抽取调用)`);
+        this.logger.info(`[memory] 重建开始:${est.sessions} 个会话 / ${est.messages} 条 L0 消息`
+            + `(预计 ≥${this.status.estCalls} 次抽取调用;事实源水位 ${wm.l0Iso ?? '空'};`
+            + `检索库 ${wm.l1Total} 条,其中晚于水位 ${wm.l1After} 条)`);
         return { ...this.status };
     }
     /** 请求取消:当前块完成后停止,已重建部分保留并照常收尾 L2/L3。 */
@@ -151,18 +206,28 @@ export class RebuildController {
     }
     async prepare() {
         try {
-            // 快照:从检索库读全量 L0(事务一致;重建期间新捕获的消息走正常轮次,天然不重不漏)
+            // 事实源（issue #14-B）：默认本地 L0；drsc 需显式配置且必须有客户端。
+            const provider = this.provider();
+            // 快照时刻:重建期间新捕获的消息走正常轮次,天然不重不漏
             this.rebuildStartMs = Date.now();
-            this.chunks = groupL0Sessions(this.db.listL0All());
-            if (this.chunks.length === 0) {
-                this.finish('failed', 'L0 快照为空');
+            const est = await provider.prepare();
+            if (est.sessions === 0) {
+                this.finish('failed', `事实源(${provider.kind})为空，无可重建内容`);
                 return;
             }
-            this.status.total = this.chunks.length;
+            this.status.total = est.sessions;
+            if (est.messages > 0)
+                this.status.messageCount = est.messages;
+            // 本次事实源的**消息 id 集**：判"来源是否还在快照里"的唯一依据。
+            // 不取时间:时间差对停写的 L0 会永久走扩（详见 rebuild-preserve 的 post-watermark）。
+            // 注意这里**不读正文**：2.5 万条 id 约 1.5MB，而全量正文是 88MB。
+            const snapshotIds = await provider.snapshotIds();
             const dataDir = resolveDataDir(this.cfg);
             // ── ① 读事实源 + 判定保留集(必须在 archiveDerived 之前:归档会把 records/ 搬走)──
             const factRead = await readFactSource(path.join(dataDir, 'records'));
-            const plan = planPreserve(factRead.records, this.stores.l1.all());
+            const plan = planPreserve(factRead.records, this.stores.l1.all(), { snapshotIds });
+            this.status.rederivableCount = plan.rederivable;
+            this.status.preserveCount = plan.preserved.length;
             // ── ② 过闸门:判不出该保留什么时**拒绝清空**(见 rebuild-preserve.ts 文件头)──
             const gate = gateClear(factRead, plan);
             if (!gate.allowed) {
@@ -197,26 +262,53 @@ export class RebuildController {
                 this.stores.persona.work.init(),
             ]);
             this.status.phase = 'distilling';
-            this.logger.info(`[memory] 重建准备完成(归档:${archiveNote ?? '无旧产物'},保留:${this.status.preserveNote},${this.chunks.length} 个会话块)`);
-            this.scheduleChunk(0);
+            this.logger.info(`[memory] 重建准备完成(归档:${archiveNote ?? '无旧产物'},保留:${this.status.preserveNote},${est.sessions} 个会话块,事实源=${provider.kind})`);
+            this.chunkIter = provider.chunks()[Symbol.asyncIterator]();
+            this.scheduleNext();
         }
         catch (err) {
             this.finish('failed', `准备阶段失败: ${errDetail(err)}`);
         }
     }
-    /** 分块链:一次只挂一个重建块,跑完再挂下一块——正常轮次可随时插队。 */
-    scheduleChunk(i) {
-        if (this.cancelRequested || i >= this.chunks.length) {
+    /**
+     * 分块链:一次只挂一个重建块,跑完再挂下一块——正常轮次可随时插队。
+     *
+     * 流式版（issue #14-B）：从事实源迭代器拉下一个会话，不再按下标从内存数组取。
+     * 内存峰值从"全量正文"降到"单会话"。
+     */
+    scheduleNext() {
+        if (this.cancelRequested) {
+            this.runner.enqueueRebuildTask(() => this.finalize());
+            return;
+        }
+        const iter = this.chunkIter;
+        if (!iter) {
             this.runner.enqueueRebuildTask(() => this.finalize());
             return;
         }
-        const chunk = this.chunks[i];
         this.runner.enqueueRebuildTask(async () => {
             // 入队后开跑前可能已收到取消(等待插队的正常轮次期间),直接跳到收尾
             if (this.cancelRequested) {
                 this.runner.enqueueRebuildTask(() => this.finalize());
                 return;
             }
+            let next;
+            try {
+                next = await iter.next();
+            }
+            catch (err) {
+                // 事实源中途失败**不能**当“跑完了”：那会把“只重建了一部分”报成成功，
+                // 而用户会拿这个结论去判断数据是否重新生成。
+                this.logger.error(`[memory] 重建事实源中断(已完成 ${this.status.done}/${this.status.total} 个会话): ${errDetail(err)}`);
+                this.finish('failed', `事实源读取中断: ${errDetail(err)}`);
+                return;
+            }
+            if (next.done === true) {
+                this.chunkIter = null;
+                this.runner.enqueueRebuildTask(() => this.finalize());
+                return;
+            }
+            const chunk = next.value;
             try {
                 const n = await this.runner.runRebuildTurn(chunk.sessionId, chunk.messages);
                 this.status.recordsBuilt += n;
@@ -224,8 +316,8 @@ export class RebuildController {
             catch (err) {
                 this.logger.warn(`[memory] 重建块失败(session=${chunk.sessionId},跳过继续): ${errDetail(err)}`);
             }
-            this.status.done = i + 1;
-            this.scheduleChunk(i + 1);
+            this.status.done += 1;
+            this.scheduleNext();
         });
     }
     async finalize() {
@@ -307,9 +399,13 @@ export class RebuildController {
         this.status.phase = phase;
         this.status.error = error;
         this.status.finishedAt = Date.now();
-        // 快照即弃:全量 L0 消息(可能几十 MB)在重建结束/取消/失败后必须释放,
-        // 不能滞留到下一次 start() 覆盖(宿主长跑内存只增不减)
-        this.chunks = [];
+        // 事实源释放:迭代器持有单会话内存，收尾必须断开（不能滞留到下一次 start 覆盖）。
+        // 若它实现了 `return`（异步生成器），顺手关掉，避免上游资源悬着。
+        const iter = this.chunkIter;
+        this.chunkIter = null;
+        if (iter !== null && typeof iter.return === 'function') {
+            void iter.return().catch(() => { });
+        }
         const cost = this.status.finishedAt - (this.status.startedAt ?? this.status.finishedAt);
         this.logger.info(`[memory] 重建结束(${phase}):${this.status.done}/${this.status.total} 会话,产出 ${this.status.recordsBuilt} 条记录,耗时 ${Math.round(cost / 1000)}s` +
             (error ? `,错误:${error}` : ''));

package/dist/pipeline/runner.d.ts

@@ -16,6 +16,7 @@ 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 { graphFeatureOn } from '../graph/gate.js';
 import type { L1Store } from '../store/l1.js';
 import type { PersonaStore } from '../store/persona.js';
 import type { SceneStore } from '../store/scenes.js';
@@ -73,6 +74,7 @@ export declare function pickNextTaskIndex(tasks: PipelineTask[]): number;
  *   primaryEffort;非链模式旧键对静态回退条目盖章接管(存量兼容)。
  * - 输出预算/输入预算/通道覆盖/远程嵌入覆盖:非零/非空运行时值直接注入对应子树。
  */
+export { graphFeatureOn };
 export declare function effectiveCfg(cfg: MemoryConfig, live?: LiveSettingsHandle): MemoryConfig;
 export declare class MemoryRunner {
     private readonly ctx;
@@ -192,7 +194,8 @@ export declare class MemoryRunner {
     };
     /**
      * 图谱投影泵入队判定:
-     * - 双门:部署级 cfg.graph.enabled + 运行时 live.enabled/distill,任一为假不入队;
+     * - 双门:`graphFeatureOn`（部署 cfg.graph.enabled **或** 面板 live.graphEnabled）
+     *   + 运行时 live.enabled/distill,任一为假不入队;
      * - 占位:同一时刻至多一个 graph 任务在队列(靠 graphPumpQueued 标志),永不与
      *   live 抢位(pickNextTaskIndex 保证 live > graph);
      * - 退避/attempts 封顶:由 GraphStore.claimNext 的 WHERE 过滤与 fail 转 dead 承接,