dsh-layered-memory 0.8.5 → 0.8.7

package/dist/embedding-worker.cjs

@@ -0,0 +1,176 @@
+/**
+ * 本地嵌入 worker：transformers.js 的模型加载与推理在本线程执行，主线程只
+ * 投递文本、收回向量。onnxruntime-node（v1.24.3）的 run/loadModel 是
+ * setImmediate 回调里的同步调用（Promise 包装不卸载计算），留在主线程会
+ * 冻结宿主事件循环——dsh 页面一切交互无响应数秒的根因。
+ *
+ * 协议（与 src/store/local-embedding.ts 的 RealWorkerChannel 配对；自增 id）：
+ * - 入向：{id,type:'ping'} | {id,type:'warmup'} | {id,type:'embed',texts,priority}
+ * - 出向：{id,ok:true,type:'pong'|'ready'|'embedded',vectors?}（向量经
+ *   transfer 列表零拷贝回传）| {id,ok:false,stage:'load'|'infer',error}
+ *   | {type:'fatal',error}
+ *
+ * 调度：单线程串行。embedBatch 拆成逐条 job、条间 setImmediate 让路——
+ * 单条请求（priority，即召回 query）unshift 插队，最坏只等"正在算的那一条"，
+ * 不会被 reindex 批次（16/32 条 ≈5-10s）堵在队尾。
+ *
+ * 信任边界（沿 AGENTS.md 0.8.2 审查记录）：runtime/ 目录在数据目录信任边界内，
+ * 本线程按其 package.json createRequire 加载 transformers——对数据目录有写
+ * 权限的进程理论上可植入恶意模块；模型文件逐文件 sha256 锁定，运行时代码
+ * 无同级防护，完整修复需安装指纹设计，暂以文档化假设为准。
+ */
+'use strict';
+
+const { parentPort, workerData } = require('node:worker_threads');
+const path = require('node:path');
+const { createRequire } = require('node:module');
+
+/** 错误消息归一化（Error 取 message，其余 String 化）。 */
+function errMsg(err) {
+  return err && err.message ? err.message : String(err);
+}
+
+const cfg = workerData || {};
+const RUNTIME_DIR = typeof cfg.runtimeDir === 'string' ? cfg.runtimeDir : '';
+const MODEL_DIR = typeof cfg.modelDir === 'string' ? cfg.modelDir : '';
+const POOLING = cfg.pooling === 'cls' ? 'cls' : 'mean';
+const DTYPE = typeof cfg.dtype === 'string' ? cfg.dtype : 'q8';
+const MAX_INPUT_CHARS = cfg.maxInputChars > 0 ? cfg.maxInputChars : 5000;
+
+let extractor = null; // pipeline('feature-extraction', …)
+let loadState = 'idle'; // idle | loading | ready | failed
+let loadPromise = null;
+let loadError = null;
+
+// ── 模型懒加载（首请求触发；失败后经 warmup 可重试，embed 请求失败快返回） ──
+function ensureLoaded() {
+  if (loadState === 'ready') return Promise.resolve();
+  if (loadState === 'loading' && loadPromise) return loadPromise;
+  loadState = 'loading';
+  loadError = null;
+  loadPromise = (async () => {
+    try {
+      if (!RUNTIME_DIR || !MODEL_DIR) throw new Error('workerData 缺少 runtimeDir/modelDir');
+      const req = createRequire(path.join(RUNTIME_DIR, 'package.json'));
+      const mod = req('@huggingface/transformers');
+      if (mod.env) {
+        mod.env.allowRemoteModels = false;
+        if (mod.env.allowLocalModels !== undefined) mod.env.allowLocalModels = true;
+      }
+      extractor = await mod.pipeline('feature-extraction', MODEL_DIR, { dtype: DTYPE });
+      loadState = 'ready';
+    } catch (err) {
+      loadState = 'failed';
+      loadError = errMsg(err);
+      loadPromise = null; // 失败后下一次 warmup 重新走加载
+      throw err;
+    }
+  })();
+  return loadPromise;
+}
+
+// ── 推理队列（逐条 job；priority 插队；条间让路） ──
+const queue = []; // [{ request, index, text }]
+let pumping = false;
+
+function postReply(msg, transfer) {
+  parentPort.postMessage(msg, transfer || []);
+}
+
+/** 请求全部条目完成 → 回执（transfer 向量缓冲零拷贝）。 */
+function settle(request) {
+  if (request.failed || request.remaining !== 0) return;
+  postReply(
+    { id: request.id, ok: true, type: 'embedded', vectors: request.vectors },
+    request.vectors.map((v) => v.buffer),
+  );
+}
+
+/** 首个失败即回执错误，并移除该请求尚未开跑的条目（正在跑的至多 1 条，算完即弃）。 */
+function failRequest(request, error, stage) {
+  if (request.failed) return;
+  request.failed = true;
+  for (let i = queue.length - 1; i >= 0; i--) {
+    if (queue[i].request === request) queue.splice(i, 1);
+  }
+  postReply({ id: request.id, ok: false, stage: stage, error: errMsg(error) });
+}
+
+async function pump() {
+  if (pumping) return;
+  pumping = true;
+  try {
+    while (queue.length > 0) {
+      const job = queue.shift();
+      if (job.request.failed) continue;
+      try {
+        const result = await extractor([job.text.slice(0, MAX_INPUT_CHARS)], { pooling: POOLING, normalize: true });
+        const data = result[0] && result[0].data;
+        job.request.vectors[job.index] = data instanceof Float32Array ? data : new Float32Array(data);
+        job.request.remaining -= 1;
+        settle(job.request);
+      } catch (err) {
+        failRequest(job.request, err, 'infer');
+      }
+      // 条间让路：交还本线程事件循环，新消息（含 priority 插队）可在批间被处理
+      await new Promise((resolve) => setImmediate(resolve));
+    }
+  } finally {
+    pumping = false;
+  }
+}
+
+function handleEmbed(msg) {
+  const texts = Array.isArray(msg.texts) ? msg.texts : [];
+  if (texts.length === 0) {
+    postReply({ id: msg.id, ok: true, type: 'embedded', vectors: [] });
+    return;
+  }
+  const request = { id: msg.id, vectors: new Array(texts.length), remaining: texts.length, failed: false };
+  // 单条请求（召回 query）插队到队首；批次追加到队尾（批内条目间仍会被后来的插队）
+  const priority = msg.priority === true && texts.length === 1;
+  for (let i = 0; i < texts.length; i++) {
+    const job = { request: request, index: i, text: String(texts[i] == null ? '' : texts[i]) };
+    if (priority) queue.unshift(job);
+    else queue.push(job);
+  }
+  void pump();
+}
+
+parentPort.on('message', (msg) => {
+  if (!msg || typeof msg.id !== 'number' || typeof msg.type !== 'string') return;
+  if (msg.type === 'ping') {
+    postReply({ id: msg.id, ok: true, type: 'pong' });
+    return;
+  }
+  if (msg.type === 'warmup') {
+    ensureLoaded().then(
+      () => postReply({ id: msg.id, ok: true, type: 'ready' }),
+      () => postReply({ id: msg.id, ok: false, stage: 'load', error: loadError ?? '模型加载失败' }),
+    );
+    return;
+  }
+  if (msg.type === 'embed') {
+    void (async () => {
+      try {
+        await ensureLoaded();
+      } catch {
+        postReply({ id: msg.id, ok: false, stage: 'load', error: loadError ?? '模型加载失败' });
+        return;
+      }
+      handleEmbed(msg);
+    })();
+    return;
+  }
+});
+
+// 未捕获异常：尽力通知主线程后强制退出（主线程的 exit 处理会拒绝全部 pending
+// 并转入 failed 态）。不保持半死状态——半死的 worker 只会让调用方挂到超时。
+process.on('uncaughtException', (err) => {
+  try {
+    postReply({ type: 'fatal', error: errMsg(err) });
+  } catch {
+    /* 端口已坏，exit 处理兜底 */
+  }
+  setTimeout(() => process.exit(1), 50);
+});

