dsh-layered-memory 0.6.0 → 0.6.1

package/README.md

@@ -27,6 +27,16 @@ L0 捕获 → L1 原子记忆 → L2 场景整合 → L3 画像蒸馏，模型
 管线原则：所有蒸馏调用复用 DSH 自身的 `ctx.llm`；任何阶段失败只记日志、绝不阻塞
 Agent 循环；召回注入用标签包裹、捕获侧自动剥离，防止反馈循环。
 
+**未蒸馏缓冲持久化**：抽取失败的待重试消息与攒触发阈值中途的消息都暂存在按档分桶的
+缓冲里（`pending.json`，每次蒸馏尝试后原子落盘）——重启不丢，启动 20 秒后自动补跑一次，
+失败则维持"等下一轮同档对话"的语义。
+
+**重建**（设置页 → 记忆 → 概览 → 重建记忆）：以 L0 原始对话为事实源重新推导全部派生层。
+旧 `records/`、`scenes/`、`persona-*.md` 整体归档（改名 `*.bak.<时间戳>`，不删除），检索库
+L1 清空、checkpoint 重置，随后按会话分块、统一 auto 档重蒸馏 L1→L2→L3（收尾强制跑一轮
+L2 残余 + L3 冷启动）。重建分块走低优先级队列——期间正常对话的蒸馏优先进行；带确认弹窗
+（会话数/消息数/预计调用数）、进度条与取消（已重建部分保留）。
+
 ### 会话级记忆档位
 
 每个会话可独立选择记忆档位，**写入与召回同档**：
@@ -134,7 +144,7 @@ npx tsc src/smoke.ts --outDir dist-smoke --module nodenext --moduleResolution no
 | `embedding.model` | 空 | embedding 模型名 |
 | `embedding.dimensions` | `0` | 向量维度（启用时必填，须与模型输出一致） |
 | `llm.provider/model` | 空 | 蒸馏模型覆盖（默认用当前默认选择） |
-| `llm.maxTokens` | `20000` | 单次蒸馏输出 token 上限（全阶段统一；推理模型的 reasoning 与正文共享该预算，过低会被思考吃光导致正文 0 字符） |
+| `llm.maxTokens` | `256000` | 单次蒸馏输出 token 上限（全阶段统一；推理模型的 reasoning 与正文共享该预算，过低会被思考吃光导致正文 0 字符） |
 | `llm.reasoningEffort` | `off` | 蒸馏思考档位（部署默认）：`off` / `high` / `max`，空串不传（跟随模型默认）。蒸馏是结构化抽取任务，默认关思考——推理模型（如 v4-flash）默认 high 档的思考可把任意输出预算全部吃光导致正文 0 字符；非推理模型不认识 effort 时需设为空串。运行时可在设置页 → 记忆 → 概览临时切换（选"跟随配置"即回退本值） |
 | `llm.temperature` | `0.3` | 蒸馏温度 |
 | `llm.maxInputChars` | `700000` | 单次蒸馏输入字符预算（超限的 L1 输入自动分块抽取） |
@@ -165,7 +175,9 @@ memory/
 ├── persona-chat.md        # L3 画像（chat 族：用户画像）
 ├── persona-work.md        # L3 画像（work 族：Team Operating Doctrine）
 ├── state.json             # 管线 checkpoint（v2 分族：families.chat / families.work）
+├── pending.json           # 未蒸馏缓冲（按档分桶；重启恢复 + 启动自动补跑）
 ├── session-modes.json     # 会话档位映射（sessionId → 档位，>90 天自动清理）
