dsh-layered-memory 0.7.0 → 0.8.0

package/dist/config.d.ts

@@ -19,8 +19,11 @@ export interface MemoryConfig {
     };
     extract: {
         enabled: boolean;
-        /** 至少攒够多少条新消息才跑一次 L1 抽取（省 token）。 */
+        /** 稳态触发阈值：单会话攒够多少条新消息才跑一次 L1 抽取（省 token）。
+         *  起步阶段生效阈值从 1 翻倍爬坡到此值（渐进阈值，ADR-0003）。 */
         minMessages: number;
+        /** 闲置兜底：会话静默多少秒后把未蒸馏切片落袋（接住"没攒够阈值用户就离开"）；0 = 关闭。 */
+        idleSeconds: number;
         /** L1 抽取时的背景消息条数（供上下文推断，不参与提取）。 */
         backgroundMessages: number;
         /** 去重候选池大小（每条新记忆的相似候选数）。 */
@@ -44,6 +47,12 @@ export interface MemoryConfig {
         enabled: boolean;
         /** 每步自动召回注入的 L1 条数。 */
         maxResults: number;
+        /** 单条注入记忆的字符上限（超限截断并提示用工具查全文）；0 = 不限。 */
+        maxCharsPerMemory: number;
+        /** 整轮注入总字符上限（超限按相关性丢尾部）；0 = 不限。 */
+        maxTotalRecallChars: number;
+        /** 召回总预算（ms）：超时跳过本轮注入、不阻塞对话；0 = 不限时。 */
+        timeoutMs: number;
         includePersona: boolean;
         includeSceneNav: boolean;
         /** 检索策略：keyword（FTS5 BM25）| embedding（向量）| hybrid（双路 + RRF 融合）。 */
@@ -102,11 +111,13 @@ export declare const memorySchema: Schema<Schemastery.ObjectS<{
     extract: Schema<Schemastery.ObjectS<{
         enabled: Schema<boolean, boolean>;
         minMessages: Schema<number, number>;
+        idleSeconds: Schema<number, number>;
         backgroundMessages: Schema<number, number>;
         candidatePool: Schema<number, number>;
     }>, Schemastery.ObjectT<{
         enabled: Schema<boolean, boolean>;
         minMessages: Schema<number, number>;
+        idleSeconds: Schema<number, number>;
         backgroundMessages: Schema<number, number>;
         candidatePool: Schema<number, number>;
     }>>;
@@ -131,6 +142,9 @@ export declare const memorySchema: Schema<Schemastery.ObjectS<{
     recall: Schema<Schemastery.ObjectS<{
         enabled: Schema<boolean, boolean>;
         maxResults: Schema<number, number>;
+        maxCharsPerMemory: Schema<number, number>;
+        maxTotalRecallChars: Schema<number, number>;
+        timeoutMs: Schema<number, number>;
         includePersona: Schema<boolean, boolean>;
         includeSceneNav: Schema<boolean, boolean>;
         strategy: Schema<"keyword" | "embedding" | "hybrid", "keyword" | "embedding" | "hybrid">;
@@ -138,6 +152,9 @@ export declare const memorySchema: Schema<Schemastery.ObjectS<{
     }>, Schemastery.ObjectT<{
         enabled: Schema<boolean, boolean>;
         maxResults: Schema<number, number>;
+        maxCharsPerMemory: Schema<number, number>;
+        maxTotalRecallChars: Schema<number, number>;
+        timeoutMs: Schema<number, number>;
         includePersona: Schema<boolean, boolean>;
         includeSceneNav: Schema<boolean, boolean>;
         strategy: Schema<"keyword" | "embedding" | "hybrid", "keyword" | "embedding" | "hybrid">;
@@ -197,11 +214,13 @@ export declare const memorySchema: Schema<Schemastery.ObjectS<{
     extract: Schema<Schemastery.ObjectS<{
         enabled: Schema<boolean, boolean>;
         minMessages: Schema<number, number>;
+        idleSeconds: Schema<number, number>;
         backgroundMessages: Schema<number, number>;
         candidatePool: Schema<number, number>;
     }>, Schemastery.ObjectT<{
         enabled: Schema<boolean, boolean>;
         minMessages: Schema<number, number>;
+        idleSeconds: Schema<number, number>;
         backgroundMessages: Schema<number, number>;
         candidatePool: Schema<number, number>;
     }>>;
@@ -226,6 +245,9 @@ export declare const memorySchema: Schema<Schemastery.ObjectS<{
     recall: Schema<Schemastery.ObjectS<{
         enabled: Schema<boolean, boolean>;
         maxResults: Schema<number, number>;
+        maxCharsPerMemory: Schema<number, number>;
+        maxTotalRecallChars: Schema<number, number>;
+        timeoutMs: Schema<number, number>;
         includePersona: Schema<boolean, boolean>;
         includeSceneNav: Schema<boolean, boolean>;
         strategy: Schema<"keyword" | "embedding" | "hybrid", "keyword" | "embedding" | "hybrid">;
@@ -233,6 +255,9 @@ export declare const memorySchema: Schema<Schemastery.ObjectS<{
     }>, Schemastery.ObjectT<{
         enabled: Schema<boolean, boolean>;
         maxResults: Schema<number, number>;
+        maxCharsPerMemory: Schema<number, number>;
+        maxTotalRecallChars: Schema<number, number>;
+        timeoutMs: Schema<number, number>;
         includePersona: Schema<boolean, boolean>;
         includeSceneNav: Schema<boolean, boolean>;
         strategy: Schema<"keyword" | "embedding" | "hybrid", "keyword" | "embedding" | "hybrid">;

package/dist/config.js

@@ -15,7 +15,8 @@ export const memorySchema = Schema.object({
     }),
     extract: Schema.object({
         enabled: Schema.boolean().default(true),
-        minMessages: Schema.number().min(1).max(100).default(1),
+        minMessages: Schema.number().min(1).max(100).default(6),
+        idleSeconds: Schema.number().min(0).max(86_400).default(300),
         backgroundMessages: Schema.number().min(0).max(50).default(10),
         candidatePool: Schema.number().min(1).max(20).default(5),
     }),
@@ -32,6 +33,10 @@ export const memorySchema = Schema.object({
     recall: Schema.object({
         enabled: Schema.boolean().default(true),
         maxResults: Schema.number().min(1).max(20).default(5),
+        // 预算与超时（ADR-0001 / 规格 A 节）：截断是引流——工具路径返回全文
+        maxCharsPerMemory: Schema.number().min(0).max(100_000).default(500),
+        maxTotalRecallChars: Schema.number().min(0).max(100_000).default(2000),
+        timeoutMs: Schema.number().min(0).max(60_000).default(5000),
         includePersona: Schema.boolean().default(true),
         includeSceneNav: Schema.boolean().default(true),
         strategy: Schema.union(['keyword', 'embedding', 'hybrid']).default('hybrid'),
@@ -52,8 +57,9 @@ export const memorySchema = Schema.object({
     llm: Schema.object({
         provider: Schema.string().default(''),
         model: Schema.string().default(''),
-        // 推理模型（如 v4-flash）的 reasoning 计入输出预算：预算不足会被思考吃光导致正文 0 字符
-        maxTokens: Schema.number().min(1024).max(1_000_000).default(256_000),
+        // 推理模型（如 v4-flash）的 reasoning 计入输出预算：预算不足会被思考吃光导致正文 0 字符。
+        // 0.8.0 起各蒸馏层显式传分层预算（见 llm.ts LAYER_MAX_TOKENS_*），本值为未分层调用的兜底总闸
+        maxTokens: Schema.number().min(1024).max(1_000_000).default(65_536),
         // 蒸馏是结构化抽取任务，默认关思考（off）：v4-flash 默认 high 档的思考可把任意 maxTokens
         // 预算全部吃光导致正文 0 字符；非推理模型不认识 effort 时会报 UNSUPPORTED_REASONING_EFFORT，设空串跳过
         reasoningEffort: Schema.union(['', 'off', 'high', 'max']).default('off'),

package/dist/hooks/recall.d.ts

@@ -1,13 +1,16 @@
 /**
- * 召回 Hook：
- * 1. agent/pre-step（waterfall）：用进入步骤的用户消息做 L1 BM25 检索，缓存到该 agent 的槽位；
- *    必须调用并返回 next()（只观察，不改写步骤）。
- * 2. agent/created：在 agent 作用域注册动态上下文 provider（L1 召回 + L3 画像 + L2 场景导航 + 工具指南）。
+ * 召回 Hook（消息侧注入版，ADR-0001）：
+ * 1. agent/pre-step（waterfall，prepend 注册）：有新的用户来源消息到达的步骤
+ *    （轮首 claim 或 steering 插话）→ 检索 L1 → 以合成消息形式注入到用户消息之前。
+ *    注入消息携带插件来源（form: 'recall'），对用户可见、随会话历史持久累积——
+ *    这就是"记忆生效"的显式提示（dsh-time-context 同款官方范式）。
+ *    纯工具步透传；召回超时（recall.timeoutMs 总预算）跳过本轮，绝不阻塞对话。
+ * 2. agent/created：在 agent 作用域注册动态上下文 provider（L3 画像 + L2 场景导航 +
+ *    工具指南——系统提示只保留稳定内容；指南三条件门控：工具开启 && 有内容）。
  *
- * 注入内容使用 <relevant-memories> / <user-persona> / <scene-navigation> / <memory-tools-guide>
- * 标签包裹——capture 侧 sanitize 会剥离这些标签，防止反馈循环。
- * auto 档两族合并时在 <user-persona>/<scene-navigation> 内部用 <domain family="..."> 子块
- * 分域（子块只出现在外层标签内部，随外层一起被 sanitize 剥离，无泄漏风险）。
+ * 注入内容使用 <relevant-memories> 标签包裹（模型侧语义边界 + 助手回显剥离锚点），
+ * 召回预算（单条/整轮）超限截断并引导模型用记忆工具查全文。
+ * L0 防污染零成本：capture 侧只收 source.kind === 'user' 的消息，注入消息天然被排除。
  *
  * 注意：PromptContext.text 是**同步**函数，画像/场景导航这类异步文件读取必须走内存缓存，
  * 由定时刷新 + 管线更新后的主动失效来更新。

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">;
@@ -118,11 +126,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 +157,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 +167,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">;

package/dist/index.js

@@ -269,8 +269,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)

package/dist/llm.d.ts

@@ -13,6 +13,19 @@ 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;
+/**
+ * 思考档预算放大：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,22 @@
 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;
+/**
+ * 思考档预算放大：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, layerMaxTokens, LAYER_MAX_TOKENS_DEDUP, LAYER_MAX_TOKENS_EXTRACT, parseJsonLogged } 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: layerMaxTokens(LAYER_MAX_TOKENS_EXTRACT, cfg.llm.reasoningEffort),
             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: layerMaxTokens(LAYER_MAX_TOKENS_DEDUP, cfg.llm.reasoningEffort),
         logger,
     });
     const decisions = parseJsonLogged(dedupRaw, 'L1 去重判定', logger);

package/dist/pipeline/l2.js

@@ -1,4 +1,4 @@
-import { callLLM, parseJsonLogged } from '../llm.js';
+import { callLLM, layerMaxTokens, LAYER_MAX_TOKENS_L2, parseJsonLogged } 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: layerMaxTokens(LAYER_MAX_TOKENS_L2, cfg.llm.reasoningEffort),
+        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, layerMaxTokens, LAYER_MAX_TOKENS_L3 } 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: layerMaxTokens(LAYER_MAX_TOKENS_L3, cfg.llm.reasoningEffort),
+        logger,
+    });
     const body = unwrapFence(raw);
     if (!body) {
         logger.error(`[memory] L3 输出为空，原始输出前 400 字符: ${raw.slice(0, 400)}`);

package/dist/pipeline/runner.d.ts

@@ -46,32 +46,57 @@ export declare class MemoryRunner {
     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 +104,10 @@ export declare class MemoryRunner {
      *  蒸馏尝试时反复整量序列化落盘（多 MB 级 IO）；重建轮豁免维持。 */
     private persistPending;
     private runTurn;
+    /**
+     * 抽取并消费一个会话切片：成功才把切片移出桶并推进爬坡阈值；失败保留切片待重试。
+     * 调用方已保证切片达到生效阈值（或 force）。背景参考按会话从 L0 现查并剔除切片
+     * 自身（ADR-0003：会话间互不污染、重启不丢背景）。
+     */
+    private extractSessionSlice;
 }