package/dist/hooks/recall.d.ts

@@ -32,17 +32,21 @@ export declare function buildRecallQuery(messages: Array<{
 }>, tailMessages?: number, maxChars?: number): string;
 /** 单会话召回统计（悬浮卡信息区数据源；每轮 O(1) 记账，agent/disposed 清理）。
  *  口径声明：这是"注入统计"而非 bench 的离线 recall@k——运行时没有 ground truth，
- *  命中率 = hitTurns / injectedTurns（发生过检索的轮次中命中 ≥1 条的占比）。 */
+ *  命中率 = hitTurns / injectedTurns。去重语义（0.8.6）：全量压制轮计入 hitTurns
+ *  （相关记忆已在模型上下文里，本质是命中而非未命中），injectedTurns 仍计全部
+ *  发生过检索的轮次（保住分母语义与悬浮卡口径连续性）。 */
 export interface RecallSessionStats {
-    /** 发生过召回检索的轮次数（含零命中与超时）。 */
+    /** 发生过召回检索的轮次数（含零命中、全量压制与超时）。 */
     injectedTurns: number;
-    /** 命中（≥1 条）轮次数。 */
+    /** 命中（≥1 条实际注入，或有命中但被去重全量压制）轮次数。 */
     hitTurns: number;
-    /** 累计命中条数（预算截断前）。 */
+    /** 累计注入条数（去重过滤后、预算截断前）。 */
     totalHits: number;
     /** 总预算超时跳过次数。 */
     timeouts: number;
-    /** 最近一轮命中条数（0 = 零命中/超时；工具指南门控沿用此信号）。 */
+    /** 累计被去重压制的命中条数（同会话已注入过，不重复注入）。 */
+    suppressedRecalls: number;
+    /** 最近一轮实际注入条数（0 = 零命中/超时/全量压制；工具指南门控沿用此信号）。 */
     lastHits: number;
     /** 最近一轮检索耗时 ms。 */
     lastDurationMs: number;
@@ -61,4 +65,4 @@ export declare function registerRecall(ctx: Context, cfg: MemoryConfig, stores:
     l1: L1Store;
     scenes: Record<'chat' | 'work', SceneStore>;
     persona: Record<'chat' | 'work', PersonaStore>;
-}, logger: MemoryLogger, live: LiveSettingsHandle, modes: SessionModeStore): RecallHooks;
+}, logger: MemoryLogger, live: LiveSettingsHandle, modes: SessionModeStore, dataDir: string): RecallHooks;

