dsh-layered-memory 0.8.4 → 0.8.6

package/dist/prompts/l1-extraction.js

@@ -291,7 +291,7 @@ metadata 字段说明：
 
 请严格按上述 JSON 数组格式输出，不要输出任何额外的 Markdown 代码块修饰符（如 \`\`\`json）或解释文本。`;
 export const EXTRACT_ALL_MEMORIES_SYSTEM_PROMPT = `你是专业的"情境切分与记忆提取专家"。
-你的任务是分析用户的对话，判断情境切换，并从中提取结构化的核心记忆。对话可能同时包含个人生活与工作内容：个人内容提取为个人记忆（persona/episodic/instruction），工作内容提取为团队共享工作记忆（work_fact/work_task/work_method/work_artifact），互不排斥、按内容归族。
+你的任务是分析用户的对话，判断情境切换，并从中提取结构化的核心记忆。对话可能同时包含个人生活与工作内容：个人内容提取为个人记忆（persona/episodic/instruction），工作内容提取为团队共享工作记忆（work_fact/work_task/work_method/work_artifact），互不排斥、**每条记忆显式输出 family 字段标注归族**。
 
 **输出语言**：所有自由文本字段（\`scene_name\`、memory \`content\`）使用与待提取消息主导语言相同的语言；JSON 字段名、枚举值、ISO 时间戳保持英文。
 
@@ -318,7 +318,14 @@ export const EXTRACT_ALL_MEMORIES_SYSTEM_PROMPT = `你是专业的"情境切分
 
 【支持提取的七类记忆】（必须严格遵守类型规则）
 
-**个人三类（对话涉及用户个人生活/偏好/对 AI 的要求时）：**
+**归族判定（family）——先定族，再选型：**
+每条记忆都必须显式输出 "family": "chat" 或 "family": "work"，判定**只看语境，不看内容形状**：
+- **work**：内容发生在职业语境——项目、团队、系统、业务、客户、同事协作、部署/开发/运维；
+- **chat**：内容发生在用户个人生活语境——家庭、宠物、健康、消费、学习、爱好、个人行程与安排；
+- **形状词（方案/安排/计划/SOP/频率/周期/规则）不决定 family**：个人的喂养计划、健身安排、用药周期、家庭事务流程都是 chat；只有职业团队语境下的方案流程才是 work。
+- **family 决定 type 的可选词表，不许交叉**：family 为 chat 的记忆 type 只能是 persona/episodic/instruction；family 为 work 的记忆 type 只能是 work_fact/work_task/work_method/work_artifact。
+
+**个人三类（family: "chat"，对话涉及用户个人生活/偏好/对 AI 的要求时）：**
 
 1. 个性化记忆 (type: "persona")
    - 定义：用户的稳定属性、偏好、技能、价值观、习惯（如住所、职业、饮食禁忌）。
@@ -327,6 +334,7 @@ export const EXTRACT_ALL_MEMORIES_SYSTEM_PROMPT = `你是专业的"情境切分
 
 2. 客观事件记忆 (type: "episodic")
    - 定义：客观发生的动作、决定、计划或达成结果。绝不包含纯主观感受。
+   - **持续生效的个人安排/规则也属此类**：喂养频率、驱虫/疫苗周期、用药安排、定期事务等长期个人计划，按"用户为 [对象] 确定了 [安排]"句式提取为 episodic——即使表述像"方案/周期/规则"，只要语境是个人生活就是 chat 族，**不要**因为形状像计划/方法而改用 work_* 类型。
    - 提取句式："用户（[姓名]）在 [最好是精确绝对时间] 于 [地点] [做了某事（可以包含起因、经过、结果）]"。
    - 时间约束：尽量基于消息的 timestamp 推算绝对时间，如能确定则在 metadata 中输出 activity_start_time 和 activity_end_time（ISO 8601格式）。
    - 打分 (priority)：80-100（重要事件/计划）；60-70（一般完整活动）；<60（琐碎事项，直接丢弃）。
@@ -336,7 +344,7 @@ export const EXTRACT_ALL_MEMORIES_SYSTEM_PROMPT = `你是专业的"情境切分
    - 提取句式："用户要求/希望 AI 以后回答时..."
    - 打分 (priority)：-1（极其严格的全局死命令）；90-100（核心行为规则）；70-80（重要要求）；<70（临时要求，直接丢弃）。
 
