dsh-layered-memory 0.8.5 → 0.8.6

package/README.en.md

@@ -90,7 +90,16 @@ synthetic message placed right before the user's new message, rendered as a
 **"Context injection · memory"** row in the chat flow (expand to see the hits) — so you
 can see "memory at work" directly. Injected content is bounded by length and
 time budgets — oversized lines are truncated (pointing the model at the memory tools for
-the full text) and a timed-out recall silently skips that turn, never slowing the chat. It
+the full text) and a timed-out recall silently skips that turn, never slowing the chat.
+**Per-session dedupe**: a memory already injected in this session is not injected again
+(the model's context already holds it — follow-up questions on the same topic save
+tokens); the record resets when the context is compacted or cleared, so memories can
+flow back in, and an updated memory (new id after a content change) is never held back
+by the old suppression. **Freshness weighting**: recall ranking applies a soft weight
+`relevance × max(0.5, 0.5^(days since last update / 30))` — among candidates of similar
+relevance the fresh one wins (slots rotate naturally), while a strongly relevant old
+memory still recalls fine (the floor caps its loss at half a ranking score, so
+long-lived facts never sink); tune via `recall.decayHalfLifeDays`, `0` disables. It
 also registers three model-callable memory tools: `memory_search` /
 `conversation_search` / `memory_read_scene`.
 
@@ -243,6 +252,7 @@ the bundle layer appends and causes `duplicate loader entry id` startup failure)
 | `recall.includeSceneNav` | `true` | Inject scene navigation into the system prompt (`<scene-navigation>`, stable zone) |
 | `recall.strategy` | `hybrid` | Retrieval strategy: `keyword` / `embedding` / `hybrid` |
 | `recall.scoreThreshold` | `0.3` | Recall score threshold (below is not injected; applies to keyword/embedding only, not pre-fusion hybrid; tool path unfiltered) |
+| `recall.decayHalfLifeDays` | `30` | Freshness-decay half-life for recall ranking (days, 0=off): ranking applies `relevance × max(0.5, 0.5^(days since last update / half-life))` — among similarly relevant candidates the fresh one wins (slots rotate), and an old memory loses at most half its ranking score (floor keeps long-lived facts afloat) |
 | `embedding.enabled` | `false` | Vector retrieval switch; off = pure FTS |
 | `embedding.baseUrl` | empty | OpenAI-compatible /embeddings endpoint (e.g. `https://api.siliconflow.cn/v1`) |
 | `embedding.apiKey` | empty | API key |
@@ -299,7 +309,10 @@ with per-file sha256; arbitrary repos cannot be downloaded).
   under `models/<id>/` in the data directory, deletable from the settings page at any time;
 - **On-demand runtime**: the inference runtime (transformers.js, ~100–200MB) is
   installed only on first switch to the local tier, into `runtime/` in the data
