dsh-layered-memory 0.8.3 → 0.8.4

package/README.en.md

@@ -10,7 +10,7 @@
 [简体中文](README.md) · [Latest release](https://github.com/JunNanLYS/dsh-layered-memory/releases/latest) · [Report issues](https://github.com/JunNanLYS/dsh-layered-memory/issues)
 
 [![npm version](https://img.shields.io/npm/v/dsh-layered-memory?color=6f83ff&style=flat-square&label=npm)](https://www.npmjs.com/package/dsh-layered-memory)
-[![DSH 0.1.0-rc.8](https://img.shields.io/badge/DSH-0.1.0--rc.8-8b5cf6?style=flat-square)](https://github.com/deepseek-ai/deepseek-harness)
+[![DSH 0.1.1-rc.2](https://img.shields.io/badge/DSH-0.1.1--rc.2-8b5cf6?style=flat-square)](https://github.com/deepseek-ai/deepseek-harness)
 [![MIT License](https://img.shields.io/badge/license-MIT-536990?style=flat-square)](LICENSE)
 
 </div>
@@ -144,39 +144,43 @@ trajectory view):
 
 ## Measured Comparison (DSH-MemBench: Automated Benchmark)
 
-Screenshots show what the plugin looks like — this section answers "**what does enabling it actually buy you?**" with measured numbers from an **automated benchmark** ([`bench/`](./bench/), one command to reproduce). Method: the same scenario bank with verbatim-identical inputs runs in **Group A (memory on)** and **Group B (memory off)**, 3 repetitions each, merged; environment DeepSeek official `deepseek-v4-flash`, plugin 0.8.0, Windows; taxonomy adapted from [LongMemEval](https://github.com/xiaowu0162/longmemeval) / [LoCoMo](https://snap-research.github.io/locomo/) / [AMB](https://github.com/vectorize-io/agent-memory-benchmark).
+Screenshots show what the plugin looks like — this section answers "**what does enabling it actually buy you?**" with measured numbers from an **automated benchmark** ([`bench/`](./bench/), one command to reproduce). Method: the same scenario bank with verbatim-identical inputs runs in **Group A (memory on)** with 3 merged repetitions and **Group B (memory off)** with 1 repetition (a memory-off long task burns multiples of the tokens per scenario — a cost guardrail); the dialog track now runs Group A only (memory-off probes in independent sessions cannot succeed, so the control carries no information — retired). Workflow-track environment: DeepSeek official `deepseek-v4-flash` (reasoning effort high), judge `glm-5.3`, plugin 0.8.3, Windows; taxonomy adapted from [LongMemEval](https://github.com/xiaowu0162/longmemeval) / [LoCoMo](https://snap-research.github.io/locomo/) / [AMB](https://github.com/vectorize-io/agent-memory-benchmark).
 
-### Dialog track (15 scenarios × 6 probe types × 3 reps = 270 questions/group): does it remember correctly
+### Dialog track (15 scenarios × 6 probe types × 3 reps = 270 questions): does it remember correctly
+
+> Archived 0.8.0 baseline (Group A data; the dialog-track B arm has since been retired — Group A only).
 
 <p align="center">
   <img src="./assets/readme/bench-dialog.svg" width="100%"
-       alt="DSH-MemBench dialog track, Group A vs Group B bar chart: overall accuracy A (memory on) 92.6% (250/270) vs B (memory off) 17.8% (48/270); per probe type, 45 each — extraction A 45/45 vs B 3/45, multi-hop A 45/45 vs B 0/45, temporal A 43/45 vs B 0/45, knowledge updates A 31/45 vs B 0/45, scene recall A 41/45 vs B 0/45, abstention both 45/45 with 0 fabricated">
+       alt="DSH-MemBench dialog track accuracy chart (Group A, memory on): overall accuracy 92.6% (250/270); per probe type, 45 each — extraction 45/45, multi-hop 45/45, temporal 43/45, knowledge updates 31/45, scene recall 41/45, abstention 45/45 with 0 fabricated; the dialog-track B arm is retired (memory-off probes in independent sessions cannot succeed)">
 </p>
 
 **Dual-channel recall** (Group A): passive injection hit rate **75.1%** (the answer's key points appear in the recall injection, 169/225); most of the rest the model recovered by **actively calling the memory tools** — 84 questions with active queries, **60 rescued by tools**. The end-to-end 92.6% is the composite of both channels plus model utilization. With the memory store accumulating across scenarios for the whole run, 144 probe injections carried other scenarios' memories (honestly counted) — yet overall accuracy held at 92.6%: interference resistance under a growing store, measured.
 
-### Workflow track (4 scenarios × 3 reps, real tool sandbox): does it do it right, and cheaper
+### Workflow track (7 scenarios · Group A ×3 / Group B ×1, real tool sandbox): does it do it right, and cheaper
 
 <p align="center">
   <img src="./assets/readme/bench-workflow.svg" width="100%"
-       alt="DSH-MemBench workflow track, Group A vs Group B: task completion A 24/33 (72.7%) vs B 11/33 (33.3%); cost comparison (Group B as the full-bar baseline) — steps 125 vs 186 (B +49%), tool calls 184 vs 296 (B +61%), input tokens 1.30M vs 1.86M (B +43%); asks-user-for-help A 0 vs B 3; login scenario input tokens A 241k vs B 453k (+88%)">
+       alt="DSH-MemBench workflow track, Group A vs Group B: probe-phase completion A 59/69 (85.5%) vs B 10/23 (43.5%); cost comparison (Group B as the full-bar baseline, per-scenario means) — steps 24.3 vs 41.4 (B +70%), tool calls 37.7 vs 62.1 (B +65%), input tokens 266k vs 1.81M (B 6.8×); style-convention scenario probes A 12/12 vs B 0/4; long-task input tokens per scenario A 266k vs B 1.81M">
 </p>
 
-**Login scenario close-up** (credentials exist only in memory; the site is a local service with unforgeable tokens): Group A completed all three runs **in a single turn each** (6/6, 241k input); Group B had to **ask the user for credentials every time** (3 asks, double the turns) and still finished only 5/6, at 453k input — **+88%**. This is one of memory's core values: **what it saves is not task difficulty, but pointless round-trips and re-teaching**.
+**Probe-phase completion 85.5% vs 43.5% (+42pp)**: both groups have live context during teach/change phases — the probe phase (continuation task in a fresh session) is the pure memory window. Group A scored a perfect 12/12 on all three new probe archetypes (workflow knowledge update / twin-runbook disambiguation / style-convention continuity), consistent across all three reps; Group B scored **0/4** on style-convention probes (naming/structure/thousands-separator/footer conventions exist only in memory — they cannot be explored out of the sandbox), while on the workflow-update scenario it can reverse-engineer the procedure by reading the script (discrimination limited by sandbox affordances, honestly noted).
+
+**Long-task cost: Group B burns 6.8× Group A's input tokens per scenario** (1.81M vs 266k) — without memory the agent advances by re-exploring, and under a high reasoning effort it even builds its own projects to probe what a one-line script convention would have done; output tokens 3× (46.2k vs 15.4k), steps +70%. This is memory's core value: **what it saves is not task difficulty, but pointless round-trips and re-exploration**.
 
 ### Methodology & reproduction
 
 ```bash
-node bench/harness/run.mjs --arm A --repeats 3 --provider deepseek-official --model deepseek-v4-flash
-node bench/harness/run.mjs --arm B --repeats 3 --provider deepseek-official --model deepseek-v4-flash   # dialog track
-node bench/harness/run.mjs --track workflow --arm A/B --repeats 3 ...                                  # workflow track
+node bench/harness/run.mjs --arm A --repeats 3 --provider deepseek-official --model deepseek-v4-flash   # dialog track (Group A only)
+node bench/harness/run.mjs --track workflow --arm AB --repeats 3 ...                                  # workflow track (A/B arms in parallel)
 node bench/harness/report.mjs --latest [dialog|workflow]                                               # aggregate report
 ```
 
-- Scoring: programmatic `contains-all` plus an LLM judge against key points (every answer and verdict is preserved in `result.json` for human audit); workflow completion is verified programmatically from produced files and their contents;
-- Metrics come from provider-reported usage (input with cache-hit split) and session-event folding; the **steady-state cache rate** excludes each session's first request (A 88.7% vs B 85.4% — memory injection does not hurt caching);
-- Regression use: run before/after a plugin change and diff with `compare.mjs` (environment header check + Group-B control-drift warning);
-- Limitations (stated honestly): single machine, 3 merged runs; the judge model is the same as the tested model; the scenario bank is author-built (biased toward memory-advantage scenarios — reproduce it yourself); the tool audit flags out-of-sandbox access (agents occasionally probed the user home dir in tests; this benchmark's answers never exist in the real memory store, so the numbers are unaffected).
+- Scoring: programmatic `contains-all` plus an LLM judge against key points (every answer and verdict is preserved in `result.json` for human audit); workflow completion is verified programmatically from produced files and their contents (four check kinds: positive / forbidden-word / must-not-exist / exists);
+- Live progress: running the benchmark auto-starts a local progress panel and opens the browser (`--no-panel` to disable) — per-arm scenario/phase/message-level progress, heartbeat & activity freshness (distinguishes "stuck" from "process died"), and cumulative cost as it accrues;
+- Metrics come from provider-reported usage (input with cache-hit split) and session-event folding; the steady-state cache rate excludes each session's first request (archived 0.8.0 baseline: A 88.7% vs B 85.4% — memory injection does not hurt caching);
+- Regression use: run before/after a plugin change and diff with `compare.mjs` (environment header check including git SHA + Group-B control-drift warning);
+- Limitations (stated honestly): single machine; Group A ×3 merged, Group B ×1 (cost guardrail — noisier); judge vs tested model: same model in the archived dialog baseline, heterogeneous in the new workflow run (glm-5.3 judging v4-flash); the scenario bank is author-built (biased toward memory-advantage scenarios — reproduce it yourself); sandbox-file affordances partially leak procedures (Group B can reverse-engineer by reading scripts — discrimination limits honestly noted); dual-tier tool audit (strict violation voids the scenario / loose heuristic flags only), with 0 violations measured on both sides.
 
 Full reports and per-question data: [`bench/baseline/`](./bench/baseline/).
 
@@ -235,7 +239,7 @@ the bundle layer appends and causes `duplicate loader entry id` startup failure)
 | `embedding.proxy` | `''` | Three-state download proxy: `''` (default) = auto-detect proxy env vars (`HTTPS_PROXY`/`ALL_PROXY` etc., honoring `NO_PROXY`); `none` = disable, always direct; any other value = proxy URL (e.g. `http://127.0.0.1:7890`). Direct connections to the mirror are intermittently unreachable on some networks (connect timeouts and poisoned bytes have both been observed) — keep the default auto-detection on machines with a proxy |
 | `llm.provider/model` | empty | Static distillation route (deployment pin): when **both** fields are set the route is locked, outranking the settings-page selection and the default model (deployments can force distillation onto a specific route); when empty the route follows "settings-page selection → default model". At runtime, switch among **configured providers** (including custom ones added in dsh Settings → Models) via the "distillation model" picker in Settings → Memory → Overview — effective immediately, no restart needed |
 | `llm.maxTokens` | `65536` | Fallback output cap for non-layered calls. Each distillation stage has its own budget (extraction 16k / dedup 8k / L2 32k / L3 16k; auto ×4 when the reasoning effort is high/xhigh/max, so thinking can't starve the text budget); the per-layer budgets are runtime-adjustable in Settings → Memory → Overview → distillation parameters (empty/0 = built-in defaults) |
-| `llm.reasoningEffort` | empty | Distillation reasoning effort: empty = **auto** (resolved from model capability: the model's default tier, else `high`); an explicit value (`off`/`none`/`low`/`medium`/`high`/`xhigh`/`max`) is only sent when the model declares support — effort vocabularies differ across providers (deepseek accepts `off`, OpenAI-style APIs use `none`, models that declare no tiers get nothing), and unsupported tiers degrade to not-sending with a one-time warning; output budgets auto-×4 at high/xhigh/max. Switchable at runtime in Settings → Memory → Overview; the selectable tiers follow the current model live |
+| `llm.reasoningEffort` | empty | Distillation reasoning effort: empty = **auto** (resolved from model capability: the model's default tier, else `high`); an explicit value (`off`/`none`/`minimal`/`low`/`medium`/`high`/`xhigh`/`max`) is only sent when the model declares support — effort vocabularies differ across providers (deepseek accepts `off`, OpenAI-style APIs use `none`, models that declare no tiers get nothing), and unsupported tiers degrade to not-sending with a one-time warning; output budgets auto-×4 at high/xhigh/max. Switchable at runtime in Settings → Memory → Overview; the selectable tiers follow the current model live |
 | `llm.temperature` | `0.3` | Distillation temperature |
 | `llm.maxInputChars` | `700000` | Input character budget per distillation call (over-budget L1 inputs are chunked automatically); runtime-adjustable in Settings → distillation parameters → input budget (empty/0 = follow this value) |
 | `llm.timeoutMs` | `120000` | Per-call distillation timeout (ms) |

package/README.md

@@ -10,7 +10,7 @@
 [English](README.en.md) · [最新发行版](https://github.com/JunNanLYS/dsh-layered-memory/releases/latest) · [反馈问题](https://github.com/JunNanLYS/dsh-layered-memory/issues)
 
 [![npm version](https://img.shields.io/npm/v/dsh-layered-memory?color=6f83ff&style=flat-square&label=npm)](https://www.npmjs.com/package/dsh-layered-memory)
-[![DSH 0.1.0-rc.8](https://img.shields.io/badge/DSH-0.1.0--rc.8-8b5cf6?style=flat-square)](https://github.com/deepseek-ai/deepseek-harness)
+[![DSH 0.1.1-rc.2](https://img.shields.io/badge/DSH-0.1.1--rc.2-8b5cf6?style=flat-square)](https://github.com/deepseek-ai/deepseek-harness)
 [![MIT License](https://img.shields.io/badge/license-MIT-536990?style=flat-square)](LICENSE)
 
 </div>
@@ -124,39 +124,43 @@ npx tsc src/smoke.ts --outDir dist-smoke --module nodenext --moduleResolution no
 
 ## 实测对比（DSH-MemBench：自动化基准）
 
-图文回答"长什么样"，这一节用**自动化基准**的实测数字回答"**开了到底有什么用**"（[`bench/`](./bench/)，一条命令可复现）。方法：同场景库、逐字相同输入，**A 组（记忆开）** 与 **B 组（记忆关）** 各跑 3 次取合并值；环境 DeepSeek 官方 `deepseek-v4-flash`、插件 0.8.0、Windows；题型设计借鉴 [LongMemEval](https://github.com/xiaowu0162/longmemeval) / [LoCoMo](https://snap-research.github.io/locomo/) / [AMB](https://github.com/vectorize-io/agent-memory-benchmark)。
+图文回答"长什么样"，这一节用**自动化基准**的实测数字回答"**开了到底有什么用**"（[`bench/`](./bench/)，一条命令可复现）。方法：同场景库、逐字相同输入，**A 组（记忆开）跑 3 次取合并值，B 组（记忆关）跑 1 次**（无记忆的长任务每场景要吞数倍 token，成本护栏）；对话赛道只跑 A 组（B 组会话独立无记忆必然失败，对照无信息量，已下线）。工作流赛道环境：DeepSeek 官方 `deepseek-v4-flash`（思考档 high）、判卷 `glm-5.3`、插件 0.8.3、Windows；题型设计借鉴 [LongMemEval](https://github.com/xiaowu0162/longmemeval) / [LoCoMo](https://snap-research.github.io/locomo/) / [AMB](https://github.com/vectorize-io/agent-memory-benchmark)。
 
-### 对话赛道（15 场景 × 6 题型 × 3 次 = 270 题/组）：答得准吗
+### 对话赛道（15 场景 × 6 题型 × 3 次 = 270 题）：答得准吗
+
+> 0.8.0 留档基线（A 组数据；此后对话赛道 B 组下线，只跑 A 组）。
 
 <p align="center">
   <img src="./assets/readme/bench-dialog.svg" width="100%"
-       alt="DSH-MemBench 对话赛道 A/B 对照条形图：A 组（记忆开）总准确率 92.6%（250/270），B 组（记忆关）17.8%（48/270）；分题型各 45 题——抽取 A 45/45 对 B 3/45、多跳 A 45/45 对 B 0/45、时序 A 43/45 对 B 0/45、知识更新 A 31/45 对 B 0/45、场景回忆 A 41/45 对 B 0/45、拒答两组均 45/45 且 0 编造">
+       alt="DSH-MemBench 对话赛道准确率图（A 组·记忆开）：总准确率 92.6%（250/270）；分题型各 45 题——抽取 45/45、多跳 45/45、时序 43/45、知识更新 31/45、场景回忆 41/45、拒答 45/45 且 0 编造；对话赛道 B 组已下线（会话独立无记忆必然失败）">
 </p>
 
 **召回双通道**（A 组）：被动注入召回率 **75.1%**（该题要点出现在召回注入中，169/225），其余多数由模型**主动调用记忆工具**查回——84 题主动查询、**60 题靠工具兜底答对**；端到端 92.6% 是两通道 + 模型利用的合成结果。记忆库跨场景全程累积下，探针召回注入混入其他场景记忆 144 次（已如实计数），总准确率仍稳在 92.6%——抗干扰能力经受住了膨胀记忆库的考验。
 
-### 工作流赛道（4 场景 × 3 次，真实工具沙箱）：做得对、做得省吗
+### 工作流赛道（7 场景 · A 组 3 次 / B 组 1 次，真实工具沙箱）：做得对、做得省吗
 
 <p align="center">
   <img src="./assets/readme/bench-workflow.svg" width="100%"
-       alt="DSH-MemBench 工作流赛道 A/B 对照图：任务完成度 A 组 24/33（72.7%）对 B 组 11/33（33.3%）；成本对比（B 组为满格基准）——步骤 125 对 186（B +49%）、工具调用 184 对 296（B +61%）、输入 token 1.30M 对 1.86M（B +43%）；向用户求助 A 0 次对 B 3 次；登录场景输入 token A 241k 对 B 453k（+88%）">
+       alt="DSH-MemBench 工作流赛道 A/B 对照图：探针段完成度 A 组 59/69（85.5%）对 B 组 10/23（43.5%）；成本对比（B 组为满格基准，每场景均值）——步骤 24.3 对 41.4（B +70%）、工具调用 37.7 对 62.1（B +65%）、输入 token 266k 对 1.81M（B 6.8 倍）；风格规范场景探针 A 12/12 对 B 0/4；长任务每场景输入 token A 266k 对 B 1.81M">
 </p>
 
-**登录场景特写**（凭据只存在于记忆，站点为本地服务、令牌不可伪造）：A 组三次全部**一轮直取**完成（6/6，241k 输入）；B 组每次都要**反问用户要凭据**（3 次求助、双倍轮次）才完成 5/6，输入 453k——**+88%**。这正是记忆的核心价值之一：**省掉的不是任务难度，是无谓的往返与重复教学**。
+**探针段完成度 85.5% vs 43.5%（+42pp）**：教学/变更段两组都有现场上下文，探针段（新会话延续任务）才是纯记忆窗口——A 组三个新考法场景（流程知识更新 / 双胞胎消歧 / 风格规范延续）全部 12/12 满分且三轮一致；B 组在风格规范场景探针 **0/4**（命名/结构/千分位/页脚约定只存记忆，沙箱探不出来），在流程更新场景则能靠读脚本逆向（判别力受沙箱可供性限制，已如实标注）。
+
+**长任务成本：B 组每场景输入 token 是 A 组的 6.8 倍**（1.81M vs 266k）——无记忆时 agent 靠重新探索前进，high 思考档下甚至会自建工程去探测本可用一条脚本约定完成的流程；输出 token 3 倍（46.2k vs 15.4k）、步骤 +70%。这正是记忆的核心价值：**省掉的不是任务难度，是无谓的往返与重复探索**。
 
 ### 方法论与复现
 
 ```bash
-node bench/harness/run.mjs --arm A --repeats 3 --provider deepseek-official --model deepseek-v4-flash
-node bench/harness/run.mjs --arm B --repeats 3 --provider deepseek-official --model deepseek-v4-flash   # 对话赛道
-node bench/harness/run.mjs --track workflow --arm A/B --repeats 3 ...                                  # 工作流赛道
+node bench/harness/run.mjs --arm A --repeats 3 --provider deepseek-official --model deepseek-v4-flash   # 对话赛道（只跑 A 组）
+node bench/harness/run.mjs --track workflow --arm AB --repeats 3 ...                                  # 工作流赛道（A/B 双组并行）
 node bench/harness/report.mjs --latest [dialog|workflow]                                               # 汇总报告
 ```
 
-- 判分：`contains-all` 程序判 + 判卷模型按要点判（答案原文与判分理由全部留痕 `result.json` 可人工复核）；工作流完成度为产物文件 + 关键内容程序化校验；
-- 指标全部来自供应商上报 usage（输入含缓存命中拆分）与会话事件折叠；**稳态缓存率**剔除每会话首请求（A 88.7% vs B 85.4%——记忆注入不伤缓存）；
-- 回归用途：改插件前后各跑一遍，`compare.mjs` 出对比表（环境头校验 + B 组对照组漂移告警）；
-- 局限（诚实声明）：单机 ×3 次合并、判卷模型与被测模型同源、作者自建场景库（倾向记忆优势场景，欢迎自行复现）；工具审计会标记越界访问（实测 Agent 偶发探测用户主目录，本基准场景答案不存于真实记忆库、数字不受影响）。
+- 判分：`contains-all` 程序判 + 判卷模型按要点判（答案原文与判分理由全部留痕 `result.json` 可人工复核）；工作流完成度为产物文件 + 关键内容程序化校验（四型判据：正检查/禁词/产物缺席/存在性）；
+- 实时进度：跑基准时自动拉起本地进度面板并打开浏览器（`--no-panel` 关闭）——A/B 双臂场景/阶段/消息粒度进度、心跳与活动新鲜度（直判"卡住 vs 进程挂了"）、累计成本随跑随涨；
+- 指标全部来自供应商上报 usage（输入含缓存命中拆分）与会话事件折叠；稳态缓存率剔除每会话首请求（0.8.0 留档基线：A 88.7% vs B 85.4%——记忆注入不伤缓存）；
+- 回归用途：改插件前后各跑一遍，`compare.mjs` 出对比表（环境头校验含 gitSha + B 组对照组漂移告警）；
+- 局限（诚实声明）：单机；A 组 ×3 合并、B 组 ×1（成本护栏，噪声更大）；判卷与被测模型：对话留档基线同源、工作流新跑为异构（glm-5.3 判 v4-flash）；作者自建场景库（倾向记忆优势场景，欢迎自行复现）；沙箱文件的可供性会部分泄露流程（B 组可读脚本逆向，判别力受限处已如实标注）；工具审计双档（严格违规判负/宽松提示），实测双方 0 违规。
 
 完整报告与逐题数据：[`bench/baseline/`](./bench/baseline/)。
 
@@ -252,7 +256,7 @@ ONNX 量化 **CPU 推理**——无需 API Key，数据不出本机）。本地
 | `embedding.proxy` | `''` | 模型下载代理三态：`''`（默认）= 自动探测代理环境变量（`HTTPS_PROXY`/`ALL_PROXY` 等，尊重 `NO_PROXY`）；`none` = 禁用强制直连；其他值 = 代理 URL（如 `http://127.0.0.1:7890`）。镜像直连在国内网络间歇不可达（直连超时与污染字节交替出现过），开代理的机器建议保持默认自动探测 |
 | `llm.provider/model` | 空 | 蒸馏模型静态路由（部署 pin）：provider 与 model **双字段齐**时锁定蒸馏路由，优先于设置页的运行时选择与默认模型（部署可强制蒸馏走指定路由）；留空则跟随"设置页选择 → 默认模型"。运行时可在设置页 → 记忆 → 概览的"蒸馏模型"选择器从**已配置的供应商**（含 dsh 设置 → 模型里添加的自定义供应商）中切换，即时生效无需重启 |
 | `llm.maxTokens` | `65536` | 未分层调用的兜底输出总闸。各蒸馏层有独立预算（抽取 16k / 去重 8k / L2 32k / L3 16k；思考档 high/xhigh/max 时自动 ×4，防 reasoning 吃光预算），分层预算可在设置页 → 记忆 → 概览 → 蒸馏参数运行时调整（留空/0 = 跟随内置默认） |
-| `llm.reasoningEffort` | 空 | 蒸馏思考档位：空串 = **自动**（按模型能力解析：模型默认档 → `high`）；显式值（`off`/`none`/`low`/`medium`/`high`/`xhigh`/`max`）仅在该模型声明支持时发送——跨供应商 effort 词汇表不同（deepseek 认 `off`，OpenAI 系是 `none`，未声明档位的模型不传），不支持的档位自动降级为不传并告警一次；思考档 high/xhigh/max 时输出预算自动 ×4。运行时在设置页 → 记忆 → 概览切换，可选档位表跟随当前模型实时显示 |
+| `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） |

package/assets/readme/bench-dialog.svg

@@ -1,87 +1,76 @@
 <svg xmlns="http://www.w3.org/2000/svg"
-     width="1200" height="690" viewBox="0 0 1200 690"
+     width="1200" height="630" viewBox="0 0 1200 630"
      role="img" aria-labelledby="benchDialogTitle benchDialogDesc">
-  <title id="benchDialogTitle">DSH-MemBench 对话赛道：A/B 两组准确率对照</title>
-  <desc id="benchDialogDesc">同题同输入对照：A 组（记忆开）总准确率 92.6%（250/270），B 组（记忆关）17.8%（48/270）。分题型（每题型 45 题）：抽取 A 45/45 对 B 3/45；多跳 A 45/45 对 B 0/45；时序 A 43/45 对 B 0/45；知识更新 A 31/45 对 B 0/45；场景回忆 A 41/45 对 B 0/45；拒答两组均 45/45、0 编造。</desc>
+  <title id="benchDialogTitle">DSH-MemBench 对话赛道：A 组（记忆开）准确率</title>
+  <desc id="benchDialogDesc">A 组（记忆开）总准确率 92.6%（250/270，15 场景 × 6 题型 × 3 次）。分题型（每题型 45 题）：抽取 45/45；多跳 45/45；时序 43/45；知识更新 31/45；场景回忆 41/45；拒答 45/45、0 编造。对话赛道 B 组已下线（会话独立、无记忆必然失败，对照无信息量）。</desc>
 
-  <rect width="1200" height="690" rx="26" fill="#0D1526"/>
+  <rect width="1200" height="630" rx="26" fill="#0D1526"/>
 
   <g font-family="-apple-system,BlinkMacSystemFont,'Segoe UI','PingFang SC','Microsoft YaHei',sans-serif">
 
     <!-- ── 标题与图例 ── -->
-    <text x="64" y="66" font-size="26" font-weight="700" fill="#EFF3FA">对话赛道：同题同输入 · A/B 对照准确率</text>
-    <text x="64" y="94" font-size="18" fill="#8296B3">15 场景 × 6 题型 × 3 次 = 270 题/组（每题型 45 题）· 条长 = 答对率，数值 = 答对题数</text>
+    <text x="64" y="66" font-size="26" font-weight="700" fill="#EFF3FA">对话赛道：记忆开 · 准确率</text>
+    <text x="64" y="94" font-size="18" fill="#8296B3">15 场景 × 6 题型 × 3 次 = 270 题（每题型 45 题）· 条长 = 答对率，数值 = 答对题数</text>
 
     <rect x="842" y="50" width="18" height="18" rx="5" fill="#FFD15D"/>
     <text x="868" y="65" font-size="18" fill="#C2CDDE">A 组 · 记忆开</text>
-    <rect x="842" y="76" width="18" height="18" rx="5" fill="#4E6DA8"/>
-    <text x="868" y="91" font-size="18" fill="#C2CDDE">B 组 · 记忆关</text>
 
     <!-- ── 网格线（0/25/50/75/100%）── -->
     <g stroke="#1C2A47" stroke-width="1">
-      <line x1="260" y1="122" x2="260" y2="614"/>
-      <line x1="435" y1="122" x2="435" y2="614"/>
-      <line x1="610" y1="122" x2="610" y2="614"/>
-      <line x1="785" y1="122" x2="785" y2="614"/>
-      <line x1="960" y1="122" x2="960" y2="614"/>
+      <line x1="260" y1="122" x2="260" y2="530"/>
+      <line x1="435" y1="122" x2="435" y2="530"/>
+      <line x1="610" y1="122" x2="610" y2="530"/>
+      <line x1="785" y1="122" x2="785" y2="530"/>
+      <line x1="960" y1="122" x2="960" y2="530"/>
     </g>
     <g font-size="17" fill="#8296B3" text-anchor="middle">
-      <text x="260" y="640">0%</text>
-      <text x="435" y="640">25%</text>
-      <text x="610" y="640">50%</text>
-      <text x="785" y="640">75%</text>
-      <text x="960" y="640">100%</text>
+      <text x="260" y="558">0%</text>
+      <text x="435" y="558">25%</text>
+      <text x="610" y="558">50%</text>
+      <text x="785" y="558">75%</text>
+      <text x="960" y="558">100%</text>
     </g>
 
     <!-- ── 总准确率（强调行）── -->
-    <text x="240" y="176" font-size="21" font-weight="700" fill="#EFF3FA" text-anchor="end">总准确率</text>
+    <text x="240" y="169" font-size="21" font-weight="700" fill="#EFF3FA" text-anchor="end">总准确率</text>
     <rect x="260" y="148" width="648" height="26" rx="6" fill="#FFD15D"/>
     <text x="922" y="169" font-size="22" font-weight="700" fill="#FFD15D">92.6%（250/270）</text>
-    <rect x="260" y="182" width="124" height="26" rx="6" fill="#4E6DA8"/>
-    <text x="396" y="203" font-size="22" font-weight="700" fill="#8FA6C6">17.8%（48/270）</text>
 
-    <line x1="64" y1="226" x2="1136" y2="226" stroke="#263A5C" stroke-width="1.5"/>
+    <line x1="64" y1="200" x2="1136" y2="200" stroke="#263A5C" stroke-width="1.5"/>
 
     <!-- ── 分题型行 ── -->
     <!-- 抽取 -->
-    <text x="240" y="286" font-size="19" fill="#C2CDDE" text-anchor="end">抽取</text>
-    <rect x="260" y="254" width="700" height="18" rx="5" fill="#FFD15D"/>
-    <text x="974" y="269" font-size="18" font-weight="700" fill="#FFD15D" font-family="ui-monospace,SFMono-Regular,Menlo,Consolas,monospace">45/45</text>
-    <rect x="260" y="278" width="47" height="18" rx="5" fill="#4E6DA8"/>
-    <text x="319" y="293" font-size="18" font-weight="700" fill="#8FA6C6" font-family="ui-monospace,SFMono-Regular,Menlo,Consolas,monospace">3/45</text>
+    <text x="240" y="249" font-size="19" fill="#C2CDDE" text-anchor="end">抽取</text>
+    <rect x="260" y="234" width="700" height="18" rx="5" fill="#FFD15D"/>
+    <text x="974" y="249" font-size="18" font-weight="700" fill="#FFD15D" font-family="ui-monospace,SFMono-Regular,Menlo,Consolas,monospace">45/45</text>
 
     <!-- 多跳 -->
-    <text x="240" y="348" font-size="19" fill="#C2CDDE" text-anchor="end">多跳</text>
-    <rect x="260" y="316" width="700" height="18" rx="5" fill="#FFD15D"/>
-    <text x="974" y="331" font-size="18" font-weight="700" fill="#FFD15D" font-family="ui-monospace,SFMono-Regular,Menlo,Consolas,monospace">45/45</text>
-    <text x="272" y="355" font-size="18" font-weight="700" fill="#8FA6C6" font-family="ui-monospace,SFMono-Regular,Menlo,Consolas,monospace">0/45</text>
+    <text x="240" y="303" font-size="19" fill="#C2CDDE" text-anchor="end">多跳</text>
+    <rect x="260" y="288" width="700" height="18" rx="5" fill="#FFD15D"/>
+    <text x="974" y="303" font-size="18" font-weight="700" fill="#FFD15D" font-family="ui-monospace,SFMono-Regular,Menlo,Consolas,monospace">45/45</text>
 
     <!-- 时序 -->
-    <text x="240" y="410" font-size="19" fill="#C2CDDE" text-anchor="end">时序</text>
-    <rect x="260" y="378" width="669" height="18" rx="5" fill="#FFD15D"/>
-    <text x="943" y="393" font-size="18" font-weight="700" fill="#FFD15D" font-family="ui-monospace,SFMono-Regular,Menlo,Consolas,monospace">43/45</text>
-    <text x="272" y="417" font-size="18" font-weight="700" fill="#8FA6C6" font-family="ui-monospace,SFMono-Regular,Menlo,Consolas,monospace">0/45</text>
+    <text x="240" y="357" font-size="19" fill="#C2CDDE" text-anchor="end">时序</text>
+    <rect x="260" y="342" width="669" height="18" rx="5" fill="#FFD15D"/>
+    <text x="943" y="357" font-size="18" font-weight="700" fill="#FFD15D" font-family="ui-monospace,SFMono-Regular,Menlo,Consolas,monospace">43/45</text>
 
     <!-- 知识更新 -->
-    <text x="240" y="472" font-size="19" fill="#C2CDDE" text-anchor="end">知识更新 *</text>
-    <rect x="260" y="440" width="482" height="18" rx="5" fill="#FFD15D"/>
-    <text x="756" y="455" font-size="18" font-weight="700" fill="#FFD15D" font-family="ui-monospace,SFMono-Regular,Menlo,Consolas,monospace">31/45</text>
-    <text x="272" y="479" font-size="18" font-weight="700" fill="#8FA6C6" font-family="ui-monospace,SFMono-Regular,Menlo,Consolas,monospace">0/45</text>
+    <text x="240" y="411" font-size="19" fill="#C2CDDE" text-anchor="end">知识更新 *</text>
+    <rect x="260" y="396" width="482" height="18" rx="5" fill="#FFD15D"/>
+    <text x="756" y="411" font-size="18" font-weight="700" fill="#FFD15D" font-family="ui-monospace,SFMono-Regular,Menlo,Consolas,monospace">31/45</text>
 
     <!-- 场景回忆 -->
-    <text x="240" y="534" font-size="19" fill="#C2CDDE" text-anchor="end">场景回忆</text>
-    <rect x="260" y="502" width="638" height="18" rx="5" fill="#FFD15D"/>
-    <text x="912" y="517" font-size="18" font-weight="700" fill="#FFD15D" font-family="ui-monospace,SFMono-Regular,Menlo,Consolas,monospace">41/45</text>
-    <text x="272" y="541" font-size="18" font-weight="700" fill="#8FA6C6" font-family="ui-monospace,SFMono-Regular,Menlo,Consolas,monospace">0/45</text>
+    <text x="240" y="465" font-size="19" fill="#C2CDDE" text-anchor="end">场景回忆</text>
+    <rect x="260" y="450" width="638" height="18" rx="5" fill="#FFD15D"/>
+    <text x="912" y="465" font-size="18" font-weight="700" fill="#FFD15D" font-family="ui-monospace,SFMono-Regular,Menlo,Consolas,monospace">41/45</text>
 
     <!-- 拒答 -->
-    <text x="240" y="596" font-size="19" fill="#C2CDDE" text-anchor="end">拒答 *</text>
-    <rect x="260" y="564" width="700" height="18" rx="5" fill="#FFD15D"/>
-    <text x="974" y="579" font-size="18" font-weight="700" fill="#FFD15D" font-family="ui-monospace,SFMono-Regular,Menlo,Consolas,monospace">45/45</text>
-    <rect x="260" y="588" width="700" height="18" rx="5" fill="#4E6DA8"/>
-    <text x="974" y="603" font-size="18" font-weight="700" fill="#8FA6C6" font-family="ui-monospace,SFMono-Regular,Menlo,Consolas,monospace">45/45</text>
+    <text x="240" y="519" font-size="19" fill="#C2CDDE" text-anchor="end">拒答 *</text>
+    <rect x="260" y="504" width="700" height="18" rx="5" fill="#FFD15D"/>
+    <text x="974" y="519" font-size="18" font-weight="700" fill="#FFD15D" font-family="ui-monospace,SFMono-Regular,Menlo,Consolas,monospace">45/45</text>
 
     <!-- ── 脚注 ── -->
-    <text x="64" y="672" font-size="16" fill="#8296B3">* 知识更新：改口后仍答旧值记 0 分（直接考核 L1 去重更新）；拒答：没发生过的事编造即 0 分（两组均 0 编造）。</text>
+    <text x="64" y="600" font-size="16" fill="#8296B3">* 知识更新：改口后仍答旧值记 0 分（直接考核 L1 去重更新）；拒答：没发生过的事编造即 0 分（0 编造）。</text>
+    <text x="64" y="622" font-size="16" fill="#8296B3">对话赛道 B 组已下线：Harness 会话彼此独立，无记忆的探针必然失败，对照无信息量。</text>
   </g>
 </svg>

package/assets/readme/bench-workflow.svg

@@ -2,7 +2,7 @@
      width="1200" height="660" viewBox="0 0 1200 660"
      role="img" aria-labelledby="benchWorkflowTitle benchWorkflowDesc">
   <title id="benchWorkflowTitle">DSH-MemBench 工作流赛道：A/B 两组完成度与成本对照</title>
-  <desc id="benchWorkflowDesc">真实工具沙箱（4 场景 × 3 次）探针会话合计：任务完成度 A 组 24/33（72.7%）对 B 组 11/33（33.3%）；成本对比以 B 组为满格基准，A 组相对更省——步骤 125 对 186（B +49%）、工具调用 184 对 296（B +61%）、输入 token 1.30M 对 1.86M（B +43%）；向用户求助 A 0 次对 B 3 次；登录场景输入 token A 241k 对 B 453k（+88%）。</desc>
+  <desc id="benchWorkflowDesc">真实工具沙箱（7 场景，A 组 3 轮 / B 组 1 轮）探针段合计：任务完成度 A 组 59/69（85.5%）对 B 组 10/23（43.5%）；成本对比以 B 组为满格基准（每场景均值），A 组相对更省——步骤 24.3 对 41.4（B +70%）、工具调用 37.7 对 62.1（B +65%）、输入 token 266k 对 1.81M（B 6.8 倍）；风格规范场景探针 A 12/12 对 B 0/4；向用户求助 A 组 3 轮共 1 次、B 组 1 轮 1 次。</desc>
 
   <rect width="1200" height="660" rx="26" fill="#0D1526"/>
 
@@ -10,70 +10,70 @@
 
     <!-- ── 标题与图例 ── -->
     <text x="64" y="66" font-size="26" font-weight="700" fill="#EFF3FA">工作流赛道：真实工具沙箱 · 做得对，也更省</text>
-    <text x="64" y="94" font-size="18" fill="#8296B3">4 场景 × 3 次 · 探针会话合计 · 成本行以 B 组为满格基准，蓝徽章 = B 组多付</text>
+    <text x="64" y="94" font-size="18" fill="#8296B3">7 场景 · A 组 3 轮 / B 组 1 轮（成本护栏）· 探针段合计 · 成本行以 B 组为满格基准</text>
 
     <rect x="842" y="50" width="18" height="18" rx="5" fill="#FFD15D"/>
     <text x="868" y="65" font-size="18" fill="#C2CDDE">A 组 · 记忆开</text>
     <rect x="842" y="76" width="18" height="18" rx="5" fill="#4E6DA8"/>
     <text x="868" y="91" font-size="18" fill="#C2CDDE">B 组 · 记忆关</text>
 
-    <!-- ── 任务完成度 ── -->
-    <text x="64" y="152" font-size="20" font-weight="700" fill="#EFF3FA">任务完成度</text>
-    <text x="186" y="152" font-size="17" fill="#8296B3">（产物程序化校验）</text>
+    <!-- ── 探针段完成度 ── -->
+    <text x="64" y="152" font-size="20" font-weight="700" fill="#EFF3FA">探针段完成度</text>
+    <text x="216" y="152" font-size="17" fill="#8296B3">（新会话延续任务，产物程序化校验）</text>
 
-    <rect x="260" y="170" width="509" height="26" rx="6" fill="#FFD15D"/>
-    <text x="783" y="191" font-size="22" font-weight="700" fill="#FFD15D">24/33 · 72.7%</text>
-    <rect x="260" y="206" width="233" height="26" rx="6" fill="#4E6DA8"/>
-    <text x="505" y="227" font-size="22" font-weight="700" fill="#8FA6C6">11/33 · 33.3%</text>
+    <rect x="260" y="170" width="598" height="26" rx="6" fill="#FFD15D"/>
+    <text x="872" y="191" font-size="22" font-weight="700" fill="#FFD15D">59/69 · 85.5%</text>
+    <rect x="260" y="206" width="304" height="26" rx="6" fill="#4E6DA8"/>
+    <text x="578" y="227" font-size="22" font-weight="700" fill="#8FA6C6">10/23 · 43.5%</text>
 
     <line x1="64" y1="258" x2="1136" y2="258" stroke="#263A5C" stroke-width="1.5"/>
 
     <!-- ── 成本对比（B = 满格基准）── -->
     <text x="64" y="290" font-size="20" font-weight="700" fill="#EFF3FA">成本对比</text>
-    <text x="166" y="290" font-size="17" fill="#8296B3">（B 组 = 满格基准，条越短越省）</text>
+    <text x="166" y="290" font-size="17" fill="#8296B3">（每场景均值，B 组 = 满格基准，条越短越省）</text>
 
     <!-- 步骤 -->
     <text x="240" y="348" font-size="19" fill="#C2CDDE" text-anchor="end">步骤</text>
-    <rect x="260" y="318" width="376" height="18" rx="5" fill="#FFD15D"/>
-    <text x="648" y="333" font-size="18" font-weight="700" fill="#FFD15D" font-family="ui-monospace,SFMono-Regular,Menlo,Consolas,monospace">125</text>
+    <rect x="260" y="318" width="329" height="18" rx="5" fill="#FFD15D"/>
+    <text x="603" y="333" font-size="18" font-weight="700" fill="#FFD15D" font-family="ui-monospace,SFMono-Regular,Menlo,Consolas,monospace">24.3</text>
     <rect x="260" y="342" width="560" height="18" rx="5" fill="#4E6DA8"/>
-    <text x="834" y="357" font-size="18" font-weight="700" fill="#8FA6C6" font-family="ui-monospace,SFMono-Regular,Menlo,Consolas,monospace">186</text>
+    <text x="834" y="357" font-size="18" font-weight="700" fill="#8FA6C6" font-family="ui-monospace,SFMono-Regular,Menlo,Consolas,monospace">41.4</text>
     <rect x="980" y="321" width="136" height="36" rx="10" fill="#315DA6"/>
-    <text x="1048" y="345" font-size="19" font-weight="700" fill="#FFD15D" text-anchor="middle">B +49%</text>
+    <text x="1048" y="345" font-size="19" font-weight="700" fill="#FFD15D" text-anchor="middle">B +70%</text>
 
     <!-- 工具调用 -->
     <text x="240" y="430" font-size="19" fill="#C2CDDE" text-anchor="end">工具调用</text>
-    <rect x="260" y="400" width="348" height="18" rx="5" fill="#FFD15D"/>
-    <text x="620" y="415" font-size="18" font-weight="700" fill="#FFD15D" font-family="ui-monospace,SFMono-Regular,Menlo,Consolas,monospace">184</text>
+    <rect x="260" y="400" width="340" height="18" rx="5" fill="#FFD15D"/>
+    <text x="614" y="415" font-size="18" font-weight="700" fill="#FFD15D" font-family="ui-monospace,SFMono-Regular,Menlo,Consolas,monospace">37.7</text>
     <rect x="260" y="424" width="560" height="18" rx="5" fill="#4E6DA8"/>
-    <text x="834" y="439" font-size="18" font-weight="700" fill="#8FA6C6" font-family="ui-monospace,SFMono-Regular,Menlo,Consolas,monospace">296</text>
+    <text x="834" y="439" font-size="18" font-weight="700" fill="#8FA6C6" font-family="ui-monospace,SFMono-Regular,Menlo,Consolas,monospace">62.1</text>
     <rect x="980" y="403" width="136" height="36" rx="10" fill="#315DA6"/>
-    <text x="1048" y="427" font-size="19" font-weight="700" fill="#FFD15D" text-anchor="middle">B +61%</text>
+    <text x="1048" y="427" font-size="19" font-weight="700" fill="#FFD15D" text-anchor="middle">B +65%</text>
 
     <!-- 输入 token -->
     <text x="240" y="512" font-size="19" fill="#C2CDDE" text-anchor="end">输入 token</text>
-    <rect x="260" y="482" width="391" height="18" rx="5" fill="#FFD15D"/>
-    <text x="663" y="497" font-size="18" font-weight="700" fill="#FFD15D" font-family="ui-monospace,SFMono-Regular,Menlo,Consolas,monospace">1.30M</text>
+    <rect x="260" y="482" width="82" height="18" rx="5" fill="#FFD15D"/>
+    <text x="356" y="497" font-size="18" font-weight="700" fill="#FFD15D" font-family="ui-monospace,SFMono-Regular,Menlo,Consolas,monospace">266k</text>
     <rect x="260" y="506" width="560" height="18" rx="5" fill="#4E6DA8"/>
-    <text x="834" y="521" font-size="18" font-weight="700" fill="#8FA6C6" font-family="ui-monospace,SFMono-Regular,Menlo,Consolas,monospace">1.86M</text>
+    <text x="834" y="521" font-size="18" font-weight="700" fill="#8FA6C6" font-family="ui-monospace,SFMono-Regular,Menlo,Consolas,monospace">1.81M</text>
     <rect x="980" y="485" width="136" height="36" rx="10" fill="#315DA6"/>
-    <text x="1048" y="509" font-size="19" font-weight="700" fill="#FFD15D" text-anchor="middle">B +43%</text>
+    <text x="1048" y="509" font-size="19" font-weight="700" fill="#FFD15D" text-anchor="middle">B +580%</text>
 
     <!-- ── 底部特写卡片 ── -->
     <rect x="64" y="544" width="512" height="72" rx="14" fill="#15223A" stroke="#263A5C" stroke-width="1.5"/>
-    <text x="88" y="574" font-size="17" fill="#8296B3">向用户求助（探针会话）</text>
+    <text x="88" y="574" font-size="17" fill="#8296B3">风格规范场景 · 探针段（约定只存记忆，沙箱探不出来）</text>
     <text x="88" y="600" font-size="20" font-weight="700">
-      <tspan fill="#FFD15D">A 0 次</tspan>
-      <tspan fill="#8FA6C6"> · B 3 次（每轮要凭据）</tspan>
+      <tspan fill="#FFD15D">A 12/12</tspan>
+      <tspan fill="#8FA6C6"> · B 0/4</tspan>
     </text>
 
     <rect x="624" y="544" width="512" height="72" rx="14" fill="#15223A" stroke="#263A5C" stroke-width="1.5"/>
-    <text x="648" y="574" font-size="17" fill="#8296B3">登录场景 · 输入 token（凭据只存在记忆里）</text>
+    <text x="648" y="574" font-size="17" fill="#8296B3">长任务成本 · 每场景输入 token（B 无记忆重新探索）</text>
     <text x="648" y="600" font-size="20" font-weight="700">
-      <tspan fill="#FFD15D">A 241k</tspan>
-      <tspan fill="#8FA6C6"> · B 453k</tspan>
+      <tspan fill="#FFD15D">A 266k</tspan>
+      <tspan fill="#8FA6C6"> · B 1.81M</tspan>
     </text>
     <rect x="1040" y="578" width="72" height="26" rx="8" fill="#315DA6"/>
-    <text x="1076" y="597" font-size="18" font-weight="700" fill="#FFD15D" text-anchor="middle">+88%</text>
+    <text x="1076" y="597" font-size="18" font-weight="700" fill="#FFD15D" text-anchor="middle">6.8×</text>
   </g>
 </svg>

package/dist/client.js

@@ -2044,7 +2044,7 @@ window.__ModuleLoader__.load({
               "div", { style: S.switchDesc },
               "各蒸馏层单次输出的 token 上限（抽取/去重/L2/L3）；留空或 0 = 跟随默认（当前生效 " +
                 layers.map(function (l) { return eff[l[0]] || "?"; }).join(" / ") +
-                "）；思考档 high/max 时实际限额自动 ×4",
+                "）；思考档 high/xhigh/max 时实际限额自动 ×4",
             )),
         ),
         react.createElement(
@@ -2197,34 +2197,37 @@ window.__ModuleLoader__.load({
                 // 分组：蒸馏参数（模型路由 / 思考档位 / 输出预算）
                 react.createElement("div", { style: S.panelLabel }, "蒸馏参数"),
                 settingsData.effort
-                  ? react.createElement(
-                      "div",
-                      { style: S.switchRow },
-                      react.createElement(Segmented, {
-                        // 档位表来自当前生效模型的能力声明（settings-get 的 effort.options；
-                        // 空声明 → 只显示 high）。''（自动）或档位不在表里时高亮实际生效值。
-                        value: (function () {
-                          var opts = settingsData.effort.options && settingsData.effort.options.length
-                            ? settingsData.effort.options : ["high"];
-                          if (opts.indexOf(settingsData.effort.current) >= 0) return settingsData.effort.current;
-                          return opts.indexOf(settingsData.effort.effective) >= 0
-                            ? settingsData.effort.effective : "high";
-                        })(),
-                        options: (settingsData.effort.options && settingsData.effort.options.length
-                          ? settingsData.effort.options : ["high"]
-                        ).map(function (k) { return { key: k, label: k }; }),
-                        disabled: !master,
-                        onChange: function (v) { toggle("reasoningEffort", v); },
-                      }),
-                      react.createElement("div", null,
-                        react.createElement("div", { style: S.switchLabel }, "蒸馏思考"),
-                        react.createElement(
-                          "div",
-                          { style: S.switchDesc },
-                          "当前生效 " + (settingsData.effort.effective || "（不传，跟随模型默认）") +
-                            (settingsData.effort.current ? "" : "（自动）"),
-                        )),
-                    )
+                  ? (function () {
+                      // 档位表来自当前生效模型的能力声明（settings-get 的 effort.options；
+                      // 空声明 → 只显示 high）。首项固定「自动」（key=''，点击回写空串=
+                      // 按模型能力解析），选过显式档位后仍可回到自动；失效档位高亮实际生效值。
+                      var f = settingsData.effort;
+                      var opts = f.options && f.options.length ? f.options : ["high"];
+                      var segOptions = [{ key: "", label: "自动" }].concat(
+                        opts.map(function (k) { return { key: k, label: k }; })
+                      );
+                      var segValue = f.current === "" || opts.indexOf(f.current) >= 0
+                        ? f.current
+                        : opts.indexOf(f.effective) >= 0 ? f.effective : "high";
+                      return react.createElement(
+                        "div",
+                        { style: S.switchRow },
+                        react.createElement(Segmented, {
+                          value: segValue,
+                          options: segOptions,
+                          disabled: !master,
+                          onChange: function (v) { toggle("reasoningEffort", v); },
+                        }),
+                        react.createElement("div", null,
+                          react.createElement("div", { style: S.switchLabel }, "蒸馏思考"),
+                          react.createElement(
+                            "div",
+                            { style: S.switchDesc },
+                            "当前生效 " + (f.effective || "（不传，跟随模型默认）") +
+                              (f.current ? "" : "（自动）"),
+                          )),
+                      );
+                    })()
                   : null,
                 react.createElement(LlmModelRow, { rpc: rpc, disabled: !master }),
                 react.createElement(BudgetInputs, {

package/dist/config.d.ts

@@ -5,6 +5,13 @@
  */
 import Schema from '@deepseek-ai/schemastery';
 import type { ExtractMode } from './types.js';
+/**
+ * 蒸馏思考档位全词汇表（唯一事实源）：'' = 自动（模型默认档 → high），
+ * 其余为各适配器通用档位词汇表（deepseek 认 'off'，OpenAI 系是 'none'）。
+ * schema（config/settings）、运行时解析（settings.resolveSettings）与 RPC
+ * 写入门（stats.settings-set）共用，勿在别处再抄字面量表。
+ */
+export declare const EFFORT_CHOICES: readonly ["", "off", "none", "minimal", "low", "medium", "high", "xhigh", "max"];
 export interface MemoryConfig {
     /** 数据目录；留空则用 $DSH_HOME/memory。 */
     dataDir: string;

package/dist/config.js

@@ -5,6 +5,13 @@
  */
 import Schema from '@deepseek-ai/schemastery';
 import { dshHomePath } from '@deepseek-ai/dsh-home-paths';
+/**
+ * 蒸馏思考档位全词汇表（唯一事实源）：'' = 自动（模型默认档 → high），
+ * 其余为各适配器通用档位词汇表（deepseek 认 'off'，OpenAI 系是 'none'）。
+ * schema（config/settings）、运行时解析（settings.resolveSettings）与 RPC
+ * 写入门（stats.settings-set）共用，勿在别处再抄字面量表。
+ */
+export const EFFORT_CHOICES = ['', 'off', 'none', 'minimal', 'low', 'medium', 'high', 'xhigh', 'max'];
 export const memorySchema = Schema.object({
     dataDir: Schema.string().default(''),
     family: Schema.union(['auto', 'chat', 'work']).default('auto'),
@@ -64,7 +71,7 @@ export const memorySchema = Schema.object({
         // 蒸馏思考档位：'' = 自动（按模型能力解析：模型默认档 → high，见 llm.ts decideSendableEffort）；
         // 显式值仅在该模型声明支持时发送（跨供应商 effort 词汇表不同：deepseek 认 'off'，
         // openai 系是 'none'，未声明档位的模型不传）。旧默认 'off' 在非 deepseek 模型上必炸（400/本地拒绝）
-        reasoningEffort: Schema.union(['', 'off', 'none', 'minimal', 'low', 'medium', 'high', 'xhigh', 'max']).default(''),
+        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),

package/dist/llm.d.ts

@@ -28,7 +28,7 @@ export declare const LAYER_DEFAULT_BUDGETS: Record<DistillBudgetLayer, number>;
 /**
  * 解析某蒸馏层的生效输出预算：运行时覆盖（cfg.llm.budgets，由 effectiveCfg 从
  * 设置页 distillBudgets 注入，0/缺省 = 跟随）→ 内置默认 → 思考档放大
- * （high/max ×4，reasoning 计入输出预算的历史事故防线）。
+ * （high/xhigh/max ×4，reasoning 计入输出预算的历史事故防线）。
  */
 export declare function resolveLayerTokens(cfg: {
     llm: {
@@ -36,9 +36,15 @@ export declare function resolveLayerTokens(cfg: {
         budgets?: Partial<Record<DistillBudgetLayer, number>>;
     };
 }, layer: DistillBudgetLayer): number;
+/**
+ * 高思考档集合（输出预算 ×4 的档位）：阶段侧 layerMaxTokens 与 callLLM 的
+ * 自动档防线共用同一张表——此前两处字面量表分叉（防线漏 xhigh），显式 xhigh
+ * 配置被双重放大 ×16。勿再在别处抄写该列表。
+ */
+export declare const HIGH_EFFORT_TIERS: readonly ["high", "xhigh", "max"];
 /**
  * 思考档预算放大：reasoning 计入输出预算（v4-flash 事故：high 思考可吃光全部
- * 预算致正文 0 字符）——effort 为 high/max 时分层预算 ×4。
+ * 预算致正文 0 字符）——effort 为 high/xhigh/max 时分层预算 ×4。
  */
 export declare function layerMaxTokens(base: number, reasoningEffort: string): number;
 /** 解析蒸馏用的 provider/model：配置优先，其次当前默认选择。 */

package/dist/llm.js

@@ -20,18 +20,24 @@ export const LAYER_DEFAULT_BUDGETS = {
 /**
  * 解析某蒸馏层的生效输出预算：运行时覆盖（cfg.llm.budgets，由 effectiveCfg 从
  * 设置页 distillBudgets 注入，0/缺省 = 跟随）→ 内置默认 → 思考档放大
- * （high/max ×4，reasoning 计入输出预算的历史事故防线）。
+ * （high/xhigh/max ×4，reasoning 计入输出预算的历史事故防线）。
  */
 export function resolveLayerTokens(cfg, layer) {
     const override = cfg.llm.budgets?.[layer];
     return layerMaxTokens(override && override > 0 ? override : LAYER_DEFAULT_BUDGETS[layer], cfg.llm.reasoningEffort);
 }
+/**
+ * 高思考档集合（输出预算 ×4 的档位）：阶段侧 layerMaxTokens 与 callLLM 的
+ * 自动档防线共用同一张表——此前两处字面量表分叉（防线漏 xhigh），显式 xhigh
+ * 配置被双重放大 ×16。勿再在别处抄写该列表。
+ */
+export const HIGH_EFFORT_TIERS = ['high', 'xhigh', 'max'];
 /**
  * 思考档预算放大：reasoning 计入输出预算（v4-flash 事故：high 思考可吃光全部
- * 预算致正文 0 字符）——effort 为 high/max 时分层预算 ×4。
+ * 预算致正文 0 字符）——effort 为 high/xhigh/max 时分层预算 ×4。
  */
 export function layerMaxTokens(base, reasoningEffort) {
-    return reasoningEffort === 'high' || reasoningEffort === 'xhigh' || reasoningEffort === 'max' ? base * 4 : base;
+    return HIGH_EFFORT_TIERS.includes(reasoningEffort) ? base * 4 : base;
 }
 /** 解析蒸馏用的 provider/model：配置优先，其次当前默认选择。 */
 export async function resolveModelRoute(ctx, cfg) {
@@ -133,10 +139,12 @@ export async function callLLM(ctx, cfg, opts) {
     const user = opts.user.length > cfg.llm.maxInputChars
         ? `${opts.user.slice(0, cfg.llm.maxInputChars)}\n\n[输入超出 ${cfg.llm.maxInputChars} 字符预算，已截断]`
         : opts.user;
-    // 输出预算 ×4 防线跟随【实际发送】的档位：阶段侧按原始配置放大（high/max），
-    // 这里补自动档（'' → 模型默认/high）解析出高档时欠放大的缺口
+    // 输出预算 ×4 防线跟随【实际发送】的档位：阶段侧已按原始配置的高档位
+    // （HIGH_EFFORT_TIERS）放大过，这里只补自动档（'' → 模型默认/高档）解析出
+    // 高档时的欠放大缺口——两侧共用一张表，配置本身就是高档时不再放大（防 ×16 双乘）
     const baseMaxTokens = opts.maxTokens ?? cfg.llm.maxTokens;
-    const maxTokens = ['high', 'xhigh', 'max'].includes(effort.effort) && !['high', 'max'].includes(cfg.llm.reasoningEffort)
+    const highTiers = HIGH_EFFORT_TIERS;
+    const maxTokens = highTiers.includes(effort.effort) && !highTiers.includes(cfg.llm.reasoningEffort)
         ? layerMaxTokens(baseMaxTokens, 'high')
         : baseMaxTokens;
     const stream = ctx.llm.stream({

package/dist/settings.d.ts

@@ -5,11 +5,11 @@
  */
 import type { Context } from '@deepseek-ai/cordis';
 import Schema from '@deepseek-ai/schemastery';
+import { EFFORT_CHOICES } from './config.js';
 import type { DistillBudgetLayer } from './llm.js';
 import type { MemoryLogger } from './types.js';
-/** 蒸馏思考档位可选项：'' = 跟随静态 config（部署默认）。 */
-/** 蒸馏思考档位：'' = 自动（模型默认档 → high）；其余为各适配器通用档位词汇表。 */
-export type EffortChoice = '' | 'off' | 'none' | 'minimal' | 'low' | 'medium' | 'high' | 'xhigh' | 'max';
+/** 蒸馏思考档位：'' = 自动（模型默认档 → high）；词汇表单源于 config.ts 的 EFFORT_CHOICES。 */
+export type EffortChoice = (typeof EFFORT_CHOICES)[number];
 /** 分层输出预算（与 llm.ts 的 DistillBudgetLayer 同键；0 = 跟随内置默认）。 */
 export type DistillBudgets = Record<DistillBudgetLayer, number>;
 export interface MemoryLiveSettings {

package/dist/settings.js

@@ -1,5 +1,6 @@
 import Schema from '@deepseek-ai/schemastery';
 import { settingsNamespace } from '@deepseek-ai/dsh-settings';
+import { EFFORT_CHOICES } from './config.js';
 const NS = settingsNamespace('dsh-memory');
 const ALWAYS_ON = {
     enabled: true,
@@ -36,7 +37,7 @@ export function liveSettingsSchema() {
         capture: Schema.boolean().default(true),
         distill: Schema.boolean().default(true),
         recall: Schema.boolean().default(true),
-        reasoningEffort: Schema.union(['', 'off', 'none', 'minimal', 'low', 'medium', 'high', 'xhigh', 'max']).default(''),
+        reasoningEffort: Schema.union([...EFFORT_CHOICES]).default(''),
         distillProvider: Schema.string().default(''),
         distillModel: Schema.string().default(''),
         distillBudgets: Schema.object({
@@ -154,7 +155,6 @@ function resolveSettings(value) {
     if (!value || typeof value !== 'object')
         return { ...ALWAYS_ON };
     const v = value;
-    const efforts = ['', 'off', 'none', 'minimal', 'low', 'medium', 'high', 'xhigh', 'max'];
     const num = (x) => (typeof x === 'number' && Number.isFinite(x) && x >= 0 ? Math.floor(x) : 0);
     const rawBudgets = (v.distillBudgets ?? {});
     return {
@@ -162,7 +162,7 @@ function resolveSettings(value) {
         capture: v.capture !== false,
         distill: v.distill !== false,
         recall: v.recall !== false,
-        reasoningEffort: typeof v.reasoningEffort === 'string' && efforts.includes(v.reasoningEffort)
+        reasoningEffort: typeof v.reasoningEffort === 'string' && EFFORT_CHOICES.includes(v.reasoningEffort)
             ? v.reasoningEffort
             : '',
         distillProvider: typeof v.distillProvider === 'string' ? v.distillProvider : '',

package/dist/stats.js

@@ -9,7 +9,7 @@
 import { createRequire } from 'node:module';
 import { closeSync, openSync, readSync, statSync } from 'node:fs';
 import { join } from 'node:path';
-import { resolveDataDir } from './config.js';
+import { EFFORT_CHOICES, resolveDataDir } from './config.js';
 import { effectiveCfg } from './pipeline/runner.js';
 import { decideSendableEffort, LAYER_DEFAULT_BUDGETS, resolveModelEfforts, resolveModelRoute } from './llm.js';
 import { errDetail } from './util/filelog.js';
@@ -234,8 +234,10 @@ async function handleEndpoint(endpoint, payload, deps) {
             }
             if (patch.reasoningEffort !== undefined) {
                 const v = String(patch.reasoningEffort);
-                if (!['', 'off', 'high', 'max'].includes(v)) {
-                    throw new Error(`非法思考档位: ${v}（允许 ''/off/high/max）`);
+                // 白名单与 schema/settings 同源（config.ts EFFORT_CHOICES）——此前此处漏扩词表，
+                // 设置页新词汇（none/minimal/low/medium/xhigh）被拒并回滚
+                if (!EFFORT_CHOICES.includes(v)) {
+                    throw new Error(`非法思考档位: ${v}（允许 '' 或 ${EFFORT_CHOICES.filter((x) => x !== '').join('/')}）`);
                 }
                 clean.reasoningEffort = v;
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-layered-memory",
-  "version": "0.8.3",
+  "version": "0.8.4",
   "description": "L0~L3 分层蒸馏记忆插件 for DeepSeek Harness：自动捕获对话（L0）、抽取原子记忆（L1）、整合场景块（L2）、蒸馏核心画像/团队方法论（L3），并在模型步骤前自动召回注入。移植自 MemoryCore (TencentDB Agent Memory) 的管线设计。",
   "type": "module",
   "main": "dist/index.js",
@@ -58,25 +58,25 @@
   },
   "peerDependencies": {
     "@deepseek-ai/cordis": "^4.0.1",
-    "@deepseek-ai/dsh-agent": "^0.1.0-rc.6",
-    "@deepseek-ai/dsh-home-paths": "^0.1.0-rc.6",
-    "@deepseek-ai/dsh-llm": "^0.1.0-rc.6",
-    "@deepseek-ai/dsh-session": "^0.1.0-rc.6",
-    "@deepseek-ai/dsh-settings": "^0.1.0-rc.6",
-    "@deepseek-ai/dsh-system-prompt": "^0.1.0-rc.6",
-    "@deepseek-ai/dsh-tools": "^0.1.0-rc.6"
+    "@deepseek-ai/dsh-agent": "^0.1.1-rc.2",
+    "@deepseek-ai/dsh-home-paths": "^0.1.1-rc.2",
+    "@deepseek-ai/dsh-llm": "^0.1.1-rc.2",
+    "@deepseek-ai/dsh-session": "^0.1.1-rc.2",
+    "@deepseek-ai/dsh-settings": "^0.1.1-rc.2",
+    "@deepseek-ai/dsh-system-prompt": "^0.1.1-rc.2",
+    "@deepseek-ai/dsh-tools": "^0.1.1-rc.2"
   },
   "devDependencies": {
     "@deepseek-ai/cordis": "4.0.1",
-    "@deepseek-ai/dsh-agent": "0.1.0-rc.8",
-    "@deepseek-ai/dsh-agent-default-model": "0.1.0-rc.8",
-    "@deepseek-ai/dsh-client-connection": "0.1.0-rc.8",
-    "@deepseek-ai/dsh-home-paths": "0.1.0-rc.8",
-    "@deepseek-ai/dsh-llm": "0.1.0-rc.8",
-    "@deepseek-ai/dsh-session": "0.1.0-rc.8",
-    "@deepseek-ai/dsh-settings": "0.1.0-rc.8",
-    "@deepseek-ai/dsh-system-prompt": "0.1.0-rc.8",
-    "@deepseek-ai/dsh-tools": "0.1.0-rc.8",
+    "@deepseek-ai/dsh-agent": "0.1.1-rc.2",
+    "@deepseek-ai/dsh-agent-default-model": "0.1.1-rc.2",
+    "@deepseek-ai/dsh-client-connection": "0.1.1-rc.2",
+    "@deepseek-ai/dsh-home-paths": "0.1.1-rc.2",
+    "@deepseek-ai/dsh-llm": "0.1.1-rc.2",
+    "@deepseek-ai/dsh-session": "0.1.1-rc.2",
+    "@deepseek-ai/dsh-settings": "0.1.1-rc.2",
+    "@deepseek-ai/dsh-system-prompt": "0.1.1-rc.2",
+    "@deepseek-ai/dsh-tools": "0.1.1-rc.2",
     "@types/node": "^22.0.0",
     "typescript": "^5.6.0"
   }