dsh-layered-memory 0.7.1 → 0.8.1

package/dist/stats.js

@@ -10,6 +10,9 @@ import { createRequire } from 'node:module';
 import { closeSync, openSync, readSync, statSync } from 'node:fs';
 import { join } from 'node:path';
 import { resolveDataDir } from './config.js';
+import { effectiveCfg } from './pipeline/runner.js';
+import { LAYER_DEFAULT_BUDGETS, 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 服务可选，缺失时跳过，不影响插件主体）。 */
@@ -30,6 +33,7 @@ export function registerMemoryRpc(ctx, cfg, stores, logger, status, live, modes,
         const dispose = connection.rpc.handle('/rpc', async (endpoint, payload) => {
             try {
                 const value = await handleEndpoint(endpoint, payload, {
+                    ctx,
                     cfg,
                     stores,
                     status,
@@ -157,9 +161,14 @@ async function handleEndpoint(endpoint, payload, deps) {
         }
         case 'dsh-memory/settings-get': {
             const s = live?.get();
+            const budgets = s?.distillBudgets ?? { extract: 0, dedup: 0, l2: 0, l3: 0 };
             return {
                 supported: live?.supported ?? false,
-                settings: s ?? { enabled: true, capture: true, distill: true, recall: true, reasoningEffort: '' },
+                settings: s ?? {
+                    enabled: true, capture: true, distill: true, recall: true,
+                    reasoningEffort: '', distillProvider: '', distillModel: '',
+                    distillBudgets: { extract: 0, dedup: 0, l2: 0, l3: 0 }, distillMaxInputChars: 0,
+                },
                 // 静态部署上限（cordis.patch.yml）：运行时开关与它取 AND
                 ceilings: { capture: cfg.capture.enabled, distill: cfg.extract.enabled, recall: cfg.recall.enabled },
                 // 蒸馏思考档位：current 是运行时覆盖（'' = 跟随配置），effective 是实际生效值
@@ -168,6 +177,23 @@ async function handleEndpoint(endpoint, payload, deps) {
                     effective: s?.reasoningEffort || cfg.llm.reasoningEffort,
                     fallback: cfg.llm.reasoningEffort,
                 },
+                // 分层输出预算：current 是运行时覆盖（0 = 跟随默认），defaults 是内置默认（UI 占位/提示用）
+                budgets: {
+                    current: budgets,
+                    defaults: { ...LAYER_DEFAULT_BUDGETS },
+                    effective: {
+                        extract: budgets.extract > 0 ? budgets.extract : LAYER_DEFAULT_BUDGETS.extract,
+                        dedup: budgets.dedup > 0 ? budgets.dedup : LAYER_DEFAULT_BUDGETS.dedup,
+                        l2: budgets.l2 > 0 ? budgets.l2 : LAYER_DEFAULT_BUDGETS.l2,
+                        l3: budgets.l3 > 0 ? budgets.l3 : LAYER_DEFAULT_BUDGETS.l3,
+                    },
+                },
+                // 输入预算（字符）：current 是运行时覆盖（0 = 跟随配置），fallback 是静态配置值
+                inputBudget: {
+                    current: s?.distillMaxInputChars ?? 0,
+                    fallback: cfg.llm.maxInputChars,
+                    effective: s && s.distillMaxInputChars > 0 ? s.distillMaxInputChars : cfg.llm.maxInputChars,
+                },
             };
         }
         case 'dsh-memory/settings-set': {
@@ -186,6 +212,37 @@ async function handleEndpoint(endpoint, payload, deps) {
                 }
                 clean.reasoningEffort = v;
             }
+            // 蒸馏模型运行时覆盖：供应商/模型 id 原样接受（不在此校验存在性——
+            // 供应商可被用户随后删除，解析侧按存在性回退并提示）
+            for (const key of ['distillProvider', 'distillModel']) {
+                if (patch[key] !== undefined) {
+                    const v = String(patch[key]);
+                    if (v.length > 200)
+                        throw new Error(`${key} 过长（≤200 字符）`);
+                    clean[key] = v;
+                }
+            }
+            // 分层输出预算：四键一起校验，非负整数 ≤ 100 万；0 = 跟随内置默认
+            if (patch.distillBudgets !== undefined) {
+                const raw = (patch.distillBudgets ?? {});
+                const budgets = {};
+                for (const key of ['extract', 'dedup', 'l2', 'l3']) {
+                    const n = Number(raw[key] ?? 0);
+                    if (!Number.isInteger(n) || n < 0 || n > 1_000_000) {
+                        throw new Error(`distillBudgets.${key} 须为 0~1000000 的整数（0 = 跟随默认）`);
+                    }
+                    budgets[key] = n;
+                }
+                clean.distillBudgets = budgets;
+            }
+            // 输入预算（字符）：0 = 跟随静态配置；正值须落在静态 schema 同款范围（1000~100 万）
+            if (patch.distillMaxInputChars !== undefined) {
+                const n = Number(patch.distillMaxInputChars);
+                if (!Number.isInteger(n) || n < 0 || n > 1_000_000 || (n > 0 && n < 1000)) {
+                    throw new Error('distillMaxInputChars 须为 0 或 1000~1000000 的整数（0 = 跟随配置）');
+                }
+                clean.distillMaxInputChars = n;
+            }
             if (Object.keys(clean).length === 0)
                 throw new Error('开关更新载荷为空');
             await live.update(clean);
@@ -270,6 +327,61 @@ async function handleEndpoint(endpoint, payload, deps) {
                 throw new Error('重建控制器未初始化');
             return rebuild.requestCancel();
         }
+        // ── 蒸馏模型选择器（用户已配置的供应商路由） ──
+        case 'dsh-memory/llm-providers': {
+            // 供应商目录（已注册适配器的活动路由）+ 默认选择 + 当前覆盖与实际生效路由
+            let providers = [];
+            try {
+                providers = deps.ctx.llm.listProviders();
+            }
+            catch (err) {
+                deps.logger.warn(`[memory] 供应商列表读取失败: ${errDetail(err)}`);
+            }
+            let def = null;
+            try {
+                const sel = deps.ctx.get('agentDefaultModel')?.currentSelection?.();
+                if (sel?.provider && sel?.model)
+                    def = { provider: sel.provider, model: sel.model };
+            }
+            catch {
+                /* 可选服务缺失 = 无默认选择 */
+            }
+            const s = live?.get();
+            const current = { provider: s?.distillProvider ?? '', model: s?.distillModel ?? '' };
+            let effective = null;
+            try {
+                effective = await resolveModelRoute(deps.ctx, effectiveCfg(cfg, live));
+            }
+            catch {
+                effective = null; // 无法解析（无默认选择且未覆盖）时 UI 显示占位
+            }
+            return {
+                supported: true,
+                providers,
+                default: def,
+                // 部署静态 pin（provider+model 双字段）优先于运行时选择，UI 据此禁用选择器
+                pinned: Boolean(cfg.llm.provider && cfg.llm.model),
+                current,
+                // 所选供应商是否仍在已注册路由中（用户删掉供应商后提示回退）
+                currentRegistered: current.provider === '' || providers.some((p) => p.id === current.provider),
+                effective,
+            };
+        }
+        case 'dsh-memory/llm-models': {
+            const p = (payload ?? {});
+            if (typeof p.provider !== 'string' || !p.provider)
+                throw new Error('provider 缺失');
+            // 两个内置适配器（deepseek/pi-ai）的 listModels 都读本地快照不触网；
+            // 仍加超时兜底，防第三方适配器实现为远端查询拖死 RPC 轮询
+            const models = await Promise.race([
+                deps.ctx.llm.listModels(p.provider),
+                new Promise((_, reject) => setTimeout(() => reject(new Error('模型列表查询超时')), 8000)),
+            ]);
+            return {
+                provider: p.provider,
+                models: models.map((m) => ({ id: m.id, name: m.name, description: m.description ?? null })),
+            };
+        }
         // ── 嵌入源（远程/本地/关闭 三态）与模型管理 ──
         case 'dsh-memory/embedding-state-get': {
             if (!embedManager)

package/dist/store/bm25.js

@@ -1,5 +1,6 @@
 /**
- * 轻量 BM25 检索（无外部依赖）：拉丁词 + CJK 二元组分词。
+ * 轻量 BM25 检索：与 FTS 共用同一分词器（util/text.ts 的 tokenize，
+ * jieba 词 + CJK 二元组并集）。
  * 仅用于 L2 场景摘要的上下文选取（小语料）；L0/L1 检索走 SQLite FTS5/向量。
  */
 import { tokenize } from '../util/text.js';

package/dist/store/download-queue.d.ts

@@ -31,10 +31,18 @@ export interface DownloaderOptions {
     /** 下载镜像根（默认 https://hf-mirror.com，可配回 https://huggingface.co）。 */
     mirror: string;
     logger?: MemoryLogger;
-    /** 测试注入；默认全局 fetch。 */
+    /** 测试注入；默认 undici fetch（按需挂代理 dispatcher）。 */
     fetchImpl?: FetchLike;
     /** 测试注入磁盘剩余字节；默认 statfs。 */
     freeBytes?: () => Promise<number | null>;
+    /** 单文件失败的自动重试间隔（毫秒），长度即重试次数；默认 [1000, 3000]。
+     *  sha256 失配重试从零开始（污染断点已删除）；数量不吻合/网络错误保留断点续传。 */
+    retryDelaysMs?: number[];
+    /** 显式代理三态：''（默认）= 探测代理环境变量；'none' = 禁用强制直连；
+     *  其他值 = 代理 URL（如 http://127.0.0.1:7890）。镜像直连在国内网络
+     *  间歇不可达（真实事故：直连超时与污染字节交替），与 curl/npm 同语义地
+     *  走用户已配置的代理是可达性的底线。 */
+    proxy?: string;
 }
 export declare class ModelDownloadQueue {
     private readonly dataDir;
@@ -42,7 +50,15 @@ export declare class ModelDownloadQueue {
     private progress;
     private busy;
     private abort;
+    /** 代理 dispatcher（按需创建；dispose 关闭连接池）。 */
+    private agent;
+    /** 默认 fetch：undici（可挂代理 dispatcher）；测试注入优先。 */
+    private readonly defaultFetch;
     constructor(dataDir: string, opts: DownloaderOptions);
+    /** 镜像根（无尾斜杠）。 */
+    private mirrorUrl;
+    /** 释放代理连接池（插件 dispose 链调用；无代理时幂等无操作）。 */
+    dispose(): void;
     /** 当前进度快照（无任务时 null）。 */
     getProgress(): DownloadProgress | null;
     /** 是否有任务在跑（含校验阶段）。 */
@@ -64,8 +80,25 @@ export declare class ModelDownloadQueue {
     /** 取消当前任务：中断 fetch，保留 .part 断点。 */
     cancel(): boolean;
     private run;
-    /** 下载单文件到最终路径（含续传与校验），返回该文件贡献的字节数。 */
+    /** 下载单文件到最终路径（含续传与校验），返回该文件贡献的字节数。
+     *  单文件失败自动重试（默认 2 次）+ **重试换缓存键**：镜像链路
+     *  （Caddy×3 → CloudFront → Cloudflare）存在缓存对象污染窗口——同一时间窗内
+     *  同一 URL 确定性拿到错误字节（2026-08-19 embeddinggemma generation_config.json
+     *  连续错哈希的真实事故），普通重试会全打同一污染缓存；每次重试追加
+     *  `?dshmem-retry=N` 参数绕开缓存键另取对象，窗口期也能自愈。
+     *  - sha256 失配：downloadFileOnce 已删除断点 → 从零重下；
+     *  - 数量不吻合/网络错误：断点保留 → Range 续传重试；
+     *  - 取消：立即上抛不重试。 */
     private downloadFile;
+    /** 单次尝试：续传探测 → fetch（attempt>0 追加缓存键参数）→ 落盘 → 尺寸与 sha256 校验 → rename。 */
+    private downloadFileOnce;
     private freeBytes;
 }
+/**
+ * 解析下载代理（三态）：`''`（默认）= 探测代理环境变量（HTTPS_PROXY > ALL_PROXY >
+ * HTTP_PROXY，大小写双形态，尊重 NO_PROXY）；`'none'` = 禁用代理强制直连；
+ * 其他值 = 显式代理 URL。与 curl/npm 同语义——用户配置了代理 env 的机器上
+ * 镜像直连往往间歇不可达（真实事故：直连超时与污染字节交替出现）。
+ */
+export declare function resolveProxyUrl(setting: string | undefined, host: string): string;
 export {};

package/dist/store/download-queue.js

@@ -6,13 +6,15 @@
  * - 断点续传：写 .part 旁车文件，重试从断点 Range 续传；服务器不支持 Range（回 200）
  *   则从头重写；取消保留断点；
  * - 完整性：每文件下满后流式哈希整文件比对目录 sha256（续传无法增量哈希，落盘后
- *   单遍校验最简单且正确）；失配删文件整体重下；
+ *   单遍校验最简单且正确）；失配删文件整体重下；单文件失败自动重试（默认 2 次，
+ *   吸收镜像瞬态污染——sha 失配从零重下、网络类错误保留断点续传）；
  * - 磁盘门禁：下载前检查数据目录所在卷剩余空间 ≥ 模型体积 × 1.2（statfs 不可用时跳过）；
  * - 同一时刻只跑一个下载任务（串行队列），后续请求直接拒绝并说明。
  */
 import { createHash } from 'node:crypto';
 import { promises as fs } from 'node:fs';
 import * as path from 'node:path';
+import { fetch as undiciFetch, ProxyAgent } from 'undici';
 import { catalogById, catalogTotalBytes, MODEL_CATALOG } from './model-catalog.js';
 const DISK_HEADROOM = 1.2;
 export class ModelDownloadQueue {
@@ -21,9 +23,40 @@ export class ModelDownloadQueue {
     progress = null;
     busy = false;
     abort = null;
+    /** 代理 dispatcher（按需创建；dispose 关闭连接池）。 */
+    agent;
+    /** 默认 fetch：undici（可挂代理 dispatcher）；测试注入优先。 */
+    defaultFetch;
     constructor(dataDir, opts) {
         this.dataDir = dataDir;
         this.opts = opts;
+        // 畸形 mirror（无 scheme 等）只跳过代理解析，不炸构造器（下载本身还会报清晰的 URL 错）
+        let host = '';
+        try {
+            host = new URL(this.mirrorUrl()).host;
+        }
+        catch {
+            /* ignore */
+        }
+        const proxy = resolveProxyUrl(opts.proxy, host);
+        if (proxy) {
+            this.agent = new ProxyAgent(proxy);
+            opts.logger?.info(`[memory] 模型下载走代理 ${proxy}（镜像直连在国内网络间歇不可达）`);
+        }
+        this.defaultFetch = ((u, init) => {
+            const dispatch = this.agent;
+            // undici fetch 的 init 接受 dispatcher；RequestInit 类型无此字段，断言透传
+            return undiciFetch(u, { ...init, ...(dispatch ? { dispatcher: dispatch } : {}) });
+        });
+    }
+    /** 镜像根（无尾斜杠）。 */
+    mirrorUrl() {
+        return this.opts.mirror.replace(/\/+$/, '');
+    }
+    /** 释放代理连接池（插件 dispose 链调用；无代理时幂等无操作）。 */
+    dispose() {
+        void this.agent?.close().catch(() => { });
+        this.agent = undefined;
     }
     /** 当前进度快照（无任务时 null）。 */
     getProgress() {
@@ -187,13 +220,46 @@ export class ModelDownloadQueue {
             prog.overallReceived = overall;
         }
     }
-    /** 下载单文件到最终路径（含续传与校验），返回该文件贡献的字节数。 */
+    /** 下载单文件到最终路径（含续传与校验），返回该文件贡献的字节数。
+     *  单文件失败自动重试（默认 2 次）+ **重试换缓存键**：镜像链路
+     *  （Caddy×3 → CloudFront → Cloudflare）存在缓存对象污染窗口——同一时间窗内
+     *  同一 URL 确定性拿到错误字节（2026-08-19 embeddinggemma generation_config.json
+     *  连续错哈希的真实事故），普通重试会全打同一污染缓存；每次重试追加
+     *  `?dshmem-retry=N` 参数绕开缓存键另取对象，窗口期也能自愈。
+     *  - sha256 失配：downloadFileOnce 已删除断点 → 从零重下；
+     *  - 数量不吻合/网络错误：断点保留 → Range 续传重试；
+     *  - 取消：立即上抛不重试。 */
     async downloadFile(entry, f, dir, onBytes) {
+        const delays = this.opts.retryDelaysMs ?? [1000, 3000];
+        let lastErr;
+        for (let attempt = 0;; attempt++) {
+            if (this.progress?.phase === 'cancelled')
+                throw new Error('已取消');
+            try {
+                return await this.downloadFileOnce(entry, f, dir, attempt, onBytes);
+            }
+            catch (err) {
+                lastErr = err;
+                // as 断言绕开 CFA 窄化——await 期间 cancel() 可能已改写 phase（同 downloadFileOnce 末段）
+                if (this.progress?.phase === 'cancelled')
+                    throw err;
+                if (attempt >= delays.length)
+                    throw err;
+                const msg = err instanceof Error ? err.message : String(err);
+                this.opts.logger?.warn(`[memory] 文件 ${f.path} 第 ${attempt + 1} 次尝试失败（${msg}），${delays[attempt]}ms 后自动重试（换缓存键）`);
+                await new Promise((r) => setTimeout(r, delays[attempt]));
+            }
+        }
+    }
+    /** 单次尝试：续传探测 → fetch（attempt>0 追加缓存键参数）→ 落盘 → 尺寸与 sha256 校验 → rename。 */
+    async downloadFileOnce(entry, f, dir, attempt, onBytes) {
         const finalPath = path.join(dir, f.path);
         const partPath = finalPath + '.part';
-        const base = this.opts.mirror.replace(/\/+$/, '');
-        const url = `${base}/${entry.repo}/resolve/${entry.revision}/${f.path}`;
-        const fetchImpl = this.opts.fetchImpl ?? ((u, init) => fetch(u, init));
+        const base = this.mirrorUrl();
+        // 重试追加缓存键参数：绕开镜像 CDN 的污染缓存对象（同窗口普通重试全打同一对象）
+        const cacheBust = attempt > 0 ? `?dshmem-retry=${attempt}` : '';
+        const url = `${base}/${entry.repo}/resolve/${entry.revision}/${f.path}${cacheBust}`;
+        const fetchImpl = this.opts.fetchImpl ?? this.defaultFetch;
         const prog = this.progress;
         let resumeFrom = 0;
         const partSize = await fileSize(partPath);
@@ -303,6 +369,37 @@ async function fileSize(p) {
         return null;
     }
 }
+/**
+ * 解析下载代理（三态）：`''`（默认）= 探测代理环境变量（HTTPS_PROXY > ALL_PROXY >
+ * HTTP_PROXY，大小写双形态，尊重 NO_PROXY）；`'none'` = 禁用代理强制直连；
+ * 其他值 = 显式代理 URL。与 curl/npm 同语义——用户配置了代理 env 的机器上
+ * 镜像直连往往间歇不可达（真实事故：直连超时与污染字节交替出现）。
+ */
+export function resolveProxyUrl(setting, host) {
+    const value = (setting ?? '').trim();
+    if (value.toLowerCase() === 'none')
+        return '';
+    if (value)
+        return value;
+    const noProxy = process.env.NO_PROXY ?? process.env.no_proxy ?? '';
+    if (noProxy) {
+        for (const raw of noProxy.split(',')) {
+            const entry = raw.trim().replace(/^\./, '').toLowerCase();
+            if (entry && (host.toLowerCase() === entry || host.toLowerCase().endsWith(`.${entry}`)))
+                return '';
+        }
+    }
+    const candidates = [
+        process.env.HTTPS_PROXY, process.env.https_proxy,
+        process.env.ALL_PROXY, process.env.all_proxy,
+        process.env.HTTP_PROXY, process.env.http_proxy,
+    ];
+    for (const c of candidates) {
+        if (c && c.trim())
+            return c.trim();
+    }
+    return '';
+}
 async function sha256File(p) {
     const { createReadStream } = await import('node:fs');
     const hash = createHash('sha256');

package/dist/store/embedding.d.ts

@@ -10,9 +10,14 @@ export interface EmbeddingProviderInfo {
     model: string;
     dimensions: number;
 }
+/** 单次嵌入调用的可选参数：timeoutMs 只允许缩短服务配置的超时（内层钳制），
+ *  永不放大——召回路径用它给 FTS 降级留时间（规格 A 节）。本地实现可忽略。 */
+export interface EmbedCallOptions {
+    timeoutMs?: number;
+}
 export interface EmbeddingService {
-    embed(text: string): Promise<Float32Array>;
-    embedBatch(texts: string[]): Promise<Float32Array[]>;
+    embed(text: string, callOpts?: EmbedCallOptions): Promise<Float32Array>;
+    embedBatch(texts: string[], callOpts?: EmbedCallOptions): Promise<Float32Array[]>;
     getDimensions(): number;
     getProviderInfo(): EmbeddingProviderInfo;
     isReady(): boolean;
@@ -46,8 +51,8 @@ export declare class RemoteEmbeddingService implements EmbeddingService {
     getDimensions(): number;
     getProviderInfo(): EmbeddingProviderInfo;
     isReady(): boolean;
-    embed(text: string): Promise<Float32Array>;
-    embedBatch(texts: string[]): Promise<Float32Array[]>;
+    embed(text: string, callOpts?: EmbedCallOptions): Promise<Float32Array>;
+    embedBatch(texts: string[], callOpts?: EmbedCallOptions): Promise<Float32Array[]>;
 }
 /**
  * 嵌入调用降级助手（L0/L1 Store 共用）：查询向量失败 → undefined（调用方降级 FTS）；
@@ -62,8 +67,9 @@ export declare class EmbedHelper {
     /** 活切换嵌入源（D4/D5）：换掉底层服务并复位一次性告警（新服务重新获得告警机会）。 */
     setService(svc: EmbeddingService): void;
     vectorReady(): boolean;
-    /** 查询向量；失败或空向量返回 undefined（调用方降级 FTS）。 */
-    query(text: string): Promise<Float32Array | undefined>;
+    /** 查询向量；失败或空向量返回 undefined（调用方降级 FTS）。
+     *  timeoutMs 为内层钳制（仅缩短服务超时），召回路径使用。 */
+    query(text: string, timeoutMs?: number): Promise<Float32Array | undefined>;
     /** 批量嵌入；服务未就绪或失败时返回全 undefined（不阻断元数据/FTS 写入）。 */
     batch(texts: string[]): Promise<Array<Float32Array | undefined>>;
     private warn;

package/dist/store/embedding.js

@@ -34,15 +34,17 @@ export class RemoteEmbeddingService {
     isReady() {
         return true;
     }
-    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 [];
         const input = texts.map((t) => t.slice(0, this.opts.maxInputChars));
         const base = this.opts.baseUrl.replace(/\/+$/, '');
+        // 内层钳制只缩短不放大：召回路径传短超时，给 FTS 降级留时间
+        const timeoutMs = Math.min(this.opts.timeoutMs, callOpts?.timeoutMs ?? this.opts.timeoutMs);
         const res = await fetch(`${base}/embeddings`, {
             method: 'POST',
             headers: {
@@ -50,7 +52,7 @@ export class RemoteEmbeddingService {
                 authorization: `Bearer ${this.opts.apiKey}`,
             },
             body: JSON.stringify({ model: this.opts.model, input }),
-            signal: AbortSignal.timeout(this.opts.timeoutMs),
+            signal: AbortSignal.timeout(timeoutMs),
         });
         if (!res.ok) {
             const body = await res.text().catch(() => '');
@@ -103,10 +105,11 @@ export class EmbedHelper {
     vectorReady() {
         return this.embed.isReady();
     }
-    /** 查询向量；失败或空向量返回 undefined（调用方降级 FTS）。 */
-    async query(text) {
+    /** 查询向量；失败或空向量返回 undefined（调用方降级 FTS）。
+     *  timeoutMs 为内层钳制（仅缩短服务超时），召回路径使用。 */
+    async query(text, timeoutMs) {
         try {
-            const vec = await this.embed.embed(text);
+            const vec = await this.embed.embed(text, timeoutMs != null ? { timeoutMs } : undefined);
             return vec.length > 0 ? vec : undefined;
         }
         catch (err) {

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>;
+    /** 该会话最近 n 条消息（时间升序；蒸馏背景参考用，按会话现查——ADR-0003）。 */
+    recentBySession(sessionId: string, limit: number): Promise<ConversationMessage[]>;
     /** 检索：FTS + 向量 hybrid（RRF 融合），返回按相关性排序的消息。 */
     search(query: string, limit: number): Promise<L0MessageRecord[]>;
     /** 活切换嵌入源：同步换底层服务（嵌入源三态切换用）。 */

package/dist/store/l0.js

@@ -99,6 +99,10 @@ export class L0Store {
         const d = new Date();
         return this.db.countL0Since(new Date(d.getFullYear(), d.getMonth(), d.getDate()).toISOString());
     }
+    /** 该会话最近 n 条消息（时间升序；蒸馏背景参考用，按会话现查——ADR-0003）。 */
+    async recentBySession(sessionId, limit) {
+        return this.db.recentL0BySession(sessionId, limit);
+    }
     /** 检索：FTS + 向量 hybrid（RRF 融合），返回按相关性排序的消息。 */
     async search(query, limit) {
         const caps = this.db.getCapabilities();

package/dist/store/l1.d.ts

@@ -10,6 +10,8 @@ export interface L1SearchOptions {
     /** 分数阈值（仅召回路径传；keyword/embedding 策略生效，FTS 含小语料例外；
      *  hybrid 按官方语义在 RRF 融合前不过滤）。 */
     scoreThreshold?: number;
+    /** 嵌入查询内层钳制（ms，只缩短不放大；召回路径传入给 FTS 降级留时间）。 */
+    embeddingTimeoutMs?: number;
 }
 export declare class L1Store {
     private readonly db;

package/dist/store/l1.js

@@ -135,7 +135,7 @@ export class L1Store {
             return this.postProcess(applyFtsThreshold(fts, threshold, limit), opts?.type, limit);
         }
         if (strategy === 'embedding') {
-            const vec = await this.helper.query(query);
+            const vec = await this.helper.query(query, opts?.embeddingTimeoutMs);
             if (!vec) {
                 // embedding 调用失败：降级 FTS，不阻断
                 const fts = this.db.searchL1Fts(query, candidateK, opts?.family);
@@ -148,7 +148,7 @@ export class L1Store {
         // → 融合分归一化：rank1 双列表命中 = 1.0，单列表命中 ≤ 0.5，保持 0~1 语义
         const [ftsList, vecRaw] = await Promise.all([
             Promise.resolve(this.db.searchL1Fts(query, candidateK, opts?.family)),
-            this.helper.query(query),
+            this.helper.query(query, opts?.embeddingTimeoutMs),
         ]);
         const vecList = vecRaw ? this.db.searchL1Vector(vecRaw, candidateK, opts?.family) : [];
         const merged = rrfMerge([ftsList, vecList], (h) => h.id);

package/dist/store/model-catalog.js

@@ -43,7 +43,7 @@ export const MODEL_CATALOG = [
             { path: 'added_tokens.json', size: 35, sha256: '50b2f405ba56a26d4913fd772089992252d7f942123cc0a034d96424221ba946' },
             { path: 'special_tokens_map.json', size: 662, sha256: '2f7b0adf4fb469770bb1490e3e35df87b1dc578246c5e7e6fc76ecf33213a397' },
             { path: 'tokenizer_config.json', size: 1156830, sha256: '3ca953eea6c3c9fcda9cf3df22949ff18b216f7c74bd6459230f3f1013953f3a' },
-            { path: 'generation_config.json', size: 133, sha256: '1fb1efd221c1ca88a736b1b36cb47d754c177677e222acb3b1e5424c5d664870' },
+            { path: 'generation_config.json', size: 133, sha256: '1fb1efd221c1ca88a736d1b36cb47d754c177677e222acb3b1e5424c5d664870' },
             { path: 'tokenizer.json', size: 20323312, sha256: '4dda02faaf32bc91031dc8c88457ac272b00c1016cc679757d1c441b248b9c47' },
             { path: 'onnx/model_quantized.onnx', size: 567874, sha256: '172efde319fe1542dc41f31be6154910b05b78f7a861c265c4600eec906bd6d8' },
             { path: 'onnx/model_quantized.onnx_data', size: 308890624, sha256: '705626e28e4c23c82ade34566b4197d97f534c12275fa406dfb71e9937d388c0' },

package/dist/store/pending.d.ts

@@ -1,15 +1,36 @@
 import type { ConversationMessage, ExtractMode, MemoryLogger } from '../types.js';
+/** 带会话标识的未蒸馏消息（会话切片的成员；CONTEXT.md「会话切片」「捕获档位」）。 */
+export interface PendingMessage extends ConversationMessage {
+    /** 捕获该消息的会话；旧格式数据无此字段，加载时归 legacy 组一次性蒸馏。 */
+    sessionId: string;
+}
 /** 三档蒸馏缓冲桶（off 在捕获侧已被拦截，永远不到这里）。 */
 export interface PendingBuckets {
-    auto: ConversationMessage[];
-    chat: ConversationMessage[];
-    work: ConversationMessage[];
+    auto: PendingMessage[];
+    chat: PendingMessage[];
+    work: PendingMessage[];
 }
+/** 旧格式（无 sessionId 字段）条目加载时归属的会话组。 */
+export declare const LEGACY_SESSION = "legacy";
+/** 各档位桶的渐进阈值状态（0 = 已毕业用稳态值；1 = 爬坡起点；ADR-0003）。 */
+export type WarmupState = Record<ExtractMode, number>;
+/** 全新起步：三档都从 1 爬坡（首轮即触发抽取）。 */
+export declare function freshWarmup(): WarmupState;
 export declare function emptyPending(): PendingBuckets;
-/** 读取缓冲文件：文件缺失/损坏 → 空桶（不抛出——丢了缓冲 L0 事实源仍在）。 */
-export declare function loadPending(file: string, logger?: MemoryLogger): Promise<PendingBuckets>;
+/** 读取缓冲文件：文件缺失/损坏 → 空桶（不抛出——丢了缓冲 L0 事实源仍在）。
+ *  旧格式条目（无 sessionId）归 legacy 组；warmup 缺省 = 全新起步。 */
+export declare function loadPending(file: string, logger?: MemoryLogger): Promise<{
+    buckets: PendingBuckets;
+    warmup: WarmupState;
+}>;
+/** 按会话分组（会话切片）：组按首条时间排序、组内按时间稳定排序——
+ *  蒸馏的一切触发都以切片为单位，切片内永不跨会话混装（ADR-0003）。 */
+export declare function groupPendingBySession(messages: PendingMessage[]): Array<{
+    sessionId: string;
+    messages: PendingMessage[];
+}>;
 /** 全量原子落盘（每次蒸馏尝试后调用；桶有上限，量级为百条级）。 */
-export declare function savePending(file: string, buckets: PendingBuckets): Promise<void>;
+export declare function savePending(file: string, buckets: PendingBuckets, warmup?: WarmupState): Promise<void>;
 export declare function pendingPathFor(dataDir: string): string;
 /** 三档 key（调度/遍历用）。 */
 export declare const PENDING_MODES: readonly ExtractMode[];