dsh-prime-memory 0.26.6 → 0.26.10

package/dist/pipeline/l1.js

@@ -8,7 +8,7 @@
  */
 import { randomBytes } from 'node:crypto';
 import { normWingEnabled } from '../config.js';
-import { callLLM, parseJsonLogged, resolveLayerTokens } from '../llm.js';
+import { callLLM, parseJsonLogged, resolveLayerTokens, resolveModelRoute } from '../llm.js';
 import { buildReceipts, newRunId, persistReceiptsSafely } from '../store/receipts.js';
 import { buildConflictPair, conflictRejectId, DEFER_MAX, normalizeClaimKey, normalizeConflictType, occupiesConflictQuota, pendingHardTotal, validateConflictPair, } from '../store/conflicts.js';
 import { formatExtractionPrompt, getExtractMemoriesSystemPrompt } from '../prompts/l1-extraction.js';
@@ -23,13 +23,19 @@ import { routeWorkspace } from '../workspace-route.js';
 /**
  * L1 抽取单块字符硬顶(修复 #10 分批过大)
  *
- * `cfg.llm.maxInputChars` 的语义是「单次 LLM 调用输入闸门」(默认 700k),被复用为
+ * `cfg.llm.maxInputChars` 的语义是「单次 LLM 调用输入闸门」(默认 200k),被复用为
  * 分块预算时算出 658k/块——一次输出须在同一 JSON 数组写完全部抽出记忆,块越大字符串越多,
  * 任一处长中文里未转义 ASCII `"` 即整批 parse 失败、该块记忆全丢;慢模型更直接撞 120s 超时。
  * 砍到 24k 后输出 ≈2–4k tokens,仍远低于 LAYER_MAX_TOKENS_EXTRACT(16k),不会引入截断,
  * 单块失败半径从「几百条」缩到「几十条」。代价是多几次小调用,但每次 5–15s 完成。
  */
 const MAX_EXTRACT_CHUNK_CHARS = 24_000;
+/**
+ * L2 场景整合单块字符硬顶（R1）：与抽取同精神——旧版一次把整族 backlog 塞单调用，
+ * 库越大越必撞超时（实测 work-L2 >60s abort）。砍到 24k 后逐块整合，失败半径从
+ * “整族 backlog”缩到“一块”。默认对齐 MAX_EXTRACT_CHUNK_CHARS。
+ */
+export const MAX_SCENE_CHUNK_CHARS = 24_000;
 /**
  * L1 去重单批发起上限(与抽取同精神)
  *
@@ -266,7 +272,9 @@ anchorMap,
  * 另两个 sidecar 里，而 merge 每次新铸 id——不搬就等于每次合并把这条记忆的
  * `used`/人工打分清零，它会被当成“没用过”而沉底。缺省不搬（行为与改动前一致）。
  */
