dsh-layered-memory 0.6.0 → 0.7.0

package/dist/pipeline/rebuild.js

@@ -0,0 +1,307 @@
+/**
+ * 重建控制器：从 L0 事实源重新推导 L1/L2/L3（用户主动动作，设置页按钮触发）。
+ *
+ * 语义（CONTEXT.md「重建」）：
+ * - L0 永不改动；旧派生层归档保留（records/ scenes/ persona-*.md → *.bak.<ts>，不硬删）；
+ * - 检索库 L1 三表清空、checkpoint 原地重置；
+ * - 统一按 auto 档、按会话分块重蒸馏；分块经 runner 的低优先级队列让位于正常轮次；
+ * - 收尾强制一轮 L2（各族残余记录）+ L3（重建后 hasPersona=false → 冷启动触发）。
+ *
+ * 失败语义：准备/归档任一步失败 → phase=failed，绝不拖垮宿主；
+ * 单块蒸馏失败继续下一块（消息留在未蒸馏缓冲，下轮对话/重启补跑自愈）。
+ */
+import { promises as fs } from 'node:fs';
+import * as path from 'node:path';
+import { resolveDataDir } from '../config.js';
+import { errDetail } from '../util/filelog.js';
+import { runSceneConsolidation } from './l2.js';
+import { runPersona } from './l3.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;
+}
+/** 抽取调用数下界估算（与 l1.ts 的 perChunk 同式；会话数与字符预算取大）。 */
+export function estimateCalls(sessions, messages, chars, maxInputChars) {
+    if (messages === 0)
+        return 0;
+    const perChunk = Math.max(20_000, maxInputChars - 42_000);
+    return Math.max(sessions, Math.ceil((chars + 64 * messages) / perChunk));
+}
+function idleStatus() {
+    return {
+        running: false,
+        phase: 'idle',
+        done: 0,
+        total: 0,
+        sessionCount: 0,
+        messageCount: 0,
+        estCalls: 0,
+        recordsBuilt: 0,
+        cancelRequested: false,
+        startedAt: null,
+        finishedAt: null,
+        error: null,
+        archiveNote: null,
+    };
+}
+/** 时间戳后缀（归档命名，秒级防撞）。 */
+function stamp(now = new Date()) {
+    const p = (n) => String(n).padStart(2, '0');
+    return `${now.getFullYear()}${p(now.getMonth() + 1)}${p(now.getDate())}-${p(now.getHours())}${p(now.getMinutes())}${p(now.getSeconds())}`;
+}
+export class RebuildController {
+    ctx;
+    cfg;
+    stores;
+    db;
+    runner;
+    logger;
+    live;
+    status = idleStatus();
+    chunks = [];
+    cancelRequested = false;
+    /** 快照时刻（收尾时按它区分重建产物与重建后新对话的记录）。 */
+    rebuildStartMs = 0;
+    constructor(ctx, cfg, stores, db, runner, logger, live) {
+        this.ctx = ctx;
+        this.cfg = cfg;
+        this.stores = stores;
+        this.db = db;
+        this.runner = runner;
+        this.logger = logger;
+        this.live = live;
+    }
+    /** 状态快照（idle 时附带实时 L0 预估，供确认弹窗显示成本）。 */
+    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, this.cfg.llm.maxInputChars),
+            };
+        }
+        return { ...this.status };
+    }
+    /** 内存中尚未处理的会话快照块数（收尾后应为 0——快照即弃，诊断/冒烟用）。 */
+    get chunkCount() {
+        return this.chunks.length;
+    }
+    /** 启动重建（校验后入队准备任务；真正的清库/归档在管线队列里串行执行，避开并发竞态）。 */
+    start() {
+        if (this.status.running)
+            throw new Error('重建已在进行中');
+        const est = this.db.l0RebuildEstimate();
+        if (est.messages === 0)
+            throw new Error('L0 无任何消息，无需重建');
+        this.cancelRequested = false;
+        this.chunks = [];
+        this.status = {
+            ...idleStatus(),
+            running: true,
+            phase: 'preparing',
+            sessionCount: est.sessions,
+            messageCount: est.messages,
+            estCalls: estimateCalls(est.sessions, est.messages, est.chars, this.cfg.llm.maxInputChars),
+            startedAt: Date.now(),
+        };
+        this.runner.enqueueRebuildTask(() => this.prepare());
+        this.logger.info(`[memory] 重建开始：${est.sessions} 个会话 / ${est.messages} 条 L0 消息（预计 ≥${this.status.estCalls} 次抽取调用）`);
+        return { ...this.status };
+    }
+    /** 请求取消：当前块完成后停止，已重建部分保留并照常收尾 L2/L3。 */
+    requestCancel() {
+        if (!this.status.running)
+            return this.getStatus();
+        this.cancelRequested = true;
+        this.status.cancelRequested = true;
+        this.logger.info('[memory] 重建取消已请求（当前块完成后停止）');
+        return { ...this.status };
+    }
+    async prepare() {
+        try {
+            // 快照：从检索库读全量 L0（事务一致；重建期间新捕获的消息走正常轮次，天然不重不漏）
+            this.rebuildStartMs = Date.now();
+            this.chunks = groupL0Sessions(this.db.listL0All());
+            if (this.chunks.length === 0) {
+                this.finish('failed', 'L0 快照为空');
+                return;
+            }
+            this.status.total = this.chunks.length;
+            // 归档旧派生层（改名不硬删；任一失败即终止——半清半留会破坏"全量重导"语义）
+            const archiveNote = await this.archiveDerived();
+            this.status.archiveNote = archiveNote ?? null;
+            // 清检索库 + 重置 checkpoint；归档后重建空目录（records/ 由 appendNew 自动重建）
+            if (!this.db.clearL1())
+                throw new Error('L1 检索库清空失败');
+            this.stores.state.reset();
+            await this.stores.state.save();
+            await Promise.all([
+                this.stores.scenes.chat.init(),
+                this.stores.scenes.work.init(),
+                this.stores.persona.chat.init(),
+                this.stores.persona.work.init(),
+            ]);
+            this.status.phase = 'distilling';
+            this.logger.info(`[memory] 重建准备完成（归档：${archiveNote ?? '无旧产物'}，${this.chunks.length} 个会话块）`);
+            this.scheduleChunk(0);
+        }
+        catch (err) {
+            this.finish('failed', `准备阶段失败: ${errDetail(err)}`);
+        }
+    }
+    /** 分块链：一次只挂一个重建块，跑完再挂下一块——正常轮次可随时插队。 */
+    scheduleChunk(i) {
+        if (this.cancelRequested || i >= this.chunks.length) {
+            this.runner.enqueueRebuildTask(() => this.finalize());
+            return;
+        }
+        const chunk = this.chunks[i];
+        this.runner.enqueueRebuildTask(async () => {
+            // 入队后开跑前可能已收到取消（等待插队的正常轮次期间），直接跳到收尾
+            if (this.cancelRequested) {
+                this.runner.enqueueRebuildTask(() => this.finalize());
+                return;
+            }
+            try {
+                const n = await this.runner.runRebuildTurn(chunk.sessionId, chunk.messages);
+                this.status.recordsBuilt += n;
+            }
+            catch (err) {
+                this.logger.warn(`[memory] 重建块失败（session=${chunk.sessionId}，跳过继续）: ${errDetail(err)}`);
+            }
+            this.status.done = i + 1;
+            this.scheduleChunk(i + 1);
+        });
+    }
+    async finalize() {
+        try {
+            this.status.phase = 'finalizing';
+            const cfg = effectiveCfg(this.cfg, this.live);
+            const liveNow = this.live.get();
+            const distillOn = liveNow.enabled && liveNow.distill;
+            // 强制 L2：把重建窗口内该族尚未整合的残余记录补一轮（正常轮次语义里差几条
+            // 不触发是常态，但"重建"应把已有记录全部落进场景）
+            if (cfg.l2.enabled && distillOn) {
+                for (const family of ['chat', 'work']) {
+                    const fstate = this.runner.states[family];
+                    if (fstate.newMemoriesSinceL2 <= 0)
+                        continue;
+                    const leftovers = this.collectRebuildRecords(family);
+                    if (leftovers.length === 0)
+                        continue;
+                    try {
+                        const t = Date.now();
+                        const result = await runSceneConsolidation(this.ctx, cfg, this.stores.scenes[family], leftovers, this.logger, family);
+                        fstate.lastL2At = Date.now();
+                        fstate.newMemoriesSinceL2 = 0;
+                        if (result.personaRequestedReason)
+                            fstate.personaRequestedReason = result.personaRequestedReason;
+                        this.logger.info(`[memory] 重建收尾 L2 完成（family=${family}，${Date.now() - t}ms，${leftovers.length} 条残余记录）`);
+                    }
+                    catch (err) {
+                        this.logger.warn(`[memory] 重建收尾 L2 失败（family=${family}）: ${errDetail(err)}`);
+                    }
+                }
+            }
+            // 强制 L3：checkpoint 已重置（hasPersona=false）→ 冷启动触发；无场景的族跳过
+            if (cfg.l3.enabled && distillOn) {
+                for (const family of ['chat', 'work']) {
+                    try {
+                        const scenes = await this.stores.scenes[family].list();
+                        if (scenes.length === 0)
+                            continue;
+                        await runPersona(this.ctx, cfg, this.stores.scenes[family], this.stores.persona[family], this.runner.states[family], this.logger, family);
+                    }
+                    catch (err) {
+                        this.logger.warn(`[memory] 重建收尾 L3 失败（family=${family}）: ${errDetail(err)}`);
+                    }
+                }
+            }
+            await this.stores.state.save();
+            this.finish(this.cancelRequested ? 'cancelled' : 'done', null);
+        }
+        catch (err) {
+            this.finish('failed', `收尾失败: ${errDetail(err)}`);
+        }
+    }
+    /**
+     * 收集重建窗口内某族的记录：重建产物全部是新插入（updated==created），
+     * 按 updated_time 倒序翻页、越过 rebuildStartMs 即停。
+     */
+    collectRebuildRecords(family) {
+        const out = [];
+        const PAGE = 200;
+        for (let offset = 0;; offset += PAGE) {
+            const { items } = this.stores.l1.list({ family, limit: PAGE, offset });
+            if (items.length === 0)
+                break;
+            let beyond = 0;
+            for (const r of items) {
+                if (r.createdAt >= this.rebuildStartMs)
+                    out.push(r);
+                else
+                    beyond++;
+            }
+            if (beyond > 0 || items.length < PAGE)
+                break;
+        }
+        return out;
+    }
+    finish(phase, error) {
+        this.status.running = false;
+        this.status.phase = phase;
+        this.status.error = error;
+        this.status.finishedAt = Date.now();
+        // 快照即弃：全量 L0 消息（可能几十 MB）在重建结束/取消/失败后必须释放，
+        // 不能滞留到下一次 start() 覆盖（M6——宿主长跑内存只增不减）
+        this.chunks = [];
+        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}` : ''));
+    }
+    /** 归档旧派生层：records/ scenes/ persona-*.md 改名 .bak.<ts>。不存在则跳过。 */
+    async archiveDerived() {
+        const dataDir = resolveDataDir(this.cfg);
+        const ts = stamp();
+        const items = [
+            [path.join(dataDir, 'records'), path.join(dataDir, `records.bak.${ts}`)],
+            [path.join(dataDir, 'scenes'), path.join(dataDir, `scenes.bak.${ts}`)],
+            [path.join(dataDir, 'persona-chat.md'), path.join(dataDir, `persona-chat.md.bak.${ts}`)],
+            [path.join(dataDir, 'persona-work.md'), path.join(dataDir, `persona-work.md.bak.${ts}`)],
+        ];
+        const archived = [];
+        for (const [from, to] of items) {
+            try {
+                await fs.access(from);
+            }
+            catch {
+                continue;
+            }
+            await fs.rename(from, to);
+            archived.push(path.basename(to));
+        }
+        return archived.length > 0 ? archived.join(', ') : undefined;
+    }
+}

package/dist/pipeline/runner.d.ts

@@ -4,9 +4,15 @@
  *
  * 会话档位：enqueue 带 mode（off 在捕获侧已被拦截）；L1 待重试缓冲按档分桶；
  * L2/L3 按记录族各自跑各自的场景/画像存储与阈值计数（分族隔离不变量）。
+ *
+ * 调度：内部是带优先级的任务列表——正常对话轮次（live）优先于重建分块（rebuild），
+ * 重建期间用户照常聊天，新轮次的蒸馏最多等一个重建块。任务串行，同一时刻至多一个在跑。
+ *
+ * 未蒸馏缓冲：pending 三桶持久化在 pending.json，进程重启不丢；init 恢复后延迟补跑一次
+ * （受 live 开关与 minMessages 阈值约束，失败维持"等下一轮同档对话"的现状语义）。
  */
 import type { Context } from '@deepseek-ai/cordis';
-import type { MemoryConfig } from '../config.js';
+import { type MemoryConfig } from '../config.js';
 import type { LiveSettingsHandle } from '../settings.js';
 import type { L0Store } from '../store/l0.js';
 import type { L1Store } from '../store/l1.js';
@@ -14,6 +20,7 @@ import type { PersonaStore } from '../store/persona.js';
 import type { SceneStore } from '../store/scenes.js';
 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;
     l1: L1Store;
@@ -21,24 +28,55 @@ export interface MemoryStores {
     persona: Record<MemoryFamily, PersonaStore>;
     state: StateStore;
 }
+/** 管线任务（优先级调度：live 优先于 rebuild）。 */
+export interface PipelineTask {
+    kind: 'live' | 'rebuild';
+    run: () => Promise<unknown>;
+}
+/** 选取下一个要执行的任务下标：最早的 live 优先，否则队首（rebuild 分块让位）。 */
+export declare function pickNextTaskIndex(tasks: PipelineTask[]): number;
+/**
+ * 运行时调参视图：UI 选择器可临时覆盖蒸馏思考档位（空串回退静态 config 默认）。
+ * 浅拷贝只覆盖 llm 一层，其余键与原 cfg 共享只读引用；pipeline 全链继续收 cfg，无需感知。
+ */
+export declare function effectiveCfg(cfg: MemoryConfig, live: LiveSettingsHandle): MemoryConfig;
 export declare class MemoryRunner {
     private readonly ctx;
     private readonly cfg;
     private readonly stores;
     private readonly logger;
     private readonly live;
-    private queue;
+    private tasks;
+    private draining;
+    /** 停止标志（dispose 序置位）：不再取新任务；进行中任务自然收尾，其 DB 写入失败由各层兜底捕获。 */
+    private stopped;
     private pending;
+    private readonly pendingFile;
     private background;
-    private states;
+    /** 分族 checkpoint（init 后可用；重建收尾也从这里读活引用）。 */
+    states: FamilyStates;
     private afterRun;
     constructor(ctx: Context, cfg: MemoryConfig, stores: MemoryStores, logger: MemoryLogger, live: LiveSettingsHandle);
     init(): Promise<void>;
+    /** 启动补跑：对每个非空桶入队一次蒸馏尝试（受 live 开关与阈值约束，失败不无限重试）。 */
+    private scheduleStartupRetry;
     /** L1 抽取待重试的消息条数（状态面板用）。 */
     get pendingCount(): number;
     /** 管线跑完一轮后的回调（用于召回缓存失效）。 */
     setAfterRun(fn: () => void): void;
-    /** 一轮对话结束后入队（L0 落盘 + 蒸馏触发判定）。 */
+    /** 一轮对话结束后入队（L0 落盘由 capture 在 turn/end 即时完成，不排蒸馏队列）。 */
     enqueue(sessionId: string, messages: ConversationMessage[], mode: ExtractMode): void;
+    /** 重建任务入队（低优先级：让位于正常轮次；由 RebuildController 分块驱动）。 */
+    enqueueRebuildTask(run: () => Promise<unknown>): void;
+    /** 重建蒸馏轮：统一 auto 档，不受缓冲 200 上限（历史会话全量入桶，由 char 预算分块）。 */
+    runRebuildTurn(sessionId: string, messages: ConversationMessage[]): Promise<number>;
+    /** 停止取新任务（插件 dispose 序调用；进行中任务照常跑完但不 await——LLM 慢调用不拖住宿主卸载）。 */
+    stop(): void;
+    private pushTask;
+    private drain;
+    /** 缓冲落盘（每次蒸馏尝试后调用；失败只告警不阻断管线）。
+     *  非重建轮持久化前按桶截断到上限：重建取消后的大桶不至于在后续每次
+     *  蒸馏尝试时反复整量序列化落盘（多 MB 级 IO）；重建轮豁免维持。 */
+    private persistPending;
     private runTurn;
 }

package/dist/pipeline/runner.js

@@ -1,16 +1,43 @@
+import { resolveDataDir } from '../config.js';
+import { emptyPending, loadPending, PENDING_MODES, pendingPathFor, savePending } from '../store/pending.js';
+import { errDetail } from '../util/filelog.js';
 import { runExtraction } from './l1.js';
 import { runSceneConsolidation } from './l2.js';
 import { runPersona } from './l3.js';
-import { errDetail } from '../util/filelog.js';
+/** 选取下一个要执行的任务下标：最早的 live 优先，否则队首（rebuild 分块让位）。 */
+export function pickNextTaskIndex(tasks) {
+    for (let i = 0; i < tasks.length; i++) {
+        if (tasks[i].kind === 'live')
+            return i;
+    }
+    return 0;
+}
+/**
+ * 运行时调参视图：UI 选择器可临时覆盖蒸馏思考档位（空串回退静态 config 默认）。
+ * 浅拷贝只覆盖 llm 一层，其余键与原 cfg 共享只读引用；pipeline 全链继续收 cfg，无需感知。
+ */
+export function effectiveCfg(cfg, live) {
+    const eff = live.get().reasoningEffort;
+    return eff ? { ...cfg, llm: { ...cfg.llm, reasoningEffort: eff } } : cfg;
+}
+/** 单桶堆积上限（防无限堆积；重建分块不受限——历史会话需全量入桶蒸馏）。 */
+const PENDING_BUCKET_CAP = 200;
+/** 启动补跑延迟：避开宿主启动期忙乱。 */
+const STARTUP_RETRY_DELAY_MS = 20_000;
 export class MemoryRunner {
     ctx;
     cfg;
     stores;
     logger;
     live;
-    queue = Promise.resolve();
-    pending = { auto: [], chat: [], work: [] };
+    tasks = [];
+    draining = false;
+    /** 停止标志（dispose 序置位）：不再取新任务；进行中任务自然收尾，其 DB 写入失败由各层兜底捕获。 */
+    stopped = false;
+    pending = emptyPending();
+    pendingFile;
     background = [];
+    /** 分族 checkpoint（init 后可用；重建收尾也从这里读活引用）。 */
     states;
     afterRun;
     constructor(ctx, cfg, stores, logger, live) {
@@ -19,6 +46,7 @@ export class MemoryRunner {
         this.stores = stores;
         this.logger = logger;
         this.live = live;
+        this.pendingFile = pendingPathFor(resolveDataDir(cfg));
     }
     async init() {
         await this.stores.state.load();
@@ -30,6 +58,33 @@ export class MemoryRunner {
             this.logger.info('[memory] state.json 已迁移为 v2 分族格式（旧数据归 chat 桶）');
             await this.stores.state.save();
         }
+        // 恢复未蒸馏缓冲（上次进程退出前未蒸馏的消息，含失败待重试与攒阈值中途的）
+        try {
+            const loaded = await loadPending(this.pendingFile, this.logger);
+            for (const key of PENDING_MODES) {
+                if (loaded[key].length > PENDING_BUCKET_CAP)
+                    loaded[key] = loaded[key].slice(-PENDING_BUCKET_CAP);
+            }
+            this.pending = loaded;
+            if (this.pendingCount > 0) {
+                this.logger.info(`[memory] 未蒸馏缓冲已恢复 ${this.pendingCount} 条（auto=${this.pending.auto.length}/chat=${this.pending.chat.length}/work=${this.pending.work.length}），${STARTUP_RETRY_DELAY_MS / 1000}s 后自动补跑`);
+                this.scheduleStartupRetry();
+            }
+        }
+        catch (err) {
+            this.logger.warn(`[memory] 未蒸馏缓冲恢复失败（空桶起步）: ${errDetail(err)}`);
+        }
+    }
+    /** 启动补跑：对每个非空桶入队一次蒸馏尝试（受 live 开关与阈值约束，失败不无限重试）。 */
+    scheduleStartupRetry() {
+        const modes = PENDING_MODES.filter((m) => this.pending[m].length > 0);
+        this.ctx.effect(() => {
+            const timer = setTimeout(() => {
+                for (const mode of modes)
+                    this.enqueue('startup-retry', [], mode);
+            }, STARTUP_RETRY_DELAY_MS);
+            return () => clearTimeout(timer);
+        });
     }
     /** L1 抽取待重试的消息条数（状态面板用）。 */
     get pendingCount() {
@@ -39,32 +94,80 @@ export class MemoryRunner {
     setAfterRun(fn) {
         this.afterRun = fn;
     }
-    /** 一轮对话结束后入队（L0 落盘 + 蒸馏触发判定）。 */
+    /** 一轮对话结束后入队（L0 落盘由 capture 在 turn/end 即时完成，不排蒸馏队列）。 */
     enqueue(sessionId, messages, mode) {
-        this.queue = this.queue
-            .then(() => this.runTurn(sessionId, messages, mode))
-            .catch((err) => {
-            this.logger.warn(`[memory] 管线失败（已兜底）: ${errDetail(err)}`);
-        });
+        this.pushTask({ kind: 'live', run: () => this.runTurn(sessionId, messages, mode) });
+    }
+    /** 重建任务入队（低优先级：让位于正常轮次；由 RebuildController 分块驱动）。 */
+    enqueueRebuildTask(run) {
+        this.pushTask({ kind: 'rebuild', run });
+    }
+    /** 重建蒸馏轮：统一 auto 档，不受缓冲 200 上限（历史会话全量入桶，由 char 预算分块）。 */
+    runRebuildTurn(sessionId, messages) {
+        return this.runTurn(sessionId, messages, 'auto', { noBufferCap: true });
+    }
+    /** 停止取新任务（插件 dispose 序调用；进行中任务照常跑完但不 await——LLM 慢调用不拖住宿主卸载）。 */
+    stop() {
+        this.stopped = true;
+    }
+    pushTask(task) {
+        if (this.stopped)
+            return;
+        this.tasks.push(task);
+        void this.drain();
+    }
+    async drain() {
+        if (this.draining)
+            return;
+        this.draining = true;
+        try {
+            while (!this.stopped && this.tasks.length > 0) {
+                const [task] = this.tasks.splice(pickNextTaskIndex(this.tasks), 1);
+                try {
+                    await task.run();
+                }
+                catch (err) {
+                    this.logger.warn(`[memory] 管线失败（已兜底）: ${errDetail(err)}`);
+                }
+            }
+        }
+        finally {
+            this.draining = false;
+        }
     }
-    async runTurn(sessionId, messages, mode) {
+    /** 缓冲落盘（每次蒸馏尝试后调用；失败只告警不阻断管线）。
+     *  非重建轮持久化前按桶截断到上限：重建取消后的大桶不至于在后续每次
+     *  蒸馏尝试时反复整量序列化落盘（多 MB 级 IO）；重建轮豁免维持。 */
+    async persistPending(noBufferCap = false) {
+        try {
+            if (!noBufferCap) {
+                for (const key of PENDING_MODES) {
+                    const bucket = this.pending[key];
+                    if (bucket.length > PENDING_BUCKET_CAP)
+                        this.pending[key] = bucket.slice(-PENDING_BUCKET_CAP);
+                }
+            }
+            await savePending(this.pendingFile, this.pending);
+        }
+        catch (err) {
+            this.logger.warn(`[memory] 未蒸馏缓冲落盘失败: ${errDetail(err)}`);
+        }
+    }
+    async runTurn(sessionId, messages, mode, opts) {
         const turnStart = Date.now();
         this.logger.info(`[memory] 蒸馏管线开始（session=${sessionId}，mode=${mode}，本轮 ${messages.length} 条消息，待重试 ${this.pendingCount} 条）`);
         // ── L0：原始对话已由 capture 在 turn/end 即时落盘（不排蒸馏队列，防慢 LLM 阻塞/退出丢消息） ──
-        // ── 运行时调参视图：UI 选择器可临时覆盖蒸馏思考档位（空串回退静态 config 默认）。
-        // 浅拷贝只覆盖 llm 一层，其余键与 this.cfg 共享只读引用；pipeline 全链继续收 cfg，无需感知。 ──
-        const liveNow = this.live.get();
-        const cfg = liveNow.reasoningEffort
-            ? { ...this.cfg, llm: { ...this.cfg.llm, reasoningEffort: liveNow.reasoningEffort } }
-            : this.cfg;
+        const cfg = effectiveCfg(this.cfg, this.live);
         // ── L1：抽取 + 去重（按档分桶，失败按桶保留待重试） ──
         let newRecords = [];
+        const liveNow = this.live.get();
         const distillOn = liveNow.enabled && liveNow.distill;
         if (cfg.extract.enabled && distillOn) {
             const bucket = this.pending[mode];
             bucket.push(...messages);
-            if (bucket.length > 200)
-                bucket.splice(0, bucket.length - 200);
+            if (!opts?.noBufferCap && bucket.length > PENDING_BUCKET_CAP) {
+                bucket.splice(0, bucket.length - PENDING_BUCKET_CAP);
+            }
             try {
                 const t = Date.now();
                 const result = await runExtraction(this.ctx, cfg, this.stores.l1, this.states, bucket, this.background, this.logger, mode);
@@ -75,11 +178,11 @@ export class MemoryRunner {
                 this.logger.info(`[memory] L1 阶段完成（${Date.now() - t}ms）`);
             }
             catch (err) {
-                // 保留 pending，下次重试；但防止无限堆积
-                if (this.pending[mode].length > 200)
-                    this.pending[mode] = [];
+                // 保留 pending 下次重试（runTurn 入口已裁到 ≤200，防无限堆积；重建轮不裁，量被会话规模约束）
                 this.logger.warn(`[memory] L1 抽取失败（mode=${mode}，pending=${this.pending[mode].length}）: ${errDetail(err)}`);
             }
+            // 缓冲每次尝试后立即落盘：进程中途退出不丢待重试/攒阈值状态
+            await this.persistPending(opts?.noBufferCap);
             // L1 计数推进后立即落盘：L2/L3 失败或进程中途退出不得回滚阈值进度
             // （记录已入库但计数丢失会让该族 L2 永远差一截，state 与 DB 脱节）
             try {
@@ -134,5 +237,6 @@ export class MemoryRunner {
         }
         this.logger.info(`[memory] 蒸馏管线结束（本轮新增 ${newRecords.length} 条，总耗时 ${Date.now() - turnStart}ms）`);
         this.afterRun?.();
+        return newRecords.length;
     }
 }