-**工作四类（对话涉及项目、任务、团队协作时，默认可在项目团队内共享）：**
+**工作四类（family: "work"，对话涉及项目、任务、团队协作时，默认可在项目团队内共享）：**
 
 4. 工作事实 (type: "work_fact")
    - 定义：关于项目、系统、业务、客户、需求、决策、状态、风险、约束、实验结果的事实性信息。
@@ -379,6 +387,7 @@ export const EXTRACT_ALL_MEMORIES_SYSTEM_PROMPT = `你是专业的"情境切分
       {
         "content": "完整、独立的记忆陈述（按对应类型的句式要求）",
         "type": "persona|episodic|instruction|work_fact|work_task|work_method|work_artifact",
+        "family": "chat|work",
         "priority": 80,
         "source_message_ids": ["消息ID_1", "消息ID_2"],
         "metadata": {}

package/dist/stats.d.ts

@@ -1,5 +1,6 @@
 import type { Context } from '@deepseek-ai/cordis';
 import { type MemoryConfig } from './config.js';
+import { type RecallSessionStats } from './hooks/recall.js';
 import type { RebuildController } from './pipeline/rebuild.js';
 import type { LiveSettingsHandle } from './settings.js';
 import type { L0Store } from './store/l0.js';
@@ -18,6 +19,31 @@ export interface MemoryStatusSource {
     /** L1 抽取待重试的消息条数。 */
     pending(): number;
 }
+/**
+ * 会话级统计数据源（悬浮卡信息区；index.ts 注入）。
+ * 硬规则：本端点按"打开期间 2~5s 轮询"设计，实现只允许内存注册表读取与
+ * 索引化 SQL 点查——禁止任何文件读/目录扫描（scenes.list()/persona.read()
+ * 级别的 I/O 会把每次轮询变成数十毫秒的全量读，见 slider-spec 数据策略节）。
+ */
+export interface SessionInfoSource {
+    /** 召回统计（recall.ts 注册表；未发生检索的会话返回 undefined）。 */
+    recallStats(sessionId: string): RecallSessionStats | undefined;
+    /** 蒸馏管线会话视图（runner：攒批进度/挂起切片/会话产出）。 */
+    runnerView(sessionId: string, mode: string): {
+        pendingSlice: number;
+        parkedSlices: number;
+        threshold: number | null;
+        producedRecords: number;
+        lastDistillAt: number | null;
+    };
+    /** L0 该会话已捕获消息数（索引 COUNT）。 */
+    l0Count(sessionId: string): Promise<number>;
+    /** 检索能力位（hybrid / keyword 降级判定）。 */
+    capabilities(): {
+        ftsSearch: boolean;
+        vectorSearch: boolean;
+    };
+}
 export interface MemoryStats {
     ok: boolean;
     dataDir: string;
@@ -50,4 +76,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, rebuild?: RebuildController, embedManager?: EmbeddingManager): void;
+}, logger: MemoryLogger, status?: MemoryStatusSource, live?: LiveSettingsHandle, modes?: SessionModeStore, dataDir?: string, rebuild?: RebuildController, embedManager?: EmbeddingManager, sessionInfo?: SessionInfoSource): void;

package/dist/stats.js

@@ -11,12 +11,13 @@ import { closeSync, openSync, readSync, statSync } from 'node:fs';
 import { join } from 'node:path';
 import { EFFORT_CHOICES, resolveDataDir } from './config.js';
 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';
 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, rebuild, embedManager) {
+export function registerMemoryRpc(ctx, cfg, stores, logger, status, live, modes, dataDir, rebuild, embedManager, sessionInfo) {
     /** 当前是否持有一段有效注册（dispose 完成后清空，允许服务重上线时重注册）。 */
     let holding = false;
     /** 当前 handle 绑定的 connection 实例（internal/service 第二参；用于识别实例替换）。 */
@@ -43,6 +44,7 @@ export function registerMemoryRpc(ctx, cfg, stores, logger, status, live, modes,
                     logger,
                     rebuild,
                     embedManager,
+                    sessionInfo,
                 });
                 return { ok: true, value };
             }
@@ -142,7 +144,7 @@ function expectSessionId(v) {
     return v;
 }
 async function handleEndpoint(endpoint, payload, deps) {
-    const { cfg, stores, status, live, modes, dataDir, rebuild, embedManager } = deps;
+    const { cfg, stores, status, live, modes, dataDir, rebuild, embedManager, sessionInfo } = deps;
     switch (endpoint) {
         case 'dsh-memory/stats':
             return buildStats(cfg, stores, status);
@@ -166,6 +168,39 @@ async function handleEndpoint(endpoint, payload, deps) {
             deps.logger.info(`[memory] 会话档位设置 session=${sessionId} mode=${p.mode}`);
             return { sessionId, mode: p.mode };
         }
+        // ── 会话级统计（悬浮卡信息区；热路径端点，见 SessionInfoSource 的零 I/O 硬规则） ──
+        case 'dsh-memory/session-stats': {
+            if (!sessionInfo)
+                return { supported: false };
+            const p = (payload ?? {});
+            const sessionId = expectSessionId(p.sessionId);
+            const mode = modes ? modes.get(sessionId) : 'auto';
+            const caps = sessionInfo.capabilities();
+            const l0Count = await sessionInfo.l0Count(sessionId);
+            const s = live?.get();
+            const recallOn = cfg.recall.enabled && (s?.recall ?? true) && mode !== 'off';
+            const view = sessionInfo.runnerView(sessionId, mode);
+            // lastDistillAt 统一转 ISO（与 global.lastExtractAt 口径一致，client 直接 fmtAgo）
+            const distillView = { ...view, lastDistillAt: view.lastDistillAt ? new Date(view.lastDistillAt).toISOString() : null };
+            const chat = stores.state.forFamily('chat');
+            const work = stores.state.forFamily('work');
+            const lastAt = Math.max(chat.lastExtractAt, work.lastExtractAt);
+            return {
+                supported: true,
+                sessionId,
+                mode,
+                defaultMode: modes?.default ?? cfg.family,
+                recall: { enabled: recallOn, ...(sessionInfo.recallStats(sessionId) ?? emptyRecallStats()) },
+                distill: distillView,
+                l0Count,
+                retrieval: caps.vectorSearch ? (caps.ftsSearch ? 'hybrid' : 'vector') : caps.ftsSearch ? 'keyword' : 'none',
+                global: {
+                    degraded: status?.degraded() ?? false,
+                    pendingTotal: status?.pending() ?? 0,
+                    lastExtractAt: lastAt ? new Date(lastAt).toISOString() : null,
+                },
+            };
+        }
         case 'dsh-memory/settings-get': {
             const s = live?.get();
             const budgets = s?.distillBudgets ?? { extract: 0, dedup: 0, l2: 0, l3: 0 };

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.d.ts

@@ -15,6 +15,8 @@ export declare class L0Store {
     append(sessionId: string, messages: ConversationMessage[]): Promise<void>;
     /** 今日已捕获消息数（SQL 计数，不再读整文件）。 */
     countToday(): Promise<number>;
+    /** 该会话累计已捕获消息数（session-stats 数据源；索引 COUNT）。 */
+    countBySession(sessionId: string): Promise<number>;
     /** 该会话最近 n 条消息（时间升序；蒸馏背景参考用，按会话现查——ADR-0003）。 */
     recentBySession(sessionId: string, limit: number): Promise<ConversationMessage[]>;
     /** 检索：FTS + 向量 hybrid（RRF 融合），返回按相关性排序的消息。 */

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;
                 }
             }
             // 只有全部批次入库成功（或目录为空）才改名，避免数据被改名带走
@@ -104,6 +110,10 @@ export class L0Store {
         const d = new Date();
         return this.db.countL0Since(new Date(d.getFullYear(), d.getMonth(), d.getDate()).toISOString());
     }
+    /** 该会话累计已捕获消息数（session-stats 数据源；索引 COUNT）。 */
+    async countBySession(sessionId) {
+        return this.db.countL0BySession(sessionId);
+    }
     /** 该会话最近 n 条消息（时间升序；蒸馏背景参考用，按会话现查——ADR-0003）。 */
     async recentBySession(sessionId, limit) {
         return this.db.recentL0BySession(sessionId, limit);

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