dsh-layered-memory 0.6.1 → 0.7.0

package/dist/config.d.ts

@@ -64,6 +64,10 @@ export interface MemoryConfig {
         maxInputChars: number;
         /** 单次调用超时（ms）。 */
         timeoutMs: number;
+        /** 允许本地嵌入模型档（部署上限：公司环境可禁下载与本地推理）。 */
+        allowLocalModels: boolean;
+        /** 模型下载镜像根地址（默认国内可达的 hf-mirror.com，可改回官方）。 */
+        mirror: string;
     };
     llm: {
         /** 蒸馏用的 provider 路由；留空用当前默认选择。 */
@@ -147,6 +151,8 @@ export declare const memorySchema: Schema<Schemastery.ObjectS<{
         dimensions: Schema<number, number>;
         maxInputChars: Schema<number, number>;
         timeoutMs: Schema<number, number>;
+        allowLocalModels: Schema<boolean, boolean>;
+        mirror: Schema<string, string>;
     }>, Schemastery.ObjectT<{
         enabled: Schema<boolean, boolean>;
         baseUrl: Schema<string, string>;
@@ -155,6 +161,8 @@ export declare const memorySchema: Schema<Schemastery.ObjectS<{
         dimensions: Schema<number, number>;
         maxInputChars: Schema<number, number>;
         timeoutMs: Schema<number, number>;
+        allowLocalModels: Schema<boolean, boolean>;
+        mirror: Schema<string, string>;
     }>>;
     llm: Schema<Schemastery.ObjectS<{
         provider: Schema<string, string>;
@@ -238,6 +246,8 @@ export declare const memorySchema: Schema<Schemastery.ObjectS<{
         dimensions: Schema<number, number>;
         maxInputChars: Schema<number, number>;
         timeoutMs: Schema<number, number>;
+        allowLocalModels: Schema<boolean, boolean>;
+        mirror: Schema<string, string>;
     }>, Schemastery.ObjectT<{
         enabled: Schema<boolean, boolean>;
         baseUrl: Schema<string, string>;
@@ -246,6 +256,8 @@ export declare const memorySchema: Schema<Schemastery.ObjectS<{
         dimensions: Schema<number, number>;
         maxInputChars: Schema<number, number>;
         timeoutMs: Schema<number, number>;
+        allowLocalModels: Schema<boolean, boolean>;
+        mirror: Schema<string, string>;
     }>>;
     llm: Schema<Schemastery.ObjectS<{
         provider: Schema<string, string>;

package/dist/config.js

@@ -11,53 +11,56 @@ export const memorySchema = Schema.object({
     capture: Schema.object({
         enabled: Schema.boolean().default(true),
         stripCodeBlocks: Schema.boolean().default(true),
-        maxMessageChars: Schema.number().default(4000),
+        maxMessageChars: Schema.number().min(200).max(200_000).default(4000),
     }),
     extract: Schema.object({
         enabled: Schema.boolean().default(true),
-        minMessages: Schema.number().default(1),
-        backgroundMessages: Schema.number().default(10),
-        candidatePool: Schema.number().default(5),
+        minMessages: Schema.number().min(1).max(100).default(1),
+        backgroundMessages: Schema.number().min(0).max(50).default(10),
+        candidatePool: Schema.number().min(1).max(20).default(5),
     }),
     l2: Schema.object({
         enabled: Schema.boolean().default(true),
-        minNewMemories: Schema.number().default(5),
-        maxScenes: Schema.number().default(12),
-        sceneContextLimit: Schema.number().default(3),
+        minNewMemories: Schema.number().min(1).max(100).default(5),
+        maxScenes: Schema.number().min(1).max(100).default(12),
+        sceneContextLimit: Schema.number().min(0).max(20).default(3),
     }),
     l3: Schema.object({
         enabled: Schema.boolean().default(true),
-        interval: Schema.number().default(20),
+        interval: Schema.number().min(1).max(200).default(20),
     }),
     recall: Schema.object({
         enabled: Schema.boolean().default(true),
-        maxResults: Schema.number().default(5),
+        maxResults: Schema.number().min(1).max(20).default(5),
         includePersona: Schema.boolean().default(true),
         includeSceneNav: Schema.boolean().default(true),
         strategy: Schema.union(['keyword', 'embedding', 'hybrid']).default('hybrid'),
-        scoreThreshold: Schema.number().default(0.3),
+        scoreThreshold: Schema.number().min(0).max(1).default(0.3),
     }),
     embedding: Schema.object({
         enabled: Schema.boolean().default(false),
         baseUrl: Schema.string().default(''),
         apiKey: Schema.string().default(''),
         model: Schema.string().default(''),
-        dimensions: Schema.number().default(0),
-        maxInputChars: Schema.number().default(5000),
-        timeoutMs: Schema.number().default(10_000),
+        // 0 = 纯 FTS 模式（合法值，勿设 min>0）
+        dimensions: Schema.number().min(0).max(8192).default(0),
+        maxInputChars: Schema.number().min(100).max(100_000).default(5000),
+        timeoutMs: Schema.number().min(1000).max(300_000).default(10_000),
+        allowLocalModels: Schema.boolean().default(true),
+        mirror: Schema.string().default('https://hf-mirror.com'),
     }),
     llm: Schema.object({
         provider: Schema.string().default(''),
         model: Schema.string().default(''),
         // 推理模型（如 v4-flash）的 reasoning 计入输出预算：预算不足会被思考吃光导致正文 0 字符
-        maxTokens: Schema.number().default(256_000),
+        maxTokens: Schema.number().min(1024).max(1_000_000).default(256_000),
         // 蒸馏是结构化抽取任务，默认关思考（off）：v4-flash 默认 high 档的思考可把任意 maxTokens
         // 预算全部吃光导致正文 0 字符；非推理模型不认识 effort 时会报 UNSUPPORTED_REASONING_EFFORT，设空串跳过
         reasoningEffort: Schema.union(['', 'off', 'high', 'max']).default('off'),
-        temperature: Schema.number().default(0.3),
+        temperature: Schema.number().min(0).max(2).default(0.3),
         // 模型上下文 1M token，日常压到 ~700k 使用（中文按 1 字≈1 token 保守折算）
-        maxInputChars: Schema.number().default(700_000),
-        timeoutMs: Schema.number().default(120_000),
+        maxInputChars: Schema.number().min(1000).max(1_000_000).default(700_000),
+        timeoutMs: Schema.number().min(1000).max(600_000).default(120_000),
     }),
     tools: Schema.boolean().default(true),
 });

package/dist/hooks/capture.d.ts

@@ -7,7 +7,23 @@ import type { L0Store } from '../store/l0.js';
 import type { LiveSettingsHandle } from '../settings.js';
 import type { MemoryLogger } from '../types.js';
 export declare function isCaptureRelevant(type: string): boolean;
-export declare function registerCapture(ctx: Context, cfg: MemoryConfig, runner: MemoryRunner, l0: L0Store, logger: MemoryLogger, live: LiveSettingsHandle, modes: SessionModeStore): void;
+/**
+ * 按会话缓冲轮次事件。turn 被消费后剩余前缀为空即删除 Map 条目——
+ * 条目随会话数累积是慢泄漏（每会话残留一个数组引用，宿主长跑不释放）。
+ */
+export declare class CaptureBuffers {
+    private readonly map;
+    /** 活跃缓冲条目数（诊断/冒烟用）。 */
+    get size(): number;
+    push(sid: string, event: SessionEvent): void;
+    /** 取出该 turn 的全部事件（不含 turn/start 自身）；无匹配 start 时返回整个缓冲。 */
+    takeTurn(sid: string, turn: number): SessionEvent[];
+}
+/**
+ * 注册 L0 捕获。返回 L0 串行链的冲刷函数（dispose 序在关库前 await，
+ * 排队中的 turn 消息先落盘）；capture 关闭时返回 undefined。
+ */
+export declare function registerCapture(ctx: Context, cfg: MemoryConfig, runner: MemoryRunner, l0: L0Store, logger: MemoryLogger, live: LiveSettingsHandle, modes: SessionModeStore): (() => Promise<void>) | undefined;
 /**
  * 缓冲上限裁剪（防御性；RELEVANT_TYPES 过滤后基本不可达）。
  * 铁律：进行中轮次（turn/start 之后、turn/end 之前）的事件绝不裁——

package/dist/hooks/capture.js

@@ -17,11 +17,49 @@ export function isCaptureRelevant(type) {
     return RELEVANT_TYPES.has(type);
 }
 const MAX_BUFFER = 500;
+/**
+ * 按会话缓冲轮次事件。turn 被消费后剩余前缀为空即删除 Map 条目——
+ * 条目随会话数累积是慢泄漏（每会话残留一个数组引用，宿主长跑不释放）。
+ */
+export class CaptureBuffers {
+    map = new Map();
+    /** 活跃缓冲条目数（诊断/冒烟用）。 */
+    get size() {
+        return this.map.size;
+    }
+    push(sid, event) {
+        let buf = this.map.get(sid);
+        if (!buf) {
+            buf = [];
+            this.map.set(sid, buf);
+        }
+        buf.push(event);
+        trimBuffer(buf);
+    }
+    /** 取出该 turn 的全部事件（不含 turn/start 自身）；无匹配 start 时返回整个缓冲。 */
+    takeTurn(sid, turn) {
+        const buf = this.map.get(sid);
+        if (!buf)
+            return [];
+        const startIdx = findTurnStart(buf, turn);
+        const turnEvents = startIdx === -1 ? buf : buf.slice(startIdx + 1);
+        const rest = startIdx === -1 ? [] : buf.slice(0, startIdx);
+        if (rest.length === 0)
+            this.map.delete(sid);
+        else
+            this.map.set(sid, rest);
+        return turnEvents;
+    }
+}
+/**
+ * 注册 L0 捕获。返回 L0 串行链的冲刷函数（dispose 序在关库前 await，
+ * 排队中的 turn 消息先落盘）；capture 关闭时返回 undefined。
+ */
 export function registerCapture(ctx, cfg, runner, l0, logger, live, modes) {
     if (!cfg.capture.enabled)
         return;
     const startFloor = Date.now();
-    const buffers = new Map();
+    const buffers = new CaptureBuffers();
     // L0 即时落盘链：turn/end 立刻写，不被蒸馏队列（慢 LLM 调用）阻塞；
     // 串行化保证同轮次顺序与单次写入（进程退出时排队中的 L0 不再依赖蒸馏完成）
     let l0Queue = Promise.resolve();
@@ -43,18 +81,10 @@ export function registerCapture(ctx, cfg, runner, l0, logger, live, modes) {
                 }
                 return;
             }
-            let buf = buffers.get(sid);
-            if (!buf) {
-                buf = [];
-                buffers.set(sid, buf);
-            }
-            buf.push(event);
-            trimBuffer(buf);
+            buffers.push(sid, event);
             if (event.type === 'turn/end') {
                 const turn = event.data.turn;
-                const startIdx = findTurnStart(buf, turn);
-                const turnEvents = startIdx === -1 ? buf : buf.slice(startIdx + 1);
-                buffers.set(sid, startIdx === -1 ? [] : buf.slice(0, startIdx));
+                const turnEvents = buffers.takeTurn(sid, turn);
                 const messages = turnEventsToMessages(turnEvents, cfg, logger);
                 if (messages.length > 0) {
                     const roles = messages.reduce((acc, m) => {
@@ -84,6 +114,10 @@ export function registerCapture(ctx, cfg, runner, l0, logger, live, modes) {
             logger.warn(`[memory] session/event 处理失败: ${err instanceof Error ? err.message : String(err)}`);
         }
     });
+    // 冲刷 = 等待串行链排空（链上每环自带 catch，永不 reject）。
+    // 注：极小概率在 await 期间又入队的新消息会落到链尾——其 JSONL 事实源照写、
+    // DB 写入由 upsert 内部兜底（关库后 warn），下次重建自愈。
+    return () => l0Queue;
 }
 /**
  * 缓冲上限裁剪（防御性；RELEVANT_TYPES 过滤后基本不可达）。

package/dist/hooks/recall.d.ts

@@ -20,6 +20,13 @@ import type { PersonaStore } from '../store/persona.js';
 import type { SceneStore } from '../store/scenes.js';
 import type { SessionModeStore } from '../store/session-modes.js';
 import type { MemoryLogger } from '../types.js';
+/**
+ * 从会话消息构建召回查询（纯函数）：末尾 N 条 + 总长截断，空输入返回空串。
+ * 全史拼接会让 MATCH 表达式随会话长度线性膨胀（整会话累计二次方成本）。
+ */
+export declare function buildRecallQuery(messages: Array<{
+    content: unknown;
+}>, tailMessages?: number, maxChars?: number): string;
 export interface RecallHooks {
     /** 管线更新后调用：画像/场景缓存立即失效并异步刷新。 */
     invalidateProfile(): void;

package/dist/hooks/recall.js

@@ -1,5 +1,20 @@
 import { blocksToText } from '../util/text.js';
 const PROFILE_TTL = 60_000;
+/** 召回查询只取会话末尾 N 条消息（长会话每步把全史拼进 FTS MATCH 会让检索成本线性上涨）。 */
+const RECALL_QUERY_TAIL_MESSAGES = 8;
+/** 召回查询总字符上限（保留末尾——最新语境权重最高）。 */
+const RECALL_QUERY_MAX_CHARS = 2_000;
+/**
+ * 从会话消息构建召回查询（纯函数）：末尾 N 条 + 总长截断，空输入返回空串。
+ * 全史拼接会让 MATCH 表达式随会话长度线性膨胀（整会话累计二次方成本）。
+ */
+export function buildRecallQuery(messages, tailMessages = RECALL_QUERY_TAIL_MESSAGES, maxChars = RECALL_QUERY_MAX_CHARS) {
+    const tail = messages.slice(-tailMessages);
+    let text = tail.map((m) => blocksToText(m.content)).join(' ').trim();
+    if (text.length > maxChars)
+        text = text.slice(-maxChars);
+    return text;
+}
 const MEMORY_TOOLS_GUIDE = `<memory-tools-guide>
 ## 记忆工具调用指南
 
@@ -57,10 +72,7 @@ export function registerRecall(ctx, cfg, stores, logger, live, modes) {
                     l1Cache.set(payload.agent.id, []);
                     return next();
                 }
-                const query = payload.messages
-                    .map((m) => blocksToText(m.content))
-                    .join(' ')
-                    .trim();
+                const query = buildRecallQuery(payload.messages);
                 if (query) {
                     const hits = await stores.l1.search(query, cfg.recall.maxResults, {
                         scoreThreshold: cfg.recall.scoreThreshold,
@@ -71,6 +83,10 @@ export function registerRecall(ctx, cfg, stores, logger, live, modes) {
                         logger.info(`[memory] 召回命中 ${hits.length} 条 L1（mode=${mode}，query="${query.slice(0, 30).replace(/\n/g, ' ')}…"，agent=${payload.agent.id}）`);
                     }
                 }
+                else {
+                    // 空查询清缓存：不把上一步的命中注入到与本步无关的上下文
+                    l1Cache.set(payload.agent.id, []);
+                }
             }
             catch (err) {
                 logger.warn(`[memory] 召回检索失败: ${err instanceof Error ? err.message : String(err)}`);

package/dist/index.d.ts

@@ -72,6 +72,8 @@ export declare const Config: import("@deepseek-ai/schemastery").default<Schemast
         dimensions: import("@deepseek-ai/schemastery").default<number, number>;
         maxInputChars: import("@deepseek-ai/schemastery").default<number, number>;
         timeoutMs: import("@deepseek-ai/schemastery").default<number, number>;
+        allowLocalModels: import("@deepseek-ai/schemastery").default<boolean, boolean>;
+        mirror: import("@deepseek-ai/schemastery").default<string, string>;
     }>, Schemastery.ObjectT<{
         enabled: import("@deepseek-ai/schemastery").default<boolean, boolean>;
         baseUrl: import("@deepseek-ai/schemastery").default<string, string>;
@@ -80,6 +82,8 @@ export declare const Config: import("@deepseek-ai/schemastery").default<Schemast
         dimensions: import("@deepseek-ai/schemastery").default<number, number>;
         maxInputChars: import("@deepseek-ai/schemastery").default<number, number>;
         timeoutMs: import("@deepseek-ai/schemastery").default<number, number>;
+        allowLocalModels: import("@deepseek-ai/schemastery").default<boolean, boolean>;
+        mirror: import("@deepseek-ai/schemastery").default<string, string>;
     }>>;
     llm: import("@deepseek-ai/schemastery").default<Schemastery.ObjectS<{
         provider: import("@deepseek-ai/schemastery").default<string, string>;
@@ -163,6 +167,8 @@ export declare const Config: import("@deepseek-ai/schemastery").default<Schemast
         dimensions: import("@deepseek-ai/schemastery").default<number, number>;
         maxInputChars: import("@deepseek-ai/schemastery").default<number, number>;
         timeoutMs: import("@deepseek-ai/schemastery").default<number, number>;
+        allowLocalModels: import("@deepseek-ai/schemastery").default<boolean, boolean>;
+        mirror: import("@deepseek-ai/schemastery").default<string, string>;
     }>, Schemastery.ObjectT<{
         enabled: import("@deepseek-ai/schemastery").default<boolean, boolean>;
         baseUrl: import("@deepseek-ai/schemastery").default<string, string>;
@@ -171,6 +177,8 @@ export declare const Config: import("@deepseek-ai/schemastery").default<Schemast
         dimensions: import("@deepseek-ai/schemastery").default<number, number>;
         maxInputChars: import("@deepseek-ai/schemastery").default<number, number>;
         timeoutMs: import("@deepseek-ai/schemastery").default<number, number>;
+        allowLocalModels: import("@deepseek-ai/schemastery").default<boolean, boolean>;
+        mirror: import("@deepseek-ai/schemastery").default<string, string>;
     }>>;
     llm: import("@deepseek-ai/schemastery").default<Schemastery.ObjectS<{
         provider: import("@deepseek-ai/schemastery").default<string, string>;

package/dist/index.js

@@ -24,7 +24,10 @@ import { MemoryRunner } from './pipeline/runner.js';
 import { RebuildController } from './pipeline/rebuild.js';
 import { registerMemoryRpc, PLUGIN_VERSION } from './stats.js';
 import { registerLiveSettings } from './settings.js';
-import { NoopEmbeddingService, RemoteEmbeddingService, } from './store/embedding.js';
+import { NoopEmbeddingService } from './store/embedding.js';
+import { EmbeddingManager, EmbeddingSourceStore, makeLocalServiceFactory, resolveInitialEmbedding, } from './store/embedding-source.js';
+import { ModelDownloadQueue } from './store/download-queue.js';
+import { PINNED_TRANSFORMERS_VERSION, RuntimeInstaller } from './store/runtime-installer.js';
 import { ensureDir } from './store/io.js';
 import { L0Store } from './store/l0.js';
 import { L1Store } from './store/l1.js';
@@ -45,25 +48,6 @@ export const inject = ['llm', 'tools', 'systemPrompt'];
  * 导致 config 里嵌套对象为 undefined、apply 抛错、fiber FAILED 拖垮宿主启动。
  */
 export const Config = memorySchema;
-/** 按配置构造 embedding 服务：未启用或配置不完整 → Noop（纯 FTS 运行）。 */
-function createEmbeddingService(cfg, logger) {
-    if (!cfg.embedding.enabled)
-        return new NoopEmbeddingService();
-    const { baseUrl, apiKey, model, dimensions } = cfg.embedding;
-    if (!baseUrl || !apiKey || !model || dimensions <= 0) {
-        logger.error('[memory] embedding.enabled=true 但 baseUrl/apiKey/model/dimensions 未配置完整，向量检索停用（纯 FTS 运行）');
-        return new NoopEmbeddingService();
-    }
-    return new RemoteEmbeddingService({
-        baseUrl,
-        apiKey,
-        model,
-        dimensions,
-        maxInputChars: cfg.embedding.maxInputChars,
-        timeoutMs: cfg.embedding.timeoutMs,
-        logger,
-    });
-}
 export async function apply(ctx, config) {
     let logger = {
         debug: (m) => ctx.logger.debug(m),
@@ -87,6 +71,8 @@ export async function apply(ctx, config) {
     }
     // ── 记忆模式运行时开关（官方 settings 服务，live 生效；缺失时恒开） ──
     const live = registerLiveSettings(ctx, logger);
+    /** 插件停机标志：置位后不再发起后台 embeddings 调用（dispose 序最先设置）。 */
+    let disposed = false;
     // ── 会话档位存储（sessionId → auto/chat/work/off；默认档 = config.family） ──
     const modes = new SessionModeStore(dataDir, config.family, logger);
     if (storageOk) {
@@ -97,15 +83,34 @@ export async function apply(ctx, config) {
             logger.warn(`[memory] 会话档位载入失败（降级为默认档内存态）: ${err instanceof Error ? err.message : String(err)}`);
         }
     }
+    // ── 嵌入源三态（D4：远程/本地/关闭）——状态文件优先于静态配置 ──
+    const sourceStore = new EmbeddingSourceStore(dataDir, logger);
+    const installer = new RuntimeInstaller(dataDir, PINNED_TRANSFORMERS_VERSION, { logger });
+    const downloader = new ModelDownloadQueue(dataDir, { mirror: config.embedding.mirror, logger });
+    const makeLocalService = makeLocalServiceFactory(installer, downloader, logger);
+    let initial = { svc: new NoopEmbeddingService(), dims: 0 };
+    /** 管理器引用：启动重嵌链/backfill 闭包在运行期解引用（声明早于创建避免 TDZ）。 */
+    let embedManagerRef;
+    if (storageOk) {
+        try {
+            await sourceStore.init();
+            initial = await resolveInitialEmbedding(config, sourceStore, downloader, makeLocalService, logger);
+        }
+        catch (err) {
+            logger.warn(`[memory] 嵌入源初始解析失败（降级纯 FTS）: ${errDetail(err)}`);
+        }
+    }
+    /** meta 写入永远用当前目标（杜绝启动期闭包里的陈旧 providerInfo 腐蚀 embedding_meta）。 */
+    const currentProviderInfo = () => embedManagerRef?.currentProviderInfo() ?? initial.providerInfo;
     // ── 检索引擎（memory.db）与向量服务 ──
-    const embed = createEmbeddingService(config, logger);
-    const db = new MemoryDb(path.join(dataDir, 'memory.db'), embed.getDimensions(), logger);
+    const embed = initial.svc;
+    const db = new MemoryDb(path.join(dataDir, 'memory.db'), initial.dims, logger);
     // 插件卸载时关闭连接（WAL 落盘），注册一次即可
     ctx.effect(() => () => db.close());
     let dbInit = { needsReindex: false };
     if (storageOk) {
         try {
-            dbInit = db.init(embed.isReady() ? embed.getProviderInfo() : undefined);
+            dbInit = db.init(initial.providerInfo);
             if (db.isDegraded()) {
                 storageOk = false;
                 logger.error('[memory] 检索库初始化失败（schema/FTS 不可用），记忆功能停用');
@@ -161,21 +166,30 @@ export async function apply(ctx, config) {
         logger.warn(`[memory] 蒸馏模型路由解析失败: ${errDetail(err)}`);
     }
     // embedding 配置变化 → 后台全量重嵌入（不阻塞启动）。
-    // meta 只在重嵌入完全成功后写入（review P7）：过早写入会让下次启动比对通过而跳过补齐。
-    if (storageOk && embed.isReady() && !db.isDegraded()) {
-        const info = embed.getProviderInfo();
+    // meta 标记条件 = 失败为 0 且缺失复查为 0（服务未就绪的空转不算成功）。
+    if (storageOk && initial.providerInfo && !db.isDegraded()) {
+        const info = initial.providerInfo;
         if (dbInit.needsReindex) {
             if (caps.vectorSearch) {
                 void (async () => {
                     try {
-                        const r1 = await stores.l1.reindex();
-                        const r0 = await stores.l0.reindex();
-                        if (r1.failed === 0 && r0.failed === 0) {
-                            db.markEmbeddingSynced(info);
-                            logger.info(`[memory] 向量重建完成：L1 ${r1.written} 条，L0 ${r0.written} 条（原因：${dbInit.reason ?? '配置变化'}）`);
+                        if (disposed || embedManagerRef?.isBusy())
+                            return;
+                        // 增量：配置变化路径向量表已被 drop，全部记录均"缺失"，等效全量；
+                        // 活切换发起时让路（swap 会 drop 表，并发跑只是白烧嵌入调用）
+                        const shouldCancel = () => disposed || !!embedManagerRef?.isBusy();
+                        const r1 = await stores.l1.reindex({ shouldCancel });
+                        const r0 = await stores.l0.reindex({ shouldCancel });
+                        // missing 复查：嵌入服务未就绪时 reindex 短路 0/0/0——那是"没跑"不是"成功"，
+                        // 不得标记 meta（否则启动链不再补，补齐被无限推迟到 backfill）
+                        const missingAfter = db.countL1VecMissing(db.getVecSkipSet('l1')) + db.countL0VecMissing(db.getVecSkipSet('l0'));
+                        if (r1.failed === 0 && r0.failed === 0 && missingAfter === 0) {
+                            db.markEmbeddingSynced(currentProviderInfo() ?? info);
+                            const skipNote = r1.skipped + r0.skipped > 0 ? `，跳过不可嵌入 ${r1.skipped + r0.skipped} 条` : '';
+                            logger.info(`[memory] 向量重建完成：L1 ${r1.written} 条，L0 ${r0.written} 条${skipNote}（原因：${dbInit.reason ?? '配置变化'}）`);
                         }
                         else {
-                            logger.warn(`[memory] 向量重建未完成（L1 失败 ${r1.failed}，L0 失败 ${r0.failed}），下次启动/补齐周期重试`);
+                            logger.warn(`[memory] 向量重建未完成（L1 失败 ${r1.failed}，L0 失败 ${r0.failed}，剩缺 ${Math.max(missingAfter, 0)} 条），下次启动/补齐周期重试`);
                         }
                     }
                     catch (err) {
@@ -186,22 +200,41 @@ export async function apply(ctx, config) {
         }
         else {
             // meta 已匹配或空库（initSchema 已写入），幂等重写一次
-            db.markEmbeddingSynced(info);
+            db.markEmbeddingSynced(currentProviderInfo() ?? info);
         }
-        // 周期性向量补齐：嵌入失败的批次/漏网记录自动补上（30 分钟一次，缺量判定幂等）
-        if (caps.vectorSearch) {
+        // 周期性向量补齐：嵌入失败的批次/漏网记录自动补上（30 分钟一次）。
+        // 判据 = 排除 skip 集后的缺失数（增量语义）：缺 1 条只补 1 条，
+        // 零向量记录进 skip 集后不再触发——否则补齐永不收敛、每 30 分钟全量重嵌。
+        // 注册不再依赖启动期 caps/providerInfo（off 起步后活切回旧源也要能补），
+        // 执行期动态查当前目标与能力位。
+        {
             const backfill = () => {
                 void (async () => {
                     try {
-                        const l1Missing = db.countL1Vec() >= 0 && db.countL1Vec() < db.countL1();
-                        const l0Missing = db.countL0Vec() >= 0 && db.countL0Vec() < db.countL0();
+                        if (disposed)
+                            return;
+                        const infoNow = currentProviderInfo();
+                        const capsNow = db.getCapabilities();
+                        if (!infoNow || !capsNow.vectorSearch)
+                            return;
+                        // 活切换链（安装/下载/重嵌）进行中让路——增量 reindex 天然幂等，
+                        // 但并发跑只是白烧一次嵌入调用
+                        if (embedManagerRef?.isBusy())
+                            return;
+                        const l1Missing = db.countL1VecMissing(db.getVecSkipSet('l1')) > 0;
+                        const l0Missing = db.countL0VecMissing(db.getVecSkipSet('l0')) > 0;
                         if (!l1Missing && !l0Missing)
                             return;
-                        const r1 = await stores.l1.reindex();
-                        const r0 = await stores.l0.reindex();
-                        if (r1.failed === 0 && r0.failed === 0) {
-                            db.markEmbeddingSynced(info);
-                            logger.info(`[memory] 向量补齐完成：L1 ${r1.written} 条，L0 ${r0.written} 条`);
+                        const shouldCancel = () => disposed || !!embedManagerRef?.isBusy();
+                        const r1 = await stores.l1.reindex({ shouldCancel });
+                        const r0 = await stores.l0.reindex({ shouldCancel });
+                        const missingAfter = db.countL1VecMissing(db.getVecSkipSet('l1')) + db.countL0VecMissing(db.getVecSkipSet('l0'));
+                        if (r1.failed === 0 && r0.failed === 0 && missingAfter === 0) {
+                            db.markEmbeddingSynced(infoNow);
+                            logger.info(`[memory] 向量补齐完成：L1 ${r1.written} 条，L0 ${r0.written} 条（跳过不可嵌入 ${r1.skipped + r0.skipped} 条）`);
+                        }
+                        else if (r1.failed > 0 || r0.failed > 0) {
+                            logger.warn(`[memory] 向量补齐未完成（L1 失败 ${r1.failed}，L0 失败 ${r0.failed}），下个周期重试`);
                         }
                     }
                     catch (err) {
@@ -219,14 +252,32 @@ export async function apply(ctx, config) {
             });
         }
     }
+    // 嵌入管理器（活切换/下载/运行时安装；存储降级时不建——RPC 走 supported=false）
+    const embedManager = storageOk && !db.isDegraded()
+        ? new EmbeddingManager({
+            dataDir,
+            cfg: config,
+            db,
+            l0: stores.l0,
+            l1: stores.l1,
+            sourceStore,
+            installer,
+            downloader,
+            initial,
+            logger,
+            makeLocal: makeLocalService,
+        })
+        : undefined;
+    embedManagerRef = embedManager;
     const runner = new MemoryRunner(ctx, config, stores, logger, live);
     await runner.init();
     // 重建控制器（存储降级时不建——RPC 端点走 supported=false 分支）
     const rebuild = storageOk && !db.isDegraded()
         ? new RebuildController(ctx, config, stores, db, runner, logger, live)
         : undefined;
+    let flushL0;
     if (storageOk) {
-        registerCapture(ctx, config, runner, stores.l0, logger, live, modes);
+        flushL0 = registerCapture(ctx, config, runner, stores.l0, logger, live, modes);
     }
     const recall = registerRecall(ctx, config, stores, logger, live, modes);
     runner.setAfterRun(recall.invalidateProfile);
@@ -234,6 +285,18 @@ export async function apply(ctx, config) {
     registerMemoryRpc(ctx, config, stores, logger, {
         degraded: () => !storageOk || db.isDegraded(),
         pending: () => runner.pendingCount,
-    }, live, modes, dataDir, rebuild);
+    }, live, modes, dataDir, rebuild, embedManager);
     logger.info(`[memory] L0~L3 分层蒸馏记忆插件就绪（L1 记忆 ${storageOk ? stores.l1.size : 0} 条 | 捕获=${storageOk && config.capture.enabled} | 蒸馏=${storageOk && config.extract.enabled} | 召回=${config.recall.enabled}）`);
+    // 停机顺序（M7）：置停机标志（后台 embeddings 不再发起）→ 停蒸馏取新任务 →
+    // 冲刷 L0 串行链（排队消息先落盘）→ 关库。cordis disposer 为 LIFO 逐个 await，
+    // 本 effect 晚注册故先执行；apply 中途失败时由上方早注册的 db.close 兜底（双关安全）。
+    ctx.effect(() => () => {
+        disposed = true;
+        runner.stop();
+        embedManager?.dispose();
+        return (async () => {
+            await flushL0?.();
+            db.close();
+        })();
+    });
 }

package/dist/pipeline/rebuild.d.ts

@@ -59,6 +59,8 @@ export declare class RebuildController {
     constructor(ctx: Context, cfg: MemoryConfig, stores: RebuildStores, db: MemoryDb, runner: Pick<MemoryRunner, 'enqueueRebuildTask' | 'runRebuildTurn' | 'states'>, logger: MemoryLogger, live: LiveSettingsHandle);
     /** 状态快照（idle 时附带实时 L0 预估，供确认弹窗显示成本）。 */
     getStatus(): RebuildStatus;
+    /** 内存中尚未处理的会话快照块数（收尾后应为 0——快照即弃，诊断/冒烟用）。 */
+    get chunkCount(): number;
     /** 启动重建（校验后入队准备任务；真正的清库/归档在管线队列里串行执行，避开并发竞态）。 */
     start(): RebuildStatus;
     /** 请求取消：当前块完成后停止，已重建部分保留并照常收尾 L2/L3。 */

package/dist/pipeline/rebuild.js

@@ -104,6 +104,10 @@ export class RebuildController {
         }
         return { ...this.status };
     }
+    /** 内存中尚未处理的会话快照块数（收尾后应为 0——快照即弃，诊断/冒烟用）。 */
+    get chunkCount() {
+        return this.chunks.length;
+    }
     /** 启动重建（校验后入队准备任务；真正的清库/归档在管线队列里串行执行，避开并发竞态）。 */
     start() {
         if (this.status.running)
@@ -270,6 +274,9 @@ export class RebuildController {
         this.status.phase = phase;
         this.status.error = error;
         this.status.finishedAt = Date.now();
+        // 快照即弃：全量 L0 消息（可能几十 MB）在重建结束/取消/失败后必须释放，
+        // 不能滞留到下一次 start() 覆盖（M6——宿主长跑内存只增不减）
+        this.chunks = [];
         const cost = this.status.finishedAt - (this.status.startedAt ?? this.status.finishedAt);
         this.logger.info(`[memory] 重建结束（${phase}）：${this.status.done}/${this.status.total} 会话，产出 ${this.status.recordsBuilt} 条记录，耗时 ${Math.round(cost / 1000)}s` +
             (error ? `，错误：${error}` : ''));

package/dist/pipeline/runner.d.ts

@@ -48,6 +48,8 @@ export declare class MemoryRunner {
     private readonly live;
     private tasks;
     private draining;
+    /** 停止标志（dispose 序置位）：不再取新任务；进行中任务自然收尾，其 DB 写入失败由各层兜底捕获。 */
+    private stopped;
     private pending;
     private readonly pendingFile;
     private background;
@@ -68,9 +70,13 @@ export declare class MemoryRunner {
     enqueueRebuildTask(run: () => Promise<unknown>): void;
     /** 重建蒸馏轮：统一 auto 档，不受缓冲 200 上限（历史会话全量入桶，由 char 预算分块）。 */
     runRebuildTurn(sessionId: string, messages: ConversationMessage[]): Promise<number>;
+    /** 停止取新任务（插件 dispose 序调用；进行中任务照常跑完但不 await——LLM 慢调用不拖住宿主卸载）。 */
+    stop(): void;
     private pushTask;
     private drain;
-    /** 缓冲落盘（每次蒸馏尝试后调用；失败只告警不阻断管线）。 */
+    /** 缓冲落盘（每次蒸馏尝试后调用；失败只告警不阻断管线）。
+     *  非重建轮持久化前按桶截断到上限：重建取消后的大桶不至于在后续每次
+     *  蒸馏尝试时反复整量序列化落盘（多 MB 级 IO）；重建轮豁免维持。 */
     private persistPending;
     private runTurn;
 }