dsh-prime-memory 0.26.6 → 0.26.10

package/CHANGELOG.md

@@ -1,5 +1,33 @@
 # 更新日志（Changelog）
 
+0.26.10: host enumeration addendum for DSH 0.2.1-rc.3 (declaration-only bump; contract plane zero diff).
+
+## [0.26.9] — 2026-10-23
+
+> 本版汇总自 0.26.6 起的「蒸馏分块分载与调度健壮性」工作（计划 distill-load-balance，[ADR-0023](./docs/adr/0023-distill-load-balance-and-secondary-route.md)）。0.26.7/0.26.8 仅本地装机、未发布，版本号并入此条。
+
+### 新增
+
+- **抽取块级容错 + 部分消费（R1′）**：`runExtraction` 每个抽取块独立 try/catch——单块超时/JSON 崩只丢该块并留待重试、下轮重投，成功块照常进去重+落库。旧行为是任一块崩整批抛穿、整片退回待重试（"114 条永不清零"的主因之一）。全块失败仍等价旧"整抛"（不误当零产出成功）。
+- **L2 场景整合分块（R1）**：`runSceneConsolidation` 按字符预算（24k 硬顶）切块逐块整合，单块路径与改前逐字一致（零漂移）；多块时跨块合并判断为近似（诚实降级）。治"大库整族 backlog 单调用必超时"。
+- **二线大容量兜底（R3）**：`llm.secondary{provider,model,reasoningEffort,triggerChars}`——单次调用输入 ≥ `triggerChars`（默认 20000）才前置二线，肥调用走能吞大输入的二线、小调用走一线。未配则不启用、绝不静默改选任意模型。
+- **fail-closed 显式路由（R4）**：`llm.requireExplicitRoute`（默认 false 灰度）开启后，一线+二线+回退链皆空 → 抛 `NoDistillRouteError`、蒸馏顺延并告警、**不记退避**，不再蹭宿主 `agentDefaultModel`（区分"没配"与"模型慢"）。
+- **路由健康学习（R9，本版已接线）**：`RouteHealthStore`（`distill-route-health.json` sidecar，读 fail-open、只降不升、陈旧过期）记某路由跑通的最小块长，`runExtraction` 读它收紧 perChunk、成功块回记，跨进程免重付退避风暴。
+- **面板可调蒸馏超时（R10）**：设置 → 记忆 → 蒸馏参数 → **蒸馏超时(ms)**（`distillTimeoutMs`，运行时 volatile 覆盖 `llm.timeoutMs`，即时生效）。仅治"慢但未被网关掐"的路由；供应商网关侧固定掐断（如某些免费路由 60s）抬此值无效，须换路由。
+- **整轮抽取墙钟预算 + 模型上限（R5）**：`llm.extractTimeBudgetMs`（默认 0=不限）超预算把剩余块留待重试下轮续，防一个慢模型独占后台串行泵；`llm.modelMaxInputChars`（默认 0=未声明）声明模型真实输入上限，perChunk 取 `min(24k, 本值−42k)`。
+- **反刍豁免退避（R6）/ live flush 队列去重（R7）**：反刍与 rebuild 同为用户显式动作，越过抽取退避；同一 `(session,mode)` 未消费的 force-flush 任务去重，治"一次长阻塞→积压排空刷屏"。
+
+### 变更
+
+- **默认输入闸门 `llm.maxInputChars` 700000 → 200000（schema 上限 1000000 → 256000）**：旧默认是远超本地/免费模型窗口的盲值；新默认让 `callLLM` 那道"最后截断闸门"符合本地模型可参与区间。注意 L1 抽取/L2 分块另有 24k 硬顶，不受此值影响；改默认主要防"下一批大调用噎住本地模型"，不改变分块大小。
+- **`engines.dsh` 去重**：package.json 尾部误加的重复 `|| 0.2.1-rc.1 || 0.2.1-rc.2` 已删，与 dsh.plugin.json 及各 peer 串逐字同串（跨宿主 6 条 RC 线兼容面不变）。
+
+### 已知限制 / 预留
+
+- **去重批容错与 checkpoint 续跑（R1″）未做**：去重阶段某批崩仍是整轮抛穿（整片保留 + 下轮从抽取重跑，无数据丢失但重付抽取成本）。当前治法是为去重/大输入换一条不被网关掐的路由（如二线）。
+- **L3 分块（R2）/ sinceL2 连续失败停攒（R8）未做**：persona 单文档整合分块伤连贯性、收益低于风险；L2 分块后慢性重面积压已缓解。
+- **`llm.chunkShrinkFactor` / `chunkShrinkMaxSteps` / `adaptiveChunk` 为预留配置，当前版本未接线生效**（同轮内超时 ×0.6 缩块尚未实现）——设了不影响行为，请勿依赖。
+
 ## [0.26.6] — 2026-10-22
 
 ### 新增

package/README.de.md

@@ -61,7 +61,7 @@ alt="DeepSeek Harness Hero-Banner: Unterhaltungen werden automatisch zu mehrschi
 > Kompatibilitätsmechanismus: Die Settings-Registrierung durchläuft zur Laufzeit drei Zweige
 > (`register` → `installSection`-Brücke → Dauerein-Notbetrieb), siehe Eintrag 0.11.0 im
 > [CHANGELOG.md](./CHANGELOG.md). `dsh.plugin.json` deklariert
