dsh-layered-memory 0.8.5 → 0.8.7

package/dist/store/l1.d.ts

@@ -21,7 +21,11 @@ export declare class L1Store {
     private readonly helper;
     private embedSvc;
     private readonly logger?;
-    constructor(dataDir: string, db: MemoryDb, embed?: EmbeddingService, strategy?: RecallStrategy, logger?: MemoryLogger);
+    /** 时效衰减半衰期（天；0=关）。 */
+    private readonly decayHalfLifeDays;
+    constructor(dataDir: string, db: MemoryDb, embed?: EmbeddingService, strategy?: RecallStrategy, logger?: MemoryLogger, 
+    /** 时效衰减半衰期（天；0=关）。缺省 30 与 config 默认一致。 */
+    decayHalfLifeDays?: number);
     init(): Promise<void>;
     /** 旧版单文件 records.jsonl 一次性导入检索库，成功后改名 .imported。 */
     private importLegacy;
@@ -44,6 +48,12 @@ export declare class L1Store {
      * 融合完整列表（融合分已归一化 0~1，可直接用于展示/过滤）。
      */
     search(query: string, limit: number, opts?: L1SearchOptions): Promise<L1Hit[]>;
+    /**
+     * 时效衰减加权（#29）：三路共用的读路径后处理——阈值过滤之后、截断之前
+     * （才能轮转名额，而不只是重排已截断的集合）。updated_at 经主表批量点查
+     * 回填（FTS 表无该列；候选池 ≤ limit×3 条主键查询，微秒级）。关闭时零开销。
+     */
+    private applyDecay;
     /** 浏览列表（UI 用）：无关键词时按更新时间倒序分页。 */
     list(opts: {
         type?: string;

package/dist/store/l1.js

@@ -11,7 +11,7 @@ import * as path from 'node:path';
 import { familyForType } from '../types.js';
 import { EmbedHelper, NoopEmbeddingService } from './embedding.js';
 import { appendJsonl, dayKey, ensureDir, readJsonl } from './io.js';
-import { RRF_K, rrfMerge } from './search-utils.js';
+import { applyDecayWeight, RRF_K, rrfMerge } from './search-utils.js';
 import { isZeroVector } from './sqlite.js';
 /** 官方过度召回倍数：候选池 = limit × 3（官方 tool 路径同款）。 */
 const CANDIDATE_MULTIPLIER = 3;
@@ -23,7 +23,11 @@ export class L1Store {
     helper;
     embedSvc;
     logger;
-    constructor(dataDir, db, embed = new NoopEmbeddingService(), strategy = 'hybrid', logger) {
+    /** 时效衰减半衰期（天；0=关）。 */
+    decayHalfLifeDays;
+    constructor(dataDir, db, embed = new NoopEmbeddingService(), strategy = 'hybrid', logger, 
+    /** 时效衰减半衰期（天；0=关）。缺省 30 与 config 默认一致。 */
+    decayHalfLifeDays) {
         this.db = db;
         this.strategy = strategy;
         this.recordsDir = path.join(dataDir, 'records');
@@ -31,6 +35,7 @@ export class L1Store {
         this.embedSvc = embed;
         this.helper = new EmbedHelper(embed, logger);
         this.logger = logger;
+        this.decayHalfLifeDays = decayHalfLifeDays ?? 30;
     }
     async init() {
         await ensureDir(this.recordsDir);
@@ -142,17 +147,17 @@ export class L1Store {
             return [];
         if (strategy === 'keyword') {
             const fts = this.db.searchL1Fts(query, candidateK, opts?.family);
-            return this.postProcess(applyFtsThreshold(fts, threshold, limit), opts?.type, limit);
+            return this.postProcess(this.applyDecay(applyFtsThreshold(fts, threshold, limit)), opts?.type, limit);
         }
         if (strategy === 'embedding') {
             const vec = await this.helper.query(query, opts?.embeddingTimeoutMs);
             if (!vec) {
                 // embedding 调用失败：降级 FTS，不阻断
                 const fts = this.db.searchL1Fts(query, candidateK, opts?.family);
-                return this.postProcess(applyFtsThreshold(fts, threshold, limit), opts?.type, limit);
+                return this.postProcess(this.applyDecay(applyFtsThreshold(fts, threshold, limit)), opts?.type, limit);
             }
             const vecHits = this.db.searchL1Vector(vec, candidateK, opts?.family);
-            return this.postProcess(filterScore(vecHits, threshold), opts?.type, limit);
+            return this.postProcess(this.applyDecay(filterScore(vecHits, threshold)), opts?.type, limit);
         }
         // hybrid（官方语义）：双路并行 → 完整列表 RRF 融合（融合前不过滤阈值）
         // → 融合分归一化：rank1 双列表命中 = 1.0，单列表命中 ≤ 0.5，保持 0~1 语义
@@ -162,7 +167,22 @@ export class L1Store {
         ]);
         const vecList = vecRaw ? this.db.searchL1Vector(vecRaw, candidateK, opts?.family) : [];
         const merged = rrfMerge([ftsList, vecList], (h) => h.id);
-        return this.postProcess(merged.map(({ rrfScore, ...h }) => ({ ...h, score: normalizeRrf(rrfScore) })), opts?.type, limit);
+        return this.postProcess(this.applyDecay(merged.map(({ rrfScore, ...h }) => ({ ...h, score: normalizeRrf(rrfScore) }))), opts?.type, limit);
+    }
+    /**
+     * 时效衰减加权（#29）：三路共用的读路径后处理——阈值过滤之后、截断之前
+     * （才能轮转名额，而不只是重排已截断的集合）。updated_at 经主表批量点查
+     * 回填（FTS 表无该列；候选池 ≤ limit×3 条主键查询，微秒级）。关闭时零开销。
+     */
+    applyDecay(hits) {
+        if (!(this.decayHalfLifeDays > 0) || hits.length === 0)
+            return hits;
+        const updatedAtById = new Map();
+        for (const r of this.db.getL1ByIds(hits.map((h) => h.id))) {
+            if (Number.isFinite(r.updatedAt))
+                updatedAtById.set(r.id, r.updatedAt);
+        }
+        return applyDecayWeight(hits, this.decayHalfLifeDays, (h) => updatedAtById.get(h.id));
     }
     /** 浏览列表（UI 用）：无关键词时按更新时间倒序分页。 */
     list(opts) {

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

@@ -1,66 +1,89 @@
-/**
- * 本地嵌入服务（D1/D6 决策）：transformers.js + ONNX，进程内 CPU 推理。
- *
- * - 懒加载（D6）：首次嵌入调用才加载模型（下载完成后的预热也走这里），
- *   加载后常驻，close() 释放（嵌入源切走/关闭时调用）；
- * - 模型从数据目录 models/<id>/ 本地加载（env.allowRemoteModels=false 杜绝联网）；
- * - loader 可注入（测试缝）：不依赖真实 transformers.js/模型文件即可测状态机；
- * - 池化方式来自模型目录（BGE 系 CLS / Gemma 系 MEAN），normalize 交给 pipeline
- *   内建 L2 归一（与远程路径的 sanitizeAndNormalize 语义一致）。
- *
- * 注意：真实模型路径的池化正确性（尤其 embeddinggemma 的 mean）属于实现期
- * 待验证项——下载预热后应做一次相似度 sanity 检查（见 PR 验证指引）。
- */
 import type { MemoryLogger } from '../types.js';
 import type { CatalogEntry } from './model-catalog.js';
-import type { EmbeddingProviderInfo, EmbeddingService } from './embedding.js';
-/** transformers.js 的 feature-extraction pipeline 最小面（结构化注入缝）。 */
-export interface ExtractorLike {
-    (texts: string[], opts: {
-        pooling: 'cls' | 'mean';
-        normalize: boolean;
-    }): Promise<Array<{
-        data: number[] | Float32Array;
-    }>>;
-    dispose?: () => Promise<void> | void;
+import type { EmbedCallOptions, EmbeddingProviderInfo, EmbeddingService } from './embedding.js';
+type LocalState = 'idle' | 'loading' | 'ready' | 'failed' | 'terminated';
+/** worker 启动参数（workerData；构造后不可变）。 */
+export interface EmbedWorkerData {
+    runtimeDir: string;
+    modelDir: string;
+    pooling: 'cls' | 'mean';
+    dtype: string;
+    maxInputChars: number;
 }
-export interface TransformersModuleLike {
-    pipeline: (task: string, model: string, opts?: Record<string, unknown>) => Promise<ExtractorLike>;
-    env?: {
-        allowLocalModels?: boolean;
-        allowRemoteModels?: boolean;
-    };
+/** 主线程 → worker 的调用（id 由通道分配）。 */
+export type EmbedWorkerCall = {
+    type: 'ping';
+} | {
+    type: 'warmup';
+} | {
+    type: 'embed';
+    texts: string[];
+    priority: boolean;
+};
+/** worker → 主线程的应答。 */
+export type EmbedWorkerReply = {
+    id: number;
+    ok: true;
+    type: 'pong';
+} | {
+    id: number;
+    ok: true;
+    type: 'ready';
+} | {
+    id: number;
+    ok: true;
+    type: 'embedded';
+    vectors: Float32Array[];
+} | {
+    id: number;
+    ok: false;
+    stage: 'load' | 'infer';
+    error: string;
+};
+/** worker 通道抽象（测试缝：smoke 注入假实现验证协议与状态机）。 */
+export interface EmbedWorkerChannel {
+    request(call: EmbedWorkerCall): Promise<EmbedWorkerReply>;
+    /** 立即终止 worker 并拒绝全部未决请求（close 语义）；幂等。 */
+    terminate(): void;
+    /** worker 意外崩溃通知（此后所有未决请求已被通道拒绝）。 */
+    setOnCrash(cb: (error: string) => void): void;
+}
+export interface LocalEmbeddingOptions {
+    /** 数据目录 runtime/（worker 据此 createRequire 加载 transformers）。 */
+    runtimeDir: string;
+    /** worker 资产路径（默认 dist/embedding-worker.cjs；测试可显式指定）。 */
+    workerPath?: string;
+    /** 通道注入缝（测试用；缺省 spawn 真实 worker）。 */
+    channel?: EmbedWorkerChannel;
+    logger?: MemoryLogger;
+    maxInputChars?: number;
 }
-/** 模块加载器（默认走 RuntimeInstaller.resolveModule；测试注入假模块）。 */
-export type ModuleLoader = () => Promise<TransformersModuleLike>;
-type LocalState = 'idle' | 'loading' | 'ready' | 'failed' | 'terminated';
 export declare class LocalEmbeddingService implements EmbeddingService {
     private state;
-    private extractor;
-    private loadPromise;
     private loadError;
-    private readonly modelDir;
+    private readonly channel;
     private readonly entry;
-    private readonly loader;
     private readonly logger?;
-    /** 输入截断（与远程路径同源的 embedding.maxInputChars 配置，缺省 5000）。 */
-    private readonly maxInputChars;
-    constructor(entry: CatalogEntry, modelDir: string, loader: ModuleLoader, logger?: MemoryLogger, maxInputChars?: number);
+    constructor(entry: CatalogEntry, modelDir: string, opts: LocalEmbeddingOptions);
     getDimensions(): number;
     getProviderInfo(): EmbeddingProviderInfo;
     isReady(): boolean;
     /** 状态（进度展示用）。 */
     getState(): LocalState;
     getLoadError(): string | null;
-    /** 后台预热：下载完成后验证可加载性（幂等；失败态可重试）。 */
+    /** 后台预热：启动后让 worker 立即加载模型（幂等；失败态可重试）。 */
     startWarmup(): void;
-    /** 等待预热完成（测试用）。 */
+    /** 等待模型就绪（warmup 协议；applyChain 的 warming 阶段与测试用）。 */
     waitForReady(): Promise<void>;
-    embed(text: string): Promise<Float32Array>;
-    embedBatch(texts: string[]): Promise<Float32Array[]>;
-    /** 释放模型（嵌入源切走/关闭时调用；幂等）。terminated 后不可再复用——
-     * 防止插件卸载/切走后残留的重嵌循环把模型重新加载常驻（内存泄漏）。 */
+    embed(text: string, callOpts?: EmbedCallOptions): Promise<Float32Array>;
+    embedBatch(texts: string[], callOpts?: EmbedCallOptions): Promise<Float32Array[]>;
+    /** 释放 worker 线程与模型（嵌入源切走/关闭时调用；幂等）。terminated 后不可
+     *  再复用——防止插件卸载/切走后残留的重嵌循环把模型重新加载常驻（内存泄漏）。 */
     close(): void;
-    private ensureLoaded;
+    /** 内层钳制（仅缩短）：超时放弃等待（迟到回复由通道按 id 丢弃），调用方降级。 */
+    private requestWithTimeout;
+    /** loading → ready 一次性日志（memory.log 时序可读性：启动到模型就绪的间隔）。 */
+    private markReady;
+    private applyLoadFailure;
 }
 export {};

package/dist/store/local-embedding.js

@@ -1,20 +1,118 @@
+/**
+ * 本地嵌入服务（D1/D6 决策，worker 线程化版）：transformers.js 的模型加载与
+ * ONNX 推理全部在 worker_threads 子线程执行（resources/embedding-worker.cjs），
+ * 本类只是主线程侧的协议代理——onnxruntime-node 的 run/loadModel 是主线程
+ * 同步调用，留在宿主事件循环会冻结整个 dsh 页面（0.8.6 修复的真实事故）。
+ *
+ * - 懒加载（D6）：首次嵌入/warmup 才让 worker 加载模型，close()=terminate
+ *   释放线程与模型（嵌入源切走/关闭时调用），terminated 后不可复用；
+ * - 模型从数据目录 models/<id>/ 本地加载（worker 侧 env.allowRemoteModels=false）；
+ * - channel 可注入（测试缝）：smoke 用假通道验证协议与状态机，不触真模型；
+ * - callOpts.timeoutMs 经 Promise.race 钳制（迟到回复按 id 丢弃——推理在
+ *   worker 线程无法真正取消，但主线程可以停止等待并降级 FTS）；
+ * - 池化方式来自模型目录（BGE 系 CLS / Gemma 系 MEAN），normalize 交给
+ *   pipeline 内建 L2 归一（与远程路径的 sanitizeAndNormalize 语义一致）。
+ */
+import * as path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { Worker } from 'node:worker_threads';
+/** 默认 worker 资产路径：dist/store/ → dist/embedding-worker.cjs（构建期拷入）。 */
+function defaultWorkerPath() {
+    return path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', 'embedding-worker.cjs');
+}
+/** 真实通道：spawn worker_threads + 自增 id 配对 + 崩溃兜底拒绝。 */
+class RealWorkerChannel {
+    worker;
+    pending = new Map();
+    nextId = 1;
+    terminated = false;
+    crashed;
+    crashCb;
+    constructor(workerPath, workerData) {
+        this.worker = new Worker(workerPath, { workerData });
+        this.worker.on('message', (msg) => {
+            if (msg && msg.type === 'fatal') {
+                this.failAll(`本地嵌入 worker 致命错误: ${msg.error ?? '未知'}`);
+                return;
+            }
+            const id = msg.id;
+            if (typeof id !== 'number')
+                return;
+            const entry = this.pending.get(id);
+            if (!entry)
+                return; // 迟到回复（调用方已超时放弃）
+            this.pending.delete(id);
+            entry.resolve(msg);
+        });
+        // error（未捕获异常且 worker 未自处理）与 exit（含 fatal 后的退出）都兜底拒绝
+        this.worker.on('error', (err) => this.failAll(`本地嵌入 worker 线程错误: ${err.message}`));
+        this.worker.on('exit', (code) => {
+            if (!this.terminated)
+                this.failAll(`本地嵌入 worker 线程退出（code=${code}）`);
+        });
+    }
+    request(call) {
+        // 已释放/已崩溃的通道快速拒绝——postMessage 到死线程是静默无回应，调用方会挂到超时
+        if (this.terminated)
+            return Promise.reject(new Error('嵌入 worker 已释放'));
+        if (this.crashed)
+            return Promise.reject(new Error(this.crashed));
+        const id = this.nextId++;
+        return new Promise((resolve, reject) => {
+            this.pending.set(id, { resolve, reject });
+            this.worker.postMessage({ ...call, id });
+        });
+    }
+    terminate() {
+        if (this.terminated)
+            return;
+        this.terminated = true;
+        this.failAll('嵌入 worker 已释放');
+        void this.worker.terminate();
+    }
+    setOnCrash(cb) {
+        this.crashCb = cb;
+        // 构造与回调注册之间发生的崩溃（spawn 即失败等）不丢通知
+        if (this.crashed)
+            cb(this.crashed);
+    }
+    failAll(error) {
+        for (const [, entry] of this.pending)
+            entry.reject(new Error(error));
+        this.pending.clear();
+        if (!this.terminated && !this.crashed) {
+            this.crashed = error;
+            this.crashCb?.(error);
+        }
+    }
+}
 export class LocalEmbeddingService {
     state = 'idle';
-    extractor = null;
-    loadPromise = null;
     loadError = null;
-    modelDir;
+    channel;
     entry;
-    loader;
     logger;
-    /** 输入截断（与远程路径同源的 embedding.maxInputChars 配置，缺省 5000）。 */
-    maxInputChars;
-    constructor(entry, modelDir, loader, logger, maxInputChars) {
+    constructor(entry, modelDir, opts) {
         this.entry = entry;
-        this.modelDir = modelDir;
-        this.loader = loader;
-        this.logger = logger;
-        this.maxInputChars = maxInputChars && maxInputChars > 0 ? maxInputChars : 5000;
+        this.logger = opts.logger;
+        const maxInputChars = opts.maxInputChars && opts.maxInputChars > 0 ? opts.maxInputChars : 5000;
+        this.channel =
+            opts.channel ??
+                new RealWorkerChannel(opts.workerPath ?? defaultWorkerPath(), {
+                    runtimeDir: opts.runtimeDir,
+                    modelDir,
+                    pooling: entry.pooling,
+                    dtype: 'q8',
+                    maxInputChars,
+                });
+        // 崩溃不自愈（换源/重启恢复）：拒绝语义沿 EmbedHelper 降级链走 FTS
+        this.channel.setOnCrash((error) => {
+            if (this.state === 'terminated')
+                return;
+            this.state = 'failed';
+            this.loadError = error;
+            this.logger?.warn(`[memory] ${error}（本地嵌入转入 failed 态，换源或重启可恢复）`);
+        });
     }
     getDimensions() {
         return this.entry.dims;
@@ -24,7 +122,7 @@ export class LocalEmbeddingService {
         return { provider: 'local', model: this.entry.id, dimensions: this.entry.dims };
     }
     isReady() {
-        return this.state === 'ready' && this.extractor !== null;
+        return this.state === 'ready';
     }
     /** 状态（进度展示用）。 */
     getState() {
@@ -33,91 +131,97 @@ export class LocalEmbeddingService {
     getLoadError() {
         return this.loadError;
     }
-    /** 后台预热：下载完成后验证可加载性（幂等；失败态可重试）。 */
+    /** 后台预热：启动后让 worker 立即加载模型（幂等；失败态可重试）。 */
     startWarmup() {
-        void this.ensureLoaded();
+        void this.waitForReady().catch(() => { });
     }
-    /** 等待预热完成（测试用）。 */
+    /** 等待模型就绪（warmup 协议；applyChain 的 warming 阶段与测试用）。 */
     async waitForReady() {
-        await this.ensureLoaded();
+        if (this.state === 'ready')
+            return;
+        if (this.state === 'terminated') {
+            throw new Error('本地嵌入服务已释放（嵌入源已切换）；本实例不可复用');
+        }
+        if (this.state !== 'failed')
+            this.state = 'loading';
+        const reply = await this.channel.request({ type: 'warmup' });
+        if (!reply.ok) {
+            this.applyLoadFailure(reply.error);
+            throw new Error(reply.error);
+        }
+        this.markReady();
     }
-    async embed(text) {
-        const [vec] = await this.embedBatch([text]);
+    async embed(text, callOpts) {
+        const [vec] = await this.embedBatch([text], callOpts);
         return vec;
     }
-    async embedBatch(texts) {
+    async embedBatch(texts, callOpts) {
         if (texts.length === 0)
             return [];
         if (this.state === 'terminated') {
             throw new Error('本地嵌入服务已释放（嵌入源已切换）；本实例不可复用');
         }
-        // 首次调用触发懒加载（D6：加载期间调用方等待而非失败——召回只慢这一次）；
-        // 只有明确失败过的服务才抛错（EmbedHelper 捕获后降级 FTS）
-        if (this.state !== 'ready') {
-            if (this.state === 'failed') {
-                throw new Error(`本地嵌入模型加载失败: ${this.loadError ?? '未知原因'}（重启插件或重新下载模型可重试）`);
-            }
-            await this.ensureLoaded();
+        if (this.state === 'failed') {
+            // 只有明确失败过的服务才抛错（EmbedHelper 捕获后降级 FTS）；warmup 可重试
+            throw new Error(`本地嵌入模型加载失败: ${this.loadError ?? '未知原因'}（重启插件或重新下载模型可重试）`);
+        }
+        if (this.state !== 'ready')
+            this.state = 'loading';
+        // 单条请求（召回 query）带优先标记：worker 侧插队，不被 reindex 批次堵队尾
+        const reply = await this.requestWithTimeout({ type: 'embed', texts, priority: texts.length === 1 }, callOpts?.timeoutMs);
+        if (!reply.ok) {
+            if (reply.stage === 'load')
+                this.applyLoadFailure(reply.error);
+            else
+                this.markReady(); // 推理失败说明模型已加载成功（loading → ready），失败只属于这一次调用
+            throw new Error(reply.error);
         }
-        const out = [];
-        // CPU 推理逐条最稳（ORT session 内部并行），量级为本插件写入/重嵌批（≤16）没问题
-        for (const text of texts) {
-            const result = await this.extractor([text.slice(0, this.maxInputChars)], { pooling: this.entry.pooling, normalize: true });
-            out.push(new Float32Array(result[0].data));
+        if (reply.type !== 'embedded')
+            throw new Error(`嵌入 worker 返回异常消息类型: ${reply.type}`);
+        this.markReady();
+        for (const v of reply.vectors) {
+            if (v.length !== this.entry.dims) {
+                throw new Error(`本地嵌入维度不匹配：期望 ${this.entry.dims}，得到 ${v.length}`);
+            }
         }
-        return out;
+        return reply.vectors;
     }
-    /** 释放模型（嵌入源切走/关闭时调用；幂等）。terminated 后不可再复用——
-     * 防止插件卸载/切走后残留的重嵌循环把模型重新加载常驻（内存泄漏）。 */
+    /** 释放 worker 线程与模型（嵌入源切走/关闭时调用；幂等）。terminated 后不可
+     *  再复用——防止插件卸载/切走后残留的重嵌循环把模型重新加载常驻（内存泄漏）。 */
     close() {
-        const ext = this.extractor;
-        this.extractor = null;
-        this.loadPromise = null;
         this.state = 'terminated';
         this.loadError = null;
+        this.channel.terminate();
+    }
+    /** 内层钳制（仅缩短）：超时放弃等待（迟到回复由通道按 id 丢弃），调用方降级。 */
+    async requestWithTimeout(call, timeoutMs) {
+        if (!(timeoutMs && timeoutMs > 0))
+            return this.channel.request(call);
+        let timer;
         try {
-            const dispose = ext?.dispose;
-            if (dispose)
-                void Promise.resolve(dispose.call(ext));
+            return await Promise.race([
+                this.channel.request(call),
+                new Promise((_, reject) => {
+                    timer = setTimeout(() => reject(new Error(`本地嵌入调用超时（${timeoutMs}ms），已放弃等待`)), timeoutMs);
+                }),
+            ]);
         }
-        catch {
-            /* 释放失败不影响状态复位 */
+        finally {
+            // 先到者胜出后清掉另一个定时器（不清理会挂住引用至自然到期，raceRecallTimeout 同款）
+            if (timer)
+                clearTimeout(timer);
         }
     }
-    async ensureLoaded() {
+    /** loading → ready 一次性日志（memory.log 时序可读性：启动到模型就绪的间隔）。 */
+    markReady() {
         if (this.state === 'ready')
             return;
-        if (this.state === 'loading' && this.loadPromise)
-            return this.loadPromise;
-        this.state = 'loading';
-        this.loadError = null;
-        this.loadPromise = (async () => {
-            try {
-                const mod = await this.loader();
-                if (mod.env) {
-                    mod.env.allowRemoteModels = false;
-                    if (mod.env.allowLocalModels !== undefined)
-                        mod.env.allowLocalModels = true;
-                }
-                const extractor = await mod.pipeline('feature-extraction', this.modelDir, { dtype: 'q8' });
-                // loading 中被 close()（terminated）：不得覆写状态复活（review C）——直接释放丢弃
-                if (this.state === 'terminated') {
-                    const dispose = extractor.dispose;
-                    if (dispose)
-                        void Promise.resolve(dispose.call(extractor)).catch(() => { });
-                    throw new Error('加载期间服务已释放');
-                }
-                this.extractor = extractor;
-                this.state = 'ready';
-                this.logger?.info(`[memory] 本地嵌入模型就绪: ${this.entry.id}（dims=${this.entry.dims}，pooling=${this.entry.pooling}）`);
-            }
-            catch (err) {
-                this.state = 'failed';
-                this.loadError = err instanceof Error ? err.message : String(err);
-                this.logger?.warn(`[memory] 本地嵌入模型加载失败（${this.entry.id}）: ${this.loadError}`);
-                throw err;
-            }
-        })();
-        return this.loadPromise;
+        this.state = 'ready';
+        this.logger?.info(`[memory] 本地嵌入模型就绪: ${this.entry.id}（dims=${this.entry.dims}，pooling=${this.entry.pooling}）`);
+    }
+    applyLoadFailure(error) {
+        this.state = 'failed';
+        this.loadError = error;
+        this.logger?.warn(`[memory] 本地嵌入模型加载失败（${this.entry.id}）: ${error}`);
     }
 }

package/dist/store/recall-dedupe.d.ts

@@ -0,0 +1,26 @@
+import type { MemoryLogger } from '../types.js';
+/** 会话条目上限（按 updatedAt 淘汰最旧；防文件无限增长）。 */
+export declare const RECALL_DEDUPE_SESSION_CAP = 200;
+/** 单会话记录 id 上限（按插入序淘汰最旧；Set 迭代序即插入序）。 */
+export declare const RECALL_DEDUPE_IDS_CAP = 512;
+export declare class RecallDedupeStore {
+    private readonly logger?;
+    private readonly file;
+    private readonly entries;
+    private persistFailed;
+    /** 串行化持久化写（避免并发原子写撞临时文件名）；init 链最前（先载入再落盘，防丢更新）。 */
+    private writeChain;
+    constructor(dataDir: string, logger?: MemoryLogger | undefined);
+    /** 载入持久化映射（合并进内存——构造与载入之间发生的 mark 不丢）；失败降级内存态。 */
+    private init;
+    /** 该会话的已注入集合（热路径同步读；未出现过的会话返回空集合，惰性建条）。 */
+    seen(sessionId: string): Set<string>;
+    /** 标记本轮实际注入的记录 id（写穿；调用方保证只传模型真实看到的条目）。 */
+    mark(sessionId: string, recordIds: string[]): void;
+    /** 清空该会话的记录（compact/clear 后上下文已丢失，记忆需可重新注入）。 */
+    reset(sessionId: string): void;
+    /** 等待在途持久化写完成（测试/停机用）。 */
+    flush(): Promise<void>;
+    private persist;
+    private serialize;
+}