dsh-layered-memory 0.8.4 → 0.8.5

package/README.en.md

@@ -21,7 +21,7 @@ Requires Node ≥ 22.16. Two invocation styles — the `npx` prefix can replace
 any command below:
 
 ```bash
-# Option 1: run the official CLI directly via npx (no pre-installed dsh; version can be pinned, e.g. dsh-layered-memory@0.8.2)
+# Option 1: run the official CLI directly via npx (no pre-installed dsh; version can be pinned, e.g. dsh-layered-memory@0.8.4)
 npx -y @deepseek-ai/dsh plugin --profile web add dsh-layered-memory
 
 # Option 2: with the dsh CLI installed (dsh is a pnpm forwarder; npm i -g pnpm first if missing)
@@ -129,6 +129,15 @@ trajectory view):
 - **Control**: the pill next to the mode selector in the input bar (`Memory · Auto`);
   clicking opens a macOS-style sliding picker above — release to snap to the nearest
   mode; adapts to light/dark themes;
+- The lower half of the popover is a **per-session info area**: recall hits
+  (hit/searched turns plus cumulative items), batching progress (this session's
+  slice x/effective threshold; the off mode shows parked slices instead), memories
+  produced for this session, and session message count — plus status lines for
+  anomalies (storage degraded / vector search unavailable) and a global summary
+  (pending distill count, last distill time). Data comes from the
+  `dsh-memory/session-stats` endpoint (in-memory registries + an indexed COUNT,
+  zero file I/O), adaptively polled while open (2s busy / 5s idle) and stopped on
+  close;
 - Each session's choice is persisted by sessionId to `session-modes.json`, surviving
   restarts/session restore; stacks with the global switches (global is the master gate);
   L2/L3 are fully family-isolated — content never leaks across families.
@@ -144,20 +153,24 @@ 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)** 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).
+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). Dialog-track environment: DeepSeek official `deepseek-v4-flash`, plugin 0.8.5 (judge same-source as tested; every answer archived for manual audit), 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), with the extended probe types and lifecycle track informed by [MemoryAgentBench](https://arxiv.org/abs/2507.05257) / [GoodAI LTM](https://github.com/GoodAI/goodai-ltm-benchmark) / BEAM.
 
-### Dialog track (15 scenarios × 6 probe types × 3 reps = 270 questions): does it remember correctly
+> The dialog track below is the **fresh 0.8.5 baseline** (fixed plugin + corrected judging criteria); the workflow-track numbers remain the archived 0.8.3 run (the bank has since grown to 8 scenarios with a prospective-memory addition — re-run pending).
 
-> Archived 0.8.0 baseline (Group A data; the dialog-track B arm has since been retired — Group A only).
+### Dialog track (20 scenarios × 10 probe types × 3 reps = 420 questions): does it remember correctly
+
+> 0.8.5 baseline (Group A data; the dialog-track B arm is retired — Group A only).
 
 <p align="center">
   <img src="./assets/readme/bench-dialog.svg" width="100%"
-       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)">
+       alt="DSH-MemBench dialog track accuracy chart (Group A, memory on): overall accuracy 95.2% (400/420); six core probe types, 60 questions each — extraction 58/60, multi-hop 60/60, temporal 56/60, updates 55/60, scene recall 52/60, abstention 60/60 with 0 fabricated; four extended probe types, 15 each — accretive completion 15/15, update chains 15/15, event ordering 14/15, paraphrase 15/15">
 </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.
+**Dual-channel recall** (Group A): passive injection hit rate **78.1%** (the answer's key points appear in the recall injection, 281/360); most of the rest the model recovered by **actively calling the memory tools** — 106 questions with active queries, **75 rescued by tools**. The end-to-end 95.2% is the composite of both channels plus model utilization. With the memory store accumulating across scenarios for the whole run, 295 probe injections carried other scenarios' memories (honestly counted) — yet accuracy actually *rose* from 92.8% (early, small store) to 97.7% (late, largest store), and offline flooding with 600 extra synthetic records moved retrieval recall@5 by only −2.8pp: interference resistance under a growing store, measured.
+
+**Layered weaknesses**: offline retrieval metrics (recall@5, controlled replay) total 73.3%, with event ordering at 0% and scene recall at 50% — end-to-end still 93%+ thanks to model robustness over adjacent injected memories. **Efficiency triangle** (the cost of memory): injections add no latency (injected turns respond 210ms *faster* on average), recall text is ~10.3% of per-turn input, and the whole distillation pipeline costs ≈2727 input / 240 output tokens per captured message (1172 calls, 0 failures).
 
-### Workflow track (7 scenarios · Group A ×3 / Group B ×1, real tool sandbox): does it do it right, and cheaper
+### Workflow track (archived 0.8.3 · 7-scenario edition · 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%"
@@ -173,14 +186,17 @@ Screenshots show what the plugin looks like — this section answers "**what doe
 ```bash
 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/run.mjs --track lifecycle --arm A ...                                              # lifecycle track (gating/off/rebuild/forget)
 node bench/harness/report.mjs --latest [dialog|workflow]                                               # aggregate report