-> `engines.dsh` 为逐 rc 精确枚举串（0.1.0-rc.2 → 0.2.1-rc.2，17 rc）.
+> `engines.dsh` 为逐 rc 精确枚举串（0.1.0-rc.2 → 0.2.1-rc.3，18 rc）.
 
 ## Schnellstart
 

package/README.en.md

@@ -61,7 +61,7 @@
 > Compatibility mechanism: settings registration uses a three-way runtime branch
 > (`register` → `installSection` bridge → always-on degradation); see the 0.11.0 entry
 > in [CHANGELOG.md](./CHANGELOG.md). `dsh.plugin.json` declares
-> `engines.dsh` 为逐 rc 精确枚举串（0.1.0-rc.2 → 0.2.1-rc.2，17 rc）.
+> `engines.dsh` 为逐 rc 精确枚举串（0.1.0-rc.2 → 0.2.1-rc.3，18 rc）.
 
 ## Getting Started
 

package/README.es.md

@@ -61,7 +61,7 @@ alt="Banner hero de DeepSeek Harness: las conversaciones se destilan automática
 > Mecanismo de compatibilidad: el registro de ajustes pasa en tiempo de ejecución por tres ramas
 > (`register` → puente `installSection` → degradación a siempre activado),
 > ver la entrada 0.11.0 del [CHANGELOG.md](./CHANGELOG.md). `dsh.plugin.json` declara
-> `engines.dsh` 为逐 rc 精确枚举串（0.1.0-rc.2 → 0.2.1-rc.2，17 rc）.
+> `engines.dsh` 为逐 rc 精确枚举串（0.1.0-rc.2 → 0.2.1-rc.3，18 rc）.
 
 ## Inicio rápido
 

package/README.fr.md

@@ -61,7 +61,7 @@ alt="Bannière hero de DeepSeek Harness : les conversations sont automatiquement
 > Mécanisme de compatibilité : l'enregistrement settings passe par trois branches à l'exécution
 > (`register` → pont `installSection` → dégradation en mode toujours actif),
 > voir l'entrée 0.11.0 du [CHANGELOG.md](./CHANGELOG.md). `dsh.plugin.json` déclare
-> `engines.dsh` 为逐 rc 精确枚举串（0.1.0-rc.2 → 0.2.1-rc.2，17 rc）.
+> `engines.dsh` 为逐 rc 精确枚举串（0.1.0-rc.2 → 0.2.1-rc.3，18 rc）.
 
 ## Démarrage rapide
 

package/README.it.md

@@ -61,7 +61,7 @@ alt="Banner hero di DeepSeek Harness: le conversazioni vengono distillate automa
 > Meccanismo di compatibilità: la registrazione delle impostazioni passa per tre rami a runtime
 > (`register` → ponte `installSection` → degrado a sempre-attivo),
 > vedi la voce 0.11.0 del [CHANGELOG.md](./CHANGELOG.md). `dsh.plugin.json` dichiara
-> `engines.dsh` 为逐 rc 精确枚举串（0.1.0-rc.2 → 0.2.1-rc.2，17 rc）.
+> `engines.dsh` 为逐 rc 精确枚举串（0.1.0-rc.2 → 0.2.1-rc.3，18 rc）.
 
 ## Avvio rapido
 

package/README.ja.md

@@ -62,7 +62,7 @@ alt="DeepSeek Harness ヒーロー画像：会話がバックグラウンドで
 
 > 互換メカニズム：settings 登録は 3 分岐のランタイム判定（`register` → `installSection` ブリッジ → 常時オン縮退）。
 > 詳細は [CHANGELOG.md](./CHANGELOG.md) の 0.11.0 エントリ参照。`dsh.plugin.json` は
-> `engines.dsh` 为逐 rc 精确枚举串（0.1.0-rc.2 → 0.2.1-rc.2，17 rc） を宣言。
+> `engines.dsh` 为逐 rc 精确枚举串（0.1.0-rc.2 → 0.2.1-rc.3，18 rc） を宣言。
 
 ## クイックスタート
 

package/README.ko.md

@@ -62,7 +62,7 @@ alt="DeepSeek Harness 히어로 이미지: 대화가 백그라운드에서 계
 
 > 호환 메커니즘: settings 등록은 3분기 런타임 분기（`register` → `installSection` 브리지 → 상시 온 강등）.
 > 자세한 내용은 [CHANGELOG.md](./CHANGELOG.md)의 0.11.0 항목 참조. `dsh.plugin.json`은
-> `engines.dsh` 为逐 rc 精确枚举串（0.1.0-rc.2 → 0.2.1-rc.2，17 rc） 선언.
+> `engines.dsh` 为逐 rc 精确枚举串（0.1.0-rc.2 → 0.2.1-rc.3，18 rc） 선언.
 
 ## 빠른 시작
 

package/README.md

