dsh-layered-memory 0.7.0 → 0.8.0

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/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();
@@ -154,17 +158,20 @@ export class L0Store {
                 opts?.onProgress?.(done, total);
                 continue;
             }
+            const pending = [];
             chunk.forEach((c, j) => {
                 if (isZeroVector(vecs[j])) {
                     skipped++;
                     skippedNow.push(c.id);
                     return;
                 }
-                if (this.db.updateL0Vec(c.id, vecs[j], ''))
-                    written++;
-                else
-                    failed++;
+                pending.push({ id: c.id, embedding: vecs[j] });
             });
+            if (pending.length > 0) {
+                const ok = this.db.updateL0VecBatch(pending, '');
+                written += ok;
+                failed += pending.length - ok;
+            }
             done += chunk.length;
             opts?.onProgress?.(done, total);
         }

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);
@@ -221,17 +221,20 @@ export class L1Store {
                 opts?.onProgress?.(done, total);
                 continue;
             }
+            const pending = [];
             chunk.forEach((c, j) => {
                 if (isZeroVector(vecs[j])) {
                     skipped++;
                     skippedNow.push(c.id);
                     return;
                 }
-                if (this.db.updateL1Vec(c.id, vecs[j]))
-                    written++;
-                else
-                    failed++;
+                pending.push({ id: c.id, embedding: vecs[j] });
             });
+            if (pending.length > 0) {
+                const ok = this.db.updateL1VecBatch(pending);
+                written += ok;
+                failed += pending.length - ok;
+            }
             done += chunk.length;
             opts?.onProgress?.(done, total);
         }

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[];

package/dist/store/pending.js

@@ -7,6 +7,12 @@
  */
 import * as path from 'node:path';
 import { atomicWriteJson, readJsonIfExists } from './io.js';
+/** 旧格式（无 sessionId 字段）条目加载时归属的会话组。 */
+export const LEGACY_SESSION = 'legacy';
+/** 全新起步：三档都从 1 爬坡（首轮即触发抽取）。 */
+export function freshWarmup() {
+    return { auto: 1, chat: 1, work: 1 };
+}
 export function emptyPending() {
     return { auto: [], chat: [], work: [] };
 }
@@ -16,7 +22,8 @@ function isMessage(m) {
     const r = m;
     return typeof r.id === 'string' && typeof r.content === 'string' && (r.role === 'user' || r.role === 'assistant');
 }