+node bench/harness/retrieval-metrics.mjs <runDir> --flood 200,600                                     # retrieval metrics + flooding curve
 ```
 
-- 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);
+- Scoring: programmatic `contains-all` plus an LLM judge against key points (every answer and verdict is preserved in `result.json` for human audit); for stale-bearing probes (updates/update-chains/forget) an old value only fails when stated *as the current answer*, and abstention probes allow citing real adjacent facts while denying the asked point; workflow completion is verified programmatically from produced files and their contents (four check kinds: positive / forbidden-word / must-not-exist / exists);
+- Metric surface: beyond the per-type accuracy table (6 core + 4 extended types), reports automatically include **offline retrieval metrics** (recall@5 / injection precision / stale leakage), the **efficiency triangle** (injection latency differential / injection share / distillation accounting per captured message), **scale-position analysis** (accuracy & contamination vs store growth), and the lifecycle-track section (family-gating matrix / off-mode dual assertions / rebuild fidelity / forget requests);
 - 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.
+- 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 (0.8.5 baseline: 89.1% — 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 + retrieval-metric comparison);
+- Limitations (stated honestly): single machine; Group A ×3 merged, Group B ×1 (cost guardrail — noisier); judge vs tested model: same model in the 0.8.5 dialog baseline, heterogeneous in the archived 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/).
 
@@ -244,6 +260,7 @@ the bundle layer appends and causes `duplicate loader entry id` startup failure)
 | `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) |
 | `tools` | `true` | Whether to register model-callable memory tools |