@@ -60,7 +60,7 @@ alt="DeepSeek Harness hero 横幅：对话自动分层蒸馏成记忆，模型
 
 > 兼容机制：settings 注册走运行时三分支（`register` → `installSection` 桥接 → 恒开降级），
 > 详见 [CHANGELOG.md](./CHANGELOG.md) 的 0.11.0 条目。`dsh.plugin.json` 声明
-> `engines.dsh` 为逐 rc 精确枚举串（0.1.0-rc.2 → 0.2.1-rc.2，17 rc）。
+> `engines.dsh` 为逐 rc 精确枚举串（0.1.0-rc.2 → 0.2.1-rc.3，18 rc）。
 
 ## 快速开始
 
@@ -352,8 +352,13 @@ 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.timeoutMs`              | `120000`                | 单次蒸馏调用超时（ms）                                                                                                                                                                                                                                                                                                                     |
+| `llm.maxInputChars`          | `200000`                | 单次蒸馏调用输入闸门（超限截断）；默认 200k 适配本地/免费模型窗口，上限 256k，可再往下调。L1 抽取/L2 另有 24k 分块硬顶，不受此值影响；运行时可在设置页 → 蒸馏参数 → 输入预算调整（留空/0 = 跟随本值）                                                                                                                                                                                                                                                                |
+| `llm.timeoutMs`              | `120000`                | 单次蒸馏调用超时（ms）；运行时可在设置页 → 蒸馏参数 → 蒸馏超时(ms) 覆盖（仅治"慢但未被网关掐"的路由，供应商网关侧固定掐断抬此值无效）                                                                                                                                                                                                                                                                                                                    |
+| `llm.extractTimeBudgetMs`  | `0`                     | 整轮抽取墙钟预算（ms）：`0` = 不限（旧行为）；`>0` 时多块抽取累计超此预算即把剩余块留待重试、下轮续跑，防一个慢模型独占后台串行泵（[ADR-0023](./docs/adr/0023-distill-load-balance-and-secondary-route.md)） |
+| `llm.modelMaxInputChars`   | `0`                     | 蒸馏模型真实输入上限（字符）：`0` = 未声明（回退保守口径 `min(24k, maxInputChars−42k)`）；声明后抽取/L2 块大小取 `min(24k, 本值−42k)`，避免默认值撞本地模型硬限 |
+| `llm.secondary`            | 关                       | 二线大容量兜底 `{provider,model,reasoningEffort,triggerChars}`：单次调用输入 ≥ `triggerChars`（默认 20000）才前置二线（肥调用走能吞大输入的二线、小调用走一线）；未配则不启用、绝不静默改选任意模型 |
+| `llm.requireExplicitRoute` | `false`                 | 显式路由闸（灰度）：`true` 时一线+二线+回退链皆空 → 蒸馏顺延并告警（`NoDistillRouteError`、不记退避），不再蹭宿主默认模型；`false` 保持旧行为 |
+| `llm.chunkShrink*` 等（预留） | —                     | ⚠ `llm.chunkShrinkFactor` / `chunkShrinkMaxSteps` / `adaptiveChunk` 为**预留配置，当前版本未接线生效**（同轮内超时 ×0.6 缩块尚未实现）——设了不影响行为，请勿依赖 |
 | `tokenCost.retentionDays`    | `365`                   | 蒸馏成本明细（token\_cost 表）保留天数，写入时滚动清理更早行；`0` = 永久保留。成本看板「近 N 天」窗口上限同此值                                                                                                                                                                                                                                                               |
 | `tools`                      | `true`                  | 是否注册模型可调用的记忆工具                                                                                                                                                                                                                                                                                                                   |
 | `benchControl`               | `false`                 | 注册 bench 控制服务（进程内 rebuild 触发/会话档位设置/蒸馏用量快照，供基准 lifecycle 赛道）。默认关——生产部署零表面积，勿随意开启                                                                                                                                                                                                                                                 |
@@ -415,6 +420,14 @@ 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 保持旧行为）。
+- **预留未生效的配置**：`llm.chunkShrinkFactor` / `llm.chunkShrinkMaxSteps` / `llm.adaptiveChunk` 已在 schema 声明但**尚未接线**（同轮内超时自动缩块未实现）——设了不影响行为；跨轮自适应已由 R9 路由健康学习承担。
+
 ## 日志与故障排查
 
 dsh 宿主把插件日志打到控制台；插件另把 info 级以上镜像到数据目录的 `memory.log`。

package/README.ru.md

@@ -61,7 +61,7 @@ alt="Баннер hero DeepSeek Harness: диалоги автоматическ
 > Механизм совместимости: регистрация настроек на этапе исполнения идёт по трём ветвям
 > (`register` → мост `installSection` → деградация в режим «всегда включено»),
 > подробнее — запись 0.11.0 в [CHANGELOG.md](./CHANGELOG.md). `dsh.plugin.json` объявляет
-> `engines.dsh` 为逐 rc 精确枚举串（0.1.0-rc.2 → 0.2.1-rc.2，17 rc）.
+> `engines.dsh` 为逐 rc 精确枚举串（0.1.0-rc.2 → 0.2.1-rc.3，18 rc）.
 
 ## Быстрый старт
 

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