dsh-prime-memory 0.26.6 → 0.26.9

package/README.md

@@ -352,7 +352,7 @@ ONNX 量化 **CPU 推理**——无需 API Key，数据不出本机）。本地
 | `llm.maxTokens`              | `65536`                 | 未分层调用的兜底输出总闸。各蒸馏层有独立预算（抽取 16k / 去重 8k / L2 32k / L3 16k；思考档 high/xhigh/max 时自动 ×4，防 reasoning 吃光预算），分层预算可在设置页 → 记忆 → 概览 → 蒸馏参数运行时调整（留空/0 = 跟随内置默认）                                                                                                                                                                               |
 | `llm.reasoningEffort`        | 空                       | 蒸馏思考档位：空串 = **自动**（按模型能力解析：模型默认档 → `high`）；显式值（`off`/`none`/`minimal`/`low`/`medium`/`high`/`xhigh`/`max`）仅在该模型声明支持时发送——跨供应商 effort 词汇表不同（deepseek 认 `off`，OpenAI 系是 `none`，未声明档位的模型不传），不支持的档位自动降级为不传并告警一次；思考档 high/xhigh/max 时输出预算自动 ×4。运行时可在设置页路由链编辑器里**逐路由**覆盖档位（行内下拉，词表按各模型声明的能力实时显示，缺省跟随本值）                                 |
 | `llm.temperature`            | `0.3`                   | 蒸馏温度                                                                                                                                                                                                                                                                                                                             |
-| `llm.maxInputChars`          | `700000`                | 单次蒸馏输入字符预算（超限的 L1 输入自动分块抽取）；运行时可在设置页 → 蒸馏参数 → 输入预算调整（留空/0 = 跟随本值）                                                                                                                                                                                                                                                                |
+| `llm.maxInputChars`          | `200000`                | 单次蒸馏调用输入闸门（超限截断）；默认 200k 适配本地/免费模型窗口，上限 256k，可再往下调。L1 抽取/L2 另有 24k 分块硬顶，不受此值影响；运行时可在设置页 → 蒸馏参数 → 输入预算调整（留空/0 = 跟随本值）                                                                                                                                                                                                                                                                |
 | `llm.timeoutMs`              | `120000`                | 单次蒸馏调用超时（ms）                                                                                                                                                                                                                                                                                                                     |
 | `tokenCost.retentionDays`    | `365`                   | 蒸馏成本明细（token\_cost 表）保留天数，写入时滚动清理更早行；`0` = 永久保留。成本看板「近 N 天」窗口上限同此值                                                                                                                                                                                                                                                               |
 | `tools`                      | `true`                  | 是否注册模型可调用的记忆工具                                                                                                                                                                                                                                                                                                                   |
@@ -415,6 +415,13 @@ ONNX 量化 **CPU 推理**——无需 API Key，数据不出本机）。本地
 
 4. **调高超时**：`llm.timeoutMs` 只在路由确实慢但网关不掐时有用；网关 20s 掐断的场景调插件超时无效，请用前两层。
 
+### 二线大容量兜底与超时可调（v0.26.7+）
+
+- **面板可调超时**：设置 → 记忆 → 蒸馏参数 → **蒸馏超时(ms)**（`distillTimeoutMs`，即时生效、无需重启）。只救"慢但未被网关掐"的路由；供应商网关侧固定掐断（如某些免费路由 60s）抬此值无效，须换路由。
+- **二线模型（大容量兜底）**：`llm.secondary{provider,model,triggerChars}`——单次调用输入 ≥ `triggerChars` 才走二线（小调用走便宜快的一线、肥调用走能吞大输入的二线）。未配则不启用、绝不静默改选任意模型。
+- **分块分载与容错**：L1 抽取 / L2 场景整合按字符预算分块，单块超时/崩只丢该块、留待重试，不再"一块崩整批丢"（待重试不再被整片回滚）。`llm.extractTimeBudgetMs`（默认 0=不限）可给整轮抽取设墙钟预算，防一个慢模型独占后台；`llm.modelMaxInputChars` 声明模型真实输入上限，块大小据此收紧。
+- **显式路由（灰度）**：`llm.requireExplicitRoute=true` 时，未显式配一线/二线/回退链 → 蒸馏顺延并告警，不再蹭宿主默认模型（默认 false 保持旧行为）。
+
 ## 日志与故障排查
 
 dsh 宿主把插件日志打到控制台；插件另把 info 级以上镜像到数据目录的 `memory.log`。

package/dist/client.js

@@ -37811,9 +37811,12 @@ var __create = Object.create;
 		  const ib = data.inputBudget || { current: 0, fallback: 0, effective: 0 };
 		  const curIn = ib.current || 0;
 		  const effIn = ib.effective || ib.fallback || 0;