+| `benchControl` | `false` | Register the in-process bench control service (rebuild trigger / session-mode setting / distillation usage snapshot — used by the benchmark's lifecycle track). Off by default — zero surface in production deployments; do not enable casually |
 
 ## Storage Layout
 

package/README.md

@@ -20,7 +20,7 @@
 需要 Node ≥ 22.16。两种调用方式任选（`npx` 前缀可替换下面任何 `dsh` 命令）：
 
 ```bash
-# 方式一：npx 直接跑官方 CLI（无需预装 dsh；可 pin 版本，如 dsh-layered-memory@0.8.2）
+# 方式一：npx 直接跑官方 CLI（无需预装 dsh；可 pin 版本，如 dsh-layered-memory@0.8.4）
 npx -y @deepseek-ai/dsh plugin --profile web add dsh-layered-memory
 
 # 方式二：已装 dsh CLI（dsh 是 pnpm 转发器，未装 pnpm 时先 npm i -g pnpm）
@@ -110,6 +110,11 @@ npx tsc src/smoke.ts --outDir dist-smoke --module nodenext --moduleResolution no
 </p>
 
 - **控件**：输入栏内、模式选择器右侧的 pill（`记忆·自动`），点击在上方浮出档位滑块深浅主题自适应；
+- 悬浮板下半部是**会话信息区**：召回命中（命中/检索轮次与累计条数）、攒批进度
+  （本会话切片 x/生效阈值；关闭档显示挂起切片数）、本会话产出记忆条数、会话消息数，
+  外加异常状态行（存储降级 / 向量检索不可用）与全局摘要（待蒸馏条数、上次蒸馏时间）；
+  数据走 `dsh-memory/session-stats` 端点（纯内存注册表 + 索引 COUNT，零文件 I/O），
+  打开期间自适应轮询（忙 2s / 静 5s），关闭即停；
 - 每会话的选择按 sessionId 持久化到 `session-modes.json`，重启/恢复会话不丢；
   与全局开关叠加（全局是总闸）；L2/L3 完全分类，分类内容不渗透。
 
@@ -124,20 +129,24 @@ npx tsc src/smoke.ts --outDir dist-smoke --module nodenext --moduleResolution no
 
 ## 实测对比（DSH-MemBench：自动化基准）
 
-图文回答"长什么样"，这一节用**自动化基准**的实测数字回答"**开了到底有什么用**"（[`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)。
+图文回答"长什么样"，这一节用**自动化基准**的实测数字回答"**开了到底有什么用**"（[`bench/`](./bench/)，一条命令可复现）。方法：同场景库、逐字相同输入，**A 组（记忆开）跑 3 次取合并值，B 组（记忆关）跑 1 次**（无记忆的长任务每场景要吞数倍 token，成本护栏）；对话赛道只跑 A 组（B 组会话独立无记忆必然失败，对照无信息量，已下线）。对话赛道环境：DeepSeek 官方 `deepseek-v4-flash`、插件 0.8.5（判卷与被测同源，答案原文全部留痕可人工复核）、Windows；题型设计借鉴 [LongMemEval](https://github.com/xiaowu0162/longmemeval) / [LoCoMo](https://snap-research.github.io/locomo/) / [AMB](https://github.com/vectorize-io/agent-memory-benchmark)，扩展题型与生命周期赛道参照 [MemoryAgentBench](https://arxiv.org/abs/2507.05257) / [GoodAI LTM](https://github.com/GoodAI/goodai-ltm-benchmark) / BEAM。
 
-### 对话赛道（15 场景 × 6 题型 × 3 次 = 270 题）：答得准吗
+> 对话赛道为 **0.8.5 新基线**（修复版插件 + 修正后的判卷口径）；工作流赛道数字仍为 0.8.3 存档（0.8.5 起场景库扩至 8 个，新增前瞻记忆场景，重跑待做）。
 
-> 0.8.0 留档基线（A 组数据；此后对话赛道 B 组下线，只跑 A 组）。
+### 对话赛道（20 场景 × 10 题型 × 3 次 = 420 题）：答得准吗
+
+> 0.8.5 基线（A 组数据；对话赛道 B 组已下线，只跑 A 组）。
 
 <p align="center">
   <img src="./assets/readme/bench-dialog.svg" width="100%"
-       alt="DSH-MemBench 对话赛道准确率图（A 组·记忆开）：总准确率 92.6%（250/270）；分题型各 45 题——抽取 45/45、多跳 45/45、时序 43/45、知识更新 31/45、场景回忆 41/45、拒答 45/45 且 0 编造；对话赛道 B 组已下线（会话独立无记忆必然失败）">
+       alt="DSH-MemBench 对话赛道准确率图（A 组·记忆开）：总准确率 95.2%（400/420）；核心六题型各 60 题——抽取 58/60、多跳 60/60、时序 56/60、更新 55/60、场景回忆 52/60、拒答 60/60 且 0 编造；扩展四题型各 15 题——增量积累 15/15、连锁更新 15/15、事件排序 14/15、同义改写 15/15">
 </p>
 
-**召回双通道**（A 组）：被动注入召回率 **75.1%**（该题要点出现在召回注入中，169/225），其余多数由模型**主动调用记忆工具**查回——84 题主动查询、**60 题靠工具兜底答对**；端到端 92.6% 是两通道 + 模型利用的合成结果。记忆库跨场景全程累积下，探针召回注入混入其他场景记忆 144 次（已如实计数），总准确率仍稳在 92.6%——抗干扰能力经受住了膨胀记忆库的考验。
+**召回双通道**（A 组）：被动注入召回率 **78.1%**（该题要点出现在召回注入中，281/360），其余多数由模型**主动调用记忆工具**查回——106 题主动查询、**75 题靠工具兜底答对**；端到端 95.2% 是两通道 + 模型利用的合成结果。记忆库跨场景全程累积下，探针召回注入混入其他场景记忆 295 次（已如实计数），总准确率反而前段 92.8% → 后段 97.7%——抗干扰能力经受住了膨胀记忆库的考验（离线灌水再灌 600 条合成噪声，检索层 recall@5 也只降 2.8pp）。
+
+**分层看短板**：检索层离线指标（recall@5 受控复现）总 73.3%，其中事件排序 0%、场景回忆 50%——端到端仍 93%+ 靠的是注入邻近记忆后模型的鲁棒性；**效率三角**（记忆的开销）：注入非但不加延迟（注入轮响应比无注入轮平均快 210ms）、注入占每轮输入约 10.3%，蒸馏全链路摊到每条捕获消息 ≈2727 输入 / 240 输出 token（1172 次调用 0 失败）。
 
-### 工作流赛道（7 场景 · A 组 3 次 / B 组 1 次，真实工具沙箱）：做得对、做得省吗
+### 工作流赛道（0.8.3 存档 · 7 场景版 · A 组 3 次 / B 组 1 次，真实工具沙箱）：做得对、做得省吗
 
 <p align="center">
   <img src="./assets/readme/bench-workflow.svg" width="100%"
@@ -153,14 +162,17 @@ npx tsc src/smoke.ts --outDir dist-smoke --module nodenext --moduleResolution no
 ```bash
 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/run.mjs --track lifecycle --arm A ...                                              # 生命周期赛道（门控/off/rebuild/遗忘）
 node bench/harness/report.mjs --latest [dialog|workflow]                                               # 汇总报告
+node bench/harness/retrieval-metrics.mjs <runDir> --flood 200,600                                     # 检索层指标 + 灌水曲线
 ```
 
-- 判分：`contains-all` 程序判 + 判卷模型按要点判（答案原文与判分理由全部留痕 `result.json` 可人工复核）；工作流完成度为产物文件 + 关键内容程序化校验（四型判据：正检查/禁词/产物缺席/存在性）；
+- 判分：`contains-all` 程序判 + 判卷模型按要点判（答案原文与判分理由全部留痕 `result.json` 可人工复核）；带 stale 的题（更新/连锁/遗忘）"旧值当作现状陈述"才判负、拒答题允许引用真实背景解释"不知道被问点"；工作流完成度为产物文件 + 关键内容程序化校验（四型判据：正检查/禁词/产物缺席/存在性）；
+- 指标面：准确率总表（6 核心 + 4 扩展题型）之外，自动产出**检索层离线指标**（recall@5 / 注入精度 / 作废泄漏）、**效率三角**（注入开销差分 / 注入占比 / 蒸馏记账摊到每消息）、**规模位置分析**（库容膨胀下的准确率/污染）与生命周期赛道专属节（分族门控矩阵 / off 双断言 / rebuild 保真 / 遗忘）；
 - 实时进度：跑基准时自动拉起本地进度面板并打开浏览器（`--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 违规。
+- 指标全部来自供应商上报 usage（输入含缓存命中拆分）与会话事件折叠；稳态缓存率剔除每会话首请求（0.8.5 基线：89.1%——记忆注入不伤缓存）；
+- 回归用途：改插件前后各跑一遍，`compare.mjs` 出对比表（环境头校验含 gitSha + B 组对照组漂移告警 + 检索层指标对比）；
+- 局限（诚实声明）：单机；A 组 ×3 合并、B 组 ×1（成本护栏，噪声更大）；判卷与被测模型：对话 0.8.5 基线同源、工作流存档跑为异构（glm-5.3 判 v4-flash）；作者自建场景库（倾向记忆优势场景，欢迎自行复现）；沙箱文件的可供性会部分泄露流程（B 组可读脚本逆向，判别力受限处已如实标注）；工具审计双档（严格违规判负/宽松提示），实测双方 0 违规。
 
 完整报告与逐题数据：[`bench/baseline/`](./bench/baseline/)。
 
@@ -261,6 +273,7 @@ ONNX 量化 **CPU 推理**——无需 API Key，数据不出本机）。本地
 | `llm.maxInputChars` | `700000` | 单次蒸馏输入字符预算（超限的 L1 输入自动分块抽取）；运行时可在设置页 → 蒸馏参数 → 输入预算调整（留空/0 = 跟随本值） |
 | `llm.timeoutMs` | `120000` | 单次蒸馏调用超时（ms） |
 | `tools` | `true` | 是否注册模型可调用的记忆工具 |
+| `benchControl` | `false` | 注册 bench 控制服务（进程内 rebuild 触发/会话档位设置/蒸馏用量快照，供基准 lifecycle 赛道）。默认关——生产部署零表面积，勿随意开启 |
 
 ## 日志与故障排查
 

package/assets/readme/bench-dialog.svg

@@ -2,75 +2,69 @@
      width="1200" height="630" viewBox="0 0 1200 630"
      role="img" aria-labelledby="benchDialogTitle benchDialogDesc">
   <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>
+  <desc id="benchDialogDesc">A 组（记忆开）总准确率 95.2%（400/420，20 场景 × 10 题型 × 3 次）。核心六题型各 60 题：抽取 58/60、多跳 60/60、时序 56/60、更新 55/60、场景回忆 52/60、拒答 60/60 且 0 编造；扩展四题型各 15 题：增量积累 15/15、连锁更新 15/15、事件排序 14/15、同义改写 15/15。对话赛道 B 组已下线（会话独立、无记忆必然失败，对照无信息量）。</desc>
 
   <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">对话赛道：记忆开 · 准确率</text>
-    <text x="64" y="94" font-size="18" fill="#8296B3">15 场景 × 6 题型 × 3 次 = 270 题（每题型 45 题）· 条长 = 答对率，数值 = 答对题数</text>
+    <text x="64" y="94" font-size="18" fill="#8296B3">20 场景 × 10 题型 × 3 次 = 420 题（核心六题型各 60 题、扩展四题型各 15 题）· 条长 = 答对率，数值 = 答对题数</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>
+    <text x="868" y="65" font-size="17" fill="#C2CDDE">核心六题型</text>
+    <rect x="966" y="50" width="18" height="18" rx="5" fill="#6FB1FF"/>
+    <text x="992" y="65" font-size="17" fill="#C2CDDE">扩展四题型</text>
 
-    <!-- ── 网格线（0/25/50/75/100%）── -->
     <g stroke="#1C2A47" stroke-width="1">
-      <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"/>
+      <line x1="260" y1="120" x2="260" y2="525"/>
+      <line x1="435" y1="120" x2="435" y2="525"/>
+      <line x1="610" y1="120" x2="610" y2="525"/>
+      <line x1="785" y1="120" x2="785" y2="525"/>
+      <line x1="960" y1="120" x2="960" y2="525"/>
     </g>
     <g font-size="17" fill="#8296B3" text-anchor="middle">
-      <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>
+      <text x="260" y="552">0%</text>
+      <text x="435" y="552">25%</text>
+      <text x="610" y="552">50%</text>
+      <text x="785" y="552">75%</text>
+      <text x="960" y="552">100%</text>
     </g>
 
-    <!-- ── 总准确率（强调行）── -->
-    <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>
+  <text x="240" y="149" font-size="18" font-weight="700" fill="#EFF3FA" text-anchor="end">总准确率</text>
+  <rect x="260" y="130" width="667" height="25" rx="6" fill="#FFD15D"/>
+  <text x="939" y="149" font-size="17" font-weight="600" fill="#FFD15D">400/420（95.2%）</text>
+  <text x="240" y="184" font-size="18" font-weight="400" fill="#C2CDDE" text-anchor="end">抽取</text>
+  <rect x="260" y="165" width="677" height="25" rx="6" fill="#FFD15D"/>
+  <text x="949" y="184" font-size="17" font-weight="600" fill="#FFD15D">58/60（96.7%）</text>
+  <text x="240" y="219" font-size="18" font-weight="400" fill="#C2CDDE" text-anchor="end">多跳</text>
+  <rect x="260" y="200" width="700" height="25" rx="6" fill="#FFD15D"/>
+  <text x="972" y="219" font-size="17" font-weight="600" fill="#FFD15D">60/60（100.0%）</text>
+  <text x="240" y="254" font-size="18" font-weight="400" fill="#C2CDDE" text-anchor="end">时序</text>
+  <rect x="260" y="235" width="653" height="25" rx="6" fill="#FFD15D"/>
+  <text x="925" y="254" font-size="17" font-weight="600" fill="#FFD15D">56/60（93.3%）</text>
+  <text x="240" y="289" font-size="18" font-weight="400" fill="#C2CDDE" text-anchor="end">更新</text>
+  <rect x="260" y="270" width="642" height="25" rx="6" fill="#FFD15D"/>
+  <text x="914" y="289" font-size="17" font-weight="600" fill="#FFD15D">55/60（91.7%）</text>
+  <text x="240" y="324" font-size="18" font-weight="400" fill="#C2CDDE" text-anchor="end">场景回忆</text>
+  <rect x="260" y="305" width="607" height="25" rx="6" fill="#FFD15D"/>
+  <text x="879" y="324" font-size="17" font-weight="600" fill="#FFD15D">52/60（86.7%）</text>
+  <text x="240" y="359" font-size="18" font-weight="400" fill="#C2CDDE" text-anchor="end">拒答（0 编造）</text>
+  <rect x="260" y="340" width="700" height="25" rx="6" fill="#FFD15D"/>
+  <text x="972" y="359" font-size="17" font-weight="600" fill="#FFD15D">60/60（100.0%）</text>
+  <text x="240" y="394" font-size="18" font-weight="400" fill="#C2CDDE" text-anchor="end">增量积累</text>
+  <rect x="260" y="375" width="700" height="25" rx="6" fill="#6FB1FF"/>
+  <text x="972" y="394" font-size="17" font-weight="600" fill="#6FB1FF">15/15（100.0%）</text>
+  <text x="240" y="429" font-size="18" font-weight="400" fill="#C2CDDE" text-anchor="end">连锁更新</text>
+  <rect x="260" y="410" width="700" height="25" rx="6" fill="#6FB1FF"/>
+  <text x="972" y="429" font-size="17" font-weight="600" fill="#6FB1FF">15/15（100.0%）</text>
+  <text x="240" y="464" font-size="18" font-weight="400" fill="#C2CDDE" text-anchor="end">事件排序</text>
+  <rect x="260" y="445" width="653" height="25" rx="6" fill="#6FB1FF"/>
+  <text x="925" y="464" font-size="17" font-weight="600" fill="#6FB1FF">14/15（93.3%）</text>
+  <text x="240" y="499" font-size="18" font-weight="400" fill="#C2CDDE" text-anchor="end">同义改写</text>
+  <rect x="260" y="480" width="700" height="25" rx="6" fill="#6FB1FF"/>
+  <text x="972" y="499" font-size="17" font-weight="600" fill="#6FB1FF">15/15（100.0%）</text>
 
-    <line x1="64" y1="200" x2="1136" y2="200" stroke="#263A5C" stroke-width="1.5"/>
-
-    <!-- ── 分题型行 ── -->
-    <!-- 抽取 -->
-    <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="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="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="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="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="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="600" font-size="16" fill="#8296B3">* 知识更新：改口后仍答旧值记 0 分（直接考核 L1 去重更新）；拒答：没发生过的事编造即 0 分（0 编造）。</text>
-    <text x="64" y="622" font-size="16" fill="#8296B3">对话赛道 B 组已下线：Harness 会话彼此独立，无记忆的探针必然失败，对照无信息量。</text>
+    <text x="64" y="600" font-size="16" fill="#8296B3">DSH-MemBench 0.8.5 基线 · DeepSeek v4-flash · 3 次重复合并 · 场景库跨场景累积（越靠后的场景记忆干扰越大）</text>
   </g>
 </svg>

package/dist/bench-control.d.ts

@@ -0,0 +1,35 @@
+/**
+ * bench 控制服务（config `benchControl` 门控，默认关）：为同进程的基准驱动插件
+ * （dsh-bench-runner 的 lifecycle 赛道）提供进程内控制面。
+ *
+ * 为什么不走 RPC：宿主侧 connection.rpc 只有 handle/intercept、没有 call()，
+ * 基准驱动包在 dsh 宿主进程内无法调用插件的 loopback RPC 端点；cordis 服务
+ * （ctx.provide / ctx.get）是唯一干净的进程内通道。生产部署不开启该配置，
+ * 服务不注册、零表面积；即便开启，暴露的也只是既有公开 API 的薄包装，
+ * 不引入新逻辑：
+ *   - RebuildController.start()/getStatus()（重建触发与状态轮询）；
+ *   - SessionModeStore.set()/get()（会话档位——capture/recall 每轮读 Map，
+ *     agent 建好后、首条消息前设档即可生效，且走 onModeChange 回调的
+ *     pending 落袋/挂起语义，不是裸改 Map）。
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import type { MemoryLogger, MemoryMode } from './types.js';
+import type { RebuildController, RebuildStatus } from './pipeline/rebuild.js';
+import type { SessionModeStore } from './store/session-modes.js';
+import type { DistillUsageSnapshot } from './llm-usage.js';
+/** 服务名（消费方：bench/harness/dsh-bench-runner 的 lifecycle 赛道）。 */
+export declare const BENCH_CONTROL_SERVICE = "dsh-memory-bench";
+export interface BenchControlSurface {
+    /** 触发全量重建（从 L0 重导派生层）；前置条件不满足时抛错（调用方捕获）。 */
+    rebuildStart(): RebuildStatus;
+    /** 重建状态快照（phase/running/recordsBuilt/…，轮询至 done/failed/cancelled）。 */
+    rebuildStatus(): RebuildStatus;
+    /** 设置会话档位（chat/work/off/auto）；对全新会话应在首条消息前设置。 */
+    setSessionMode(sessionId: string, mode: MemoryMode): void;
+    /** 查询会话档位（未设过的会话返回部署默认档）。 */
+    getSessionMode(sessionId: string): MemoryMode;
+    /** 蒸馏用量快照（按层累计的调用数/输入字符/输出 token——「记忆开销」记账）。 */
+    getDistillUsage(): DistillUsageSnapshot;
+}
+/** 注册控制服务，返回注销函数（调用方在插件 dispose 时执行）。 */
+export declare function registerBenchControl(ctx: Context, rebuild: RebuildController, modes: SessionModeStore, logger: MemoryLogger): () => void;

package/dist/bench-control.js

@@ -0,0 +1,16 @@
+import { snapshotDistillUsage } from './llm-usage.js';
+/** 服务名（消费方：bench/harness/dsh-bench-runner 的 lifecycle 赛道）。 */
+export const BENCH_CONTROL_SERVICE = 'dsh-memory-bench';
+/** 注册控制服务，返回注销函数（调用方在插件 dispose 时执行）。 */
+export function registerBenchControl(ctx, rebuild, modes, logger) {
+    const surface = {
+        rebuildStart: () => rebuild.start(),
+        rebuildStatus: () => rebuild.getStatus(),
+        setSessionMode: (sessionId, mode) => modes.set(sessionId, mode),
+        getSessionMode: (sessionId) => modes.get(sessionId),
+        getDistillUsage: () => snapshotDistillUsage(),
+    };
+    const dispose = ctx.provide(BENCH_CONTROL_SERVICE, surface);
+    logger.info('[memory] bench 控制服务已提供（dsh-memory-bench，仅基准/调试部署）');
+    return dispose;
+}

package/dist/client.js

@@ -244,6 +244,23 @@ window.__ModuleLoader__.load({
       }
     }
 
+    /** 相对时间（悬浮卡摘要行用）：刚刚 / N 分钟前 / N 小时前 / N 天前；无效返回 null。 */
+    function fmtAgo(iso) {
+      if (!iso) return null;
+      try {
+        var t = new Date(iso).getTime();
+        if (!t) return null;
+        var s = Math.floor((Date.now() - t) / 1000);
+        if (s < 0) s = 0;
+        if (s < 45) return "刚刚";
+        if (s < 3600) return Math.floor(s / 60) + " 分钟前";
+        if (s < 86400) return Math.floor(s / 3600) + " 小时前";
+        return Math.floor(s / 86400) + " 天前";
+      } catch (e) {
+        return null;
+      }
+    }
+
     // ── Switch 组件 ──
     function Switch(props) {
       var on = !!props.checked;
@@ -673,6 +690,151 @@ window.__ModuleLoader__.load({
           props.error
             ? react.createElement("div", { style: { fontSize: 11, color: "var(--dsh-mem-danger)", marginTop: 10, whiteSpace: "nowrap" } }, props.error)
             : null,
+          // 会话信息区（分隔线 + 2×2 指标 + 状态行）：session-stats 热路径端点，
+          // 宿主不支持 / 数据缺失时整体不渲染（best-effort 增强，不占位）
+          props.rpc && props.sessionId
+            ? react.createElement(SessionInfoArea, { rpc: props.rpc, sessionId: props.sessionId })
+            : null,
+        ),
+      );
+    }
+
+    // ── 会话信息区：悬浮卡下半部（召回命中 / 攒批进度 / 会话产出 / 会话消息） ──
+    // 数据通道 dsh-memory/session-stats（宿主侧零文件 I/O：内存注册表 + 索引 COUNT，
+    // 见 slider-spec 数据策略节）；自适应轮询：忙时（攒批/挂起/全局待蒸馏）2s，静默 5s，
+    // 浮层卸载即停（ModeSlider 只在 pill 展开期间挂载）。
+    function sinfoCell(val, label, title) {
+      return react.createElement(
+        "div",
+        { title: title || null },
+        react.createElement("div", { className: "dsh-mem-sinfo-val" }, val),
+        react.createElement("div", { className: "dsh-mem-sinfo-label" }, label),
+      );
+    }
+
+    function SessionInfoArea(props) {
+      var rpc = props.rpc;
+      var sessionId = props.sessionId;
+      // undefined=首帧加载中；null=宿主不支持（整体隐藏）；对象=最新快照
+      var stState = react.useState(undefined);
+      var stats = stState[0];
+      var setStats = stState[1];
+      var busyRef = react.useRef(false);
+
+      react.useEffect(function () {
+        if (!rpc || !sessionId) return undefined;
+        var alive = true;
+        var timer = null;
+        var seq = 0;
+        var tick = function () {
+          var token = ++seq;
+          rpc("dsh-memory/session-stats", { sessionId: sessionId })
+            .then(function (r) {
+              if (!alive || token !== seq) return;
+              if (r && r.ok && r.value && r.value.supported === false) {
+                setStats(null); // 宿主无数据源：整体隐藏
+              } else if (r && r.ok && r.value) {
+                setStats(r.value);
+                var d = r.value.distill || {};
+                var g = r.value.global || {};
+                busyRef.current = (d.pendingSlice || 0) > 0 || (d.parkedSlices || 0) > 0 || (g.pendingTotal || 0) > 0;
+              }
+              // RPC 失败：保持旧快照（信息区不因瞬时错误闪没）
+            })
+            .catch(function () {})
+            .then(function () {
+              if (alive) timer = setTimeout(tick, busyRef.current ? 2000 : 5000);
+            });
+        };
+        tick();
+        return function () {
+          alive = false;
+          if (timer) clearTimeout(timer);
+        };
+      }, [rpc, sessionId]);
+
+      // 首帧占位骨架（防内容跳变）；宿主不支持则整体隐藏
+      if (stats === null) return null;
+      if (stats === undefined) {
+        return react.createElement(
+          "div",
+          { className: "dsh-mem-sinfo" },
+          react.createElement(
+            "div",
+            { className: "dsh-mem-sinfo-grid" },
+            sinfoCell("…", "召回命中"),
+            sinfoCell("…", "攒批进度"),
+            sinfoCell("…", "本会话记忆"),
+            sinfoCell("…", "会话消息"),
+          ),
+        );
+      }
+
+      var rc = stats.recall || {};
+      var di = stats.distill || {};
+      var gl = stats.global || {};
+      var isOff = stats.mode === "off";
+
+      // 召回命中：口径是"注入统计"（命中轮次/检索轮次），停用时显示状态而非误导性 0/0
+      var rcVal;
+      var rcLabel;
+      var rcTitle;
+      if (rc.enabled === false) {
+        rcVal = "停用";
+        rcLabel = "召回命中";
+        rcTitle = "召回已停用（开关关闭 / 档位关闭 / 部署未启用）";
+      } else {
+        rcVal = (rc.hitTurns || 0) + "/" + (rc.injectedTurns || 0);
+        rcLabel = "召回命中 · " + (rc.totalHits || 0) + " 条";
+        rcTitle =
+          "最近一轮命中 " + (rc.lastHits || 0) + " 条，耗时 " + (rc.lastDurationMs || 0) + "ms" +
+          ((rc.timeouts || 0) > 0 ? "，超时跳过 " + rc.timeouts + " 次" : "");
+      }
+
+      // 攒批进度（x/生效阈值，含 warmup 爬坡）；off 档显示挂起切片数
+      var dVal;
+      var dLabel;
+      var dTitle;
+      if (isOff) {
+        dVal = String(di.parkedSlices || 0);
+        dLabel = "挂起切片";
+        dTitle = "档位关闭：未蒸馏切片挂起，切回档位后继续";
+      } else {
+        dVal = (di.pendingSlice || 0) + "/" + (di.threshold != null ? di.threshold : "-");
+        dLabel = (di.parkedSlices || 0) > 0 ? "攒批 · 挂起 " + di.parkedSlices : "攒批进度";
+        dTitle = "达到阈值后自动蒸馏（阈值随使用渐进爬坡到稳态）";
+      }
+
+      var pTitle = di.lastDistillAt ? "最近蒸馏 " + fmtTime(di.lastDistillAt) : "本会话尚未蒸馏";
+      var warn = gl.degraded ? "⚠ 存储不可用，记忆功能已停用" : null;
+      var note = null;
+      if (!gl.degraded) {
+        if (stats.retrieval === "keyword" && !isOff) note = "检索降级：纯关键词（向量不可用）";
+        else if (stats.retrieval === "none") note = "检索不可用（FTS 与向量均失效）";
+      }
+      var ago = fmtAgo(gl.lastExtractAt);
+
+      return react.createElement(
+        "div",
+        { className: "dsh-mem-sinfo" },
+        warn
+          ? react.createElement("div", { className: "dsh-mem-sinfo-warn" }, warn)
+          : null,
+        react.createElement(
+          "div",
+          { className: "dsh-mem-sinfo-grid" },
+          sinfoCell(rcVal, rcLabel, rcTitle),
+          sinfoCell(dVal, dLabel, dTitle),
+          sinfoCell(String(di.producedRecords || 0), "本会话记忆", pTitle),
+          sinfoCell(stats.l0Count != null ? String(stats.l0Count) : "…", "会话消息"),
+        ),
+        note
+          ? react.createElement("div", { className: "dsh-mem-sinfo-note" }, note)
+          : null,
+        react.createElement(
+          "div",
+          { className: "dsh-mem-sinfo-sum" },
+          "待蒸馏 " + (gl.pendingTotal || 0) + " · 上次蒸馏 " + (ago || "尚未蒸馏"),
         ),
       );
     }
@@ -930,6 +1092,15 @@ window.__ModuleLoader__.load({
         "  box-shadow: 0 16px 48px rgba(0,0,0,0.24); }",
         "body[data-ds-dark-theme] .dsh-mem-rb-modal { box-shadow: 0 16px 48px rgba(0,0,0,0.6); }",
         ".dsh-mem-rb-muted { font-size: 12px; color: var(--dsh-mem-text-3); }",
+        // ── 会话信息区（悬浮卡下半部）：分隔线 + 2×2 指标 + 状态行；纯静态 DOM，
+        // 不进粒子层 rAF 循环，轮询数据到达才触发本组件小树 re-render ──
+        ".dsh-mem-sinfo { margin-top: 12px; padding-top: 10px; border-top: 1px solid var(--dsh-mem-border); }",
+        ".dsh-mem-sinfo-grid { display: grid; grid-template-columns: 1fr 1fr; gap: 8px 10px; }",
+        ".dsh-mem-sinfo-val { font-size: 13px; font-weight: 600; color: var(--dsh-mem-text-1); line-height: 18px; font-variant-numeric: tabular-nums; }",
+        ".dsh-mem-sinfo-label { font-size: 11px; color: var(--dsh-mem-text-3); line-height: 15px; white-space: nowrap; overflow: hidden; text-overflow: ellipsis; }",
+        ".dsh-mem-sinfo-warn { font-size: 11px; color: var(--dsh-mem-danger); line-height: 16px; margin-bottom: 6px; }",
+        ".dsh-mem-sinfo-note { font-size: 11px; color: var(--dsh-mem-text-3); line-height: 16px; margin-top: 8px; }",
+        ".dsh-mem-sinfo-sum { font-size: 11px; color: var(--dsh-mem-text-3); line-height: 16px; margin-top: 8px; }",
         // reduced-motion 兜底放样式表末尾：同特异性下后置声明才能压过上面的组件类
         "@media (prefers-reduced-motion: reduce) {",
         "  .dsh-mem-root, .dsh-mem-root *, .dsh-mem-btn, .dsh-mem-input, .dsh-mem-select, .dsh-mem-rb-fill, .dsh-mem-scene-chev, .dsh-mem-sel-chev { transition: none; }",
@@ -1066,6 +1237,8 @@ window.__ModuleLoader__.load({
               mode: mode || "auto",
               onCommit: commit,
               error: error,
+              rpc: rpc,
+              sessionId: sessionId,
             })
           : null,
       );

package/dist/config.d.ts

@@ -113,6 +113,9 @@ export interface MemoryConfig {
     };
     /** 是否注册模型可调用的记忆工具。 */
     tools: boolean;
+    /** 注册 bench 控制服务（dsh-memory-bench，进程内 rebuild 触发面）。
+     *  仅供基准/调试部署（bench profile 的 lifecycle 赛道），默认关——生产零表面积。 */
+    benchControl: boolean;
 }
 export declare const memorySchema: Schema<Schemastery.ObjectS<{
     dataDir: Schema<string, string>;
@@ -219,6 +222,7 @@ export declare const memorySchema: Schema<Schemastery.ObjectS<{
         timeoutMs: Schema<number, number>;
     }>>;
     tools: Schema<boolean, boolean>;
+    benchControl: Schema<boolean, boolean>;
 }>, Schemastery.ObjectT<{
     dataDir: Schema<string, string>;
     family: Schema<"chat" | "work" | "auto", "chat" | "work" | "auto">;
@@ -324,5 +328,6 @@ export declare const memorySchema: Schema<Schemastery.ObjectS<{
         timeoutMs: Schema<number, number>;
     }>>;
     tools: Schema<boolean, boolean>;
+    benchControl: Schema<boolean, boolean>;
 }>>;
 export declare function resolveDataDir(cfg: MemoryConfig): string;

package/dist/config.js

@@ -78,6 +78,7 @@ export const memorySchema = Schema.object({
         timeoutMs: Schema.number().min(1000).max(600_000).default(120_000),
     }),
     tools: Schema.boolean().default(true),
+    benchControl: Schema.boolean().default(false),
 });
 export function resolveDataDir(cfg) {
     if (cfg.dataDir)