-  directory — never in the plugin's dependency tree or install directory;
+  directory — never in the plugin's dependency tree or install directory; model
+  loading and inference run on a **dedicated worker thread**, so the host event
+  loop is never frozen (conversations and page interactions stay responsive while
+  text is being embedded);
 - **Live switching**: one click to swap sources — everything is re-embedded in the
   background (visible progress, cancellable; retrieval silently degrades to keywords
   in the meantime, conversations unaffected; a dimension change rebuilds the vector

package/README.md

@@ -74,7 +74,7 @@ npx tsc src/smoke.ts --outDir dist-smoke --module nodenext --moduleResolution no
        alt="dsh-layered-memory 运行时数据流：左侧 User 与 Assistant 的会话事件流入插件（L0 捕获、L1–L3 蒸馏、检索召回、记忆工具），插件经 agent/pre-step 把相关记忆注入右侧 DSH 核心；蒸馏复用核心的 ctx.llm，数据双写 ~/.dsh/memory/">
 </p>
 
-插件挂在 dsh 原生事件上（`session/event` 捕获、`agent/pre-step` 注入），蒸馏调用复用宿主 `ctx.llm`。召回以**消息侧注入**呈现：相关记忆作为一条合成消息排在用户新消息之前，会话流里显示为**"上下文注入 · memory"**行（点开看命中内容）——用户能直接看到"记忆生效了"；注入内容有长度预算与时间预算，超限截断/超时跳过，绝不拖慢对话。
+插件挂在 dsh 原生事件上（`session/event` 捕获、`agent/pre-step` 注入），蒸馏调用复用宿主 `ctx.llm`。召回以**消息侧注入**呈现：相关记忆作为一条合成消息排在用户新消息之前，会话流里显示为**"上下文注入 · memory"**行（点开看命中内容）——用户能直接看到"记忆生效了"；注入内容有长度预算与时间预算，超限截断/超时跳过，绝不拖慢对话。**同会话去重**：已注入过的记忆不再重复注入（模型上下文里已经有了，追问同类问题时省 token）；上下文被 `/compact` 压缩或清空时自动重置，记忆可重新注入；被更新的记忆（内容变化换新 id）不受旧压制。**时效加权**：召回排序按 `相关度 × max(0.5, 0.5^(距上次更新天数/30))` 软加权——相关度相近的候选之间新鲜记忆优先（名额自然轮转），相关度足够高的老记忆照常召回（地板保证最多损失一半排序分，长期事实不沉底）；`recall.decayHalfLifeDays` 可调，0=关闭。
 
 **记忆工具(3):**
 - memory_search
@@ -206,7 +206,8 @@ ONNX 量化 **CPU 推理**——无需 API Key，数据不出本机）。本地
   绕开镜像 CDN 偶发的坏缓存对象），校验失配从零重下、网络错误保留断点续传；
   落盘数据目录 `models/<id>/`，不用了随时在设置页删除；
 - **按需运行时**：首次切换本地档才安装推理运行时（transformers.js，约 100~200MB，
-  装进数据目录 `runtime/`——不进插件依赖树，不碰插件安装目录）；
+  装进数据目录 `runtime/`——不进插件依赖树，不碰插件安装目录）；模型加载与推理在
+  **独立 worker 线程**执行，不冻结宿主事件循环（嵌入计算期间对话与页面交互照常）；
 - **活切换**：一键换源——自动后台全量重嵌（进度可见、可取消，期间检索自动降级
   关键词，不影响对话；维度变化时向量表按新维度重建）；切换失败保持旧源，重启仍按原源运行；
 - **生效规则 = 部署上限 AND 运行时选择**：`embedding.allowLocalModels=false` 可整体
@@ -256,6 +257,7 @@ ONNX 量化 **CPU 推理**——无需 API Key，数据不出本机）。本地
 | `recall.includeSceneNav` | `true` | 系统提示注入场景导航（`<scene-navigation>`，稳定区） |
 | `recall.strategy` | `hybrid` | 检索策略：`keyword` / `embedding` / `hybrid` |
 | `recall.scoreThreshold` | `0.3` | 召回分数阈值（低于不注入；仅 keyword/embedding 策略生效，hybrid 融合前不过滤；工具路径不过滤） |
+| `recall.decayHalfLifeDays` | `30` | 召回时效衰减半衰期（天，0=关）：排序按 `相关度 × max(0.5, 0.5^(距更新天数/半衰期))` 软加权——相关度相近的候选间新鲜记忆优先（名额轮转），老记忆最多损失一半排序分（地板兜底，长期事实不沉底） |
 | `embedding.enabled` | `false` | 向量检索开关；关闭即纯 FTS 运行 |
 | `embedding.baseUrl` | 空 | OpenAI 兼容 /embeddings 地址（如 `https://api.siliconflow.cn/v1`） |
 | `embedding.apiKey` | 空 | API Key |

package/dist/config.d.ts

@@ -66,6 +66,9 @@ export interface MemoryConfig {
         strategy: 'keyword' | 'embedding' | 'hybrid';
         /** 召回路径分数阈值（0~1，低于该分不注入；工具路径不过滤）。 */
         scoreThreshold: number;
+        /** 时效衰减半衰期（天，0=关）：召回排序的 freshness 加权——score × max(0.5, 0.5^(Δ天/半衰期))，
+         *  只影响相关度相近候选间的名次（老记忆最多损失一半排序分，不淘汰）。 */
+        decayHalfLifeDays: number;
     };
     embedding: {
         /** 向量检索总开关；关闭时纯 FTS 运行（官方 provider="none" 同款）。 */
@@ -170,6 +173,7 @@ export declare const memorySchema: Schema<Schemastery.ObjectS<{
         includeSceneNav: Schema<boolean, boolean>;
         strategy: Schema<"keyword" | "embedding" | "hybrid", "keyword" | "embedding" | "hybrid">;
         scoreThreshold: Schema<number, number>;
+        decayHalfLifeDays: Schema<number, number>;
     }>, Schemastery.ObjectT<{
         enabled: Schema<boolean, boolean>;
         maxResults: Schema<number, number>;
@@ -180,6 +184,7 @@ export declare const memorySchema: Schema<Schemastery.ObjectS<{
         includeSceneNav: Schema<boolean, boolean>;
         strategy: Schema<"keyword" | "embedding" | "hybrid", "keyword" | "embedding" | "hybrid">;
         scoreThreshold: Schema<number, number>;
+        decayHalfLifeDays: Schema<number, number>;
     }>>;
     embedding: Schema<Schemastery.ObjectS<{
         enabled: Schema<boolean, boolean>;
@@ -276,6 +281,7 @@ export declare const memorySchema: Schema<Schemastery.ObjectS<{
         includeSceneNav: Schema<boolean, boolean>;
         strategy: Schema<"keyword" | "embedding" | "hybrid", "keyword" | "embedding" | "hybrid">;
         scoreThreshold: Schema<number, number>;
+        decayHalfLifeDays: Schema<number, number>;
     }>, Schemastery.ObjectT<{
         enabled: Schema<boolean, boolean>;
         maxResults: Schema<number, number>;
@@ -286,6 +292,7 @@ export declare const memorySchema: Schema<Schemastery.ObjectS<{
         includeSceneNav: Schema<boolean, boolean>;
         strategy: Schema<"keyword" | "embedding" | "hybrid", "keyword" | "embedding" | "hybrid">;
         scoreThreshold: Schema<number, number>;
+        decayHalfLifeDays: Schema<number, number>;
     }>>;
     embedding: Schema<Schemastery.ObjectS<{
         enabled: Schema<boolean, boolean>;

package/dist/config.js

@@ -48,6 +48,9 @@ export const memorySchema = Schema.object({
         includeSceneNav: Schema.boolean().default(true),
         strategy: Schema.union(['keyword', 'embedding', 'hybrid']).default('hybrid'),
         scoreThreshold: Schema.number().min(0).max(1).default(0.3),
+        // 时效衰减（#29）：乘法软加权 + 地板 0.5（老记忆最多损失一半排序分），只轮转
+        // 相关度相近候选的名次；0=关（bench 基线可比性可 pin 0）
+        decayHalfLifeDays: Schema.number().min(0).max(3650).default(30),
     }),
     embedding: Schema.object({
         enabled: Schema.boolean().default(false),

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>;
@@ -167,6 +169,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 +180,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>;

package/dist/index.js

@@ -131,7 +131,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 +292,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, {

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/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 {