+		  const tb = data.timeoutBudget || { current: 0, fallback: 0, effective: 0 };
+		  const curTo = tb.current || 0;
+		  const effTo = tb.effective || tb.fallback || 0;
 		  const shown = (key) => {
 		    if (draft && draft[key] !== void 0) return draft[key];
-		    const c = key === "input" ? curIn : cur[key] || 0;
+		    const c = key === "input" ? curIn : key === "timeout" ? curTo : cur[key] || 0;
 		    return c > 0 ? String(c) : "";
 		  };
 		  const commitPart = (keys, buildPayload, applyView) => {
@@ -37823,11 +37826,11 @@ var __create = Object.create;
 		      const key = keys[i];
 		      const raw = (draft[key] !== void 0 ? draft[key] : shown(key)).trim();
 		      const n = raw === "" ? 0 : Number(raw);
-		      const max = key === "input" ? 1e6 : 1e6;
-		      const min = key === "input" ? raw === "" ? 0 : 1e3 : 0;
+		      const max = key === "timeout" ? 6e5 : key === "input" ? 256e3 : 1e6;
+		      const min = key === "input" || key === "timeout" ? raw === "" ? 0 : 1e3 : 0;
 		      if (!Number.isInteger(n) || n < min || n > max) {
 		        onError(
-		          key === "input" ? "输入预算须为 0 或 1000~1000000 的整数（留空或 0 = 跟随配置）" : "输出预算须为 0~1000000 的整数（留空或 0 = 跟随默认）"
+		          key === "input" ? "输入预算须为 0 或 1000~256000 的整数（留空或 0 = 跟随配置）" : key === "timeout" ? "蒸馏超时须为 0 或 1000~600000 的整数（留空或 0 = 跟随配置）" : "输出预算须为 0~1000000 的整数（留空或 0 = 跟随默认）"
 		        );
 		        setDraft(null);
 		        return;
@@ -37888,12 +37891,27 @@ var __create = Object.create;
 		      }
 		    );
 		  };
+		  const commitTimeout = () => {
+		    commitPart(
+		      ["timeout"],
+		      (v) => ({ distillTimeoutMs: v.timeout }),
+		      (prev, v) => ({
+		        ...prev,
+		        settings: { ...prev.settings, distillTimeoutMs: v.timeout },
+		        timeoutBudget: {
+		          ...prev.timeoutBudget || { current: 0, fallback: 0, effective: 0 },
+		          current: v.timeout,
+		          effective: v.timeout > 0 ? v.timeout : tb.fallback || 0
+		        }
+		      })
+		    );
+		  };
 		  const dirty = (keys) => {
 		    if (!draft) return false;
 		    for (let i = 0; i < keys.length; i++) {
 		      const key = keys[i];
 		      const want = (draft[key] !== void 0 ? draft[key] : "").trim();
-		      const was = key === "input" ? curIn > 0 ? String(curIn) : "" : (cur[key] || 0) > 0 ? String(cur[key]) : "";
+		      const was = key === "input" ? curIn > 0 ? String(curIn) : "" : key === "timeout" ? curTo > 0 ? String(curTo) : "" : (cur[key] || 0) > 0 ? String(cur[key]) : "";
 		      if (want !== was) return true;
 		    }
 		    return false;
@@ -37975,6 +37993,28 @@ var __create = Object.create;
 		        ),
 		        /* @__PURE__ */ (0, import_jsx_runtime8.jsx)("span", { style: { fontSize: 11, color: "var(--dsh-mem-text-3)" }, children: "字符" })
 		      ] }) })
+		    ] }) : null,
+		    showInput ? /* @__PURE__ */ (0, import_jsx_runtime8.jsxs)("div", { style: { marginTop: 12 }, children: [
+		      /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(
+		        "div",
+		        {
+		          style: S.switchLabel,
+		          title: '单次蒸馏调用超时(ms)：治"慢但未被网关掐"的路由需更大超时窗；留空或 0 = 跟随配置（当前生效 ' + (effTo || "?") + "ms，来自 llm.timeoutMs）。注：供应商网关侧固定掐断（如某些路由 60s）抬此值无效，须换路由",
+		          children: "蒸馏超时"
+		        }
+		      ),
+		      /* @__PURE__ */ (0, import_jsx_runtime8.jsx)("div", { style: { display: "flex", flexDirection: "column", gap: 6, marginTop: 4 }, children: /* @__PURE__ */ (0, import_jsx_runtime8.jsxs)("div", { style: rowStyle, children: [
+		        /* @__PURE__ */ (0, import_jsx_runtime8.jsx)("span", { style: { width: 68, flexShrink: 0, fontSize: 12, color: "var(--dsh-mem-text-2)" }, children: "超时" }),
+		        inputBox(
+		          "timeout",
+		          "超时",
+		          "单次蒸馏调用超时(ms)（留空 = 跟随配置 " + (tb.fallback || "?") + "）",
+		          110,
+		          tb.fallback,
+		          commitTimeout
+		        ),
+		        /* @__PURE__ */ (0, import_jsx_runtime8.jsx)("span", { style: { fontSize: 11, color: "var(--dsh-mem-text-3)" }, children: "ms" })
+		      ] }) })
 		    ] }) : null
 		  ] });
 		}