package/dist/hooks/recall.js

@@ -1,4 +1,5 @@
 import { createUserMessage } from '@deepseek-ai/dsh-llm';
+import { RecallDedupeStore } from '../store/recall-dedupe.js';
 import { applyRecallBudget, raceRecallTimeout, RECALL_EMBED_CAP_MS } from '../util/recall-budget.js';
 import { errDetail } from '../util/filelog.js';
 import { blocksToText } from '../util/text.js';
@@ -37,9 +38,20 @@ const MEMORY_TOOLS_GUIDE = `<memory-tools-guide>
 </memory-tools-guide>`;
 /** 新建零值统计（首次出现的会话）。 */
 export function emptyRecallStats(now = Date.now()) {
-    return { injectedTurns: 0, hitTurns: 0, totalHits: 0, timeouts: 0, lastHits: 0, lastDurationMs: 0, updatedAt: now };
+    return {
+        injectedTurns: 0,
+        hitTurns: 0,
+        totalHits: 0,
+        timeouts: 0,
+        suppressedRecalls: 0,
+        lastHits: 0,
+        lastDurationMs: 0,
+        updatedAt: now,
+    };
 }
-export function registerRecall(ctx, cfg, stores, logger, live, modes) {
+export function registerRecall(ctx, cfg, stores, logger, live, modes, dataDir) {
+    /** 召回去重存储（同会话已注入的记忆不再重复注入；写穿持久化，重启不丢）。 */
+    const dedupe = new RecallDedupeStore(dataDir, logger);
     /** 每 agent 召回统计（工具指南门控读 lastHits；悬浮卡信息区读全量计数）。 */
     const recallStats = new Map();
     const statFor = (id) => {
@@ -77,10 +89,18 @@ export function registerRecall(ctx, cfg, stores, logger, live, modes) {
     const invalidateProfile = () => {
         void refreshProfile();
     };
-    // agent 销毁时清掉召回统计槽
+    // agent 销毁时清掉召回统计槽（去重记录不随 agent 清——持久化语义：会话恢复后继续压制）
     ctx.on('agent/disposed', (payload) => {
         recallStats.delete(payload.agent.id);
     });
+    // 上下文压缩/清空 → 已注入内容从模型上下文丢失，重置该会话的去重压制
+    // （resume/startup 不重置：历史仍在，已注入的记忆模型还持有）。
+    ctx.on('agent/session-start', (payload) => {
+        if (payload.source === 'compact' || payload.source === 'clear') {
+            dedupe.reset(payload.agent.id);
+            logger.info(`[memory] 召回去重重置（agent=${payload.agent.id}，source=${payload.source}）`);
+        }
+    });
     // ── 1. pre-step 消息侧注入：记忆先行于每一条新的用户输入（ADR-0001） ──
     // prepend 注册 + 先 next() 再改写：不劫持其他监听器（dsh-time-context 官方范式）。
     if (cfg.recall.enabled) {
@@ -112,7 +132,7 @@ export function registerRecall(ctx, cfg, stores, logger, live, modes) {
                 const hits = await raceRecallTimeout(stores.l1.search(query, cfg.recall.maxResults, {
                     scoreThreshold: cfg.recall.scoreThreshold,
                     family: mode === 'auto' ? undefined : mode,
-                    // 远程嵌入 fetch 内层钳制：给 FTS 降级留出总预算内的时间（本地推理不钳）
+                    // 嵌入内层钳制：给 FTS 降级留出总预算内的时间（远程限 HTTP fetch；本地经 worker 代理 race 放弃）
                     embeddingTimeoutMs: RECALL_EMBED_CAP_MS,
                 }), cfg.recall.timeoutMs);
                 st.updatedAt = Date.now();
@@ -122,16 +142,28 @@ export function registerRecall(ctx, cfg, stores, logger, live, modes) {
                     return decision;
                 }
                 st.lastDurationMs = Date.now() - searchStart;
-                st.lastHits = hits.length;
+                // 召回去重：同会话已注入过的记录不再重复注入（模型上下文已持有，省 token）。
+                // 纯过滤——剩几条注几条，全量压制（0 条新鲜命中）是正确状态而非未命中。
+                const seen = dedupe.seen(payload.agent.id);
+                const fresh = hits.filter((h) => !seen.has(h.id));
+                const suppressed = hits.length - fresh.length;
+                st.suppressedRecalls += suppressed;
+                if (suppressed > 0) {
+                    logger.debug?.(`[memory] 召回去重：压制 ${suppressed} 条已注入记忆（agent=${payload.agent.id}，余 ${fresh.length} 条新鲜命中）`);
+                }
                 if (hits.length > 0) {
+                    // 全量压制轮也计入命中：相关记忆已在模型上下文里，本质是命中
                     st.hitTurns++;
-                    st.totalHits += hits.length;
+                    st.totalHits += fresh.length;
                 }
-                if (hits.length === 0)
+                if (fresh.length === 0)
                     return decision;
-                const lines = applyRecallBudget(hits.map((h) => `- [${h.scene_name ? `${h.type}|${h.scene_name}` : h.type}] ${h.content}`), { maxCharsPerMemory: cfg.recall.maxCharsPerMemory, maxTotalRecallChars: cfg.recall.maxTotalRecallChars });
+                const lines = applyRecallBudget(fresh.map((h) => `- [${h.scene_name ? `${h.type}|${h.scene_name}` : h.type}] ${h.content}`), { maxCharsPerMemory: cfg.recall.maxCharsPerMemory, maxTotalRecallChars: cfg.recall.maxTotalRecallChars });
                 if (lines.length === 0)
                     return decision;
+                // 预算截断只丢尾部（前缀保留）：实际注入 = fresh 的前 lines.length 条——只标记模型真实看到的
+                dedupe.mark(payload.agent.id, fresh.slice(0, lines.length).map((h) => h.id));
+                st.lastHits = lines.length;
                 const text = [
                     '<relevant-memories>',
                     '以下是当前对话召回的相关记忆，不代表当前任务进程，仅作为参考：',

package/dist/index.d.ts

@@ -61,6 +61,7 @@ export declare const Config: import("@deepseek-ai/schemastery").default<Schemast
         includeSceneNav: import("@deepseek-ai/schemastery").default<boolean, boolean>;
         strategy: import("@deepseek-ai/schemastery").default<"keyword" | "embedding" | "hybrid", "keyword" | "embedding" | "hybrid">;
         scoreThreshold: import("@deepseek-ai/schemastery").default<number, number>;
+        decayHalfLifeDays: import("@deepseek-ai/schemastery").default<number, number>;
     }>, Schemastery.ObjectT<{
         enabled: import("@deepseek-ai/schemastery").default<boolean, boolean>;
         maxResults: import("@deepseek-ai/schemastery").default<number, number>;
@@ -71,6 +72,7 @@ export declare const Config: import("@deepseek-ai/schemastery").default<Schemast
         includeSceneNav: import("@deepseek-ai/schemastery").default<boolean, boolean>;
         strategy: import("@deepseek-ai/schemastery").default<"keyword" | "embedding" | "hybrid", "keyword" | "embedding" | "hybrid">;
         scoreThreshold: import("@deepseek-ai/schemastery").default<number, number>;
+        decayHalfLifeDays: import("@deepseek-ai/schemastery").default<number, number>;
     }>>;
     embedding: import("@deepseek-ai/schemastery").default<Schemastery.ObjectS<{
         enabled: import("@deepseek-ai/schemastery").default<boolean, boolean>;
@@ -112,6 +114,11 @@ export declare const Config: import("@deepseek-ai/schemastery").default<Schemast
         maxInputChars: import("@deepseek-ai/schemastery").default<number, number>;
         timeoutMs: import("@deepseek-ai/schemastery").default<number, number>;
     }>>;
+    tokenCost: import("@deepseek-ai/schemastery").default<Schemastery.ObjectS<{
+        retentionDays: import("@deepseek-ai/schemastery").default<number, number>;
+    }>, Schemastery.ObjectT<{
+        retentionDays: import("@deepseek-ai/schemastery").default<number, number>;
+    }>>;
     tools: import("@deepseek-ai/schemastery").default<boolean, boolean>;
     benchControl: import("@deepseek-ai/schemastery").default<boolean, boolean>;
 }>, Schemastery.ObjectT<{
@@ -167,6 +174,7 @@ export declare const Config: import("@deepseek-ai/schemastery").default<Schemast
         includeSceneNav: import("@deepseek-ai/schemastery").default<boolean, boolean>;
         strategy: import("@deepseek-ai/schemastery").default<"keyword" | "embedding" | "hybrid", "keyword" | "embedding" | "hybrid">;
         scoreThreshold: import("@deepseek-ai/schemastery").default<number, number>;
+        decayHalfLifeDays: import("@deepseek-ai/schemastery").default<number, number>;
     }>, Schemastery.ObjectT<{
         enabled: import("@deepseek-ai/schemastery").default<boolean, boolean>;
         maxResults: import("@deepseek-ai/schemastery").default<number, number>;
@@ -177,6 +185,7 @@ export declare const Config: import("@deepseek-ai/schemastery").default<Schemast
         includeSceneNav: import("@deepseek-ai/schemastery").default<boolean, boolean>;
         strategy: import("@deepseek-ai/schemastery").default<"keyword" | "embedding" | "hybrid", "keyword" | "embedding" | "hybrid">;
         scoreThreshold: import("@deepseek-ai/schemastery").default<number, number>;
+        decayHalfLifeDays: import("@deepseek-ai/schemastery").default<number, number>;
     }>>;
     embedding: import("@deepseek-ai/schemastery").default<Schemastery.ObjectS<{
         enabled: import("@deepseek-ai/schemastery").default<boolean, boolean>;
@@ -218,6 +227,11 @@ export declare const Config: import("@deepseek-ai/schemastery").default<Schemast
         maxInputChars: import("@deepseek-ai/schemastery").default<number, number>;
         timeoutMs: import("@deepseek-ai/schemastery").default<number, number>;
     }>>;
+    tokenCost: import("@deepseek-ai/schemastery").default<Schemastery.ObjectS<{
+        retentionDays: import("@deepseek-ai/schemastery").default<number, number>;
+    }>, Schemastery.ObjectT<{
+        retentionDays: import("@deepseek-ai/schemastery").default<number, number>;
+    }>>;
     tools: import("@deepseek-ai/schemastery").default<boolean, boolean>;
     benchControl: import("@deepseek-ai/schemastery").default<boolean, boolean>;
 }>>;

package/dist/index.js

@@ -41,6 +41,7 @@ import { registerMemoryTools } from './tools/index.js';
 import { errDetail, withFileLog } from './util/filelog.js';
 import { resolveModelRoute, invalidateEffortCache } from './llm.js';
 import { effectiveCfg } from './pipeline/runner.js';
+import { initTokenCost, resetTokenCost } from './token-cost.js';
 export const name = 'dsh-memory-plugin';
 /** 硬依赖：蒸馏要用 llm，工具注册要用 tools，召回注入要用 systemPrompt。 */
 export const inject = ['llm', 'tools', 'systemPrompt'];
@@ -113,6 +114,7 @@ export async function apply(ctx, config) {
     // ── 检索引擎（memory.db）与向量服务 ──
     const embed = initial.svc;
     const db = new MemoryDb(path.join(dataDir, 'memory.db'), initial.dims, logger);
+    initTokenCost(db, config.tokenCost.retentionDays);
     // 插件卸载时关闭连接（WAL 落盘），注册一次即可
     ctx.effect(() => () => db.close());
     let dbInit = { needsReindex: false };
@@ -131,7 +133,7 @@ export async function apply(ctx, config) {
     }
     const stores = {
         l0: new L0Store(dataDir, db, embed, logger),
-        l1: new L1Store(dataDir, db, embed, config.recall.strategy, logger),
+        l1: new L1Store(dataDir, db, embed, config.recall.strategy, logger, config.recall.decayHalfLifeDays),
         // L2/L3 分族隔离：各自目录与文件（scenes/chat|work、persona-chat|work.md）
         scenes: {
             chat: new SceneStore(dataDir, 'chat', logger),
@@ -292,7 +294,7 @@ export async function apply(ctx, config) {
     if (storageOk) {
         flushL0 = registerCapture(ctx, config, runner, stores.l0, logger, live, modes);
     }
-    const recall = registerRecall(ctx, config, stores, logger, live, modes);
+    const recall = registerRecall(ctx, config, stores, logger, live, modes, dataDir);
     runner.setAfterRun(recall.invalidateProfile);
     registerMemoryTools(ctx, config, stores, logger, modes);
     registerMemoryRpc(ctx, config, stores, logger, {
@@ -325,6 +327,7 @@ export async function apply(ctx, config) {
         return (async () => {
             await flushL0?.();
             db.close();
+            resetTokenCost();
         })();
     });
 }

package/dist/llm.js

@@ -1,6 +1,7 @@
 import { createUserMessage, ReasoningEffortId } from '@deepseek-ai/dsh-llm';
 import { errDetail } from './util/filelog.js';
 import { recordDistillCall } from './llm-usage.js';
+import { recordCostCall } from './token-cost.js';
 // ── 分层输出预算（规格 C 节）：结构化蒸馏远用不到总闸级预算，逐层设护栏；
 //    模型跑偏时单次损失有界。数值"先试跑"状态，按线上截断率调整。
 /** L1 抽取（大输入块的 JSON 记忆数组输出）。 */
@@ -203,11 +204,15 @@ export async function callLLM(ctx, cfg, opts) {
         // 记账含失败路径（failures 计数；tokens 尽当时流内已到的 usage）
         if (opts.layer)
             recordDistillCall(opts.layer, user.length, outputTokens, reasoningTokens, true);
+        if (opts.layer)
+            recordCostCall(provider, model, opts.layer, user.length, outputTokens, reasoningTokens);
         opts.logger?.warn(`[memory] LLM 调用失败 ${provider}/${model}（${((Date.now() - startedAt) / 1000).toFixed(1)}s）: ${errDetail(err)}`);
         throw err;
     }
     if (opts.layer)
         recordDistillCall(opts.layer, user.length, outputTokens, reasoningTokens, false);
+    if (opts.layer)
+        recordCostCall(provider, model, opts.layer, user.length, outputTokens, reasoningTokens);
     const out = (blockText || deltaText).trim();
     if (out.length === 0) {
         // 空输出是最难排查的失败：流正常结束但一个字没吐。必须记录 finish 原因、

package/dist/pipeline/runner.d.ts

@@ -65,6 +65,9 @@ export declare class MemoryRunner {
     private lastActivity;
     /** 每会话累计产出 L1 条数与最近蒸馏时间（session-stats 数据源；LRU 上限防泄漏）。 */
     private sessionProduced;
+    /** 抽取连续失败退避（瞬态，不持久化：重启后允许首试再退避）：
+     *  sessionId → 连败次数与下次可自动重试时间（修闲置兜底×LLM 超时的重试风暴）。 */
+    private extractFailures;
     private readonly pendingFile;
     /** 分族 checkpoint（init 后可用；重建收尾也从这里读活引用）。 */
     states: FamilyStates;
@@ -121,6 +124,8 @@ export declare class MemoryRunner {
     onModeChange(sessionId: string, oldMode: string, newMode: string): void;
     private pushTask;
     private drain;
+    /** 该会话是否处于抽取退避窗口内。 */
+    private inExtractBackoff;
     /** 缓冲落盘（每次蒸馏尝试后调用；失败只告警不阻断管线）。
      *  非重建轮持久化前按桶截断到上限：重建取消后的大桶不至于在后续每次
      *  蒸馏尝试时反复整量序列化落盘（多 MB 级 IO）；重建轮豁免维持。 */

package/dist/pipeline/runner.js

@@ -1,7 +1,7 @@
 import { resolveDataDir } from '../config.js';
 import { emptyPending, freshWarmup, groupPendingBySession, loadPending, PENDING_MODES, pendingPathFor, savePending, } from '../store/pending.js';
 import { errDetail } from '../util/filelog.js';
-import { advanceWarmupThreshold, effectiveExtractThreshold, idleSessionsToFlush, modeSwitchAction, pickSessionBackground, } from './trigger.js';
+import { advanceWarmupThreshold, effectiveExtractThreshold, extractionBackoffMs, idleSessionsToFlush, modeSwitchAction, pickSessionBackground, } from './trigger.js';
 import { runExtraction } from './l1.js';
 import { runSceneConsolidation } from './l2.js';
 import { runPersona } from './l3.js';
@@ -84,6 +84,9 @@ export class MemoryRunner {
     lastActivity = new Map();
     /** 每会话累计产出 L1 条数与最近蒸馏时间（session-stats 数据源；LRU 上限防泄漏）。 */
     sessionProduced = new Map();
+    /** 抽取连续失败退避（瞬态，不持久化：重启后允许首试再退避）：
+     *  sessionId → 连败次数与下次可自动重试时间（修闲置兜底×LLM 超时的重试风暴）。 */
+    extractFailures = new Map();
     pendingFile;
     /** 分族 checkpoint（init 后可用；重建收尾也从这里读活引用）。 */
     states;
@@ -251,7 +254,7 @@ export class MemoryRunner {
         }
         if (infos.size === 0)
             return;
-        const targets = idleSessionsToFlush([...infos.values()], this.lastActivity, now, idleMs, (sid) => this.modes?.get(sid) === 'off');
+        const targets = idleSessionsToFlush([...infos.values()], this.lastActivity, now, idleMs, (sid) => this.modes?.get(sid) === 'off').filter((sid) => !this.inExtractBackoff(sid, now)); // 退避中的会话不入队（任务堆积源头）
         for (const sid of targets) {
             this.logger.info(`[memory] 闲置兜底：会话 ${sid} 静默达标，未蒸馏切片落袋`);
             this.enqueueSessionSlices(sid);
@@ -306,6 +309,11 @@ export class MemoryRunner {
             this.draining = false;
         }
     }
+    /** 该会话是否处于抽取退避窗口内。 */
+    inExtractBackoff(sessionId, now = Date.now()) {
+        const f = this.extractFailures.get(sessionId);
+        return !!f && now < f.nextAt;
+    }
     /** 缓冲落盘（每次蒸馏尝试后调用；失败只告警不阻断管线）。
      *  非重建轮持久化前按桶截断到上限：重建取消后的大桶不至于在后续每次
      *  蒸馏尝试时反复整量序列化落盘（多 MB 级 IO）；重建轮豁免维持。 */
@@ -347,11 +355,15 @@ export class MemoryRunner {
             // force：重建轮全量蒸馏（历史小会话也必须出记忆，不受阈值约束）。
             const effective = effectiveExtractThreshold(this.warmup[mode], cfg.extract.minMessages);
             const sliceLen = bucket.reduce((n, m) => (m.sessionId === sessionId ? n + 1 : n), 0);
-            if (opts?.force || sliceLen >= effective) {
+            // 抽取失败退避：重建轮（noBufferCap，用户显式动作、有自己的失败/取消 UI）豁免
+            const backedOff = !opts?.noBufferCap && this.inExtractBackoff(sessionId);
+            if ((opts?.force || sliceLen >= effective) && !backedOff) {
                 newRecords = await this.extractSessionSlice(sessionId, mode, cfg, effective, opts);
             }
             else {
-                this.logger.debug?.(`[memory] 会话切片攒批中（session=${sessionId}，mode=${mode}，${sliceLen}/${effective}）`);
+                this.logger.debug?.(backedOff
+                    ? `[memory] 蒸馏退避中，本轮跳过抽取（session=${sessionId}，mode=${mode}）`
+                    : `[memory] 会话切片攒批中（session=${sessionId}，mode=${mode}，${sliceLen}/${effective}）`);
                 // 攒阈值中途也落盘：进程退出后切片与爬坡状态不丢
                 await this.persistPending(opts?.noBufferCap);
             }
@@ -428,6 +440,8 @@ export class MemoryRunner {
                     this.warmup[mode] = advanceWarmupThreshold(this.warmup[mode], cfg.extract.minMessages);
                 // 会话产出记账（成功消费即记——零产出也算"蒸馏过"，lastAt 推进）
                 this.noteSessionDistill(sessionId, result.newRecords.length);
+                // 成功消费清零失败退避（切片已出桶，后续轮次恢复正常触发）
+                this.extractFailures.delete(sessionId);
             }
             this.logger.info(`[memory] L1 阶段完成（session=${sessionId}，mode=${mode}，切片 ${slice.length} 条，背景 ${background.length} 条，阈值 ${effectiveThreshold}，${Date.now() - t}ms）`);
             // 缓冲与爬坡每次尝试后立即落盘：进程中途退出不丢待重试/攒阈值状态
@@ -445,6 +459,11 @@ export class MemoryRunner {
         catch (err) {
             // 保留切片下次重试（桶入口已裁到 ≤200，防无限堆积；重建轮不裁，量被会话规模约束）
             this.logger.warn(`[memory] L1 抽取失败（session=${sessionId}，mode=${mode}，切片 ${slice.length} 条）: ${errDetail(err)}`);
+            // 指数退避：压制闲置兜底/补跑在 LLM 故障期间的连环重试（成功消费时清零）
+            const streak = (this.extractFailures.get(sessionId)?.streak ?? 0) + 1;
+            const delayMs = extractionBackoffMs(streak);
+            this.extractFailures.set(sessionId, { streak, nextAt: Date.now() + delayMs });
+            this.logger.info(`[memory] 蒸馏连续失败 ${streak} 次，${Math.round(delayMs / 1000)}s 内暂停该会话的自动重试`);
             await this.persistPending(opts?.noBufferCap).catch(() => { });
             return [];
         }

package/dist/pipeline/trigger.d.ts

@@ -24,6 +24,8 @@ export declare function modeSwitchAction(oldMode: string, newMode: string): Mode
 export declare function pickSessionBackground<T extends {
     id: string;
 }>(recent: readonly T[], sliceIds: ReadonlySet<string>, n: number): T[];
+/** 连续失败第 failStreak 次后的自动重试等待时长（1 → 60s，2 → 120s，…封顶 30min）。 */
+export declare function extractionBackoffMs(failStreak: number): number;
 export interface IdleSliceInfo {
     sessionId: string;
     /** 该会话跨桶合计的切片条数。 */

package/dist/pipeline/trigger.js

@@ -43,6 +43,17 @@ export function pickSessionBackground(recent, sliceIds, n) {
         return [];
     return recent.filter((m) => !sliceIds.has(m.id)).slice(-n);
 }
+// ── 抽取失败退避（修"重试风暴"：LLM 网关故障期间闲置兜底每 30s 入队一个任务，
+//    在 120s LLM 超时的等待中堆积成连环调用）──
+/** 退避基数与封顶：60s 起步指数翻倍，封顶 30 分钟（LLM 故障自愈的合理量级）。 */
+const EXTRACT_BACKOFF_BASE_MS = 60_000;
+const EXTRACT_BACKOFF_CAP_MS = 30 * 60_000;
+/** 连续失败第 failStreak 次后的自动重试等待时长（1 → 60s，2 → 120s，…封顶 30min）。 */
+export function extractionBackoffMs(failStreak) {
+    if (!Number.isFinite(failStreak) || failStreak <= 0)
+        return EXTRACT_BACKOFF_BASE_MS;
+    return Math.min(EXTRACT_BACKOFF_BASE_MS * 2 ** (failStreak - 1), EXTRACT_BACKOFF_CAP_MS);
+}
 /**
  * 闲置扫描：静默达标且有切片的会话。off 档会话跳过（挂起语义）；
  * 活动时间优先取运行时记录，缺省回退切片内最晚消息时间。

package/dist/stats.js

@@ -14,6 +14,7 @@ import { effectiveCfg } from './pipeline/runner.js';
 import { emptyRecallStats } from './hooks/recall.js';
 import { decideSendableEffort, LAYER_DEFAULT_BUDGETS, resolveModelEfforts, resolveModelRoute } from './llm.js';
 import { errDetail } from './util/filelog.js';
+import { snapshotTokenCost } from './token-cost.js';
 const require = createRequire(import.meta.url);
 export const PLUGIN_VERSION = require('../package.json').version;
 /** 注册状态 RPC（web 侧 connection 服务可选，缺失时跳过，不影响插件主体）。 */
@@ -148,6 +149,16 @@ async function handleEndpoint(endpoint, payload, deps) {
     switch (endpoint) {
         case 'dsh-memory/stats':
             return buildStats(cfg, stores, status);
+        case 'dsh-memory/token-cost': {
+            const p = (payload ?? {});
+            const granularity = p.granularity === 'week' || p.granularity === 'month' ? p.granularity : 'day';
+            // rangeDays 须为正整数且不超过明细保留期（tokenCost.retentionDays，0=永久保留则放行 1~3650），否则回退默认窗口
+            const retention = cfg.tokenCost.retentionDays;
+            const upper = retention > 0 ? retention : 3650;
+            const rawDays = p.rangeDays;
+            const rangeDays = typeof rawDays === 'number' && Number.isInteger(rawDays) && rawDays > 0 && rawDays <= upper ? rawDays : 0;
+            return snapshotTokenCost(granularity, rangeDays);
+        }
         case 'dsh-memory/session-mode-get': {
             if (!modes)
                 throw new Error('档位存储未初始化');

package/dist/store/embedding-source.d.ts

@@ -35,7 +35,8 @@ export interface InitialEmbedding {
 /** 远程档部署上限：静态四件套 + enabled。 */
 export declare function remoteCeiling(cfg: MemoryConfig): boolean;
 export declare function resolveInitialEmbedding(cfg: MemoryConfig, sourceStore: EmbeddingSourceStore, downloader: ModelDownloadQueue, makeLocal: (modelId: string) => LocalEmbeddingService | null, logger?: MemoryLogger): Promise<InitialEmbedding>;
-/** 本地服务构造工厂（index.ts 的初始解析与 Manager 共用一份实现，防漂移）。 */
+/** 本地服务构造工厂（index.ts 的初始解析与 Manager 共用一份实现，防漂移）。
+ *  推理在 worker 线程（见 local-embedding.ts）；此处只传 runtime 目录与模型目录。 */
 export declare function makeLocalServiceFactory(installer: RuntimeInstaller, downloader: ModelDownloadQueue, logger?: MemoryLogger, maxInputChars?: number): (modelId: string) => LocalEmbeddingService | null;
 export type ApplyPhase = 'idle' | 'installing-runtime' | 'warming' | 'switching' | 'reindexing' | 'done' | 'error';
 export interface ReindexProgressState {

package/dist/store/embedding-source.js

@@ -101,13 +101,18 @@ export async function resolveInitialEmbedding(cfg, sourceStore, downloader, make
     });
     return { svc, dims: cfg.embedding.dimensions, providerInfo: svc.getProviderInfo() };
 }
-/** 本地服务构造工厂（index.ts 的初始解析与 Manager 共用一份实现，防漂移）。 */
+/** 本地服务构造工厂（index.ts 的初始解析与 Manager 共用一份实现，防漂移）。
+ *  推理在 worker 线程（见 local-embedding.ts）；此处只传 runtime 目录与模型目录。 */
 export function makeLocalServiceFactory(installer, downloader, logger, maxInputChars) {
     return (modelId) => {
         const entry = catalogById(modelId);
         if (!entry)
             return null;
-        return new LocalEmbeddingService(entry, downloader.modelsDir(entry.id), () => Promise.resolve(installer.resolveModule()), logger, maxInputChars);
+        return new LocalEmbeddingService(entry, downloader.modelsDir(entry.id), {
+            runtimeDir: installer.runtimeDir,
+            logger,
+            maxInputChars,
+        });
     };
 }
 export class EmbeddingManager {

package/dist/store/embedding.d.ts

@@ -11,7 +11,8 @@ export interface EmbeddingProviderInfo {
     dimensions: number;
 }
 /** 单次嵌入调用的可选参数：timeoutMs 只允许缩短服务配置的超时（内层钳制），
- *  永不放大——召回路径用它给 FTS 降级留时间（规格 A 节）。本地实现可忽略。 */
+ *  永不放大——召回路径用它给 FTS 降级留时间（规格 A 节）。本地实现经 worker
+ *  代理以 Promise.race 钳制（迟到回复丢弃，推理在 worker 线程无法真正取消）。 */
 export interface EmbedCallOptions {
     timeoutMs?: number;
 }

package/dist/store/l0.js

@@ -42,10 +42,16 @@ export class L0Store {
                 if (!f.endsWith('.jsonl'))
                     continue;
                 const records = await readJsonl(path.join(this.legacyDir, f));
-                if (records.length > 0) {
-                    total += records.length;
-                    if (this.db.upsertL0Batch(records))
-                        imported += records.length;
+                // 最小有效性门（同 L1 的 importLegacy）：坏行读取时丢弃，按 valid 数判迁移完成
+                const valid = records.filter((r) => r && typeof r.id === 'string' && r.content);
+                const badCount = records.length - valid.length;
+                if (badCount > 0) {
+                    this.logger?.warn(`[memory] 旧版 L0 文件 ${f} 丢弃 ${badCount} 条坏行（缺 id/content）`);
+                }
+                if (valid.length > 0) {
+                    total += valid.length;
+                    if (this.db.upsertL0Batch(valid))
+                        imported += valid.length;
                 }
             }
             // 只有全部批次入库成功（或目录为空）才改名，避免数据被改名带走