dsh-layered-memory 0.5.4 → 0.6.1

package/dist/config.d.ts

@@ -72,6 +72,8 @@ export interface MemoryConfig {
         model: string;
         /** 单次蒸馏调用的输出 token 上限（推理模型的 reasoning 与正文共享该预算）。 */
         maxTokens: number;
+        /** 蒸馏调用的思考档位；空串不传（跟随模型默认）。 */
+        reasoningEffort: string;
         temperature: number;
         /** 单次蒸馏调用的用户 prompt 字符预算（≈token 数，按中文 1 字≈1 token 保守估算）。 */
         maxInputChars: number;
@@ -158,6 +160,7 @@ export declare const memorySchema: Schema<Schemastery.ObjectS<{
         provider: Schema<string, string>;
         model: Schema<string, string>;
         maxTokens: Schema<number, number>;
+        reasoningEffort: Schema<"" | "off" | "high" | "max", "" | "off" | "high" | "max">;
         temperature: Schema<number, number>;
         maxInputChars: Schema<number, number>;
         timeoutMs: Schema<number, number>;
@@ -165,6 +168,7 @@ export declare const memorySchema: Schema<Schemastery.ObjectS<{
         provider: Schema<string, string>;
         model: Schema<string, string>;
         maxTokens: Schema<number, number>;
+        reasoningEffort: Schema<"" | "off" | "high" | "max", "" | "off" | "high" | "max">;
         temperature: Schema<number, number>;
         maxInputChars: Schema<number, number>;
         timeoutMs: Schema<number, number>;
@@ -247,6 +251,7 @@ export declare const memorySchema: Schema<Schemastery.ObjectS<{
         provider: Schema<string, string>;
         model: Schema<string, string>;
         maxTokens: Schema<number, number>;
+        reasoningEffort: Schema<"" | "off" | "high" | "max", "" | "off" | "high" | "max">;
         temperature: Schema<number, number>;
         maxInputChars: Schema<number, number>;
         timeoutMs: Schema<number, number>;
@@ -254,6 +259,7 @@ export declare const memorySchema: Schema<Schemastery.ObjectS<{
         provider: Schema<string, string>;
         model: Schema<string, string>;
         maxTokens: Schema<number, number>;
+        reasoningEffort: Schema<"" | "off" | "high" | "max", "" | "off" | "high" | "max">;
         temperature: Schema<number, number>;
         maxInputChars: Schema<number, number>;
         timeoutMs: Schema<number, number>;

package/dist/config.js

@@ -50,7 +50,10 @@ export const memorySchema = Schema.object({
         provider: Schema.string().default(''),
         model: Schema.string().default(''),
         // 推理模型（如 v4-flash）的 reasoning 计入输出预算：预算不足会被思考吃光导致正文 0 字符
-        maxTokens: Schema.number().default(20_000),
+        maxTokens: Schema.number().default(256_000),
+        // 蒸馏是结构化抽取任务，默认关思考（off）：v4-flash 默认 high 档的思考可把任意 maxTokens
+        // 预算全部吃光导致正文 0 字符；非推理模型不认识 effort 时会报 UNSUPPORTED_REASONING_EFFORT，设空串跳过
+        reasoningEffort: Schema.union(['', 'off', 'high', 'max']).default('off'),
         temperature: Schema.number().default(0.3),
         // 模型上下文 1M token，日常压到 ~700k 使用（中文按 1 字≈1 token 保守折算）
         maxInputChars: Schema.number().default(700_000),

package/dist/index.d.ts

@@ -85,6 +85,7 @@ export declare const Config: import("@deepseek-ai/schemastery").default<Schemast
         provider: import("@deepseek-ai/schemastery").default<string, string>;
         model: import("@deepseek-ai/schemastery").default<string, string>;
         maxTokens: import("@deepseek-ai/schemastery").default<number, number>;
+        reasoningEffort: import("@deepseek-ai/schemastery").default<"" | "off" | "high" | "max", "" | "off" | "high" | "max">;
         temperature: import("@deepseek-ai/schemastery").default<number, number>;
         maxInputChars: import("@deepseek-ai/schemastery").default<number, number>;
         timeoutMs: import("@deepseek-ai/schemastery").default<number, number>;
@@ -92,6 +93,7 @@ export declare const Config: import("@deepseek-ai/schemastery").default<Schemast
         provider: import("@deepseek-ai/schemastery").default<string, string>;
         model: import("@deepseek-ai/schemastery").default<string, string>;
         maxTokens: import("@deepseek-ai/schemastery").default<number, number>;
+        reasoningEffort: import("@deepseek-ai/schemastery").default<"" | "off" | "high" | "max", "" | "off" | "high" | "max">;
         temperature: import("@deepseek-ai/schemastery").default<number, number>;
         maxInputChars: import("@deepseek-ai/schemastery").default<number, number>;
         timeoutMs: import("@deepseek-ai/schemastery").default<number, number>;
@@ -174,6 +176,7 @@ export declare const Config: import("@deepseek-ai/schemastery").default<Schemast
         provider: import("@deepseek-ai/schemastery").default<string, string>;
         model: import("@deepseek-ai/schemastery").default<string, string>;
         maxTokens: import("@deepseek-ai/schemastery").default<number, number>;
+        reasoningEffort: import("@deepseek-ai/schemastery").default<"" | "off" | "high" | "max", "" | "off" | "high" | "max">;
         temperature: import("@deepseek-ai/schemastery").default<number, number>;
         maxInputChars: import("@deepseek-ai/schemastery").default<number, number>;
         timeoutMs: import("@deepseek-ai/schemastery").default<number, number>;
@@ -181,6 +184,7 @@ export declare const Config: import("@deepseek-ai/schemastery").default<Schemast
         provider: import("@deepseek-ai/schemastery").default<string, string>;
         model: import("@deepseek-ai/schemastery").default<string, string>;
         maxTokens: import("@deepseek-ai/schemastery").default<number, number>;
+        reasoningEffort: import("@deepseek-ai/schemastery").default<"" | "off" | "high" | "max", "" | "off" | "high" | "max">;
         temperature: import("@deepseek-ai/schemastery").default<number, number>;
         maxInputChars: import("@deepseek-ai/schemastery").default<number, number>;
         timeoutMs: import("@deepseek-ai/schemastery").default<number, number>;

package/dist/index.js

@@ -21,6 +21,7 @@ import { memorySchema, resolveDataDir } from './config.js';
 import { registerCapture } from './hooks/capture.js';
 import { registerRecall } from './hooks/recall.js';
 import { MemoryRunner } from './pipeline/runner.js';
+import { RebuildController } from './pipeline/rebuild.js';
 import { registerMemoryRpc, PLUGIN_VERSION } from './stats.js';
 import { registerLiveSettings } from './settings.js';
 import { NoopEmbeddingService, RemoteEmbeddingService, } from './store/embedding.js';
@@ -220,6 +221,10 @@ export async function apply(ctx, config) {
     }
     const runner = new MemoryRunner(ctx, config, stores, logger, live);
     await runner.init();
+    // 重建控制器（存储降级时不建——RPC 端点走 supported=false 分支）
+    const rebuild = storageOk && !db.isDegraded()
+        ? new RebuildController(ctx, config, stores, db, runner, logger, live)
+        : undefined;
     if (storageOk) {
         registerCapture(ctx, config, runner, stores.l0, logger, live, modes);
     }
@@ -229,6 +234,6 @@ export async function apply(ctx, config) {
     registerMemoryRpc(ctx, config, stores, logger, {
         degraded: () => !storageOk || db.isDegraded(),
         pending: () => runner.pendingCount,
-    }, live, modes, dataDir);
+    }, live, modes, dataDir, rebuild);
     logger.info(`[memory] L0~L3 分层蒸馏记忆插件就绪（L1 记忆 ${storageOk ? stores.l1.size : 0} 条 | 捕获=${storageOk && config.capture.enabled} | 蒸馏=${storageOk && config.extract.enabled} | 召回=${config.recall.enabled}）`);
 }

package/dist/llm.js

@@ -1,4 +1,4 @@
-import { createUserMessage } from '@deepseek-ai/dsh-llm';
+import { createUserMessage, ReasoningEffortId } from '@deepseek-ai/dsh-llm';
 import { errDetail } from './util/filelog.js';
 /** 解析蒸馏用的 provider/model：配置优先，其次当前默认选择。 */
 export async function resolveModelRoute(ctx, cfg) {
@@ -35,6 +35,10 @@ export async function callLLM(ctx, cfg, opts) {
         messages: [createUserMessage({ content: [{ type: 'text', text: user }], source: { kind: 'user' } })],
         temperature: opts.temperature ?? cfg.llm.temperature,
         maxTokens: opts.maxTokens ?? cfg.llm.maxTokens,
+        // 默认 off：蒸馏是结构化抽取，high 思考可吃光全部输出预算致正文 0 字符；空串不传（非推理模型）
+        ...(cfg.llm.reasoningEffort
+            ? { reasoningEffort: ReasoningEffortId(cfg.llm.reasoningEffort) }
+            : {}),
         signal,
     });
     const startedAt = Date.now();

package/dist/pipeline/rebuild.d.ts

@@ -0,0 +1,78 @@
+import type { Context } from '@deepseek-ai/cordis';
+import { type MemoryConfig } from '../config.js';
+import type { L1Store } from '../store/l1.js';
+import type { PersonaStore } from '../store/persona.js';
+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 MemoryRunner } from './runner.js';
+/** 重建所需的存储子集（l0 不需要——快照直接走 db）。 */
+export interface RebuildStores {
+    l1: L1Store;
+    scenes: Record<MemoryFamily, SceneStore>;
+    persona: Record<MemoryFamily, PersonaStore>;
+    state: StateStore;
+}
+export type RebuildPhase = 'idle' | 'preparing' | 'distilling' | 'finalizing' | 'done' | 'cancelled' | 'failed';
+export interface RebuildStatus {
+    running: boolean;
+    phase: RebuildPhase;
+    /** 已完成的会话块数 / 总块数。 */
+    done: number;
+    total: number;
+    /** L0 体量（idle 时为实时预估，运行中为快照值）。 */
+    sessionCount: number;
+    messageCount: number;
+    /** 预计 LLM 抽取调用次数（下界估算：块数与字符预算取大）。 */
+    estCalls: number;
+    /** 重建产出的 L1 记录累计条数。 */
+    recordsBuilt: number;
+    cancelRequested: boolean;
+    startedAt: number | null;
+    finishedAt: number | null;
+    error: string | null;
+    /** 归档产物名（提示用户可手工找回）。 */
+    archiveNote: string | null;
+}
+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;
+export declare class RebuildController {
+    private readonly ctx;
+    private readonly cfg;
+    private readonly stores;
+    private readonly db;
+    private readonly runner;
+    private readonly logger;
+    private readonly live;
+    private status;
+    private chunks;
+    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 预估，供确认弹窗显示成本）。 */
+    getStatus(): RebuildStatus;
+    /** 启动重建（校验后入队准备任务；真正的清库/归档在管线队列里串行执行，避开并发竞态）。 */
+    start(): RebuildStatus;
+    /** 请求取消：当前块完成后停止，已重建部分保留并照常收尾 L2/L3。 */
+    requestCancel(): RebuildStatus;
+    private prepare;
+    /** 分块链：一次只挂一个重建块，跑完再挂下一块——正常轮次可随时插队。 */
+    private scheduleChunk;
+    private finalize;
+    /**
+     * 收集重建窗口内某族的记录：重建产物全部是新插入（updated==created），
+     * 按 updated_time 倒序翻页、越过 rebuildStartMs 即停。
+     */
+    private collectRebuildRecords;
+    private finish;
+    /** 归档旧派生层：records/ scenes/ persona-*.md 改名 .bak.<ts>。不存在则跳过。 */
+    private archiveDerived;
+}

package/dist/pipeline/rebuild.js

@@ -0,0 +1,300 @@
+/**
+ * 重建控制器：从 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 };
+    }
+    /** 启动重建（校验后入队准备任务；真正的清库/归档在管线队列里串行执行，避开并发竞态）。 */
+    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();
+        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,49 @@ 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;
     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>;
+    private pushTask;
+    private drain;
+    /** 缓冲落盘（每次蒸馏尝试后调用；失败只告警不阻断管线）。 */
+    private persistPending;
     private runTurn;
 }