package/dist/config.d.ts

@@ -61,6 +61,10 @@ export interface MemoryConfig {
         backgroundMessages: number;
         /** 去重候选池大小(每条新记忆的相似候选数)。 */
         candidatePool: number;
+        /** L1 去重批连续失败上限:达此值则 fail-loud + park,不再无限重放同肥调用。R1″。 */
+        dedupRetryCap?: number;
+        /** 抽取结果 checkpoint 落盘:去重/落库失败后下轮从去重续跑、不重抽已成功块。R1″。 */
+        extractCheckpoint?: boolean;
     };
     l2: {
         enabled: boolean;
@@ -70,6 +74,8 @@ export interface MemoryConfig {
         maxScenes: number;
         /** L2 prompt 里附带的相似场景全文数量上限。 */
         sceneContextLimit: number;
+        /** L2 场景整合连续失败上限:达此值停攒该族 + fail-loud,避免同肥调用每轮重放。R8。 */
+        consecutiveFailCap?: number;
     };
     l3: {
         enabled: boolean;
@@ -390,6 +396,31 @@ export interface MemoryConfig {
         maxInputChars: number;
         /** 单次蒸馏调用超时(ms)。 */
         timeoutMs: number;
+        /** R5 整轮抽取墙钟预算(ms)：多块抽取累计超此预算即把剩余块留 pending 下轮续，
+         *  防一个慢模型独占串行泵十几分钟。0 = 不限（旧行为）。 */
+        extractTimeBudgetMs?: number;
+        /** 二线蒸馏模型(大容量兜底):仅当单次调用输入字符 ≥ triggerChars 才启用;
+         *  provider/model 任一为空 = 该档不可用(不隐式改选默认模型)。R3。 */
+        secondary?: {
+            provider: string;
+            model: string;
+            reasoningEffort?: string;
+            triggerChars: number;
+        };
+        /** 蒸馏模型真实输入上限(字符):perChunk 初值天花板;0/未声明 = 回退旧口径
+         *  min(24k, maxInputChars-42k)。R5/R11。 */
+        modelMaxInputChars?: number;
+        /** 自适应分块:超时/报错后块大小按此因子缩减(默认 0.6=减四成)。R5。 */
+        chunkShrinkFactor?: number;
+        /** 块缩减最大重试步数(触底=单条或达此步数即止)。R5。 */
+        chunkShrinkMaxSteps?: number;
+        /** 自适应分块总开关:关=固定 perChunk(零漂移)。R5。 */
+        adaptiveChunk?: {
+            enabled: boolean;
+        };
+        /** 蒸馏须显式配路由:true 时一线+二线+链皆空 → 抛 NoDistillRouteError(不蹭默认模型)。
+         *  灰度默认 false(不破坏"留空跟默认模型"的存量用户)。R4。 */
+        requireExplicitRoute?: boolean;
         /** 分层输出预算运行时覆盖(设置页 distillBudgets 经 effectiveCfg 注入;
          *  0/缺省 = 用内置默认。非静态 schema——预算无部署上限语义)。 */
         budgets?: Partial<{

package/dist/config.js

@@ -54,7 +54,9 @@ export function liveSettingsSchema() {
             // 图谱投影输出预算(投影 job 单批 ≤8 条记录,默认 8000)
             graph: budget(),
         }).default({ extract: 0, dedup: 0, l2: 0, l3: 0, graph: 0 }),
-        distillMaxInputChars: Schema.number().min(0).max(1_000_000).default(0),
+        distillMaxInputChars: Schema.number().min(0).max(256_000).default(0),
+        // R10 蒸馏超时运行时覆盖(ms):0 = 跟随静态 llm.timeoutMs;上限与部署 schema 同(600s)
+        distillTimeoutMs: Schema.number().min(0).max(600_000).default(0),
         // 蒸馏通道运行时覆盖:'' = 跟随部署 config / 'host' = 复用宿主 / 'direct' = 原生直连
         distillMode: Schema.union(['', 'host', 'direct']).default(''),
         directBaseURL: Schema.string().default(''),
@@ -144,12 +146,15 @@ export const memorySchema = Schema.object({
         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),
+        dedupRetryCap: Schema.number().min(1).max(20).default(5),
+        extractCheckpoint: Schema.boolean().default(true),
     }),
     l2: Schema.object({
         enabled: Schema.boolean().default(true),
         minNewMemories: Schema.number().min(1).max(100).default(5),
         maxScenes: Schema.number().min(1).max(100).default(12),
         sceneContextLimit: Schema.number().min(0).max(20).default(3),
+        consecutiveFailCap: Schema.number().min(1).max(20).default(3),
     }),
     l3: Schema.object({
         enabled: Schema.boolean().default(true),
@@ -361,9 +366,26 @@ export const memorySchema = Schema.object({
         // 旧默认 'off' 在非 deepseek 模型上必炸(400/本地拒绝)
         reasoningEffort: Schema.union([...EFFORT_CHOICES]).default(''),
         temperature: Schema.number().min(0).max(2).default(0.3),
-        // 模型上下文 1M token,日常压到 ~700k 使用(中文按 1 字≈1 token 保守折算)
-        maxInputChars: Schema.number().min(1000).max(1_000_000).default(700_000),
+        // 单次调用输入闸门默认压到本地模型可参与区间(200k,可再降);上限 256k(<256 KiB)。
+        // 旧 700k 为盲值、远超本地/免费路由窗口 → 大调用撞模型硬限。抽取/L2 分块另有 24k 硬顶，不受此影响。
+        maxInputChars: Schema.number().min(1000).max(256_000).default(200_000),
         timeoutMs: Schema.number().min(1000).max(600_000).default(120_000),
+        // R5 整轮抽取墙钟预算(ms):0=不限(旧行为);>0 超预算把剩余块留 pending 下轮续
+        extractTimeBudgetMs: Schema.number().min(0).max(3_600_000).default(0),
+        // 二线蒸馏模型(大容量兜底):输入 ≥ triggerChars 才启用;provider/model 空=该档不可用
+        secondary: Schema.object({
+            provider: Schema.string().default(''),
+            model: Schema.string().default(''),
+            reasoningEffort: Schema.union([...EFFORT_CHOICES]).default(''),
+            triggerChars: Schema.number().min(1000).max(1_000_000).default(20_000),
+        }).default({ provider: '', model: '', reasoningEffort: '', triggerChars: 20_000 }),
+        // 蒸馏模型真实输入上限(0=未声明,回退旧口径 min(24k, maxInputChars-42k))
+        modelMaxInputChars: Schema.number().min(0).max(1_000_000).default(0),
+        chunkShrinkFactor: Schema.number().min(0.1).max(0.95).default(0.6),
+        chunkShrinkMaxSteps: Schema.number().min(0).max(8).default(4),
+        adaptiveChunk: Schema.object({ enabled: Schema.boolean().default(true) }).default({ enabled: true }),
+        // 灰度默认 false:翻 true 后蒸馏须显式配路由(不蹭宿主默认模型),配 NoDistillRouteError
+        requireExplicitRoute: Schema.boolean().default(false),
     }),
     hall: Schema.object({
         enabled: Schema.array(Schema.string()).default([...WING_DEFAULT_ENABLED]),

package/dist/contract.d.ts

@@ -77,7 +77,10 @@ export interface MemoryLiveSettings {
     /** 输入预算运行时覆盖(字符,≈token):单次蒸馏调用的输入上限,L1 按此分块、
      *  超限截断;0 = 跟随静态配置 llm.maxInputChars。 */
     distillMaxInputChars: number;
-    /** 运行时按层路由链:层键 l1/l2/l3 各一条完整链;非空即完整接管该层解析
+    /** R10 蒸馏调用超时运行时覆盖(ms)：0 = 跟随静态配置 llm.timeoutMs；>0 = 覆盖。
+     *  治"慢但未被网关掐"的路由需更大超时窗（注：供应商网关侧固定掐断抬此值无效，须换路由）。 */
+    distillTimeoutMs: number;
+    /** 运行时按层路由链：层键 l1/l2/l3 各一条完整链；非空即完整接管该层解析
      *  (压过静态 layerRoutes,层内第一优先级);空数组 = 该层跟随(静态层链 → 全局解析逐级兜底)。
      *  写入经 settings-set 逐层校验(头行必须显式)。 */
     distillLayerChains: Record<LayerRouteKey, DistillChainEntry[]>;
@@ -805,6 +808,12 @@ export interface SettingsGetResponse {
         fallback: number;
         effective: number;
     };
+    /** R10 蒸馏超时(ms)：current 运行时覆盖(0=跟随) / fallback 静态 llm.timeoutMs / effective 生效值。 */
+    timeoutBudget: {
+        current: number;
+        fallback: number;
+        effective: number;
+    };
 }
 /** dsh-memory/settings-set(patch 语义:只带要改的键)。 */
 export interface SettingsSetRequest {
@@ -826,6 +835,8 @@ export interface SettingsSetRequest {
         graph: number;
     };
     distillMaxInputChars?: number;
+    /** R10 蒸馏超时运行时覆盖(ms)：0 = 跟随配置。 */
+    distillTimeoutMs?: number;
     /** md 投射/后缀收敛的单次动作护栏覆盖:0 = 跟随部署 `cfg.memExport.maxRecords`。 */
     mdExportMaxRecords?: number;
     /** 蒸馏通道运行时覆盖:'' = 跟随部署 config;'host' = 复用宿主;'direct' = 插件原生直连。 */

package/dist/index.js

@@ -34,6 +34,7 @@ import { SceneStore } from './store/scenes.js';
 import { SessionModeStore } from './store/session-modes.js';
 import { StateStore } from './store/state.js';
 import { SlotStore } from './store/slots.js';
+import { RouteHealthStore, routeHealthPathFor } from './store/route-health.js';
 import { registerMemoryTools } from './tools/index.js';
 import { registerSlotTools } from './tools/slots.js';
 import { registerSlotRecall } from './hooks/slot-recall.js';
@@ -207,6 +208,7 @@ export async function apply(ctx, config) {
     };
     const stores = {
         usage: undefined, // 装配于下方(依赖 dataDir 就绪)
+        routeHealth: undefined, // R9 路由健康学习，装配于下方
         // DRSC 客户端(T8.4 读切):蒸馏背景窗 + conversation_search 工具面的历史供给。
         // 硬依赖无本地回退(l0 表退役);trustedHosts 惰性读取(webStartup 可能晚到)。
         drsc: new DrscClient({ trustedHosts: () => readStartupTrustedHosts(ctx) }),
@@ -434,6 +436,10 @@ export async function apply(ctx, config) {
     const recallUsage = new RecallUsageStore(dataDir, logger);
     await recallUsage.init();
     stores.usage = recallUsage;
+    // R9 路由健康学习：跨进程留存"退避后跑通的最小块长"，供 runExtraction 收紧 perChunk。
+    const routeHealth = new RouteHealthStore(routeHealthPathFor(dataDir));
+    await routeHealth.load();
+    stores.routeHealth = routeHealth;
     // 召回相关度反馈（人在召回卡上打 -1..5）与「已声明过时」待播报队列。
     // 两个都是低频用户动作 → 立即落盘；sidecar 缺席/损坏只降级为只读，不阻断任何读路径。
     const recallFeedback = new RecallFeedbackStore(dataDir, logger);

package/dist/llm.d.ts

@@ -71,11 +71,25 @@ export declare const HIGH_EFFORT_TIERS: readonly ["high", "xhigh", "max"];
  * 预算致正文 0 字符)——effort 为 high/xhigh/max 时分层预算 ×4。
  */
 export declare function layerMaxTokens(base: number, reasoningEffort: string): number;
+/** 无可用蒸馏路由(显式一线/二线/链皆缺且 requireExplicitRoute=true)：
+ *  runner 据此 skip+顺延、不记退避——区别于"模型慢/超时"(那才退避)。R4。 */
+export declare class NoDistillRouteError extends Error {
+    constructor(msg?: string);
+}
 /** 解析蒸馏用的 provider/model:配置优先,其次当前默认选择。 */
 export declare function resolveModelRoute(ctx: Context, cfg: MemoryConfig): Promise<{
     provider: string;
     model: string;
 }>;
+/**
+ * 二线(大容量兜底)选路(R3)：单次调用输入字符 ≥ triggerChars 且二线已配 → 返回二线路由，
+ * 否则 null（走一线/链）。二线未配（provider/model 任一空）→ 永不命中，不隐式改选任意模型。
+ */
+export declare function pickSecondary(cfg: MemoryConfig, inputChars: number): {
+    provider: string;
+    model: string;
+    reasoningEffort?: string;
+} | null;
 /** 回退链条目(配置形态;reasoningEffort 为该路由的档位覆盖,'' = 跟随全局)。 */
 export interface FallbackRouteEntry {
     provider: string;

package/dist/llm.js

@@ -46,11 +46,28 @@ export const HIGH_EFFORT_TIERS = ['high', 'xhigh', 'max'];
 export function layerMaxTokens(base, reasoningEffort) {
     return HIGH_EFFORT_TIERS.includes(reasoningEffort) ? base * 4 : base;
 }
+/** 无可用蒸馏路由(显式一线/二线/链皆缺且 requireExplicitRoute=true)：
+ *  runner 据此 skip+顺延、不记退避——区别于"模型慢/超时"(那才退避)。R4。 */
+export class NoDistillRouteError extends Error {
+    constructor(msg = '无可用蒸馏路由:已开启 llm.requireExplicitRoute,但未显式配置一线/二线/回退链') {
+        super(msg);
+        this.name = 'NoDistillRouteError';
+    }
+}
 /** 解析蒸馏用的 provider/model:配置优先,其次当前默认选择。 */
 export async function resolveModelRoute(ctx, cfg) {
     if (cfg.llm.provider && cfg.llm.model) {
         return { provider: cfg.llm.provider, model: cfg.llm.model };
     }
+    // R4 fail-closed:开了 requireExplicitRoute 且二线/回退链都未配 → 不蹭宿主默认模型,
+    // 抛专用错误(runner 侧 skip+顺延、不记退避——"没配路由"≠"模型慢")。关时逐字走旧路径。
+    if (cfg.llm.requireExplicitRoute === true) {
+        const sec = cfg.llm.secondary;
+        const hasSecondary = !!(sec && sec.provider && sec.model);
+        const hasChain = (cfg.llm.fallbacks?.length ?? 0) > 0;
+        if (!hasSecondary && !hasChain)
+            throw new NoDistillRouteError();
+    }
     // agentDefaultModel 是可选服务,缺失时不得抛错。
     const defaults = ctx.get('agentDefaultModel');
     const sel = defaults?.currentSelection?.();
@@ -59,6 +76,19 @@ export async function resolveModelRoute(ctx, cfg) {
     }
     throw new Error('无法解析蒸馏模型路由:请在插件 config 中配置 llm.provider / llm.model,或确保存在默认模型选择');
 }
+/**
+ * 二线(大容量兜底)选路(R3)：单次调用输入字符 ≥ triggerChars 且二线已配 → 返回二线路由，
+ * 否则 null（走一线/链）。二线未配（provider/model 任一空）→ 永不命中，不隐式改选任意模型。
+ */
+export function pickSecondary(cfg, inputChars) {
+    const sec = cfg.llm.secondary;
+    if (!sec || !sec.provider || !sec.model)
+        return null;
+    const trigger = sec.triggerChars > 0 ? sec.triggerChars : Number.POSITIVE_INFINITY;
+    if (!(inputChars >= trigger))
+        return null;
+    return { provider: sec.provider, model: sec.model, ...(sec.reasoningEffort ? { reasoningEffort: sec.reasoningEffort } : {}) };
+}
 /**
  * 组装蒸馏路由链(纯决策,决策表缝):主路由在前、回退条目按配置顺序在后。
  * provider/model 缺失的条目剔除;与主路由或先前条目完全相同(provider+model)的
@@ -370,8 +400,17 @@ export async function callLLM(ctx, cfg, opts) {
     // 宿主路由链:opts.layer 配了层链的层走层链完整替换,其余走全局解析;
     // direct 模式下这一段充当付费/默认模型的兜底安全网。
     const routes = await resolveLayerRoutes(ctx, cfg, opts.layer);
-    for (let i = 0; i < routes.length; i++) {
-        const route = routes[i];
+    // R3 二线(大容量兜底)：输入 ≥ triggerChars 且二线已配 → 前置二线，让肥调用先走大容量档；
+    // 二线未配时 sec=null → 链逐字不变（零漂移）。已在链里的同路由去重。
+    const sec = pickSecondary(cfg, opts.user.length);
+    const chain = sec
+        ? [
+            { provider: sec.provider, model: sec.model, effort: sec.reasoningEffort ?? '' },
+            ...routes.filter((r) => !(r.provider === sec.provider && r.model === sec.model)),
+        ]
+        : routes;
+    for (let i = 0; i < chain.length; i++) {
+        const route = chain[i];
         try {
             return await callRoute(ctx, cfg, opts, route);
         }
@@ -381,7 +420,7 @@ export async function callLLM(ctx, cfg, opts) {
                 throw err;
             lastErr = err;
             warnRouteDeadOnce(route, opts.logger);
-            const next = routes[i + 1];
+            const next = chain[i + 1];
             if (next) {
                 opts.logger?.info(`[memory] 蒸馏路由降级 ${route.provider}/${route.model} → ${next.provider}/${next.model}(${errDetail(err)})`);
             }

package/dist/pipeline/l1.d.ts

@@ -1,8 +1,15 @@
 import type { Context } from '@deepseek-ai/cordis';
 import type { MemoryConfig } from '../config.js';
+import type { RouteHealthStore } from '../store/route-health.js';
 import type { L1Store } from '../store/l1.js';
 import type { MemoryState } from '../store/state.js';
 import type { ConversationAnchor, ConversationMessage, ExtractedMemory, ExtractMode, MemoryFamily, MemoryLogger, MemoryRecord, MemoryScope } from '../types.js';
+/**
+ * L2 场景整合单块字符硬顶（R1）：与抽取同精神——旧版一次把整族 backlog 塞单调用，
+ * 库越大越必撞超时（实测 work-L2 >60s abort）。砍到 24k 后逐块整合，失败半径从
+ * “整族 backlog”缩到“一块”。默认对齐 MAX_EXTRACT_CHUNK_CHARS。
+ */
+export declare const MAX_SCENE_CHUNK_CHARS = 24000;
 export interface ExtractionResult {
     stored: number;
     skipped: boolean;
@@ -12,6 +19,8 @@ export interface ExtractionResult {
     runId?: string;
     /** §F 追踪捎带:六值决策词表聚合;早退分支缺省。 */
     byKind?: Record<string, number>;
+    /** R1′ 抽取块级失败的消息：调用方应留桶下轮重投(部分消费，不整批回滚)。 */
+    failedMessages?: ConversationMessage[];
 }
 /** 分族 checkpoint 桶(活引用,改动由调用方 save 落盘)。 */
 export type FamilyStates = Record<MemoryFamily, MemoryState>;
@@ -55,7 +64,9 @@ export declare function toStoreRecord(m: PendingMemory, now: number, ts: number,
  * 按字符预算把消息切成多块(保持顺序,单条超预算独占一块,由 callLLM 兜底截断)。
  * 每条消息按 content 长度 + 64 字符脚手架开销(id/时间戳行)计。
  */
-export declare function chunkByCharBudget(messages: ConversationMessage[], budgetChars: number): ConversationMessage[][];
+export declare function chunkByCharBudget<T extends {
+    content: string;
+}>(messages: readonly T[], budgetChars: number): T[][];
 export declare function runExtraction(ctx: Context, cfg: MemoryConfig, store: L1Store, states: FamilyStates, pending: ConversationMessage[], background: ConversationMessage[], logger: MemoryLogger, mode: ExtractMode, 
 /**
  * §E 当前工作区标识(由调用方经 `sessionWorkspaceIdOf` 解析;拿不到传 undefined)。
@@ -74,4 +85,6 @@ anchorMap?: ReadonlyMap<string, ConversationAnchor>,
  * 另两个 sidecar 里，而 merge 每次新铸 id——不搬就等于每次合并把这条记忆的
  * `used`/人工打分清零，它会被当成“没用过”而沉底。缺省不搬（行为与改动前一致）。
  */
-mergeRekey?: (oldId: string, newId: string) => void): Promise<ExtractionResult>;
+mergeRekey?: (oldId: string, newId: string) => void, 
+/** R9 路由健康学习（可选）：读已学到的跑通块长收紧 perChunk，成功块回记。未传=不启用。 */
+routeHealth?: RouteHealthStore): Promise<ExtractionResult>;

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>;
+}

package/dist/store/route-health.js

@@ -0,0 +1,115 @@
+/**
+ * 蒸馏路由健康学习(R9)：按 `provider/model` 记「自适应退避后实测跑通的最小块长」，
+ * 跨进程留存，令下次 perChunk 初值直接取跑通过的值、不必每进程重付退避风暴；
+ * 面板可回显「实测最小可用块长 / 最后退避长度」。
+ *
+ * 运行时学习值、非磁盘契约：
+ * - 读 **fail-open**（缺文件/损坏/未知版本 → 空表起步，绝不抛、不阻蒸馏——学习值丢了最多少一次优化）；
+ * - 写走 `atomicWriteJson`（原子 + 覆盖保护）；
+ * - **只降不升**：更小的跑通块长才覆盖 lastGood（换 provider/过期由读侧决定重探，见 R5 接线）。
+ *
+ * 本模块 Phase 1 仅落地存储与纯逻辑，尚未接线到 runExtraction（接线在 Phase 4 R5/R9）。
+ */
+import * as path from 'node:path';
+import { atomicWriteJson, readJsonStrict } from '../util/io.js';
+import { ROUTE_HEALTH_FILE_VERSION } from './file-versions.js';
+function keyOf(provider, model) {
+    return `${provider}/${model}`;
+}
+/** 学习值默认过期(ms)：超此龄视为陈旧、读侧应重探（换模型/网关不至于被历史最小值锁死）。 */
+export const ROUTE_HEALTH_STALE_MS = 7 * 24 * 60 * 60_000;
+export function routeHealthPathFor(dataDir) {
+    return path.join(dataDir, 'distill-route-health.json');
+}
+export class RouteHealthStore {
+    file;
+    routes = new Map();
+    dirty = false;
+    constructor(file) {
+        this.file = file;
+    }
+    /** 读盘 fail-open：缺/坏/未知版本 → 空表、不抛。 */
+    async load() {
+        const r = await readJsonStrict(this.file, { expectedVersion: ROUTE_HEALTH_FILE_VERSION });
+        this.routes = new Map();
+        if (!r.ok)
+            return; // missing / corrupt / unreadable / unknown_version 一律空起步
+        const raw = r.value?.routes;
+        if (!raw || typeof raw !== 'object')
+            return;
+        for (const [k, v] of Object.entries(raw)) {
+            if (!v || typeof v !== 'object')
+                continue;
+            const e = v;
+            if (typeof e.lastGoodChunkChars !== 'number' || !Number.isFinite(e.lastGoodChunkChars))
+                continue;
+            this.routes.set(k, {
+                lastGoodChunkChars: Math.max(0, Math.floor(e.lastGoodChunkChars)),
+                latencyEmaMs: typeof e.latencyEmaMs === 'number' && Number.isFinite(e.latencyEmaMs) ? e.latencyEmaMs : 0,
+                updatedAt: typeof e.updatedAt === 'string' ? e.updatedAt : '',
+            });
+        }
+    }
+    /** 该路由已学到、且未过期的跑通块长；0 = 无可用学习值（未学到或已陈旧）。 */
+    lastGoodChunkChars(provider, model, now = Date.now(), staleMs = ROUTE_HEALTH_STALE_MS) {
+        const e = this.routes.get(keyOf(provider, model));
+        if (!e || e.lastGoodChunkChars <= 0)
+            return 0;
+        const t = Date.parse(e.updatedAt);
+        if (Number.isFinite(t) && now - t > staleMs)
+            return 0; // 陈旧 → 交读侧重探
+        return e.lastGoodChunkChars;
+    }
+    /** 该路由延迟 EMA(ms)；0 = 未记。 */
+    latencyEma(provider, model) {
+        return this.routes.get(keyOf(provider, model))?.latencyEmaMs ?? 0;
+    }
+    /**
+     * 记一次「跑通」的块长：只降不升（更小块长才覆盖 lastGood），并更新延迟 EMA。
+     * @param chunkChars 本次成功的块长(字符)
+     * @param latencyMs  本次成功调用耗时(可选，用于 EMA)
+     */
+    recordGood(provider, model, chunkChars, latencyMs) {
+        if (!(chunkChars > 0) || !Number.isFinite(chunkChars))
+            return;
+        const k = keyOf(provider, model);
+        const cur = this.routes.get(k);
+        const next = {
+            lastGoodChunkChars: cur && cur.lastGoodChunkChars > 0
+                ? Math.min(cur.lastGoodChunkChars, Math.floor(chunkChars))
+                : Math.floor(chunkChars),
+            latencyEmaMs: latencyMs !== undefined && Number.isFinite(latencyMs) && latencyMs >= 0
+                ? cur && cur.latencyEmaMs > 0
+                    ? cur.latencyEmaMs * 0.7 + latencyMs * 0.3
+                    : latencyMs
+                : (cur?.latencyEmaMs ?? 0),
+            updatedAt: new Date().toISOString(),
+        };
+        this.routes.set(k, next);
+        this.dirty = true;
+    }
+    /** 清除学习值：传 provider+model 清单条，否则清全部（面板「重置学习值」一键）。 */
+    reset(provider, model) {
+        if (provider && model)
+            this.routes.delete(keyOf(provider, model));
+        else
+            this.routes.clear();
+        this.dirty = true;
+    }
+    /** 全量快照（面板回显用）。 */
+    snapshot() {
+        return [...this.routes.entries()].map(([key, v]) => ({ key, ...v }));
+    }
+    /** 有变更才落盘；失败由调用方兜底（不抛穿蒸馏）。@returns 是否写了盘 */
+    async save() {
+        if (!this.dirty)
+            return false;
+        const routes = {};
+        for (const [k, v] of this.routes)
+            routes[k] = v;
+        const payload = { version: ROUTE_HEALTH_FILE_VERSION, routes };
+        await atomicWriteJson(this.file, payload);
+        this.dirty = false;
+        return true;
+    }
+}

package/dsh.plugin.json

@@ -1,7 +1,7 @@
 {
   "id": "dsh-prime-memory",
   "name": "dsh-prime-memory",
-  "version": "0.26.6",
+  "version": "0.26.9",
   "description": {
     "en": "Layered distilled memory plugin (L0 capture → L1 atomic memory → L2 scenes → L3 persona) with automatic recall injection before each model step.",
     "zh": "L0~L3 分层蒸馏记忆插件:自动捕获对话、抽取原子记忆、整合场景块、蒸馏核心画像,并在模型步骤前自动召回注入。"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-prime-memory",
-  "version": "0.26.6",
+  "version": "0.26.9",
   "publishConfig": {
     "registry": "https://registry.npmjs.org",
     "access": "public",
@@ -64,7 +64,7 @@
   },
   "engines": {
     "node": ">=22.16.0",
-    "dsh": "0.1.0-rc.2 || 0.1.0-rc.3 || 0.1.0-rc.6 || 0.1.0-rc.7 || 0.1.0-rc.8 || 0.1.1-rc.1 || 0.1.1-rc.2 || 0.1.2-rc.1 || 0.1.5-rc.1 || 0.1.5-rc.2 || 0.1.5-rc.3 || 0.1.7-rc.1 || 0.1.7-rc.2 || 0.2.0-rc.1 || 0.2.0-rc.2 || 0.2.1-rc.1 || 0.2.1-rc.2 || 0.2.1-rc.1 || 0.2.1-rc.2"
+    "dsh": "0.1.0-rc.2 || 0.1.0-rc.3 || 0.1.0-rc.6 || 0.1.0-rc.7 || 0.1.0-rc.8 || 0.1.1-rc.1 || 0.1.1-rc.2 || 0.1.2-rc.1 || 0.1.5-rc.1 || 0.1.5-rc.2 || 0.1.5-rc.3 || 0.1.7-rc.1 || 0.1.7-rc.2 || 0.2.0-rc.1 || 0.2.0-rc.2 || 0.2.1-rc.1 || 0.2.1-rc.2"
   },
   "keywords": [
     "dsh",