+├── records.bak.<ts>/      # 重建时归档的旧产物（scenes/persona 同款 *.bak.<ts>）
 └── memory.log             # 诊断日志（info+，超 2MB 轮转为 memory.log.1）
 ```
 

package/dist/client.js

@@ -492,8 +492,9 @@ window.__ModuleLoader__.load({
       );
     }
 
-    // ── auto 档边缘流光 + 浮层玻璃材质：inline style 放不了 @keyframes/@property/媒体查询，
-    // 惰性注入一次性样式表（id 防重复）。dsw 主题变量参考其前端令牌：暗色走 body[data-ds-dark-theme]。 ──
+    // ── auto 档边缘流光 + 浮层玻璃材质 + 重建面板样式：inline style 放不了
+    // @keyframes/@property/媒体查询，惰性注入一次性样式表（id 防重复）。
+    // dsw 主题变量参考其前端令牌：暗色走 body[data-ds-dark-theme]。 ──
     var FLOW_STYLE_ID = "dsh-mem-flow-style";
     function ensureFlowStyle() {
       if (document.getElementById(FLOW_STYLE_ID)) return;
@@ -548,6 +549,41 @@ window.__ModuleLoader__.load({
         "@media (prefers-reduced-transparency: reduce) {",
         "  .dsh-mem-glass { background: var(--dsw-alias-bg-layer-2, #ffffff); backdrop-filter: none; -webkit-backdrop-filter: none; }",
         "}",
+        // ── 重建面板（Light/Dark 双主题：基底用 dsw 真实令牌 bg-layer-2/border-l2，
+        //    暗色由 body[data-ds-dark-theme] 切换；强调红/进度蓝紫双主题各调一档） ──
+        ".dsh-mem-rb-card {",
+        "  border: 1px solid var(--dsw-alias-border-l2, #e5e7eb);",
+        "  border-radius: 10px;",
+        "  background: var(--dsw-alias-bg-layer-2, #ffffff);",
+        "  padding: 12px 14px;",
+        "  margin-bottom: 14px;",
+        "  font-size: 13px;",
+        "}",
+        ".dsh-mem-rb-btn {",
+        "  padding: 5px 14px; font-size: 13px; border-radius: 6px; cursor: pointer;",
+        "  border: 1px solid var(--dsw-alias-border-l2, #d0d7de);",
+        "  background: var(--dsw-alias-bg-layer-2, #ffffff);",
+        "  color: inherit;",
+        "}",
+        ".dsh-mem-rb-btn:disabled { opacity: 0.45; cursor: not-allowed; }",
+        ".dsh-mem-rb-danger { border-color: rgba(207,34,46,0.45); color: #cf222e; background: transparent; }",
+        "body[data-ds-dark-theme] .dsh-mem-rb-danger { color: #f4707b; border-color: rgba(244,112,123,0.5); }",
+        ".dsh-mem-rb-primary { background: #cf222e; border-color: #cf222e; color: #fff; }",
+        "body[data-ds-dark-theme] .dsh-mem-rb-primary { background: #b62324; border-color: #b62324; }",
+        ".dsh-mem-rb-bar { height: 8px; border-radius: 4px; overflow: hidden; flex: 1;",
+        "  background: var(--dsw-alias-border-l2, #e8ebef); }",
+        "body[data-ds-dark-theme] .dsh-mem-rb-bar { background: rgba(255,255,255,0.12); }",
+        ".dsh-mem-rb-fill { height: 100%; border-radius: 4px;",
+        "  background: linear-gradient(90deg, #0969da, #8250df); transition: width .4s ease; }",
+        ".dsh-mem-rb-overlay { position: fixed; inset: 0; background: rgba(0,0,0,0.35);",
+        "  display: flex; align-items: center; justify-content: center; z-index: 2000; }",
+        ".dsh-mem-rb-modal { width: 440px; max-width: calc(100vw - 48px); border-radius: 12px;",
+        "  padding: 18px 20px; font-size: 13px; line-height: 1.6;",
+        "  border: 1px solid var(--dsw-alias-border-l2, #e5e7eb);",
+        "  background: var(--dsw-alias-bg-layer-2, #ffffff);",
+        "  box-shadow: 0 16px 48px rgba(0,0,0,0.24); }",
+        "body[data-ds-dark-theme] .dsh-mem-rb-modal { box-shadow: 0 16px 48px rgba(0,0,0,0.6); }",
+        ".dsh-mem-rb-muted { font-size: 12px; color: var(--dsw-alias-label-caption, #6e7781); }",
       ].join("\n");
       document.head.appendChild(el);
     }
@@ -665,6 +701,188 @@ window.__ModuleLoader__.load({
       );
     }
 
+    // ── 重建面板：从 L0 重导 L1/L2/L3（确认弹窗 + 进度 + 取消；Light/Dark 双主题走 class） ──
+    var RB_PHASE_LABEL = {
+      preparing: "准备中（归档旧数据 · 清空检索库）",
+      distilling: "分块蒸馏中",
+      finalizing: "收尾（强制 L2 场景 + L3 画像）",
+    };
+
+    function RebuildPanel(props) {
+      var rpc = props.rpc;
+      var rbState = react.useState(null);
+      var rb = rbState[0];
+      var setRb = rbState[1];
+      var confirmState = react.useState(false);
+      var confirmOpen = confirmState[0];
+      var setConfirmOpen = confirmState[1];
+      var busyState = react.useState(false);
+      var busy = busyState[0];
+      var setBusy = busyState[1];
+      var errState = react.useState(null);
+      var rbError = errState[0];
+      var setRbError = errState[1];
+
+      var refresh = react.useCallback(function () {
+        rpc("dsh-memory/rebuild-status", {})
+          .then(function (r) {
+            if (r && r.ok) setRb(r.value);
+          })
+          .catch(function () {});
+      }, [rpc]);
+
+      react.useEffect(function () { refresh(); }, [refresh]);
+
+      // 运行中 1.5s 高频轮询进度；空闲不轮询（重新打开 Tab 时挂载刷新一次）
+      var running = !!(rb && rb.running);
+      react.useEffect(function () {
+        if (!running) return;
+        var timer = setInterval(refresh, 1500);
+        return function () { clearInterval(timer); };
+      }, [running, refresh]);
+
+      if (!rb || rb.supported === false) return null;
+      ensureFlowStyle();
+
+      var start = function () {
+        setBusy(true);
+        setRbError(null);
+        rpc("dsh-memory/rebuild-start", {})
+          .then(function (r) {
+            setBusy(false);
+            if (r && r.ok) {
+              setConfirmOpen(false);
+              setRb(r.value);
+            } else {
+              setRbError(r && r.error ? r.error.message : "启动失败");
+            }
+          })
+          .catch(function (e) {
+            setBusy(false);
+            setRbError(String((e && e.message) || e));
+          });
+      };
+      var cancel = function () {
+        setBusy(true);
+        rpc("dsh-memory/rebuild-cancel", {})
+          .then(function (r) {
+            setBusy(false);
+            if (r && r.ok) setRb(r.value);
+          })
+          .catch(function () {
+            setBusy(false);
+          });
+      };
+
+      var empty = !running && (rb.messageCount === 0 || rb.estCalls === 0);
+      var pct = rb.total > 0 ? Math.round((rb.done / rb.total) * 100) : 0;
+
+      var lastNote = null;
+      if (!running && rb.phase === "done") {
+        lastNote =
+          "上次重建：完成（" + rb.done + "/" + rb.total + " 会话，产出 " + rb.recordsBuilt + " 条记录）" +
+          (rb.finishedAt ? " · " + fmtTime(new Date(rb.finishedAt).toISOString()) : "");
+      } else if (!running && rb.phase === "cancelled") {
+        lastNote = "上次重建：已取消（完成 " + rb.done + "/" + rb.total + " 会话，已重建部分保留）";
+      } else if (!running && rb.phase === "failed") {
+        lastNote = "上次重建：失败 — " + (rb.error || "未知错误");
+      }
+
+      return react.createElement(
+        "div", { className: "dsh-mem-rb-card" },
+        react.createElement(
+          "div", { style: { display: "flex", alignItems: "center", gap: 10, flexWrap: "wrap" } },
+          react.createElement("div", { style: { fontWeight: 600, whiteSpace: "nowrap" } }, "重建记忆"),
+          react.createElement(
+            "div", { className: "dsh-mem-rb-muted", style: { flex: 1, minWidth: 180 } },
+            running
+              ? (RB_PHASE_LABEL[rb.phase] || rb.phase) + " · " + rb.done + "/" + rb.total + " 会话（" + pct + "%）"
+              : "从 L0 原始对话重新蒸馏 L1/L2/L3；旧数据先归档（不删除）",
+          ),
+          running
+            ? react.createElement("button", {
+                type: "button",
+                className: "dsh-mem-rb-btn",
+                disabled: busy || rb.cancelRequested,
+                onClick: cancel,
+              }, rb.cancelRequested ? "取消中…" : "取消重建")
+            : react.createElement("button", {
+                type: "button",
+                className: "dsh-mem-rb-btn dsh-mem-rb-danger",
+                disabled: busy || empty,
+                title: empty ? "L0 无消息，无可重建内容" : "重新蒸馏全部记忆",
+                onClick: function () { setConfirmOpen(true); },
+              }, busy ? "…" : "开始重建"),
+        ),
+        running
+          ? react.createElement(
+              "div", { style: { display: "flex", alignItems: "center", gap: 10, marginTop: 10 } },
+              react.createElement(
+                "div", { className: "dsh-mem-rb-bar" },
+                react.createElement("div", { className: "dsh-mem-rb-fill", style: { width: pct + "%" } }),
+              ),
+              react.createElement(
+                "span", { className: "dsh-mem-rb-muted", style: { whiteSpace: "nowrap" } },
+                "产出 " + rb.recordsBuilt + " 条",
+              ),
+            )
+          : null,
+        lastNote
+          ? react.createElement("div", { className: "dsh-mem-rb-muted", style: { marginTop: 8 } }, lastNote)
+          : null,
+        rbError
+          ? react.createElement("div", { style: { marginTop: 8, fontSize: 12, color: "#cf222e" } }, rbError)
+          : null,
+        confirmOpen
+          ? react.createElement(
+              "div", {
+                className: "dsh-mem-rb-overlay",
+                onClick: function (e) {
+                  if (e.target === e.currentTarget) setConfirmOpen(false);
+                },
+              },
+              react.createElement(
+                "div", { className: "dsh-mem-rb-modal" },
+                react.createElement(
+                  "div", { style: { fontSize: 15, fontWeight: 600, marginBottom: 10 } },
+                  "确认重建全部记忆？",
+                ),
+                react.createElement(
+                  "div", null,
+                  "将以 L0 原始对话为事实源重新蒸馏：",
+                  react.createElement("b", null, rb.sessionCount + " 个会话 · " + rb.messageCount + " 条消息"),
+                  "，预计 ≥" + rb.estCalls + " 次蒸馏调用。",
+                ),
+                react.createElement(
+                  "div", { style: { marginTop: 8 } },
+                  "现有 L1 记忆 / L2 场景 / L3 画像会整体归档（*.bak.时间戳，可手工找回），随后清空重建；重建期间可正常对话，新对话的蒸馏优先进行；中途可取消，已重建部分保留。",
+                ),
+                react.createElement(
+                  "div", { style: { display: "flex", justifyContent: "flex-end", gap: 8, marginTop: 16 } },
+                  react.createElement(
+                    "button", {
+                      type: "button",
+                      className: "dsh-mem-rb-btn",
+                      onClick: function () { setConfirmOpen(false); },
+                    },
+                    "取消",
+                  ),
+                  react.createElement(
+                    "button", {
+                      type: "button",
+                      className: "dsh-mem-rb-btn dsh-mem-rb-primary",
+                      disabled: busy,
+                      onClick: start,
+                    },
+                    busy ? "启动中…" : "开始重建",
+                  ),
+                ),
+              ),
+            )
+          : null,
+      );
+    }
+
     // ── Tab：概览（开关面板 + 计数） ──
     function OverviewTab(props) {
       var rpc = props.rpc;
@@ -812,6 +1030,7 @@ window.__ModuleLoader__.load({
                   : null,
               )
             : null,
+        react.createElement(RebuildPanel, { rpc: rpc }),
         error
           ? react.createElement("div", { style: S.error }, "获取状态失败：" + error)
           : !stats

package/dist/config.js

@@ -50,7 +50,7 @@ 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'),

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/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;
 }

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,32 +92,65 @@ 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 });
+    }
+    pushTask(task) {
+        this.tasks.push(task);
+        void this.drain();
     }
-    async runTurn(sessionId, messages, mode) {
+    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 阻塞/退出丢消息） ──
-        // ── 运行时调参视图：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 +161,13 @@ export class MemoryRunner {
                 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 {
@@ -134,5 +222,6 @@ export class MemoryRunner {
         }
         this.logger.info(`[memory] 蒸馏管线结束（本轮新增 ${newRecords.length} 条，总耗时 ${Date.now() - turnStart}ms）`);
         this.afterRun?.();
+        return newRecords.length;
     }
 }

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