dsh-layered-memory 0.5.4 → 0.6.1

package/dist/pipeline/runner.js

@@ -1,16 +1,41 @@
+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;
+    pending = emptyPending();
+    pendingFile;
     background = [];
+    /** 分族 checkpoint（init 后可用；重建收尾也从这里读活引用）。 */
     states;
     afterRun;
     constructor(ctx, cfg, stores, logger, live) {
@@ -19,6 +44,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 +56,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,41 +92,82 @@ 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 });
     }
-    async runTurn(sessionId, messages, mode) {
+    pushTask(task) {
+        this.tasks.push(task);
+        void this.drain();
+    }
+    async drain() {
+        if (this.draining)
+            return;
+        this.draining = true;
+        try {
+            while (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 persistPending() {
+        try {
+            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 阻塞/退出丢消息） ──
+        const cfg = effectiveCfg(this.cfg, this.live);
         // ── L1：抽取 + 去重（按档分桶，失败按桶保留待重试） ──
         let newRecords = [];
-        const distillOn = this.live.get().enabled && this.live.get().distill;
-        if (this.cfg.extract.enabled && distillOn) {
+        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, this.cfg, this.stores.l1, this.states, bucket, this.background, this.logger, mode);
+                const result = await runExtraction(this.ctx, cfg, this.stores.l1, this.states, bucket, this.background, this.logger, mode);
                 if (!result.skipped)
                     this.pending[mode] = [];
-                this.background = [...this.background.slice(-this.cfg.extract.backgroundMessages), ...messages];
+                this.background = [...this.background.slice(-cfg.extract.backgroundMessages), ...messages];
                 newRecords = result.newRecords;
                 this.logger.info(`[memory] L1 阶段完成（${Date.now() - t}ms）`);
             }
             catch (err) {
-                // 保留 pending，下次重试；但防止无限堆积
-                if (this.pending[mode].length > 200)
+                // 保留 pending，下次重试；但防止无限堆积（重建轮不限，量被会话规模天然约束）
+                if (!opts?.noBufferCap && this.pending[mode].length > PENDING_BUCKET_CAP)
                     this.pending[mode] = [];
                 this.logger.warn(`[memory] L1 抽取失败（mode=${mode}，pending=${this.pending[mode].length}）: ${errDetail(err)}`);
             }
+            // 缓冲每次尝试后立即落盘：进程中途退出不丢待重试/攒阈值状态
+            await this.persistPending();
             // L1 计数推进后立即落盘：L2/L3 失败或进程中途退出不得回滚阈值进度
             // （记录已入库但计数丢失会让该族 L2 永远差一截，state 与 DB 脱节）
             try {
@@ -84,16 +178,16 @@ export class MemoryRunner {
             }
         }
         // ── L2/L3：按记录族各自判定与执行 ──
-        if (this.cfg.l2.enabled && distillOn) {
+        if (cfg.l2.enabled && distillOn) {
             for (const family of ['chat', 'work']) {
                 const familyRecords = newRecords.filter((r) => (r.family ?? 'chat') === family);
                 if (familyRecords.length === 0)
                     continue;
                 const fstate = this.states[family];
-                if (fstate.newMemoriesSinceL2 >= this.cfg.l2.minNewMemories) {
+                if (fstate.newMemoriesSinceL2 >= cfg.l2.minNewMemories) {
                     try {
                         const t = Date.now();
-                        const result = await runSceneConsolidation(this.ctx, this.cfg, this.stores.scenes[family], familyRecords, this.logger, family);
+                        const result = await runSceneConsolidation(this.ctx, cfg, this.stores.scenes[family], familyRecords, this.logger, family);
                         fstate.lastL2At = Date.now();
                         fstate.newMemoriesSinceL2 = 0;
                         if (result.personaRequestedReason)
@@ -105,14 +199,14 @@ export class MemoryRunner {
                     }
                 }
                 else {
-                    this.logger.debug?.(`[memory] L2 跳过（family=${family}，本族新增 ${familyRecords.length} 条，累计未整合 ${fstate.newMemoriesSinceL2}/${this.cfg.l2.minNewMemories}）`);
+                    this.logger.debug?.(`[memory] L2 跳过（family=${family}，本族新增 ${familyRecords.length} 条，累计未整合 ${fstate.newMemoriesSinceL2}/${cfg.l2.minNewMemories}）`);
                 }
             }
         }
-        if (this.cfg.l3.enabled && distillOn) {
+        if (cfg.l3.enabled && distillOn) {
             for (const family of ['chat', 'work']) {
                 try {
-                    await runPersona(this.ctx, this.cfg, this.stores.scenes[family], this.stores.persona[family], this.states[family], this.logger, family);
+                    await runPersona(this.ctx, cfg, this.stores.scenes[family], this.stores.persona[family], this.states[family], this.logger, family);
                 }
                 catch (err) {
                     this.logger.warn(`[memory] L3 画像蒸馏失败（family=${family}）: ${errDetail(err)}`);
@@ -128,5 +222,6 @@ export class MemoryRunner {
         }
         this.logger.info(`[memory] 蒸馏管线结束（本轮新增 ${newRecords.length} 条，总耗时 ${Date.now() - turnStart}ms）`);
         this.afterRun?.();
+        return newRecords.length;
     }
 }

package/dist/settings.d.ts

@@ -6,6 +6,8 @@
 import type { Context } from '@deepseek-ai/cordis';
 import Schema from '@deepseek-ai/schemastery';
 import type { MemoryLogger } from './types.js';
+/** 蒸馏思考档位可选项：'' = 跟随静态 config（部署默认）。 */
+export type EffortChoice = '' | 'off' | 'high' | 'max';
 export interface MemoryLiveSettings {
     /** 总开关：关 = 捕获/蒸馏/召回注入全停（数据保留） */
     enabled: boolean;
@@ -15,6 +17,8 @@ export interface MemoryLiveSettings {
     distill: boolean;
     /** 召回注入（画像/记忆上下文） */
     recall: boolean;
+    /** 蒸馏思考档位运行时覆盖：'' = 跟随静态 config（llm.reasoningEffort） */
+    reasoningEffort: EffortChoice;
 }
 export interface LiveSettingsHandle {
     /** settings 服务是否可用（不可用时 UI 侧隐藏开关面板） */

package/dist/settings.js

@@ -1,13 +1,14 @@
 import Schema from '@deepseek-ai/schemastery';
 import { settingsNamespace } from '@deepseek-ai/dsh-settings';
 const NS = settingsNamespace('dsh-memory');
-const ALWAYS_ON = { enabled: true, capture: true, distill: true, recall: true };
+const ALWAYS_ON = { enabled: true, capture: true, distill: true, recall: true, reasoningEffort: '' };
 export function liveSettingsSchema() {
     return Schema.object({
         enabled: Schema.boolean().default(true),
         capture: Schema.boolean().default(true),
         distill: Schema.boolean().default(true),
         recall: Schema.boolean().default(true),
+        reasoningEffort: Schema.union(['', 'off', 'high', 'max']).default(''),
     });
 }
 export function registerLiveSettings(ctx, logger) {
@@ -27,7 +28,8 @@ export function registerLiveSettings(ctx, logger) {
             scope.watch((next) => {
                 const prev = current;
                 current = resolveSettings(next);
-                logger.info(`[memory] 记忆模式开关更新：总=${current.enabled} 捕获=${current.capture} 蒸馏=${current.distill} 召回=${current.recall}（此前 总=${prev.enabled}）`);
+                logger.info(`[memory] 记忆模式开关更新：总=${current.enabled} 捕获=${current.capture} 蒸馏=${current.distill} 召回=${current.recall}` +
+                    `，蒸馏思考=${current.reasoningEffort || '跟随配置'}（此前 总=${prev.enabled}）`);
             });
             inner = {
                 supported: true,
@@ -36,7 +38,8 @@ export function registerLiveSettings(ctx, logger) {
                     await scope.update(patch);
                 },
             };
-            logger.info(`[memory] 记忆模式开关就绪（settings 命名空间 dsh-memory，当前：总=${current.enabled} 捕获=${current.capture} 蒸馏=${current.distill} 召回=${current.recall}）`);
+            logger.info(`[memory] 记忆模式开关就绪（settings 命名空间 dsh-memory，当前：总=${current.enabled} 捕获=${current.capture} 蒸馏=${current.distill} 召回=${current.recall}` +
+                `，蒸馏思考=${current.reasoningEffort || '跟随配置'}）`);
             return true;
         }
         catch (err) {
@@ -64,10 +67,14 @@ function resolveSettings(value) {
     if (!value || typeof value !== 'object')
         return { ...ALWAYS_ON };
     const v = value;
+    const efforts = ['', 'off', 'high', 'max'];
     return {
         enabled: v.enabled !== false,
         capture: v.capture !== false,
         distill: v.distill !== false,
         recall: v.recall !== false,
+        reasoningEffort: typeof v.reasoningEffort === 'string' && efforts.includes(v.reasoningEffort)
+            ? v.reasoningEffort
+            : '',
     };
 }

package/dist/stats.d.ts

@@ -1,5 +1,6 @@
 import type { Context } from '@deepseek-ai/cordis';
 import { type MemoryConfig } from './config.js';
+import type { RebuildController } from './pipeline/rebuild.js';
 import type { LiveSettingsHandle } from './settings.js';
 import type { L0Store } from './store/l0.js';
 import type { L1Store } from './store/l1.js';
@@ -43,4 +44,4 @@ export declare function registerMemoryRpc(ctx: Context, cfg: MemoryConfig, store
     scenes: Record<MemoryFamily, SceneStore>;
     persona: Record<MemoryFamily, PersonaStore>;
     state: StateStore;
-}, logger: MemoryLogger, status?: MemoryStatusSource, live?: LiveSettingsHandle, modes?: SessionModeStore, dataDir?: string): void;
+}, logger: MemoryLogger, status?: MemoryStatusSource, live?: LiveSettingsHandle, modes?: SessionModeStore, dataDir?: string, rebuild?: RebuildController): void;

package/dist/stats.js

@@ -12,7 +12,7 @@ import { resolveDataDir } from './config.js';
 const require = createRequire(import.meta.url);
 export const PLUGIN_VERSION = require('../package.json').version;
 /** 注册状态 RPC（web 侧 connection 服务可选，缺失时跳过，不影响插件主体）。 */
-export function registerMemoryRpc(ctx, cfg, stores, logger, status, live, modes, dataDir) {
+export function registerMemoryRpc(ctx, cfg, stores, logger, status, live, modes, dataDir, rebuild) {
     /** 当前是否持有一段有效注册（dispose 完成后清空，允许服务重上线时重注册）。 */
     let holding = false;
     const tryRegister = () => {
@@ -34,6 +34,7 @@ export function registerMemoryRpc(ctx, cfg, stores, logger, status, live, modes,
                     modes,
                     dataDir: dataDir ?? resolveDataDir(cfg),
                     logger,
+                    rebuild,
                 });
                 return { ok: true, value };
             }
@@ -104,7 +105,7 @@ async function buildStats(cfg, stores, status) {
     };
 }
 async function handleEndpoint(endpoint, payload, deps) {
-    const { cfg, stores, status, live, modes, dataDir } = deps;
+    const { cfg, stores, status, live, modes, dataDir, rebuild } = deps;
     switch (endpoint) {
         case 'dsh-memory/stats':
             return buildStats(cfg, stores, status);
@@ -130,26 +131,41 @@ async function handleEndpoint(endpoint, payload, deps) {
             deps.logger.info(`[memory] 会话档位设置 session=${p.sessionId} mode=${p.mode}`);
             return { sessionId: p.sessionId, mode: p.mode };
         }
-        case 'dsh-memory/settings-get':
+        case 'dsh-memory/settings-get': {
+            const s = live?.get();
             return {
                 supported: live?.supported ?? false,
-                settings: live?.get() ?? { enabled: true, capture: true, distill: true, recall: true },
+                settings: s ?? { enabled: true, capture: true, distill: true, recall: true, reasoningEffort: '' },
                 // 静态部署上限（cordis.patch.yml）：运行时开关与它取 AND
                 ceilings: { capture: cfg.capture.enabled, distill: cfg.extract.enabled, recall: cfg.recall.enabled },
+                // 蒸馏思考档位：current 是运行时覆盖（'' = 跟随配置），effective 是实际生效值
+                effort: {
+                    current: s?.reasoningEffort ?? '',
+                    effective: s?.reasoningEffort || cfg.llm.reasoningEffort,
+                    fallback: cfg.llm.reasoningEffort,
+                },
             };
+        }
         case 'dsh-memory/settings-set': {
             if (!live)
                 throw new Error('开关通道未初始化');
             const patch = (payload ?? {});
-            const allowed = ['enabled', 'capture', 'distill', 'recall'];
             const clean = {};
-            for (const key of allowed) {
+            for (const key of ['enabled', 'capture', 'distill', 'recall']) {
                 if (typeof patch[key] === 'boolean')
                     clean[key] = patch[key];
             }
+            if (patch.reasoningEffort !== undefined) {
+                const v = String(patch.reasoningEffort);
+                if (!['', 'off', 'high', 'max'].includes(v)) {
+                    throw new Error(`非法思考档位: ${v}（允许 ''/off/high/max）`);
+                }
+                clean.reasoningEffort = v;
+            }
             if (Object.keys(clean).length === 0)
                 throw new Error('开关更新载荷为空');
             await live.update(clean);
+            deps.logger.info(`[memory] 设置更新：${JSON.stringify(clean)}`);
             return { ok: true, settings: live.get() };
         }
         case 'dsh-memory/list-records': {
@@ -200,6 +216,30 @@ async function handleEndpoint(endpoint, payload, deps) {
             const p = (payload ?? {});
             return { lines: readLogTail(join(dataDir, 'memory.log'), Math.min(Math.max(Number(p.lines) || 200, 1), 1000)) };
         }
+        case 'dsh-memory/rebuild-status': {
+            if (!rebuild)
+                return { supported: false, running: false, phase: 'idle' };
+            return rebuild.getStatus();
+        }
+        case 'dsh-memory/rebuild-start': {
+            if (!rebuild)
+                throw new Error('重建控制器未初始化（存储不可用）');
+            if (status?.degraded())
+                throw new Error('存储处于降级状态，无法重建');
+            const s = live?.get();
+            if (s && (!s.enabled || !s.distill))
+                throw new Error('蒸馏开关已关闭，请先开启蒸馏再重建');
+            if (!cfg.extract.enabled)
+                throw new Error('部署配置已停用蒸馏（extract.enabled=false），无法重建');
+            const result = rebuild.start();
+            deps.logger.info('[memory] 收到重建指令（设置页按钮）');
+            return result;
+        }
+        case 'dsh-memory/rebuild-cancel': {
+            if (!rebuild)
+                throw new Error('重建控制器未初始化');
+            return rebuild.requestCancel();
+        }
         default:
             throw new Error(`unknown endpoint: ${endpoint}`);
     }

package/dist/store/pending.d.ts

@@ -0,0 +1,15 @@
+import type { ConversationMessage, ExtractMode, MemoryLogger } from '../types.js';
+/** 三档蒸馏缓冲桶（off 在捕获侧已被拦截，永远不到这里）。 */
+export interface PendingBuckets {
+    auto: ConversationMessage[];
+    chat: ConversationMessage[];
+    work: ConversationMessage[];
+}
+export declare function emptyPending(): PendingBuckets;
+/** 读取缓冲文件：文件缺失/损坏 → 空桶（不抛出——丢了缓冲 L0 事实源仍在）。 */
+export declare function loadPending(file: string, logger?: MemoryLogger): Promise<PendingBuckets>;
+/** 全量原子落盘（每次蒸馏尝试后调用；桶有上限，量级为百条级）。 */
+export declare function savePending(file: string, buckets: PendingBuckets): Promise<void>;
+export declare function pendingPathFor(dataDir: string): string;
+/** 三档 key（调度/遍历用）。 */
+export declare const PENDING_MODES: readonly ExtractMode[];

package/dist/store/pending.js

@@ -0,0 +1,56 @@
+/**
+ * 未蒸馏缓冲持久化（pending.json）：
+ * 按档分桶的"已捕获但尚未成功蒸馏"消息——既包括抽取失败的待重试消息，
+ * 也包括攒够触发阈值之前的消息。跨重启不丢（CONTEXT.md「未蒸馏缓冲」）。
+ *
+ * 与 state.json / session-modes.json 同款原子写；读取宽容（坏行丢弃、坏文件空桶起步）。
+ */
+import * as path from 'node:path';
+import { atomicWriteJson, readJsonIfExists } from './io.js';
+export function emptyPending() {
+    return { auto: [], chat: [], work: [] };
+}
+function isMessage(m) {
+    if (!m || typeof m !== 'object')
+        return false;
+    const r = m;
+    return typeof r.id === 'string' && typeof r.content === 'string' && (r.role === 'user' || r.role === 'assistant');
+}
+/** 读取缓冲文件：文件缺失/损坏 → 空桶（不抛出——丢了缓冲 L0 事实源仍在）。 */
+export async function loadPending(file, logger) {
+    const out = emptyPending();
+    let raw;
+    try {
+        raw = await readJsonIfExists(file);
+    }
+    catch {
+        raw = undefined;
+    }
+    if (!raw || typeof raw !== 'object' || !raw.buckets || typeof raw.buckets !== 'object')
+        return out;
+    let dropped = 0;
+    for (const key of ['auto', 'chat', 'work']) {
+        const arr = raw.buckets[key];
+        if (!Array.isArray(arr))
+            continue;
+        for (const m of arr) {
+            if (isMessage(m))
+                out[key].push(m);
+            else
+                dropped++;
+        }
+    }
+    if (dropped > 0)
+        logger?.warn(`[memory] 未蒸馏缓冲文件含 ${dropped} 条坏记录，已丢弃`);
+    return out;
+}
+/** 全量原子落盘（每次蒸馏尝试后调用；桶有上限，量级为百条级）。 */
+export async function savePending(file, buckets) {
+    const payload = { version: 1, buckets };
+    await atomicWriteJson(file, payload);
+}
+export function pendingPathFor(dataDir) {
+    return path.join(dataDir, 'pending.json');
+}
+/** 三档 key（调度/遍历用）。 */
+export const PENDING_MODES = ['auto', 'chat', 'work'];

package/dist/store/sqlite.d.ts

@@ -75,6 +75,13 @@ export declare class MemoryDb {
     upsertL1(record: MemoryRecord, embedding?: Float32Array): boolean;
     /** 批量删除 L1（元数据 + 向量 + FTS），返回删除条数。 */
     deleteL1Batch(ids: string[]): number;
+    /**
+     * 清空 L1 检索库全部数据（重建用）。records/FTS 直接 DELETE；
+     * 向量表走 DROP + 重建（vec0 的全表 DELETE 语义不可靠，dropVectorTables
+     * 会连 l0_vec 一起删——L0 向量必须保留——故此处单独处理 l1_vec）。
+     * L0 表与 embedding_meta 不动：backfill 的行数比对天然重新一致。
+     */
+    clearL1(): boolean;
     countL1(): number;
     /** 全量读取（调试/迁移/重嵌入用；检索请走 FTS/向量）。 */
     getAllL1(): MemoryRecord[];
@@ -101,6 +108,14 @@ export declare class MemoryDb {
     countL0(): number;
     /** 统计 recorded_at >= iso 的消息数（状态面板"今日捕获"用）。 */
     countL0Since(iso: string): number;
+    /** L0 全量列举（重建快照用；按时间升序，事务一致性避开 JSONL 追加竞态）。 */
+    listL0All(): L0MessageRecord[];
+    /** 重建成本预估（一次全表聚合：会话数 / 消息数 / 字符量）。 */
+    l0RebuildEstimate(): {
+        sessions: number;
+        messages: number;
+        chars: number;
+    };
     /** 向量表行数（backfill 判据：与元数据行数的差值即缺失向量数；不可用时返回 -1）。 */
     countL1Vec(): number;
     countL0Vec(): number;

package/dist/store/sqlite.js

@@ -518,6 +518,46 @@ export class MemoryDb {
             return 0;
         }
     }
+    /**
+     * 清空 L1 检索库全部数据（重建用）。records/FTS 直接 DELETE；
+     * 向量表走 DROP + 重建（vec0 的全表 DELETE 语义不可靠，dropVectorTables
+     * 会连 l0_vec 一起删——L0 向量必须保留——故此处单独处理 l1_vec）。
+     * L0 表与 embedding_meta 不动：backfill 的行数比对天然重新一致。
+     */
+    clearL1() {
+        if (this.degraded)
+            return false;
+        try {
+            this.db.exec('BEGIN');
+            try {
+                this.db.exec('DELETE FROM l1_records');
+                if (this.ftsAvailable)
+                    this.db.exec('DELETE FROM l1_fts');
+                this.db.exec('COMMIT');
+            }
+            catch (err) {
+                try {
+                    this.db.exec('ROLLBACK');
+                }
+                catch {
+                    /* ignore */
+                }
+                throw err;
+            }
+            // vec0 全表 DELETE 语义不可靠 → DROP + 重建空表；放事务外（vtab DDL 事务性弱）。
+            // 中间态：向量行短暂孤儿——检索侧对缺 meta 的向量本就跳过（searchL1Vector 回查过滤）。
+            if (this.stmtDeleteL1Vec) {
+                this.db.exec('DROP TABLE IF EXISTS l1_vec');
+                this.prepareL1VecStatements();
+            }
+            this.logger?.info(`${TAG} L1 检索库已清空（重建）`);
+            return true;
+        }
+        catch (err) {
+            this.logger?.warn(`${TAG} L1 清空失败: ${err instanceof Error ? err.message : String(err)}`);
+            return false;
+        }
+    }
     countL1() {
         if (this.degraded)
             return 0;
@@ -724,6 +764,42 @@ export class MemoryDb {
             return 0;
         }
     }
+    /** L0 全量列举（重建快照用；按时间升序，事务一致性避开 JSONL 追加竞态）。 */
+    listL0All() {
+        if (this.degraded)
+            return [];
+        try {
+            const rows = this.db
+                .prepare('SELECT record_id, session_id, role, message_text, recorded_at, timestamp FROM l0_conversations ORDER BY timestamp ASC')
+                .all();
+            return rows.map((r) => ({
+                sessionId: r.session_id,
+                recordedAt: r.recorded_at,
+                id: r.record_id,
+                role: r.role,
+                content: r.message_text,
+                timestamp: r.timestamp ?? 0,
+            }));
+        }
+        catch (err) {
+            this.logger?.warn(`${TAG} L0 全量列举失败（返回空）: ${err instanceof Error ? err.message : String(err)}`);
+            return [];
+        }
+    }
+    /** 重建成本预估（一次全表聚合：会话数 / 消息数 / 字符量）。 */
+    l0RebuildEstimate() {
+        if (this.degraded)
+            return { sessions: 0, messages: 0, chars: 0 };
+        try {
+            const row = this.db
+                .prepare('SELECT COUNT(DISTINCT session_id) AS s, COUNT(*) AS n, COALESCE(SUM(LENGTH(message_text)), 0) AS c FROM l0_conversations')
+                .get();
+            return { sessions: row?.s ?? 0, messages: row?.n ?? 0, chars: row?.c ?? 0 };
+        }
+        catch {
+            return { sessions: 0, messages: 0, chars: 0 };
+        }
+    }
     /** 向量表行数（backfill 判据：与元数据行数的差值即缺失向量数；不可用时返回 -1）。 */
     countL1Vec() {
         if (this.degraded || !this.stmtSearchL1Vec)

package/dist/store/state.d.ts

@@ -30,6 +30,12 @@ export declare class StateStore {
     get didMigrate(): boolean;
     /** 取某族的 checkpoint（活引用——改字段后 save 生效）。 */
     forFamily(family: MemoryFamily): MemoryState;
+    /**
+     * 重建用：两族 checkpoint 重置为默认值。
+     * 必须原地突变（Object.assign）——runner.states 等处持有桶对象的活引用，
+     * 换新对象会让引用指向已废弃的桶，后续计数写到内存孤儿上。
+     */
+    reset(): void;
     save(): Promise<void>;
     static pathFor(dataDir: string): string;
 }

package/dist/store/state.js

@@ -52,6 +52,17 @@ export class StateStore {
     forFamily(family) {
         return this.buckets[family];
     }
+    /**
+     * 重建用：两族 checkpoint 重置为默认值。
+     * 必须原地突变（Object.assign）——runner.states 等处持有桶对象的活引用，
+     * 换新对象会让引用指向已废弃的桶，后续计数写到内存孤儿上。
+     */
+    reset() {
+        for (const family of ['chat', 'work']) {
+            Object.assign(this.buckets[family], defaultState());
+            this.buckets[family].personaRequestedReason = undefined;
+        }
+    }
     async save() {
         const file = { version: 2, families: this.buckets };
         await atomicWriteJson(this.file, file);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-layered-memory",
-  "version": "0.5.4",
+  "version": "0.6.1",
   "description": "L0~L3 分层蒸馏记忆插件 for DeepSeek Harness：自动捕获对话（L0）、抽取原子记忆（L1）、整合场景块（L2）、蒸馏核心画像/团队方法论（L3），并在模型步骤前自动召回注入。移植自 MemoryCore (TencentDB Agent Memory) 的管线设计。",
   "type": "module",
   "main": "dist/index.js",