-mergeRekey) {
+mergeRekey, 
+/** R9 路由健康学习（可选）：读已学到的跑通块长收紧 perChunk，成功块回记。未传=不启用。 */
+routeHealth) {
     if (!cfg.extract.enabled)
         return { stored: 0, skipped: true, sceneName: chainHead(states, mode), newRecords: [] };
     // 触发阈值(渐进爬坡 + 按会话切片计数)由 runner 判定(trigger.ts);
@@ -314,12 +322,31 @@ mergeRekey) {
     const backgroundMsgs = background.slice(-cfg.extract.backgroundMessages);
     // 预留:背景消息(≤10 条 ×4000 字)+ prompt 脚手架
     // 硬顶 24k(见 MAX_EXTRACT_CHUNK_CHARS 注释);若配置更小则跟随配置
-    const perChunk = Math.min(MAX_EXTRACT_CHUNK_CHARS, Math.max(20_000, cfg.llm.maxInputChars - 42_000));
+    let perChunk = Math.min(MAX_EXTRACT_CHUNK_CHARS, Math.max(20_000, cfg.llm.maxInputChars - 42_000));
+    // R5: 尊重模型真实输入上限（若声明），避免 700k 盲值撞本地模型硬限
+    if (cfg.llm.modelMaxInputChars && cfg.llm.modelMaxInputChars > 0) {
+        perChunk = Math.min(perChunk, Math.max(20_000, cfg.llm.modelMaxInputChars - 42_000));
+    }
+    // R9: 用该路由已学到的跑通块长再收紧 perChunk（best-effort；路由解析失败则跳过）
+    let rhKey;
+    if (routeHealth) {
+        try {
+            rhKey = await resolveModelRoute(ctx, cfg);
+            const lg = routeHealth.lastGoodChunkChars(rhKey.provider, rhKey.model);
+            if (lg > 0)
+                perChunk = Math.min(perChunk, Math.max(20_000, lg));
+        }
+        catch {
+            rhKey = undefined;
+        }
+    }
     const chunks = chunkByCharBudget(pending, perChunk);
     if (chunks.length > 1) {
         logger.info(`[memory] L1 输入超预算(${pending.length} 条消息),分 ${chunks.length} 块抽取(每块 ≤${perChunk} 字符)`);
     }
     const extracted = [];
+    // R1′ 抽取块级失败的消息(留桶下轮重投，实现部分消费)
+    const failedMessages = [];
     let lastScene = chainState.lastSceneName;
     let sceneCount = 0;
     // 治理归属(ADR-0015 T1.7/T1.9):repoKey=basename(归一 cwd),**进管线时一次算定**
@@ -330,30 +357,52 @@ mergeRekey) {
     const halls = mode === 'auto' && !hallCandidates.includes(WING_FALLBACK)
         ? [...hallCandidates, WING_FALLBACK]
         : hallCandidates;
+    const timeBudgetMs = cfg.llm.extractTimeBudgetMs ?? 0;
+    const extractStart = Date.now();
     for (const chunk of chunks) {
+        // R5 整轮墙钟预算：超预算把本块(及后续块)留 pending 下轮续，防慢模型独占串行泵
+        if (timeBudgetMs > 0 && chunks.length > 1 && Date.now() - extractStart > timeBudgetMs) {
+            failedMessages.push(...chunk);
+            continue;
+        }
         const userPrompt = formatExtractionPrompt({
             newMessages: chunk,
             backgroundMessages: backgroundMsgs,
             previousSceneName: lastScene || '无',
             halls,
         });
-        const raw = await callLLM(ctx, cfg, {
-            system: getExtractMemoriesSystemPrompt(mode, {
-                usageScenario: cfg.usageScenario?.enabled === true,
-                narrative: cfg.narrativeTemplates?.enabled === true,
-                // 名称蒸馏（Phase 3）：示例段只在总开关开着时付（它与 title 是两层成本，
-                // 分开开关才能 A/B）。关着时这份 opts 产出的提示与改动前逐字相同。
-                title: cfg.naming?.enabled === true,
-                fewShot: cfg.naming?.enabled === true && cfg.naming.fewShot === true,
-            }),
-            user: userPrompt,
-            maxTokens: resolveLayerTokens(cfg, 'extract'),
-            layer: 'l1-extract',
-            logger,
-        });
-        const scenes = parseJsonLogged(raw, 'L1 抽取', logger);
-        if (!Array.isArray(scenes))
-            throw new Error('L1 抽取输出不是 JSON 数组');
+        let scenes;
+        try {
+            const raw = await callLLM(ctx, cfg, {
+                system: getExtractMemoriesSystemPrompt(mode, {
+                    usageScenario: cfg.usageScenario?.enabled === true,
+                    narrative: cfg.narrativeTemplates?.enabled === true,
+                    // 名称蒸馏（Phase 3）：示例段只在总开关开着时付（它与 title 是两层成本，
+                    // 分开开关才能 A/B）。关着时这份 opts 产出的提示与改动前逐字相同。
+                    title: cfg.naming?.enabled === true,
+                    fewShot: cfg.naming?.enabled === true && cfg.naming.fewShot === true,
+                }),
+                user: userPrompt,
+                maxTokens: resolveLayerTokens(cfg, 'extract'),
+                layer: 'l1-extract',
+                logger,
+            });
+            const parsed = parseJsonLogged(raw, 'L1 抽取', logger);
+            if (!Array.isArray(parsed))
+                throw new Error('L1 抽取输出不是 JSON 数组');
+            scenes = parsed;
+            // R9: 记录该路由跑通的实际块长（只降不升），供下轮收紧 perChunk
+            if (routeHealth && rhKey) {
+                const chunkChars = chunk.reduce((n, m) => n + m.content.length + 64, 0);
+                routeHealth.recordGood(rhKey.provider, rhKey.model, chunkChars);
+            }
+        }
+        catch (err) {
+            // R1′ 块级容错：单块超时/崩只丢这块、留桶下轮重投，不掀翻整批(旧行为是整抛)
+            failedMessages.push(...chunk);
+            logger.warn(`[memory] L1 抽取块失败(${chunk.length} 条消息留待重投): ${err instanceof Error ? err.message : String(err)}`);
+            continue;
+        }
         for (const scene of scenes) {
             if (!scene || typeof scene.scene_name !== 'string')
                 continue;
@@ -397,10 +446,14 @@ mergeRekey) {
         }
     }
     if (extracted.length === 0) {
+        // 全部块失败：等价旧"整抛"语义——runner catch 会保留整片 + 记退避(不误当零产出成功)
+        if (failedMessages.length > 0) {
+            throw new Error(`L1 抽取全部 ${chunks.length} 块失败(逐块错误见上)`);
+        }
         logger.info(`[memory] L1 抽取完成:无可提取记忆(mode=${mode},${pending.length} 条消息,${sceneCount} 个情境)`);
         // 成功但零产出:同样推进时间戳/场景,与失败(lastExtractAt 保持 0)区分开
         markExtracted(states, mode, lastScene);
-        return { stored: 0, skipped: false, sceneName: lastScene, newRecords: [] };
+        return { stored: 0, skipped: false, sceneName: lastScene, newRecords: [], failedMessages: [] };
     }
     // ── Step 2: 去重(batch 冲突检测;候选只在本族内召回,去重永不跨族) ──
     const matches = await Promise.all(extracted.map(async (m) => ({
@@ -773,7 +826,7 @@ mergeRekey) {
     }
     markExtracted(states, mode, lastScene);
     logger.info(`[memory] L1 抽取完成(mode=${mode}):消息 ${pending.length} 条,抽取 ${extracted.length} 条,去重后新增 ${added.length} 条(取代退场 ${supersededBy.size} 条,chat=${addedByFamily.chat}/work=${addedByFamily.work}),累计 chat=${states.chat.totalExtracted}/work=${states.work.totalExtracted}`);
-    return { stored: added.length, skipped: false, sceneName: lastScene, newRecords: added, runId, byKind };
+    return { stored: added.length, skipped: false, sceneName: lastScene, newRecords: added, runId, byKind, failedMessages };
 }
 /** auto 档取最近活跃的族 checkpoint(情境链/计数锚点)。 */
 function activeState(states) {

package/dist/pipeline/l2.js

@@ -1,71 +1,93 @@
 import { callLLM, parseJsonLogged, resolveLayerTokens } from '../llm.js';
 import { buildScenePrompt, formatSceneSummaries } from '../prompts/scene.js';
 import { Bm25Index } from '../store/bm25.js';
+import { chunkByCharBudget, MAX_SCENE_CHUNK_CHARS } from './l1.js';
 const REQUEST_RE = /\[PERSONA_UPDATE_REQUEST\]\s*reason:\s*([\s\S]*?)\[\/PERSONA_UPDATE_REQUEST\]/;
 export async function runSceneConsolidation(ctx, cfg, scenes, newMemories, logger, family) {
     if (!cfg.l2.enabled || newMemories.length === 0) {
         return { changed: 0 };
     }
     const summaries = await scenes.list();
-    // ── 组装 prompt ──
-    const memoriesJson = JSON.stringify(newMemories.map((m) => ({
-        record_id: m.id,
-        content: m.content,
-        type: m.type,
-        priority: m.priority,
-        scene_name: m.scene_name,
-        // repo 归属(ADR-0015 T1.9/T1.10):L2 场景归属决策可见项目边界——
-        // this-repo 记录不得并入跨项目场景;'' = 未归属(不引导分组)。
-        repoKeyName: m.repoKeyName ?? '',
-        applicability: m.applicability ?? '',
-        timestamps: m.timestamps.map((t) => new Date(t).toISOString()),
-    })), null, 2);
+    // 跨块共享的上下文：相关场景全文只选一次（BM25 按全量新记忆选），各块复用。
     const sceneSummaries = formatSceneSummaries(summaries);
     const sceneContents = await pickSceneContents(scenes, summaries, newMemories, cfg.l2.sceneContextLimit);
-    const { systemPrompt, userPrompt } = buildScenePrompt({
-        memoriesJson,
-        sceneSummaries,
-        sceneContents,
-        currentTimestamp: new Date().toISOString(),
-        existingSceneFiles: summaries.map((s) => s.path),
-        maxScenes: cfg.l2.maxScenes,
-        family,
-    });
-    const raw = await callLLM(ctx, cfg, {
-        system: systemPrompt,
-        user: userPrompt,
-        maxTokens: resolveLayerTokens(cfg, 'l2'),
-        layer: 'l2',
-        logger,
-    });
-    // ── 解析:先取 PERSONA_UPDATE_REQUEST 标记,再解析操作数组 ──
-    const reqMatch = REQUEST_RE.exec(raw);
-    const personaRequestedReason = reqMatch?.[1]?.trim() || undefined;
-    const opsRaw = reqMatch ? raw.replace(REQUEST_RE, '') : raw;
-    const ops = parseJsonLogged(opsRaw, 'L2 场景操作', logger);
-    if (!Array.isArray(ops))
-        throw new Error('L2 输出不是操作数组');
+    // R1 分块分载：把 newMemories 按字符预算切块逐块整合（旧版一次塞整族 backlog → 大库必撞超时）。
+    // 单块（小 backlog）时与改前逐字一致（零漂移）；多块时跨块合并判断为近似（诚实降级）。
+    const perChunk = Math.min(MAX_SCENE_CHUNK_CHARS, Math.max(20_000, cfg.llm.maxInputChars - 42_000));
+    const chunks = chunkByCharBudget(newMemories, perChunk);
+    if (chunks.length > 1) {
+        logger.info(`[memory] L2 输入超预算(${newMemories.length} 条新记忆),分 ${chunks.length} 块整合(每块 ≤${perChunk} 字符)`);
+    }
     let changed = 0;
-    for (const op of ops) {
-        if (!op || typeof op.path !== 'string')
-            continue;
+    let failedChunks = 0;
+    let personaRequestedReason;
+    for (const chunk of chunks) {
+        const memoriesJson = JSON.stringify(chunk.map((m) => ({
+            record_id: m.id,
+            content: m.content,
+            type: m.type,
+            priority: m.priority,
+            scene_name: m.scene_name,
+            // repo 归属(ADR-0015 T1.9/T1.10):L2 场景归属决策可见项目边界——
+            // this-repo 记录不得并入跨项目场景;'' = 未归属(不引导分组)。
+            repoKeyName: m.repoKeyName ?? '',
+            applicability: m.applicability ?? '',
+            timestamps: m.timestamps.map((t) => new Date(t).toISOString()),
+        })), null, 2);
+        const { systemPrompt, userPrompt } = buildScenePrompt({
+            memoriesJson,
+            sceneSummaries,
+            sceneContents,
+            currentTimestamp: new Date().toISOString(),
+            existingSceneFiles: summaries.map((s) => s.path),
+            maxScenes: cfg.l2.maxScenes,
+            family,
+        });
         try {
-            if (op.op === 'write' && typeof op.content === 'string') {
-                await scenes.write(op.path, op.content);
-                changed++;
-                logger.debug?.(`[memory] L2 写入场景 ${op.path} (${op.content.length} 字符)`);
-            }
-            else if (op.op === 'delete') {
-                await scenes.write(op.path, '[DELETED]');
-                changed++;
-                logger.debug?.(`[memory] L2 删除场景 ${op.path}`);
+            const raw = await callLLM(ctx, cfg, {
+                system: systemPrompt,
+                user: userPrompt,
+                maxTokens: resolveLayerTokens(cfg, 'l2'),
+                layer: 'l2',
+                logger,
+            });
+            // 解析:先取 PERSONA_UPDATE_REQUEST 标记,再解析操作数组
+            const reqMatch = REQUEST_RE.exec(raw);
+            if (reqMatch?.[1]?.trim())
+                personaRequestedReason = reqMatch[1].trim();
+            const opsRaw = reqMatch ? raw.replace(REQUEST_RE, '') : raw;
+            const ops = parseJsonLogged(opsRaw, 'L2 场景操作', logger);
+            if (!Array.isArray(ops))
+                throw new Error('L2 输出不是操作数组');
+            for (const op of ops) {
+                if (!op || typeof op.path !== 'string')
+                    continue;
+                try {
+                    if (op.op === 'write' && typeof op.content === 'string') {
+                        await scenes.write(op.path, op.content);
+                        changed++;
+                        logger.debug?.(`[memory] L2 写入场景 ${op.path} (${op.content.length} 字符)`);
+                    }
+                    else if (op.op === 'delete') {
+                        await scenes.write(op.path, '[DELETED]');
+                        changed++;
+                        logger.debug?.(`[memory] L2 删除场景 ${op.path}`);
+                    }
+                }
+                catch (err) {
+                    logger.warn(`[memory] L2 操作失败 ${op.path}: ${err instanceof Error ? err.message : String(err)}`);
+                }
             }
         }
         catch (err) {
-            logger.warn(`[memory] L2 操作失败 ${op.path}: ${err instanceof Error ? err.message : String(err)}`);
+            // R1 块级容错：单块超时/崩只丢这块，不掀全族（旧行为是整抛）
+            failedChunks++;
+            logger.warn(`[memory] L2 分块整合失败(family=${family},${chunk.length} 条记忆本块丢弃): ${err instanceof Error ? err.message : String(err)}`);
+            continue;
         }
     }
-    logger.info(`[memory] L2 场景整合完成(family=${family}):${newMemories.length} 条新记忆 → ${changed} 个文件操作(场景总数 ${summaries.length})` +
+    logger.info(`[memory] L2 场景整合完成(family=${family}):${newMemories.length} 条新记忆 → ${changed} 个文件操作(场景总数 ${summaries.length}` +
+        (chunks.length > 1 ? `,分 ${chunks.length} 块、失败 ${failedChunks} 块` : '') + `)` +
         (personaRequestedReason ? `,请求 L3 更新:${personaRequestedReason}` : ''));
     return { changed, personaRequestedReason };
 }

package/dist/pipeline/ruminate.js

@@ -167,6 +167,8 @@ export class RuminateController {
         //   经 runTurn 的 `bucket.push(...messages)` 会重复入桶 → 反刍后待处理计数“还原/变多”。）
         this.runner.enqueue(session.sessionId, [], session.mode, {
             force: true,
+            // R6：反刍与 rebuild 同为用户显式动作 → 越过抽取退避，保证"催一把"能真跑不被跳过
+            bypassBackoff: true,
             onTurnDone: (records) => {
                 this.totalL1 += records;
                 this.status.recordsBuilt = this.totalL1;

package/dist/pipeline/runner.d.ts

@@ -22,6 +22,7 @@ import type { SceneStore } from '../store/scenes.js';
 import type { StateStore } from '../store/state.js';
 import type { ConversationMessage, ExtractMode, MemoryFamily, MemoryLogger } from '../types.js';
 import type { FamilyStates } from './l1.js';
+import type { RouteHealthStore } from '../store/route-health.js';
 export interface MemoryStores {
     /**
      * DRSC 客户端(T8.4 读切):蒸馏背景窗的历史供给面(op=session&tail&redact=1)。
@@ -44,6 +45,8 @@ export interface MemoryStores {
     feedback?: {
         rekey(oldId: string, newId: string): boolean;
     };
+    /** R9 路由健康学习（可选）：未传则 runExtraction 不启用自适应块长学习。 */
+    routeHealth?: RouteHealthStore;
 }
 /** 管线任务(优先级调度:live > graph > rebuild)。 */
 export interface PipelineTask {
@@ -97,6 +100,8 @@ export declare class MemoryRunner {
     private extractFailures;
     /** 图谱泵在队列中的占位标志(同一时刻至多一个 graph 任务;护栏四件套之一)。 */
     private graphPumpQueued;
+    /** R7：已入队、尚未消费的 force-flush 键集（`session:mode`），同键不重复入队（治积压刷屏）。 */
+    private flushQueued;
     private readonly pendingFile;
     /** 分族 checkpoint(init 后可用;重建收尾也从这里读活引用)。 */
     states: FamilyStates;
@@ -132,6 +137,7 @@ export declare class MemoryRunner {
      *  onTurnDone 在该任务真正跑完后回调,携带本轮新增记录数(供反刍统计真实产出)。 */
     enqueue(sessionId: string, messages: ConversationMessage[], mode: ExtractMode, opts?: {
         force?: boolean;
+        bypassBackoff?: boolean;
         onTurnDone?: (records: number) => void;
     }): void;
     /** 重建任务入队(低优先级:让位于正常轮次;由 RebuildController 分块驱动)。 */

package/dist/pipeline/runner.js

@@ -1,5 +1,6 @@
 import { resolveDataDir } from '../config.js';
 import { GRAPH_PRIORITY_NEW } from '../graph/types.js';
+import { NoDistillRouteError } from '../llm.js';
 import { startValidityBackfill } from '../validity-backfill.js';
 import { drscRowToConversationMessage } from '../clients/drsc.js';
 import { trace } from '../store/trace.js';
@@ -83,6 +84,8 @@ export function effectiveCfg(cfg, live) {
         : null;
     const layerChains = layerPick && Object.keys(layerPick).length ? layerPick : null;
     const maxInput = s && s.distillMaxInputChars > 0 ? s.distillMaxInputChars : null;
+    // R10 蒸馏超时运行时覆盖：>0 才注入 llm.timeoutMs，否则跟随静态配置
+    const timeoutOv = s && s.distillTimeoutMs > 0 ? s.distillTimeoutMs : null;
     // 旧档位键的全局接管(含给静态回退条目盖章):仅非链模式保留(旧存量值兼容)
     const fallbacksTakeover = !chainMode && eff && cfg.llm?.fallbacks?.length
         ? cfg.llm.fallbacks.map((f) => ({ ...f, reasoningEffort: eff }))
@@ -169,6 +172,7 @@ export function effectiveCfg(cfg, live) {
             ...(override ?? {}),
             ...(budgets ? { budgets } : {}),
             ...(maxInput ? { maxInputChars: maxInput } : {}),
+            ...(timeoutOv ? { timeoutMs: timeoutOv } : {}),
             ...(fallbacksTakeover ? { fallbacks: fallbacksTakeover } : {}),
             ...(chainEffort ? { primaryEffort: chainEffort } : {}),
             ...(chainFallbacks ? { fallbacks: chainFallbacks } : {}),
@@ -212,6 +216,8 @@ export class MemoryRunner {
     extractFailures = new Map();
     /** 图谱泵在队列中的占位标志(同一时刻至多一个 graph 任务;护栏四件套之一)。 */
     graphPumpQueued = false;
+    /** R7：已入队、尚未消费的 force-flush 键集（`session:mode`），同键不重复入队（治积压刷屏）。 */
+    flushQueued = new Set();
     pendingFile;
     /** 分族 checkpoint(init 后可用;重建收尾也从这里读活引用)。 */
     states;
@@ -357,9 +363,25 @@ export class MemoryRunner {
     /** 一轮对话结束后入队(L0 落盘由 capture 在 turn/end 即时完成,不排蒸馏队列)。
      *  onTurnDone 在该任务真正跑完后回调,携带本轮新增记录数(供反刍统计真实产出)。 */
     enqueue(sessionId, messages, mode, opts) {
+        // R7：闲置/反刍/换档触发的 force-flush（空消息 + force）按 (session,mode) 去重，
+        // 同键未消费前不重复入队（一次长阻塞不再积压几十个 no-op 排空刷屏）。
+        const isFlush = opts?.force === true && messages.length === 0;
+        const fkey = isFlush ? `${sessionId}:${mode}` : '';
+        if (isFlush && this.flushQueued.has(fkey))
+            return;
+        if (isFlush)
+            this.flushQueued.add(fkey);
         this.pushTask({
             kind: 'live',
-            run: () => this.runTurn(sessionId, messages, mode, opts),
+            run: async () => {
+                try {
+                    return await this.runTurn(sessionId, messages, mode, opts);
+                }
+                finally {
+                    if (isFlush)
+                        this.flushQueued.delete(fkey); // 无论成败都释占，避免键泄漏永久屏蔽后续 flush
+                }
+            },
             ...(opts?.onTurnDone ? { onDone: (r) => opts.onTurnDone?.(typeof r === 'number' ? r : 0) } : {}),
         });
     }
@@ -637,7 +659,7 @@ export class MemoryRunner {
             const effective = effectiveExtractThreshold(this.warmup[mode], cfg.extract.minMessages);
             const sliceLen = bucket.reduce((n, m) => (m.sessionId === sessionId ? n + 1 : n), 0);
             // 抽取失败退避:重建轮(noBufferCap,用户显式动作、有自己的失败/取消 UI)豁免
-            const backedOff = !opts?.noBufferCap && this.inExtractBackoff(sessionId);
+            const backedOff = !opts?.noBufferCap && !opts?.bypassBackoff && this.inExtractBackoff(sessionId);
             if ((opts?.force || sliceLen >= effective) && !backedOff) {
                 newRecords = await this.extractSessionSlice(sessionId, mode, cfg, effective, opts);
                 // 新记录入投影队列(优先级恒高于存量补投影)并拉起图谱泵;入队本身廉价,
@@ -790,9 +812,12 @@ export class MemoryRunner {
             (oldId, newId) => {
                 this.stores.usage?.rekey(oldId, newId);
                 this.stores.feedback?.rekey(oldId, newId);
-            });
+            }, this.stores.routeHealth);
+            // R9: 本轮学到的跑通块长落盘（best-effort，失败不阻蒸馏）
+            await this.stores.routeHealth?.save().catch(() => { });
             if (!result.skipped) {
-                this.pending[mode] = rest;
+                // R1′ 部分消费：成功块出桶、抽取失败块留桶下轮重投（rest ∪ failedMessages）
+                this.pending[mode] = [...rest, ...(result.failedMessages ?? [])];
                 // 重建轮(force)不是有机对话,不推进爬坡
                 if (!opts?.force)
                     this.warmup[mode] = advanceWarmupThreshold(this.warmup[mode], cfg.extract.minMessages);
@@ -844,6 +869,12 @@ export class MemoryRunner {
                 ok: false,
                 errorKind: err instanceof Error ? err.name : 'error',
             });
+            // R4:无可用蒸馏路由=配置缺失、非模型慢——不进退避(否则把"没配"误当故障反复退避)，只顺延。
+            if (err instanceof NoDistillRouteError) {
+                this.logger.warn(`[memory] 无可用蒸馏路由,本轮蒸馏顺延、不记退避(session=${sessionId},mode=${mode})`);
+                await this.persistPending(opts?.noBufferCap).catch(() => { });
+                return [];
+            }
             // 指数退避:压制闲置兜底/补跑在 LLM 故障期间的连环重试(成功消费时清零)
             const streak = (this.extractFailures.get(sessionId)?.streak ?? 0) + 1;
             const delayMs = extractionBackoffMs(streak);

package/dist/settings.js

@@ -70,6 +70,7 @@ const ALWAYS_ON = {
     distillChain: [],
     distillBudgets: { extract: 0, dedup: 0, l2: 0, l3: 0, graph: 0 },
     distillMaxInputChars: 0,
+    distillTimeoutMs: 0,
     distillLayerChains: { l1: [], l2: [], l3: [] },
     distillMode: '',
     directBaseURL: '',
@@ -309,6 +310,8 @@ function resolveSettings(value) {
             graph: num(rawBudgets.graph),
         },
         distillMaxInputChars: num(v.distillMaxInputChars),
+        // R10 蒸馏超时运行时覆盖：钳 0~600000（与 live schema 同上限）；0 = 跟随部署 llm.timeoutMs
+        distillTimeoutMs: Math.min(600_000, Math.max(0, num(v.distillTimeoutMs))),
         // 蒸馏通道:mode 白名单(非法归 '' = 跟随部署);端点与密钥截断防御但保留原始内容
         distillMode: v.distillMode === 'host' || v.distillMode === 'direct' ? v.distillMode : '',
         directBaseURL: typeof v.directBaseURL === 'string' ? v.directBaseURL.slice(0, 2000) : '',

package/dist/stats.js

@@ -1344,6 +1344,7 @@ export async function handleEndpoint(endpoint, payload, deps) {
                     toolRoom: true, toolGraph: true, toolRuminate: true, toolConflict: true, toolMutate: true, toolSkills: true,
                     reasoningEffort: '', distillProvider: '', distillModel: '', distillChain: [],
                     distillBudgets: { extract: 0, dedup: 0, l2: 0, l3: 0, graph: 0 }, distillMaxInputChars: 0,
+                    distillTimeoutMs: 0,
                     distillLayerChains: { l1: [], l2: [], l3: [] },
                     distillMode: '', directBaseURL: '', directApiKey: '',
                     embedRemoteBaseURL: '', embedRemoteApiKey: '', embedRemoteModel: '', embedRemoteDimensions: 0,
@@ -1386,6 +1387,12 @@ export async function handleEndpoint(endpoint, payload, deps) {
                     fallback: cfg.llm.maxInputChars,
                     effective: s && s.distillMaxInputChars > 0 ? s.distillMaxInputChars : cfg.llm.maxInputChars,
                 },
+                // R10 蒸馏超时(ms)：current 是运行时覆盖(0 = 跟随配置)，fallback 是静态 llm.timeoutMs
+                timeoutBudget: {
+                    current: s?.distillTimeoutMs ?? 0,
+                    fallback: cfg.llm.timeoutMs,
+                    effective: s && s.distillTimeoutMs > 0 ? s.distillTimeoutMs : cfg.llm.timeoutMs,
+                },
             };
             return resp;
         }
@@ -1468,14 +1475,22 @@ export async function handleEndpoint(endpoint, payload, deps) {
                 }
                 clean.distillBudgets = budgets;
             }
-            // 输入预算(字符):0 = 跟随静态配置;正值须落在静态 schema 同款范围(1000~100 万)
+            // 输入预算(字符):0 = 跟随静态配置;正值须落在静态 schema 同款范围(1000~256k)
             if (patch.distillMaxInputChars !== undefined) {
                 const n = Number(patch.distillMaxInputChars);
-                if (!Number.isInteger(n) || n < 0 || n > 1_000_000 || (n > 0 && n < 1000)) {
-                    throw new Error('distillMaxInputChars 须为 0 或 1000~1000000 的整数(0 = 跟随配置)');
+                if (!Number.isInteger(n) || n < 0 || n > 256_000 || (n > 0 && n < 1000)) {
+                    throw new Error('distillMaxInputChars 须为 0 或 1000~256000 的整数(0 = 跟随配置)');
                 }
                 clean.distillMaxInputChars = n;
             }
+            // R10 蒸馏超时(ms)：0 = 跟随静态配置；正值 1000~600000（与 live schema 同上限）
+            if (patch.distillTimeoutMs !== undefined) {
+                const n = Number(patch.distillTimeoutMs);
+                if (!Number.isInteger(n) || n < 0 || n > 600_000 || (n > 0 && n < 1000)) {
+                    throw new Error('distillTimeoutMs 须为 0 或 1000~600000 的整数(0 = 跟随配置)');
+                }
+                clean.distillTimeoutMs = n;
+            }
             // 蒸馏通道运行时覆盖(direct 解耦):mode 白名单;endpoint 可回显;apiKey 属机密——
             // 写入后存 settings,但不回读到 UI、不落本条日志(下方日志先剔除后记录)
             if (patch.distillMode !== undefined) {

package/dist/store/file-versions.d.ts

@@ -29,3 +29,5 @@ export declare const PENDING_FILE_VERSION = 1;
 export declare const RECONCILE_STATE_FILE_VERSION = 1;
 /** `mem-md-ledger.json`（md 投射指纹账本，N9；派生态，删了可重建）。*/
 export declare const MEM_MD_LEDGER_FILE_VERSION = 1;
+/** `distill-route-health.json`（蒸馏路由健康学习值，R9；运行时派生，删了可重学）。*/
+export declare const ROUTE_HEALTH_FILE_VERSION = 1;

package/dist/store/file-versions.js

@@ -29,3 +29,5 @@ export const PENDING_FILE_VERSION = 1;
 export const RECONCILE_STATE_FILE_VERSION = 1;
 /** `mem-md-ledger.json`（md 投射指纹账本，N9；派生态，删了可重建）。*/
 export const MEM_MD_LEDGER_FILE_VERSION = 1;
+/** `distill-route-health.json`（蒸馏路由健康学习值，R9；运行时派生，删了可重学）。*/
+export const ROUTE_HEALTH_FILE_VERSION = 1;

package/dist/store/route-health.d.ts

@@ -0,0 +1,38 @@
+/** 单条路由健康记录。 */
+export interface RouteHealthEntry {
+    /** 退避后实测跑通的最小块长(字符)；0 = 未学到。 */
+    lastGoodChunkChars: number;
+    /** 该路由延迟 EMA(ms)；0 = 未记。R5 自适应可据此调初值。 */
+    latencyEmaMs: number;
+    /** 最近一次记录时刻(ISO)。 */
+    updatedAt: string;
+}
+/** 学习值默认过期(ms)：超此龄视为陈旧、读侧应重探（换模型/网关不至于被历史最小值锁死）。 */
+export declare const ROUTE_HEALTH_STALE_MS: number;
+export declare function routeHealthPathFor(dataDir: string): string;
+export declare class RouteHealthStore {
+    private readonly file;
+    private routes;
+    private dirty;
+    constructor(file: string);
+    /** 读盘 fail-open：缺/坏/未知版本 → 空表、不抛。 */
+    load(): Promise<void>;
+    /** 该路由已学到、且未过期的跑通块长；0 = 无可用学习值（未学到或已陈旧）。 */
+    lastGoodChunkChars(provider: string, model: string, now?: number, staleMs?: number): number;
+    /** 该路由延迟 EMA(ms)；0 = 未记。 */
+    latencyEma(provider: string, model: string): number;
+    /**
+     * 记一次「跑通」的块长：只降不升（更小块长才覆盖 lastGood），并更新延迟 EMA。
+     * @param chunkChars 本次成功的块长(字符)
+     * @param latencyMs  本次成功调用耗时(可选，用于 EMA)
+     */
+    recordGood(provider: string, model: string, chunkChars: number, latencyMs?: number): void;
+    /** 清除学习值：传 provider+model 清单条，否则清全部（面板「重置学习值」一键）。 */
+    reset(provider?: string, model?: string): void;
+    /** 全量快照（面板回显用）。 */
+    snapshot(): Array<{
+        key: string;
+    } & RouteHealthEntry>;
+    /** 有变更才落盘；失败由调用方兜底（不抛穿蒸馏）。@returns 是否写了盘 */
+    save(): Promise<boolean>;
+}