dsh-layered-memory 0.7.1 → 0.8.1

package/dist/hooks/recall.js

@@ -1,3 +1,6 @@
+import { createUserMessage } from '@deepseek-ai/dsh-llm';
+import { applyRecallBudget, raceRecallTimeout, RECALL_EMBED_CAP_MS } from '../util/recall-budget.js';
+import { errDetail } from '../util/filelog.js';
 import { blocksToText } from '../util/text.js';
 const PROFILE_TTL = 60_000;
 /** 召回查询只取会话末尾 N 条消息（长会话每步把全史拼进 FTS MATCH 会让检索成本线性上涨）。 */
@@ -28,9 +31,13 @@ const MEMORY_TOOLS_GUIDE = `<memory-tools-guide>
 每轮对话中，memory_search 和 conversation_search **合计最多调用 3 次**。
 - 首次搜索无结果时，可换关键词或换工具重试，但总调用次数不要超过 3 次。
 - 若 3 次搜索后仍无结果，说明该信息不在记忆中，请直接根据已有信息回复用户。
+
+注：若当前环境限制直接调用工具（如仅允许代码执行入口），请经由该环境的工具调用机制
+（如 run_code 程序内）使用以上记忆工具。
 </memory-tools-guide>`;
 export function registerRecall(ctx, cfg, stores, logger, live, modes) {
-    const l1Cache = new Map();
+    /** 每 agent 最近一次注入的命中条数（工具指南门控的"本轮召回命中"信号）。 */
+    const recallHits = new Map();
     // 画像/场景导航按族缓存（分族隔离：注入时按会话档位选族）
     const profileCache = {
         chat: { persona: '', nav: '' },
@@ -46,7 +53,7 @@ export function registerRecall(ctx, cfg, stores, logger, live, modes) {
             profileCache.work = work;
         }
         catch (err) {
-            logger.warn(`[memory] 画像/场景缓存刷新失败: ${err instanceof Error ? err.message : String(err)}`);
+            logger.warn(`[memory] 画像/场景缓存刷新失败: ${errDetail(err)}`);
         }
     };
     // 初始刷新 + 定时刷新（TTL）
@@ -58,43 +65,72 @@ export function registerRecall(ctx, cfg, stores, logger, live, modes) {
     const invalidateProfile = () => {
         void refreshProfile();
     };
-    // agent 销毁时清掉召回缓存槽
+    // agent 销毁时清掉召回信号槽
     ctx.on('agent/disposed', (payload) => {
-        l1Cache.delete(payload.agent.id);
+        recallHits.delete(payload.agent.id);
     });
-    // ── 1. pre-step：检索并缓存（按会话档位过滤族：纯档只查本族，auto 不过滤，off 跳过） ──
+    // ── 1. pre-step 消息侧注入：记忆先行于每一条新的用户输入（ADR-0001） ──
+    // prepend 注册 + 先 next() 再改写：不劫持其他监听器（dsh-time-context 官方范式）。
     if (cfg.recall.enabled) {
         ctx.on('agent/pre-step', async (payload, next) => {
+            const decision = await next();
+            if (decision.kind === 'reject' || payload.signal.aborted)
+                return decision;
             try {
                 const s = live.get();
                 const mode = modes.get(payload.agent.id);
-                if (!s.enabled || !s.recall || mode === 'off') {
-                    l1Cache.set(payload.agent.id, []);
-                    return next();
-                }
+                if (!s.enabled || !s.recall || mode === 'off')
+                    return decision;
+                // 只在有新的用户来源消息的步骤注入（轮首 claim 或 steering 插话）；纯工具步透传
+                const hasNewUserMessage = decision.messages.some((m) => m.source?.kind === 'user');
+                if (!hasNewUserMessage)
+                    return decision;
                 const query = buildRecallQuery(payload.messages);
-                if (query) {
-                    const hits = await stores.l1.search(query, cfg.recall.maxResults, {
-                        scoreThreshold: cfg.recall.scoreThreshold,
-                        family: mode === 'auto' ? undefined : mode,
-                    });
-                    l1Cache.set(payload.agent.id, hits);
-                    if (hits.length > 0) {
-                        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, []);
+                recallHits.set(payload.agent.id, 0);
+                if (!query)
+                    return decision;
+                const hits = await raceRecallTimeout(stores.l1.search(query, cfg.recall.maxResults, {
+                    scoreThreshold: cfg.recall.scoreThreshold,
+                    family: mode === 'auto' ? undefined : mode,
+                    // 远程嵌入 fetch 内层钳制：给 FTS 降级留出总预算内的时间（本地推理不钳）
+                    embeddingTimeoutMs: RECALL_EMBED_CAP_MS,
+                }), cfg.recall.timeoutMs);
+                if (hits === undefined) {
+                    logger.warn('[memory] 召回超时，跳过本轮注入（不阻塞对话）');
+                    return decision;
                 }
+                recallHits.set(payload.agent.id, hits.length);
+                if (hits.length === 0)
+                    return decision;
+                const lines = applyRecallBudget(hits.map((h) => `- [${h.scene_name ? `${h.type}|${h.scene_name}` : h.type}] ${h.content}`), { maxCharsPerMemory: cfg.recall.maxCharsPerMemory, maxTotalRecallChars: cfg.recall.maxTotalRecallChars });
+                if (lines.length === 0)
+                    return decision;
+                const text = [
+                    '<relevant-memories>',
+                    '以下是当前对话召回的相关记忆，不代表当前任务进程，仅作为参考：',
+                    '',
+                    ...lines,
+                    '',
+                    '</relevant-memories>',
+                ].join('\n');
+                logger.info(`[memory] 召回注入 ${lines.length} 条 L1（mode=${mode}，query="${query.slice(0, 30).replace(/\n/g, ' ')}…"，agent=${payload.agent.id}，消息侧）`);
+                const injection = createUserMessage({
+                    content: [{ type: 'text', text }],
+                    // plugin 字段是宿主 UI 的署名后缀（"上下文注入 · memory"）——用展示友好的
+                    // 子系统名，不用 cordis id（dsh-memory）；kind:'plugin' 的标题恒为通用
+                    // "上下文注入"（专用"跨会话召回"标题仅留给 session-reference 来源）
+                    source: { kind: 'plugin', plugin: 'memory', form: 'recall' },
+                });
+                // 注入消息排在用户新消息之前（原版 prepend 语义：先线索后问题）
+                return { kind: 'enter', messages: [injection, ...decision.messages] };
             }
             catch (err) {
-                logger.warn(`[memory] 召回检索失败: ${err instanceof Error ? err.message : String(err)}`);
+                logger.warn(`[memory] 召回注入失败（跳过本轮）: ${errDetail(err)}`);
+                return decision;
             }
-            return next();
-        });
+        }, { prepend: true });
     }
-    // ── 2. agent 作用域上下文 provider ──
+    // ── 2. agent 作用域上下文 provider（系统提示稳定区：画像 + 导航 + 门控指南） ──
     // 插件可能在默认 agent 创建之后才加载（组合顺序由依赖决定），
     // 因此除了监听 agent/created，还要给已存在的 agent 补注册。
     const registered = new WeakSet();
@@ -107,16 +143,6 @@ export function registerRecall(ctx, cfg, stores, logger, live, modes) {
         registered.add(agent);
         try {
             contextDisposers.push(agent.ctx.systemPrompt.context({
-                name: 'memory:recall',
-                order: 500,
-                text: () => {
-                    const s = live.get();
-                    if (!s.enabled || !s.recall)
-                        return '';
-                    const hits = l1Cache.get(agent.id) ?? [];
-                    return formatL1Memories(hits);
-                },
-            }), agent.ctx.systemPrompt.context({
                 name: 'memory:profile',
                 order: 510,
                 text: () => {
@@ -130,9 +156,14 @@ export function registerRecall(ctx, cfg, stores, logger, live, modes) {
                     const body = mode === 'auto'
                         ? formatProfileAuto(profileCache.chat, profileCache.work)
                         : formatProfileSingle(profileCache[mode]);
-                    if (!body)
-                        return MEMORY_TOOLS_GUIDE;
-                    return `${body}\n\n${MEMORY_TOOLS_GUIDE}`;
+                    const hasRecallHit = (recallHits.get(agent.id) ?? 0) > 0;
+                    // 指南三条件门控：工具已注册（cfg.tools）&&（稳定内容 ∥ 本轮召回命中）——
+                    // 空库用户与关闭工具的用户不付这份固定 token（原版 auto-recall 同款语义）
+                    if (!cfg.tools)
+                        return body;
+                    if (!body && !hasRecallHit)
+                        return '';
+                    return body ? `${body}\n\n${MEMORY_TOOLS_GUIDE}` : MEMORY_TOOLS_GUIDE;
                 },
             }));
         }
@@ -160,18 +191,6 @@ export function registerRecall(ctx, cfg, stores, logger, live, modes) {
     });
     return { invalidateProfile };
 }
-function formatL1Memories(items) {
-    if (items.length === 0)
-        return '';
-    const lines = ['<relevant-memories>', ''];
-    for (const item of items) {
-        // [type|scene] 标签 + 内容（官方召回行格式）
-        const tag = item.scene_name ? `${item.type}|${item.scene_name}` : item.type;
-        lines.push(`- [${tag}] ${item.content}`);
-    }
-    lines.push('', '</relevant-memories>');
-    return lines.join('\n');
-}
 /** auto 档 <user-persona> 内的域说明：让模型理解分块结构与两域的独立性。 */
 const DOMAIN_HINT = '以下内容按记忆域分块：chat=用户个人画像（User Narrative Profile），work=团队工作准则（Team Operating Doctrine）。' +
     '两域独立蒸馏与更新，请按当前对话语境参考对应域，不要把一域的内容当作另一域的事实。';

package/dist/index.d.ts

@@ -23,11 +23,13 @@ export declare const Config: import("@deepseek-ai/schemastery").default<Schemast
     extract: import("@deepseek-ai/schemastery").default<Schemastery.ObjectS<{
         enabled: import("@deepseek-ai/schemastery").default<boolean, boolean>;
         minMessages: import("@deepseek-ai/schemastery").default<number, number>;
+        idleSeconds: import("@deepseek-ai/schemastery").default<number, number>;
         backgroundMessages: import("@deepseek-ai/schemastery").default<number, number>;
         candidatePool: import("@deepseek-ai/schemastery").default<number, number>;
     }>, Schemastery.ObjectT<{
         enabled: import("@deepseek-ai/schemastery").default<boolean, boolean>;
         minMessages: import("@deepseek-ai/schemastery").default<number, number>;
+        idleSeconds: import("@deepseek-ai/schemastery").default<number, number>;
         backgroundMessages: import("@deepseek-ai/schemastery").default<number, number>;
         candidatePool: import("@deepseek-ai/schemastery").default<number, number>;
     }>>;
@@ -52,6 +54,9 @@ export declare const Config: import("@deepseek-ai/schemastery").default<Schemast
     recall: import("@deepseek-ai/schemastery").default<Schemastery.ObjectS<{
         enabled: import("@deepseek-ai/schemastery").default<boolean, boolean>;
         maxResults: import("@deepseek-ai/schemastery").default<number, number>;
+        maxCharsPerMemory: import("@deepseek-ai/schemastery").default<number, number>;
+        maxTotalRecallChars: import("@deepseek-ai/schemastery").default<number, number>;
+        timeoutMs: import("@deepseek-ai/schemastery").default<number, number>;
         includePersona: import("@deepseek-ai/schemastery").default<boolean, boolean>;
         includeSceneNav: import("@deepseek-ai/schemastery").default<boolean, boolean>;
         strategy: import("@deepseek-ai/schemastery").default<"keyword" | "embedding" | "hybrid", "keyword" | "embedding" | "hybrid">;
@@ -59,6 +64,9 @@ export declare const Config: import("@deepseek-ai/schemastery").default<Schemast
     }>, Schemastery.ObjectT<{
         enabled: import("@deepseek-ai/schemastery").default<boolean, boolean>;
         maxResults: import("@deepseek-ai/schemastery").default<number, number>;
+        maxCharsPerMemory: import("@deepseek-ai/schemastery").default<number, number>;
+        maxTotalRecallChars: import("@deepseek-ai/schemastery").default<number, number>;
+        timeoutMs: import("@deepseek-ai/schemastery").default<number, number>;
         includePersona: import("@deepseek-ai/schemastery").default<boolean, boolean>;
         includeSceneNav: import("@deepseek-ai/schemastery").default<boolean, boolean>;
         strategy: import("@deepseek-ai/schemastery").default<"keyword" | "embedding" | "hybrid", "keyword" | "embedding" | "hybrid">;
@@ -74,6 +82,7 @@ export declare const Config: import("@deepseek-ai/schemastery").default<Schemast
         timeoutMs: import("@deepseek-ai/schemastery").default<number, number>;
         allowLocalModels: import("@deepseek-ai/schemastery").default<boolean, boolean>;
         mirror: import("@deepseek-ai/schemastery").default<string, string>;
+        proxy: 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>;
@@ -84,6 +93,7 @@ export declare const Config: import("@deepseek-ai/schemastery").default<Schemast
         timeoutMs: import("@deepseek-ai/schemastery").default<number, number>;
         allowLocalModels: import("@deepseek-ai/schemastery").default<boolean, boolean>;
         mirror: import("@deepseek-ai/schemastery").default<string, string>;
+        proxy: import("@deepseek-ai/schemastery").default<string, string>;
     }>>;
     llm: import("@deepseek-ai/schemastery").default<Schemastery.ObjectS<{
         provider: import("@deepseek-ai/schemastery").default<string, string>;
@@ -118,11 +128,13 @@ export declare const Config: import("@deepseek-ai/schemastery").default<Schemast
     extract: import("@deepseek-ai/schemastery").default<Schemastery.ObjectS<{
         enabled: import("@deepseek-ai/schemastery").default<boolean, boolean>;
         minMessages: import("@deepseek-ai/schemastery").default<number, number>;
+        idleSeconds: import("@deepseek-ai/schemastery").default<number, number>;
         backgroundMessages: import("@deepseek-ai/schemastery").default<number, number>;
         candidatePool: import("@deepseek-ai/schemastery").default<number, number>;
     }>, Schemastery.ObjectT<{
         enabled: import("@deepseek-ai/schemastery").default<boolean, boolean>;
         minMessages: import("@deepseek-ai/schemastery").default<number, number>;
+        idleSeconds: import("@deepseek-ai/schemastery").default<number, number>;
         backgroundMessages: import("@deepseek-ai/schemastery").default<number, number>;
         candidatePool: import("@deepseek-ai/schemastery").default<number, number>;
     }>>;
@@ -147,6 +159,9 @@ export declare const Config: import("@deepseek-ai/schemastery").default<Schemast
     recall: import("@deepseek-ai/schemastery").default<Schemastery.ObjectS<{
         enabled: import("@deepseek-ai/schemastery").default<boolean, boolean>;
         maxResults: import("@deepseek-ai/schemastery").default<number, number>;
+        maxCharsPerMemory: import("@deepseek-ai/schemastery").default<number, number>;
+        maxTotalRecallChars: import("@deepseek-ai/schemastery").default<number, number>;
+        timeoutMs: import("@deepseek-ai/schemastery").default<number, number>;
         includePersona: import("@deepseek-ai/schemastery").default<boolean, boolean>;
         includeSceneNav: import("@deepseek-ai/schemastery").default<boolean, boolean>;
         strategy: import("@deepseek-ai/schemastery").default<"keyword" | "embedding" | "hybrid", "keyword" | "embedding" | "hybrid">;
@@ -154,6 +169,9 @@ export declare const Config: import("@deepseek-ai/schemastery").default<Schemast
     }>, Schemastery.ObjectT<{
         enabled: import("@deepseek-ai/schemastery").default<boolean, boolean>;
         maxResults: import("@deepseek-ai/schemastery").default<number, number>;
+        maxCharsPerMemory: import("@deepseek-ai/schemastery").default<number, number>;
+        maxTotalRecallChars: import("@deepseek-ai/schemastery").default<number, number>;
+        timeoutMs: import("@deepseek-ai/schemastery").default<number, number>;
         includePersona: import("@deepseek-ai/schemastery").default<boolean, boolean>;
         includeSceneNav: import("@deepseek-ai/schemastery").default<boolean, boolean>;
         strategy: import("@deepseek-ai/schemastery").default<"keyword" | "embedding" | "hybrid", "keyword" | "embedding" | "hybrid">;
@@ -169,6 +187,7 @@ export declare const Config: import("@deepseek-ai/schemastery").default<Schemast
         timeoutMs: import("@deepseek-ai/schemastery").default<number, number>;
         allowLocalModels: import("@deepseek-ai/schemastery").default<boolean, boolean>;
         mirror: import("@deepseek-ai/schemastery").default<string, string>;
+        proxy: 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>;
@@ -179,6 +198,7 @@ export declare const Config: import("@deepseek-ai/schemastery").default<Schemast
         timeoutMs: import("@deepseek-ai/schemastery").default<number, number>;
         allowLocalModels: import("@deepseek-ai/schemastery").default<boolean, boolean>;
         mirror: import("@deepseek-ai/schemastery").default<string, string>;
+        proxy: 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

@@ -39,6 +39,7 @@ import { StateStore } from './store/state.js';
 import { registerMemoryTools } from './tools/index.js';
 import { errDetail, withFileLog } from './util/filelog.js';
 import { resolveModelRoute } from './llm.js';
+import { effectiveCfg } from './pipeline/runner.js';
 export const name = 'dsh-memory-plugin';
 /** 硬依赖：蒸馏要用 llm，工具注册要用 tools，召回注入要用 systemPrompt。 */
 export const inject = ['llm', 'tools', 'systemPrompt'];
@@ -86,7 +87,11 @@ export async function apply(ctx, config) {
     // ── 嵌入源三态（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 downloader = new ModelDownloadQueue(dataDir, {
+        mirror: config.embedding.mirror,
+        logger,
+        proxy: config.embedding.proxy,
+    });
     const makeLocalService = makeLocalServiceFactory(installer, downloader, logger);
     let initial = { svc: new NoopEmbeddingService(), dims: 0 };
     /** 管理器引用：启动重嵌链/backfill 闭包在运行期解引用（声明早于创建避免 TDZ）。 */
@@ -157,9 +162,10 @@ export async function apply(ctx, config) {
         logger.warn(`[memory] 检索策略 ${config.recall.strategy} 需要向量能力（embedding 未启用/不可用），本次运行按 keyword（FTS5 BM25）检索`);
     }
     logger.info(`[memory] 数据目录: ${dataDir}（v${PLUGIN_VERSION}，默认档=${config.family}，检索: FTS=${caps.ftsSearch} 向量=${caps.vectorSearch}${storageOk ? '' : '，存储不可用已停用捕获/蒸馏'}）`);
-    // 蒸馏模型路由：启动期解析一次并记录（路由错误是最难事后排查的问题之一）
+    // 蒸馏模型路由：启动期解析一次并记录（路由错误是最难事后排查的问题之一）；
+    // 用运行时调参视图解析——用户已用 UI 覆盖蒸馏模型时，日志反映实际路由
     try {
-        const route = await resolveModelRoute(ctx, config);
+        const route = await resolveModelRoute(ctx, effectiveCfg(config, live));
         logger.info(`[memory] 蒸馏模型路由: ${route.provider}/${route.model}`);
     }
     catch (err) {
@@ -269,8 +275,12 @@ export async function apply(ctx, config) {
         })
         : undefined;
     embedManagerRef = embedManager;
-    const runner = new MemoryRunner(ctx, config, stores, logger, live);
+    const runner = new MemoryRunner(ctx, config, stores, logger, live, modes);
     await runner.init();
+    // 档位切换同步（ADR-0003）：切走按捕获档位落袋 / 切 off 挂起 / 切回清挂起
+    modes.setModeChangeHandler((sessionId, oldMode, newMode) => runner.onModeChange(sessionId, oldMode, newMode));
+    // 闲置兜底：静默达标会话的未蒸馏切片自动落袋（idleSeconds=0 关闭）
+    runner.startIdleTimer();
     // 重建控制器（存储降级时不建——RPC 端点走 supported=false 分支）
     const rebuild = storageOk && !db.isDegraded()
         ? new RebuildController(ctx, config, stores, db, runner, logger, live)
@@ -294,6 +304,7 @@ export async function apply(ctx, config) {
         disposed = true;
         runner.stop();
         embedManager?.dispose();
+        downloader.dispose();
         return (async () => {
             await flushL0?.();
             db.close();

package/dist/llm.d.ts

@@ -13,6 +13,34 @@ export interface LlmCallOptions {
     /** 诊断日志（缺失时静默，不影响调用） */
     logger?: MemoryLogger;
 }
+/** L1 抽取（大输入块的 JSON 记忆数组输出）。 */
+export declare const LAYER_MAX_TOKENS_EXTRACT = 16000;
+/** L1 去重（合并决策数组，输出比抽取短）。 */
+export declare const LAYER_MAX_TOKENS_DEDUP = 8000;
+/** L2 场景整合（完整场景 Markdown 文件输出，输出最重的层）。 */
+export declare const LAYER_MAX_TOKENS_L2 = 32000;
+/** L3 画像（完整 persona 文档）。 */
+export declare const LAYER_MAX_TOKENS_L3 = 16000;
+/** 分层输出预算键（运行时设置 / UI 与内置默认共用同一套键名）。 */
+export type DistillBudgetLayer = 'extract' | 'dedup' | 'l2' | 'l3';
+/** 各层内置默认预算（设置页"0 = 跟随默认"的默认值来源）。 */
+export declare const LAYER_DEFAULT_BUDGETS: Record<DistillBudgetLayer, number>;
+/**
+ * 解析某蒸馏层的生效输出预算：运行时覆盖（cfg.llm.budgets，由 effectiveCfg 从
+ * 设置页 distillBudgets 注入，0/缺省 = 跟随）→ 内置默认 → 思考档放大
+ * （high/max ×4，reasoning 计入输出预算的历史事故防线）。
+ */
+export declare function resolveLayerTokens(cfg: {
+    llm: {
+        reasoningEffort: string;
+        budgets?: Partial<Record<DistillBudgetLayer, number>>;
+    };
+}, layer: DistillBudgetLayer): number;
+/**
+ * 思考档预算放大：reasoning 计入输出预算（v4-flash 事故：high 思考可吃光全部
+ * 预算致正文 0 字符）——effort 为 high/max 时分层预算 ×4。
+ */
+export declare function layerMaxTokens(base: number, reasoningEffort: string): number;
 /** 解析蒸馏用的 provider/model：配置优先，其次当前默认选择。 */
 export declare function resolveModelRoute(ctx: Context, cfg: MemoryConfig): Promise<{
     provider: string;

package/dist/llm.js

@@ -1,5 +1,38 @@
 import { createUserMessage, ReasoningEffortId } from '@deepseek-ai/dsh-llm';
 import { errDetail } from './util/filelog.js';
+// ── 分层输出预算（规格 C 节）：结构化蒸馏远用不到总闸级预算，逐层设护栏；
+//    模型跑偏时单次损失有界。数值"先试跑"状态，按线上截断率调整。
+/** L1 抽取（大输入块的 JSON 记忆数组输出）。 */
+export const LAYER_MAX_TOKENS_EXTRACT = 16_000;
+/** L1 去重（合并决策数组，输出比抽取短）。 */
+export const LAYER_MAX_TOKENS_DEDUP = 8_000;
+/** L2 场景整合（完整场景 Markdown 文件输出，输出最重的层）。 */
+export const LAYER_MAX_TOKENS_L2 = 32_000;
+/** L3 画像（完整 persona 文档）。 */
+export const LAYER_MAX_TOKENS_L3 = 16_000;
+/** 各层内置默认预算（设置页"0 = 跟随默认"的默认值来源）。 */
+export const LAYER_DEFAULT_BUDGETS = {
+    extract: LAYER_MAX_TOKENS_EXTRACT,
+    dedup: LAYER_MAX_TOKENS_DEDUP,
+    l2: LAYER_MAX_TOKENS_L2,
+    l3: LAYER_MAX_TOKENS_L3,
+};
+/**
+ * 解析某蒸馏层的生效输出预算：运行时覆盖（cfg.llm.budgets，由 effectiveCfg 从
+ * 设置页 distillBudgets 注入，0/缺省 = 跟随）→ 内置默认 → 思考档放大
+ * （high/max ×4，reasoning 计入输出预算的历史事故防线）。
+ */
+export function resolveLayerTokens(cfg, layer) {
+    const override = cfg.llm.budgets?.[layer];
+    return layerMaxTokens(override && override > 0 ? override : LAYER_DEFAULT_BUDGETS[layer], cfg.llm.reasoningEffort);
+}
+/**
+ * 思考档预算放大：reasoning 计入输出预算（v4-flash 事故：high 思考可吃光全部
+ * 预算致正文 0 字符）——effort 为 high/max 时分层预算 ×4。
+ */
+export function layerMaxTokens(base, reasoningEffort) {
+    return reasoningEffort === 'high' || reasoningEffort === 'max' ? base * 4 : base;
+}
 /** 解析蒸馏用的 provider/model：配置优先，其次当前默认选择。 */
 export async function resolveModelRoute(ctx, cfg) {
     if (cfg.llm.provider && cfg.llm.model) {

package/dist/pipeline/l1.js

@@ -3,7 +3,7 @@
  * 移植 MemoryCore 的 l1 runner 语义（抽取 prompt → batch 冲突检测 → apply）。
  */
 import { randomBytes } from 'node:crypto';
-import { callLLM, parseJsonLogged } from '../llm.js';
+import { callLLM, parseJsonLogged, resolveLayerTokens } from '../llm.js';
 import { formatExtractionPrompt, getExtractMemoriesSystemPrompt } from '../prompts/l1-extraction.js';
 import { formatBatchConflictPrompt, getConflictDetectionSystemPrompt } from '../prompts/l1-dedup.js';
 import { familyForType } from '../types.js';
@@ -37,9 +37,8 @@ export function chunkByCharBudget(messages, budgetChars) {
 export async function runExtraction(ctx, cfg, store, states, pending, background, logger, mode) {
     if (!cfg.extract.enabled)
         return { stored: 0, skipped: true, sceneName: chainHead(states, mode), newRecords: [] };
-    if (pending.length < cfg.extract.minMessages) {
-        return { stored: 0, skipped: true, sceneName: chainHead(states, mode), newRecords: [] };
-    }
+    // 触发阈值（渐进爬坡 + 按会话切片计数）由 runner 判定（trigger.ts）；
+    // 此处不再重复 gate——重建轮 force 与 warmup 早期轮次都会传入小于稳态值的切片。
     // 纯档强制族 = 档位族；auto 档抽取后的记录族按 type 前缀判定
     const forcedFamily = mode === 'auto' ? undefined : mode;
     // 情境链锚点桶：纯档用本族；auto 用最近活跃的族（chainHead 同源）
@@ -64,6 +63,7 @@ export async function runExtraction(ctx, cfg, store, states, pending, background
         const raw = await callLLM(ctx, cfg, {
             system: getExtractMemoriesSystemPrompt(mode),
             user: userPrompt,
+            maxTokens: resolveLayerTokens(cfg, 'extract'),
             logger,
         });
         const scenes = parseJsonLogged(raw, 'L1 抽取', logger);
@@ -101,6 +101,7 @@ export async function runExtraction(ctx, cfg, store, states, pending, background
     const dedupRaw = await callLLM(ctx, cfg, {
         system: getConflictDetectionSystemPrompt(mode),
         user: dedupPrompt,
+        maxTokens: resolveLayerTokens(cfg, 'dedup'),
         logger,
     });
     const decisions = parseJsonLogged(dedupRaw, 'L1 去重判定', logger);

package/dist/pipeline/l2.js

@@ -1,4 +1,4 @@
-import { callLLM, parseJsonLogged } from '../llm.js';
+import { callLLM, parseJsonLogged, resolveLayerTokens } from '../llm.js';
 import { buildScenePrompt, formatSceneSummaries } from '../prompts/scene.js';
 import { Bm25Index } from '../store/bm25.js';
 const REQUEST_RE = /\[PERSONA_UPDATE_REQUEST\]\s*reason:\s*([\s\S]*?)\[\/PERSONA_UPDATE_REQUEST\]/;
@@ -27,7 +27,12 @@ export async function runSceneConsolidation(ctx, cfg, scenes, newMemories, logge
         maxScenes: cfg.l2.maxScenes,
         family,
     });
-    const raw = await callLLM(ctx, cfg, { system: systemPrompt, user: userPrompt, logger });
+    const raw = await callLLM(ctx, cfg, {
+        system: systemPrompt,
+        user: userPrompt,
+        maxTokens: resolveLayerTokens(cfg, 'l2'),
+        logger,
+    });
     // ── 解析：先取 PERSONA_UPDATE_REQUEST 标记，再解析操作数组 ──
     const reqMatch = REQUEST_RE.exec(raw);
     const personaRequestedReason = reqMatch?.[1]?.trim() || undefined;

package/dist/pipeline/l3.js

@@ -1,4 +1,4 @@
-import { callLLM } from '../llm.js';
+import { callLLM, resolveLayerTokens } from '../llm.js';
 import { buildPersonaPrompt } from '../prompts/persona.js';
 export async function runPersona(ctx, cfg, scenes, persona, state, logger, family) {
     if (!cfg.l3.enabled)
@@ -48,7 +48,12 @@ export async function runPersona(ctx, cfg, scenes, persona, state, logger, famil
         existingPersona,
         triggerInfo: reason,
     });
-    const raw = await callLLM(ctx, cfg, { system: systemPrompt, user: userPrompt, logger });
+    const raw = await callLLM(ctx, cfg, {
+        system: systemPrompt,
+        user: userPrompt,
+        maxTokens: resolveLayerTokens(cfg, 'l3'),
+        logger,
+    });
     const body = unwrapFence(raw);
     if (!body) {
         logger.error(`[memory] L3 输出为空，原始输出前 400 字符: ${raw.slice(0, 400)}`);

package/dist/pipeline/rebuild.js

@@ -99,7 +99,7 @@ export class RebuildController {
                 ...this.status,
                 sessionCount: est.sessions,
                 messageCount: est.messages,
-                estCalls: estimateCalls(est.sessions, est.messages, est.chars, this.cfg.llm.maxInputChars),
+                estCalls: estimateCalls(est.sessions, est.messages, est.chars, effectiveCfg(this.cfg, this.live).llm.maxInputChars),
             };
         }
         return { ...this.status };
@@ -123,7 +123,7 @@ export class RebuildController {
             phase: 'preparing',
             sessionCount: est.sessions,
             messageCount: est.messages,
-            estCalls: estimateCalls(est.sessions, est.messages, est.chars, this.cfg.llm.maxInputChars),
+            estCalls: estimateCalls(est.sessions, est.messages, est.chars, effectiveCfg(this.cfg, this.live).llm.maxInputChars),
             startedAt: Date.now(),
         };
         this.runner.enqueueRebuildTask(() => this.prepare());

package/dist/pipeline/runner.d.ts

@@ -36,42 +36,73 @@ export interface PipelineTask {
 /** 选取下一个要执行的任务下标：最早的 live 优先，否则队首（rebuild 分块让位）。 */
 export declare function pickNextTaskIndex(tasks: PipelineTask[]): number;
 /**
- * 运行时调参视图：UI 选择器可临时覆盖蒸馏思考档位（空串回退静态 config 默认）。
- * 浅拷贝只覆盖 llm 一层，其余键与原 cfg 共享只读引用；pipeline 全链继续收 cfg，无需感知。
+ * 运行时调参视图：UI 选择器可临时覆盖蒸馏思考档位、蒸馏模型路由与分层输出预算
+ * （空串/0 回退静态 config / 内置默认）。浅拷贝只覆盖 llm 一层，其余键与原 cfg
+ * 共享只读引用；pipeline 全链继续收 cfg，无需感知。
+ *
+ * 蒸馏模型覆盖优先级：部署静态 pin（cfg.llm.provider+model 双字段齐）不可被
+ * 运行时覆盖（部署可强制蒸馏走内网路由，防用户选择把对话外送）；未 pin 时
+ * 运行时选择（distillProvider+distillModel 成对）生效；再退 agentDefaultModel。
+ * 输出预算无部署上限语义：非零运行时值直接注入 cfg.llm.budgets（0/缺省不注入）。
  */
-export declare function effectiveCfg(cfg: MemoryConfig, live: LiveSettingsHandle): MemoryConfig;
+export declare function effectiveCfg(cfg: MemoryConfig, live?: LiveSettingsHandle): MemoryConfig;
 export declare class MemoryRunner {
     private readonly ctx;
     private readonly cfg;
     private readonly stores;
     private readonly logger;
     private readonly live;
+    /** 会话档位只读句柄（闲置扫描跳过 off 档会话；挂起语义）。 */
+    private readonly modes?;
     private tasks;
     private draining;
     /** 停止标志（dispose 序置位）：不再取新任务；进行中任务自然收尾，其 DB 写入失败由各层兜底捕获。 */
     private stopped;
     private pending;
+    /** 各档位桶渐进阈值（1 起步翻倍至稳态毕业；ADR-0003，随 pending.json 持久化）。 */
+    private warmup;
+    /** 每会话最后活动时间（闲置兜底判定用）。 */
+    private lastActivity;
     private readonly pendingFile;
-    private background;
     /** 分族 checkpoint（init 后可用；重建收尾也从这里读活引用）。 */
     states: FamilyStates;
     private afterRun;
-    constructor(ctx: Context, cfg: MemoryConfig, stores: MemoryStores, logger: MemoryLogger, live: LiveSettingsHandle);
+    constructor(ctx: Context, cfg: MemoryConfig, stores: MemoryStores, logger: MemoryLogger, live: LiveSettingsHandle, 
+    /** 会话档位只读句柄（闲置扫描跳过 off 档会话；挂起语义）。 */
+    modes?: {
+        get(sessionId: string): string;
+    } | undefined);
     init(): Promise<void>;
-    /** 启动补跑：对每个非空桶入队一次蒸馏尝试（受 live 开关与阈值约束，失败不无限重试）。 */
+    /** 启动补跑：对每个非空桶的每个会话切片入队一次蒸馏尝试（受 live 开关与
+     *  生效阈值约束；不足阈值的消息等用户继续或闲置兜底，失败不无限重试）。 */
     private scheduleStartupRetry;
     /** L1 抽取待重试的消息条数（状态面板用）。 */
     get pendingCount(): number;
     /** 管线跑完一轮后的回调（用于召回缓存失效）。 */
     setAfterRun(fn: () => void): void;
     /** 一轮对话结束后入队（L0 落盘由 capture 在 turn/end 即时完成，不排蒸馏队列）。 */
-    enqueue(sessionId: string, messages: ConversationMessage[], mode: ExtractMode): void;
+    enqueue(sessionId: string, messages: ConversationMessage[], mode: ExtractMode, opts?: {
+        force?: boolean;
+    }): void;
     /** 重建任务入队（低优先级：让位于正常轮次；由 RebuildController 分块驱动）。 */
     enqueueRebuildTask(run: () => Promise<unknown>): void;
-    /** 重建蒸馏轮：统一 auto 档，不受缓冲 200 上限（历史会话全量入桶，由 char 预算分块）。 */
+    /** 重建蒸馏轮：统一 auto 档，全量强制蒸馏（不受阈值约束——历史小会话也必须出记忆）、
+     *  不受缓冲 200 上限（历史会话全量入桶，由 char 预算分块）。 */
     runRebuildTurn(sessionId: string, messages: ConversationMessage[]): Promise<number>;
     /** 停止取新任务（插件 dispose 序调用；进行中任务照常跑完但不 await——LLM 慢调用不拖住宿主卸载）。 */
     stop(): void;
+    /** 启动闲置兜底定时器（index.ts 装配；idleSeconds=0 关闭）。 */
+    startIdleTimer(): void;
+    /** 闲置扫描：静默达标且有切片的会话按捕获档位落袋（off 档会话挂起跳过）。 */
+    private flushIdleSlices;
+    /** 把某会话在各桶中的切片按捕获档位逐个入队强制蒸馏（闲置兜底 / 档位切换共用）。 */
+    private enqueueSessionSlices;
+    /**
+     * 档位切换同步（session-modes 的 set() 回调，ADR-0003）：
+     * 非 off 间切换 → 该会话切片立即按捕获档位蒸馏（新档位从空切片起步）；
+     * 切到 off → 挂起（切片留存，闲置扫描跳过）；从 off 切回 → 挂起片按捕获档位落袋。
+     */
+    onModeChange(sessionId: string, oldMode: string, newMode: string): void;
     private pushTask;
     private drain;
     /** 缓冲落盘（每次蒸馏尝试后调用；失败只告警不阻断管线）。
@@ -79,4 +110,10 @@ export declare class MemoryRunner {
      *  蒸馏尝试时反复整量序列化落盘（多 MB 级 IO）；重建轮豁免维持。 */
     private persistPending;
     private runTurn;
+    /**
+     * 抽取并消费一个会话切片：成功才把切片移出桶并推进爬坡阈值；失败保留切片待重试。
+     * 调用方已保证切片达到生效阈值（或 force）。背景参考按会话从 L0 现查并剔除切片
+     * 自身（ADR-0003：会话间互不污染、重启不丢背景）。
+     */
+    private extractSessionSlice;
 }