-/** 读取缓冲文件：文件缺失/损坏 → 空桶（不抛出——丢了缓冲 L0 事实源仍在）。 */
+/** 读取缓冲文件：文件缺失/损坏 → 空桶（不抛出——丢了缓冲 L0 事实源仍在）。
+ *  旧格式条目（无 sessionId）归 legacy 组；warmup 缺省 = 全新起步。 */
 export async function loadPending(file, logger) {
     const out = emptyPending();
     let raw;
@@ -26,27 +33,60 @@ export async function loadPending(file, logger) {
     catch {
         raw = undefined;
     }
-    if (!raw || typeof raw !== 'object' || !raw.buckets || typeof raw.buckets !== 'object')
-        return out;
+    if (!raw || typeof raw !== 'object' || !raw.buckets || typeof raw.buckets !== 'object') {
+        return { buckets: out, warmup: freshWarmup() };
+    }
     let dropped = 0;
+    let legacy = 0;
     for (const key of ['auto', 'chat', 'work']) {
         const arr = raw.buckets[key];
         if (!Array.isArray(arr))
             continue;
         for (const m of arr) {
-            if (isMessage(m))
-                out[key].push(m);
-            else
+            if (!isMessage(m)) {
                 dropped++;
+                continue;
+            }
+            const sid = m.sessionId;
+            if (typeof sid === 'string' && sid) {
+                out[key].push({ ...m, sessionId: sid });
+            }
+            else {
+                legacy++;
+                out[key].push({ ...m, sessionId: LEGACY_SESSION });
+            }
         }
     }
     if (dropped > 0)
         logger?.warn(`[memory] 未蒸馏缓冲文件含 ${dropped} 条坏记录，已丢弃`);
-    return out;
+    if (legacy > 0)
+        logger?.info(`[memory] 未蒸馏缓冲含 ${legacy} 条旧格式条目，归入 legacy 会话组`);
+    const warmup = freshWarmup();
+    for (const key of ['auto', 'chat', 'work']) {
+        const w = raw.warmup?.[key];
+        if (typeof w === 'number' && Number.isFinite(w) && w >= 0)
+            warmup[key] = Math.floor(w);
+    }
+    return { buckets: out, warmup };
+}
+/** 按会话分组（会话切片）：组按首条时间排序、组内按时间稳定排序——
+ *  蒸馏的一切触发都以切片为单位，切片内永不跨会话混装（ADR-0003）。 */
+export function groupPendingBySession(messages) {
+    const groups = new Map();
+    for (const m of messages) {
+        const g = groups.get(m.sessionId);
+        if (g)
+            g.push(m);
+        else
+            groups.set(m.sessionId, [m]);
+    }
+    return [...groups.entries()]
+        .map(([sessionId, msgs]) => ({ sessionId, messages: [...msgs].sort((a, b) => a.timestamp - b.timestamp) }))
+        .sort((a, b) => a.messages[0].timestamp - b.messages[0].timestamp);
 }
 /** 全量原子落盘（每次蒸馏尝试后调用；桶有上限，量级为百条级）。 */
-export async function savePending(file, buckets) {
-    const payload = { version: 1, buckets };
+export async function savePending(file, buckets, warmup) {
+    const payload = { version: 1, buckets, ...(warmup ? { warmup } : {}) };
     await atomicWriteJson(file, payload);
 }
 export function pendingPathFor(dataDir) {

package/dist/store/runtime-installer.d.ts

@@ -28,14 +28,17 @@ export declare class RuntimeInstaller {
     private readonly target;
     private readonly logger?;
     private readonly spawnImpl;
+    /** 随包 lockfile 路径（测试可注入；默认取 dist 根下构建期拷入的资产）。 */
+    private readonly lockfileSource;
     private progress;
     private child;
     private current;
-    /** 安装超时（npm 卡死不罕见：registry 停滞即永挂，applyBusy 会被锁死）。 */
+    /** 安装超时（npm 卡死不罕见：registry 停滞即永挂，applyBusy 会被锁死）。每次 spawn 独立计时。 */
     private static INSTALL_TIMEOUT_MS;
     constructor(dataDir: string, targetVersion: string, opts?: {
         logger?: MemoryLogger;
         spawnImpl?: SpawnImpl;
+        lockfileSource?: string;
     });
     /** 包内模块名（与钉死版本一起构成安装目标）。 */
     static packageName: string;
@@ -56,5 +59,7 @@ export declare class RuntimeInstaller {
     /** 从 runtime 目录解析已安装的 transformers 模块（LocalEmbeddingService 用）。 */
     resolveModule(): unknown;
     private pushLine;
+    /** 跑一次 npm 子进程（采集尾行 + 超时 kill），返回退出码（null = 被杀死/启动失败）。 */
+    private runNpm;
     private installOnce;
 }

package/dist/store/runtime-installer.js

@@ -4,7 +4,11 @@
  * 插件 npm 包本体不带重依赖，不用本地嵌入的用户零成本。
  *
  * - 安装位置：数据目录 runtime/（自带 package.json 锚定，防 npm 向上层目录逃逸安装）；
- * - 子进程 npm install --ignore-scripts --no-audit --no-fund，钉死精确版本；
+ * - 子进程 npm ci --ignore-scripts --no-audit --no-fund，钉死精确版本 + 随包 lockfile
+ *   （resources/runtime-package-lock.json，构建期拷入 dist/）锁定完整传递依赖树——
+ *   纯 install 只锁直接依赖的精确版本，传递依赖按 semver 浮动解析，registry 端
+ *   后续发布/投毒会随安装时间漂移；lockfile 把树冻结在作者侧。ci 失败（lock 与
+ *   package.json 漂移等）自动回退 npm install 精确版本（可用性优先，树不再受锁）；
  * - 进度（用户硬性要求：不能傻等）：npm 非交互模式无百分比 API，采用不确定进度——
  *   已耗时 + 子进程 stdout/stderr 尾行实时流出 + 可 kill；
  * - 幂等：已装版本 == 目标版本直接就绪；版本漂移（插件升级换了钉死版本）重装覆盖。
@@ -13,6 +17,7 @@ import { spawn } from 'node:child_process';
 import { createRequire } from 'node:module';
 import { promises as fs } from 'node:fs';
 import * as path from 'node:path';
+import { fileURLToPath } from 'node:url';
 /** 钉死的 transformers.js 版本（D8：精确版本，升级插件时在此变更并重装运行时）。 */
 export const PINNED_TRANSFORMERS_VERSION = '4.2.0';
 export class RuntimeInstaller {
@@ -20,15 +25,19 @@ export class RuntimeInstaller {
     target;
     logger;
     spawnImpl;
+    /** 随包 lockfile 路径（测试可注入；默认取 dist 根下构建期拷入的资产）。 */
+    lockfileSource;
     progress;
     child = null;
     current = null;
-    /** 安装超时（npm 卡死不罕见：registry 停滞即永挂，applyBusy 会被锁死）。 */
+    /** 安装超时（npm 卡死不罕见：registry 停滞即永挂，applyBusy 会被锁死）。每次 spawn 独立计时。 */
     static INSTALL_TIMEOUT_MS = 10 * 60_000;
     constructor(dataDir, targetVersion, opts) {
         this.runtimeDir = path.join(dataDir, 'runtime');
         this.target = targetVersion;
         this.logger = opts?.logger;
+        this.lockfileSource =
+            opts?.lockfileSource ?? path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', 'runtime-package-lock.json');
         this.spawnImpl =
             opts?.spawnImpl ??
                 ((command, args, cwd) => {
@@ -127,41 +136,71 @@ export class RuntimeInstaller {
         if (lines.length > 5)
             lines.splice(0, lines.length - 5);
     }
+    /** 跑一次 npm 子进程（采集尾行 + 超时 kill），返回退出码（null = 被杀死/启动失败）。 */
+    async runNpm(args) {
+        const child = this.spawnImpl('npm', args, this.runtimeDir);
+        this.child = child;
+        child.onStdout((l) => this.pushLine(l));
+        child.onStderr((l) => this.pushLine(l));
+        const timeout = setTimeout(() => {
+            this.pushLine('安装超时（10 分钟），终止子进程');
+            child.kill();
+        }, RuntimeInstaller.INSTALL_TIMEOUT_MS);
+        const code = await child.exited;
+        clearTimeout(timeout);
+        this.child = null;
+        return code;
+    }
     async installOnce() {
-        // 锚定 package.json：没有它 npm 会向上层目录找最近的 package.json 安装（逃逸事故）
+        // 锚定 package.json（带精确依赖）：没有它 npm 会向上层目录找最近的 package.json 安装（逃逸事故）；
+        // npm ci 还要求它与 lockfile 根条目一致——每次安装都写规范化形状，覆盖历史遗留/被 npm 改写的副本。
         await fs.mkdir(this.runtimeDir, { recursive: true });
-        const manifestPath = path.join(this.runtimeDir, 'package.json');
-        try {
-            await fs.access(manifestPath);
-        }
-        catch {
-            await fs.writeFile(manifestPath, JSON.stringify({ name: 'dsh-memory-runtime', private: true }, null, 2));
-        }
+        const manifest = {
+            name: 'dsh-memory-runtime',
+            private: true,
+            dependencies: { [RuntimeInstaller.packageName]: this.target },
+        };
+        await fs.writeFile(path.join(this.runtimeDir, 'package.json'), JSON.stringify(manifest, null, 2));
         this.progress = {
             phase: 'installing',
             targetVersion: this.target,
             installedVersion: await this.installedVersion(),
             startedAt: Date.now(),
             elapsedMs: 0,
-            lastLines: [`npm install ${RuntimeInstaller.packageName}@${this.target}（--ignore-scripts）`],
+            lastLines: [],
         };
-        const child = this.spawnImpl('npm', ['install', '--ignore-scripts', '--no-audit', '--no-fund', '--loglevel', 'notice', `${RuntimeInstaller.packageName}@${this.target}`], this.runtimeDir);
-        this.child = child;
-        child.onStdout((l) => this.pushLine(l));
-        child.onStderr((l) => this.pushLine(l));
-        const timeout = setTimeout(() => {
-            this.pushLine('安装超时（10 分钟），终止子进程');
-            child.kill();
-        }, RuntimeInstaller.INSTALL_TIMEOUT_MS);
         this.logger?.info(`[memory] 运行时安装开始: ${RuntimeInstaller.packageName}@${this.target} → ${this.runtimeDir}`);
-        const code = await new Promise((resolve) => {
-            void child.exited.then((c) => {
-                clearTimeout(timeout);
-                resolve(c);
-            });
-        });
+        // 首选 npm ci + 随包 lockfile（传递依赖树冻结在作者侧）；lockfile 资产缺失（npm 包被裁剪等）
+        // 或 ci 失败（lock 与锚定版本漂移等）回退 npm install 精确版本——可用性优先。
+        let code = null;
+        let usedCi = false;
+        try {
+            const lock = await fs.readFile(this.lockfileSource, 'utf8');
+            await fs.writeFile(path.join(this.runtimeDir, 'package-lock.json'), lock);
+            this.pushLine(`npm ci（随包 lockfile 锁定依赖树，@${this.target}，--ignore-scripts）`);
+            usedCi = true;
+            code = await this.runNpm(['ci', '--ignore-scripts', '--no-audit', '--no-fund', '--loglevel', 'notice']);
+        }
+        catch {
+            /* 无随包 lockfile，直接走 install 回退 */
+        }
+        if (!usedCi || code !== 0) {
+            if (usedCi) {
+                this.pushLine('npm ci 失败（lockfile 与钉死版本漂移？），回退 npm install');
+                this.logger?.warn('[memory] 运行时 npm ci 失败，回退 npm install（传递依赖不再受随包 lockfile 锁定）');
+            }
+            this.pushLine(`npm install ${RuntimeInstaller.packageName}@${this.target}（--ignore-scripts）`);
+            code = await this.runNpm([
+                'install',
+                '--ignore-scripts',
+                '--no-audit',
+                '--no-fund',
+                '--loglevel',
+                'notice',
+                `${RuntimeInstaller.packageName}@${this.target}`,
+            ]);
+        }
         this.progress.elapsedMs = Date.now() - this.progress.startedAt;
-        this.child = null;
         const version = await this.installedVersion();
         this.progress.installedVersion = version;
         if (this.progress.phase === 'cancelled') {

package/dist/store/search-utils.js

@@ -3,8 +3,9 @@
  * - rrfMerge：RRF（Reciprocal Rank Fusion，k=60）多路结果融合，hybrid 检索用；
  * - bm25RankToScore：FTS5 bm25 rank（负值=更相关）转 0~1 分数；
  * - buildFtsQuery / tokenizeForFts：FTS5 查询构造与写入侧分词。
- *   官方用 jieba 分词；这里用项目自带的 CJK 二元组 + 英文词分词（util/text.ts），
- *   读写两侧共用同一分词器，保证查询 token 与索引 token 对齐，且零原生依赖。
+ *   分词走 util/text.ts 的 tokenize（jieba 词 + CJK 二元组并集，@node-rs/jieba
+ *   预编译二进制，加载失败自动回退纯二元组），读写两侧共用同一分词器，
+ *   保证查询 token 与索引 token 对齐；FTS 索引按分词器版本戳自动重建（sqlite.ts）。
  */
 import { tokenize } from '../util/text.js';
 /** 标准 RRF 常数（原论文值）；k 越大越偏向低排名项（分布更平滑）。 */

package/dist/store/session-modes.d.ts

@@ -7,6 +7,8 @@ export declare class SessionModeStore {
     private readonly entries;
     private readonly loaded;
     private persistFailed;
+    /** 档位切换回调（index.ts 装配 runner 的同步动作：切片落袋/挂起，ADR-0003）。 */
+    private onModeChange?;
     /** 串行化持久化写（避免并发原子写撞临时文件名）。 */
     private writeChain;
     constructor(dataDir: string, defaultMode: Extract<MemoryMode, 'auto' | 'chat' | 'work'>, logger?: MemoryLogger | undefined);
@@ -15,6 +17,8 @@ export declare class SessionModeStore {
     get default(): MemoryMode;
     /** 同步读取：未设置过的会话返回默认档。 */
     get(sessionId: string): MemoryMode;
+    /** 注册档位切换回调（同步调用；回调异常只记日志不阻断写穿）。 */
+    setModeChangeHandler(cb: (sessionId: string, oldMode: MemoryMode, newMode: MemoryMode) => void): void;
     /** 设置会话档位（写穿持久化；持久化失败保持内存态生效）。 */
     set(sessionId: string, mode: MemoryMode): void;
     /** 等待在途持久化写完成（测试/停机用）。 */

package/dist/store/session-modes.js

@@ -5,6 +5,7 @@
  * 存储失败只降级为内存态（warn 不崩），与插件的存储降级不变量一致。
  */
 import * as path from 'node:path';
+import { errDetail } from '../util/filelog.js';
 import { atomicWriteJson, ensureDir, readJsonIfExists } from './io.js';
 const MODES = ['auto', 'chat', 'work', 'off'];
 const PRUNE_MS = 90 * 24 * 3600_000;
@@ -19,6 +20,8 @@ export class SessionModeStore {
     entries = new Map();
     loaded;
     persistFailed = false;
+    /** 档位切换回调（index.ts 装配 runner 的同步动作：切片落袋/挂起，ADR-0003）。 */
+    onModeChange;
     /** 串行化持久化写（避免并发原子写撞临时文件名）。 */
     writeChain = Promise.resolve();
     constructor(dataDir, defaultMode, logger) {
@@ -52,10 +55,23 @@ export class SessionModeStore {
     get(sessionId) {
         return this.entries.get(sessionId)?.mode ?? this.loaded;
     }
+    /** 注册档位切换回调（同步调用；回调异常只记日志不阻断写穿）。 */
+    setModeChangeHandler(cb) {
+        this.onModeChange = cb;
+    }
     /** 设置会话档位（写穿持久化；持久化失败保持内存态生效）。 */
     set(sessionId, mode) {
+        const old = this.get(sessionId);
         this.entries.set(sessionId, { mode, updatedAt: Date.now() });
         this.writeChain = this.writeChain.then(() => this.persist());
+        if (old !== mode && this.onModeChange) {
+            try {
+                this.onModeChange(sessionId, old, mode);
+            }
+            catch (err) {
+                this.logger?.warn(`[memory] 档位切换回调失败: ${errDetail(err)}`);
+            }
+        }
     }
     /** 等待在途持久化写完成（测试/停机用）。 */
     flush() {

package/dist/store/sqlite.d.ts

@@ -34,6 +34,8 @@ export declare class MemoryDb {
     private readonly logger?;
     private stmtUpsertL1;
     private stmtGetL1;
+    /** 主表存在性点查（防御性 FTS 删除的前置判断，走主键索引）。 */
+    private stmtL1Exists;
     private stmtDeleteL1Meta;
     private stmtDeleteL1Vec?;
     private stmtInsertL1Vec?;
@@ -44,6 +46,8 @@ export declare class MemoryDb {
     private stmtL1FtsSearchFamily;
     private stmtUpsertL0;
     private stmtGetL0;
+    /** 主表存在性点查（同 L1：防御性 FTS 删除的前置判断）。 */
+    private stmtL0Exists;
     private stmtDeleteL0Vec?;
     private stmtInsertL0Vec?;
     private stmtSearchL0Vec?;
@@ -81,8 +85,13 @@ export declare class MemoryDb {
     private hasColumn;
     /** 重建后的 l1_fts 从 l1_records 全量回灌（仅在 drop 重建时调用）。 */
     private backfillL1Fts;
+    /** 重建后的 l0_fts 从 l0_conversations 全量回灌（仅 drop 重建时调用；iterate 流式防大库内存峰值）。 */
+    private backfillL0Fts;
     private readEmbeddingMeta;
     private writeEmbeddingMeta;
+    /** 通用字符串 kv（embedding_meta 表兼作元数据 kv 存储，如 FTS 分词器版本戳）。 */
+    private readMetaString;
+    private writeMetaString;
     /**
      * 持久化 embedding meta（语义：物理向量表当前对应的 provider/维度）。
      * 活切换在 swapProvider 成功后即写（表已是新维度）；启动/补齐链在
@@ -139,6 +148,9 @@ export declare class MemoryDb {
     countL0(): number;
     /** 统计 recorded_at >= iso 的消息数（状态面板"今日捕获"用）。 */
     countL0Since(iso: string): number;
+    /** 按会话取最近消息（时间升序返回；走 idx_l0_session_id 索引）。
+     *  蒸馏背景参考专用——按会话现查替代全局内存数组（ADR-0003）。 */
+    recentL0BySession(sessionId: string, limit: number): L0MessageRecord[];
     /** L0 全量列举（重建快照用；按时间升序，事务一致性避开 JSONL 追加竞态）。 */
     listL0All(): L0MessageRecord[];
     /** 重建成本预估（一次全表聚合：会话数 / 消息数 / 字符量）。 */
@@ -176,6 +188,21 @@ export declare class MemoryDb {
     /** 只更新向量行（重嵌入用）。 */
     updateL1Vec(id: string, embedding: Float32Array): boolean;
     updateL0Vec(id: string, embedding: Float32Array, recordedAt: string): boolean;
+    /**
+     * 批量更新 L1 向量行（重嵌入热路径）：单事务写入整批，替代逐条裸写——
+     * 逐条每行一次隐式事务，批量场景（万级记录重嵌）开销集中在 fsync 上。
+     * 整批失败回退逐条：好行照常入库，坏行只丢自身（向量行 id 寻址，无顺序依赖）。
+     * 返回成功写入的行数（零向量行防御性跳过、不计入）。
+     */
+    updateL1VecBatch(items: Array<{
+        id: string;
+        embedding: Float32Array;
+    }>): number;
+    /** L0 版 updateL1VecBatch（语义同：单事务 + 失败回退逐条）。recordedAt 整批统一。 */
+    updateL0VecBatch(items: Array<{
+        id: string;
+        embedding: Float32Array;
+    }>, recordedAt: string): number;
     close(): void;
 }
 /** 全零向量（cosine 未定义，不可入向量表）。reindex 侧用它区分"不可嵌入"与"写入失败"。 */