diff --git a/bench/README.md b/bench/README.md
index 1718ae85..a196fd86 100644
--- a/bench/README.md
+++ b/bench/README.md
@@ -1,262 +1,63 @@
-# bench
+# Benchmark Manual
 
-轻量、零依赖、自包含的测量工装:一套入口、两种测量模式、一份数据契约。它**只在仓库里跑** —— 不随
-npm 包发布、不参与构建、不进 `verify:release` / `release.yml`,也从不成为默认门禁(设计议题 #205)。
+## 测试前的准备
 
-本套收编了两份来源:**#103(@OldLigant)** 的无模型工具级确定性对比,和 **#183(@Richeir)** 的模型
-驱动 token A/B 骨架;口径对齐 **#173** 的意图 —— 本地性能测量只作人类证据,不进 CI。归属记录见
-`docs/CHANGELOG.md`。
+```console
+npm ci --ignore-scripts
+npm run build && npm run build:ptc     # lib/ + 原生 worker
+```
 
-## 三种入口形态
+### 再准备 dsh + 两个 profile
 
-| 形态 | 命令 | 用途 |
-| --- | --- | --- |
-| 唯一跨平台入口 | `node bench/cli.mjs <command>` | 全部子命令: `setup \| ab \| report \| panel \| tools` |
-| npm scripts | `npm run bench:ab` 等 | 日常使用;装包后 `bench/` 不存在,脚本给出明确报错而不是 ENOENT |
-| 底层单脚本 | `node bench/setup.mjs` / `bench/compare.mjs` / `bench/report/panel.mjs` / `bench/tools/index.mjs` | 排障与单步重跑;`ab` 只是按顺序把 runner 与 compare 连起来 |
+```console
+npm i -g @deepseek-ai/dsh
+node bench/cli.mjs setup              # 会自动添加 2 个 headless profile（base、dsh），然后在 dsh 上面安装本地代码 build 出来的插件
+```
 
-`node bench/cli.mjs --help` 列出全部子命令,`<command> --help` 给出该命令自己的旗标。任何路径都从
-模块位置解析(在哪个工作目录下调用都一样),且**不经过 shell** —— `.cmd`/`.ps1` shim 无法被 Node 管道,
-而 shell 会重新解释每个参数。
+### 配 LLM 链接
 
-## 退出码
+跑 `node bench/cli.mjs setup` 会在自动创建；也可以手动创建（会覆盖已有的）：
 
-| 码 | 含义 |
-| --- | --- |
-| `0` | 正常;或一个**弃权**的成本门(噪声底未知 ⇒ 不读方向) |
-| `1` | 失败:`report` 的判决门失败 · `tools` 出现被接受状态之外的项 · `setup` 的某个检查或步骤失败 |
-| `2` | 用法/输入错误:未知命令、未知旗标、缺值、越界参数;装包后缺 `bench/` 也走这里 |
-| `3` | **已声明但尚未接线**:目标文件不存在,或存在但没导出 `main(argv, io)` —— 打印所属切片与目标路径,绝不静默成功 |
+```console
+cp bench/llm.patch.example.yml bench/llm.patch.yml           # bash
+```
 
-`report`(以及 `ab` 的最后一步)的退出码**就是裁决**:`1` 表示门禁失败;一个没能跑起来的成本门
-(噪声底未知等)弃权并退 `0`。
+填 `bench/llm.patch.yml`：
 
-## 两种测量模式(以及各自不该断言什么)
+- `baseURL`：服务器地址，如 `https://host/v1`
+- `<model-id>` ：模型 id，两处必须一致
+- `apiKeyEnv`：放密钥的环境变量名，如 `BENCH_SERVER_API_KEY`
+- `contextWindow` / `maxTokens`：模型真实窗口 / 单次输出上限（默认最大 256K 上下文，单次最大 32K 输出）
 
-| 模式 | 入口 | 用模型 | 断言什么 | 不该断言什么 |
-| --- | --- | --- | --- | --- |
-| 成本 A/B | `bench ab` → `bench report` | 是 | **通过率先行**(任一任务 ✅→❌ 就是回归);只有**两侧都通过**的配对参与成本统计;方向必须超过 A/A 噪声底 | 时间;落在噪声带内的 Δ;没有噪声底时的任何方向 |
-| 工具级确定性对比 | `bench tools` | 否 | 只有 `MATCH / EXPECTED_DIFFERENCE / EXPECTED_REJECTION` 算通过,其余状态(含 `MISMATCH` / `UNSTABLE`)都退 `1` | 时间;同二进制两侧的"提速";任何性能结论 |
-| 本地性能(#173 的意图) | 各命令打印的 median | 否 | **什么都不裁决** —— median 只作人类证据 | 进 CI、进门禁、进任何性能回归判定 |
+密钥只放在 `~/.dsh/.credentials.yaml` 的 `ref` 节点下面的环境变量里面，这样避免出现在项目源文件、对话的上下文
 
-三者共同的一条:**永不裁决时间**。
+## 怎么跑全量
 
-### 成本 A/B 的口径
+```console
+node bench/cli.mjs ab
+```
 
-1. **通过率先行**:`--fail-on both`(默认)先判通过率,任一任务从 ✅ 变 ❌ 即失败;`--fail-on pass-drop`
-   只判通过率,`regression` 只判 token,`none` 只出报告;
-2. **配对**:按 `task × repeat` 配对;`--regression-scope task|total|both` 决定 token 回归判每个任务、
-   判总量还是两者都判;`--tolerance-pct N`(默认 `2`)是回归容忍带;
-3. **只有两侧都通过的配对参与成本统计** —— 一侧失败的配对连 token 一起被排除,并在报告里单列;
-4. **A/A 噪声底**:没有噪声底时,所有成本方向弃权(`noise-floor-unknown`),报告只给测到的 Δ。
+## 怎么跑单个 task
 
-### 工具级确定性对比的口径
+```console
+node bench/cli.mjs ab --task csv-sum
+```
 
-- `tools/measure.mjs` 的 `compare()` **判断顺序本身就是语义**:`TIMEOUT → ERROR → UNSTABLE →
-  (!sameAsBaseline ? (expectedDifference ? EXPECTED_DIFFERENCE : MISMATCH)) → expectedError 命中 ?
-  EXPECTED_REJECTION → (!eligible ? WORKER_ERROR) → MATCH`。其中"两侧返回同一个 error 信封"若不在
-  任务里显式声明为 `expectedError`,必须落 `WORKER_ERROR`,**不能**当成 `MATCH`(否则一次崩溃会被报告成提速);
-- `speedup` 只在 `MATCH` 且 candidate median > 0 时才有意义;任一轮超时或不稳定,整项不给方向;
-- 夹具在**计时之外**用 `mkdtemp` 生成,跑完删除;删除**之前**先整树盘点,遇到不是自己创建的内容就报错并保留现场;
-- 报告**独占创建**(`flag: 'wx'`):重跑不覆盖上一次的证据,而是退 `1` 并提示 `Refusing to overwrite`;
-- 每次调用都显式带 `outputMode`(native 默认是 content):省略参数两侧就不可比。
+## 结果在哪看
 
-## 子命令
+- 在 bench/runs 文件夹里面可以看到
+- 文件夹名称格式为 `benchmark-YYYY-MM-DD-NN`（按当天日期编号，从 `-00` 起）
+- 跑完自动在组目录写 `DSH-OPS Benchmark Report <UTC>.md`
 
-| 子命令 | 目标 | 做什么 |
-| --- | --- | --- |
-| `setup` | `bench/setup.mjs` | 自检 + 幂等准备两侧 profile(`bench-base` / `bench-ops`),打印跑 sweep 的那一条命令 |
-| `ab` | `bench/run.mjs` → `bench/compare.mjs` | 先基线、再候选、再比较,三步共用**一个** `bench/runs/benchmark-test-NN` 组目录 |
-| `report` | `bench/compare.mjs` | 从已封存的 `run.json` 渲染报告(`DSH-OPS Benchmark Report <UTC>.md`) |
-| `panel` | `bench/report/panel.mjs` | 生成/打开一个只读 `run.json` 的 `panel.html` |
-| `tools` | `bench/tools/index.mjs` | 无模型的工具级确定性对比 |
+## 任务一览
 
-### `setup`
+六个任务各自压一种能力，`ops_*` 工具名来自 `publicToolName()`。每个任务的期望值都由夹具生成器现算（`derive*`），判卷在 `bench/lib/verify.mjs`。
 
-`--base-profile` / `--cand-profile` / `--template`(默认 `headless`),`--pin-shell <path>` / `--no-pin`,
-`--permission-mode <mode>` / `--no-permission-mode`(`danger-full-access`(默认)/ `workspace-write` /
-`read-only` / `none`),`--plugin <spec>`(`local` 默认装本 checkout 的本地构建 / npm spec / `none`),
-`--reinstall`,`--dsh-home <dir>`,`--dsh <path>`,`--force`,`--dry-run`,`--no-build-check`。
-
-顺序是故意的:先跑 preflight(权限组合、`PSModulePath`、本地构建),**检查失败就在碰 profile 之前拒绝**;
-一套配置一旦会被写成"量的是权限模式"或"跑的是旧构建",改 profile 也修不好,只会在下一次运行里让报错更难读。
-`--dry-run` 打印每一步写入与命令,什么也不改。
-
-`setup` 会把 `bench/llm.patch.example.yml` 复制成 `bench/llm.patch.yml`(仅当后者不存在),之后的每次 dsh
-调用都以 `--patch` 带上它;把服务器、模型 id 与 `apiKeyEnv` 填进副本即可,**密钥只放环境变量或
-`~/.dsh/.credentials.yaml`,绝不写进这个文件**。副本是操作员的,存在就一字不改。
-
-### `ab`
-
-`--task <id>`(可重复)、`--repeat <N>`、`--folder <name>`、`--base <label>` / `--cand <label>`
-(默认 `bench-base` / `bench-ops`)、`--show`,其余旗标原样交给 runner。
-
-每次 dsh 调用默认带上 `bench/llm.patch.yml`:换文件用 `--llm-patch <path>`,确实不要 overlay(两侧各跑
-各自 profile 自带的路由)用 `--no-llm-patch`,sweep 会把"两侧不共享任何路由"这句说出口。默认 overlay
-不存在、又没给 `--no-llm-patch` 时,runner 在 spawn 之前退 `2` 并点名文件和两条出路 —— 静默换一条路由
-开跑的代价是:两臂一模一样,报告里根本看不出来。默认 overlay 是隐式选中的,所以归档的 `argv` 会把
-`--llm-patch <path>` 补进去,免得一份说不清走了哪条路由的 summary 被当成证据。
-
-`--show` 打印将执行的三条命令并立刻退出(纯函数,不写任何东西、不跑任何会话)。组号在这里**只分配一次**:
-如果每侧各自按时间戳分配目录,两侧会落进不同的组,最后什么都配对不上。
-
-### `report`
-
-两侧各自可以是 label(`bench/runs/*-<label>`,含一层组目录,最新时间戳优先)、一个 run 目录、或一个
-`run.json` / 旧版 `summary.json` 路径。`--folder` 限定组,`--runs` 换根,`--aggregate median|min`,
-`--json` 输出比较文档而不是报告,`--out <file>`(`-` 只到 stdout)。默认落点是**当次跑的组目录**,
-文件名带写入时刻:一次 `bench/runs/<组>/<stamp>-<label>` 里的跑,报告写成
-`bench/runs/<组>/DSH-OPS Benchmark Report <UTC>.md`(UTC 与目录名同形,冒号换横线,如
-`2026-10-20T12-36-38Z`),所以 `full-sweep-4` 的报告就在 `bench/runs/full-sweep-4/`,不在某个 arm 目录里;
-重跑一次就是一份新报告,不覆盖上一份。不在组目录下的跑(直接挂在 `bench/runs/` 下)没有可上提的组,
-报告留在自己的 run 目录里。
-
-### `panel`
-
-`panel --out <dir> <run.json>` 写 `panel.html`;`panel --serve <dir> [--port <n>]` 起一个零依赖
-`node:http` 静态服务(只绑 `127.0.0.1`,默认端口 `0` 由系统分配)。只读:不发请求、不写 `~/.dsh`、
-不常驻、不注册 DSH 插件。`file://` 双击时浏览器的 `fetch` 会被 CORS 拦下,页面用文件选择/拖拽回退。
-
-### `tools`
-
-`--baseline` / `--candidate`(两个 worker 可执行文件)、`--out`(报告路径,**必须不存在**)、
-`--temp-dir`、`--scale`、`--timeout-ms`(这套旗标沿用 #103 的参数面,随接线片一并落地)。预热 1 次 +
-5 轮交替配对,同二进制两侧时它只证明"harness 没坏、输出可重复",**不是**性能基准。
-
-## 如何读报告(`DSH-OPS Benchmark Report <UTC>.md`)
-
-按这个顺序读,不要跳(报告正文与标题都是英文,小节名照英文读):
-
-1. **`Per-task pairs`**:`task | base | cand(Δ%) | steps base→cand(Δ%) | tool calls base→cand(Δ%) | tool errors | pass`;
-   数值单元格自带括号 Δ%,不单列;steps / tool calls 取该侧全部 repeat 的中位数(`--aggregate min` 时取最小值),
-   tool errors 与 pass 统计全部 repeat,配对可用数/排除数不再进这张表(它们留在 JSON 与门禁理由里);
-   表格以 `TOTAL` 行收尾,没有单独的 geomean 行(几何均值仍在 JSON 里);
-2. **`Tool calls (per-side overlap counts)`**:紧跟第一个表 —— 每个工具一行,`base` / `cand` 是整轮合计,
-   后面每个 task 一列,格子写成 `base → cand`;`ops_*` 工具计数上升标绿、下降标红,
-   其它工具相反(下降绿、上升红);两侧都没调用的格子写 `—`,相等不标色;
-3. **`Per-task bucket detail`** / **`usage split`** / **`steps and tool calls`**(都是诊断,不改判决):
-   按 input / output / cacheRead 分桶看 Δ,或给出每任务的步数与工具调用数;
-4. **`Warnings`**与**`Evidence`**:前者列出无法支撑结论的行(如某侧丢了 `step_end.usage`),后者给出 `run.json` 与
-   归档路径;
-5. **`Conclusion`**(报告的最后一段):通过率、配对 token Δ、噪声底、方向、门禁与判定理由,顺序就是判决顺序。
-
-标题下没有汇总行:判决只写在结尾的 **`Conclusion`** 里,标题之后直接进数据。
-
-所有百分数按方向着色:**小于等于 0 绿、大于 0 红**(与 `panel.html` 同一套色,写成行内 `style`)。
-着色只是包一层 `<span>`,数字本身不被改写;GitHub 会剥掉 `style`,在那边退化成纯文本。
-
-**工具调用**表的颜色看"采用方向",不是数字本身的涨跌:`ops_*` 工具计数上升是绿(插件工具接住了),下降是红;
-其它工具上升是红(候选仍在伸手够插件没覆盖的工具),下降是绿。计数相等不标色,两侧都没调用写 `—`。
-
-## 面板怎么读(五个标签)
-
-| 标签 | 内容 |
-| --- | --- |
-| 概览 | 结论条 + 每任务配对表 + 噪声带 + token 归因 |
-| 对话 | 左 base / 右 cand 同任务同 repeat 并排,标出首个分歧点 |
-| 轨迹 | 时间线:`tool_call` / `tool_result` / 里程碑 / 心跳 / stall |
-| 判卷 | verifier 明细:检查项 / 期望 / 实际 / 证据路径 |
-| 原始 JSON | 只读视图 + 复制 + 下载 |
-
-页面**从不内联数据**:它只带数据文件的*名字*,在查看时 `fetch` 同目录的 JSON;每个值都用 `textContent`
-写入,所以 transcript 里的 `<script>` 会被显示而不是解析,勾选「纯文本模式」可把任何标签降级成纯文本。
-面板只认 `schemaVersion 1`,遇到未知版本直接拒绝而不是猜。
-
-## A/A 噪声底、配对口径与"永不裁决时间"
-
-- A/A 噪声底是"基线与自身对照"得到的区间。**默认未知** ⇒ 成本门弃权,报告只给 Δ、不给方向;
-- 要给噪声底,二选一:`--noise-floor-pct N`(固定一个已测量的半宽)或 `--noise <base> <cand>`
-  (用两次基线运行现测);
-- 成本**只统计两侧都通过的配对**:一侧通过、另一侧失败的配对既不能证明变快也不能证明变慢;
-- 任何模式都**不裁决时间**:共享 runner 上的时间不可比,时序只打印、只作人类证据。
-
-## 任务编写语义
-
-任务文件是 `bench/tasks/*.task.json`,字段白名单是 `id` / `title` / `prompt` / `fixture` / `verify` /
-`repeat` / `timeoutMs`(多一个字段就是拼写错误,直接报错并点名文件与字段)。`prompt` 是模型唯一看到的东西,
-不能以 `-` 开头(headless launcher 会把它当选项)、不能以空白开头、不能含 NUL;`timeoutMs` 默认 900000
-(15 min),合法区间 `1000 .. 86400000`;`repeat` 是每任务预算,`1 .. 100`,runner 的 `--repeat N` 仍可覆盖。
-
-判卷(`lib/verify.mjs`)里几个容易写错的语义:
-
-- `fileEquals` **两侧都 `trim()`**(行尾换行不算差异);`fileLines` 逐行 `trim()` 且丢掉空行、折叠 CRLF;
-- `countFiles` **递归**计数,可按 `prefix` / `suffix` / `extension` 过滤;
-- `contentHashes` **只看直接子项**(不递归),逐个比对名字与原字节的 sha256,并拒绝任何多出来的文件;
-  它是"改名而不是重写"的判据 —— 删掉重建或截断再写能骗过 `countFiles`,骗不过它;
-- `expect` 命名的是 fixture 导出的期望值;键写错会直接抛 `fixture exports have no key "..." (known: ...)`,
-  不是静默失败;
-- `fileContains` 对**空文件恒失败**(`actual !== ''` 是前置条件),即"读不到内容"不等于"包含"。
-
-## 两套语料的分工
-
-| 语料 | 位置 | 产出 | 谁用 |
+| 任务 | 工作量 | 主要测什么 | 相关工具 |
 | --- | --- | --- | --- |
-| 模型任务语料 | `bench/lib/fixtures/**`(`csv` / `log` / `tree` / `symbol` / `corpus` / `deep` / `repair`) | 每个生成器建一个任务工作区,并以 `derive*` 重新算出期望值 | `bench ab`(模型驱动) |
-| 工具级尺寸边界语料 | `bench/tools/index.mjs`(`createToolFixtures`,`SEED = 870016`) | 固定尺寸边界:`33 MiB` 拒绝、`8 MiB` hex 窗口、`1 MiB` 行边界 | `bench tools`(无模型) |
-
-两套不要混:`tools/` 的语料靠着它喂养的那次运行,`lib/fixtures/**` 是另一个目录,产出的是任务工作区。
-`--scale` 只缩放**文件数**(small / deep / dense),尺寸边界永远保留,所以 `--scale 0.01` 仍能冒烟到每一条边界。
-真要搬家,必须保持 `SEED` 与五个夹具族逐字节不变,否则比较就丢了基线。
-
-## run.json 契约
-
-`runs/<stamp>-<label>/run.json` 是**唯一数据源**:写入期事件追加为 NDJSON(崩溃安全),封存时归并
-进它,面板/报告/比较都读它,不额外落 CSV 或散文件。本表被 `test/bench-cli.test.mjs` 交叉校验。
-
-| 字段 | 含义 |
-| --- | --- |
-| `schemaVersion` | 契约版本号,`1`;读者遇到未知版本必须拒绝 |
-| `meta` | 采集环境事实:harness 版本、模式、平台、node、dsh、模型、git sha/branch、命令行、起止时间,以及两侧 arm 的标签与 profile 指纹 |
-| `arms` | 两侧 arm 的完整描述:label、profile、profileHash(单变量校验的指纹)、dsh 路径/版本、环境覆盖 |
-| `results` | 每 `task`×`repeat`×`arm` 一行:该行 metrics(exit / steps / toolCalls / durationMs / usage 分桶)、verify 逐检查项、events 引用 |
-| `verify` | 全量检查项汇总:checks / passed / failed / degraded(是否出现无法支撑成本结论的行)、notes |
-| `events` | 事件归档方式:写入期 NDJSON、封存时归并;含文件清单、事件数、哈希与合并时间 |
-| `archive` | 归档清单:每个文件的相对路径、字节数、sha256 与 role |
-
-三条数据纪律(硬边界 #205 §1):
-
-1. **数据只存 JSON**:原始数据只落 `run.json`,不内联、不额外落 CSV/散文件;
-2. **轨迹落独立文件**:事件与 stderr 是 `results/<task>-r<n>.events.ndjson`、`.stderr.ndjson`,
-   轨迹是独立的 `results/<task>-r<n>.trace.ndjson`,只在 `archive[]` 里登记 —— 它们不进 `run.json` 的正文;
-3. **HTML 不内联数据**:`panel.html` 只是"读同目录 JSON 的查看器"。
-
-## 有界兜底(P7)
-
-单发会话的两道超时都是有界的,坏掉的子进程不会把 sweep 挂死:`spawnErrorGraceMs` 默认 `1000`(spawn 立刻
-失败时,等 1 s 让 close 事件落地再结算,而不是把"没有 pid"当成没跑过);`killGraceMs` 默认 `5000`(kill 之后
-最多等 5 s 收尸,超时就从已归档的文件里记录这一行)。两者都可被调用方覆盖。
-
-## 状态名对照
-
-本议题 #205 曾把工具级对比的不匹配写作 `UNEXPECTED_DIFFERENCE`,代码里的名字是 **`MISMATCH`**。完整集合:
-`MATCH` / `MISMATCH` / `EXPECTED_DIFFERENCE` / `EXPECTED_REJECTION` / `UNSTABLE` / `TIMEOUT` / `ERROR` /
-`WORKER_ERROR`;只有 `MATCH`、`EXPECTED_DIFFERENCE`、`EXPECTED_REJECTION` 是"预期结果",其余都退 `1`。
-
-## CI 里怎么跑
-
-- **默认不跑**:`push` / `pull_request` / `merge_group` 里没有 `workflow_dispatch` 的 `inputs`,bench 作业
-  整段跳过,这些运行逐字节不变;
-- **opt-in**:手动触发时给一个布尔输入 `bench`(默认 `false`)才跑 `bench-smoke`;
-- **同二进制两侧**:CI 跑的是 `bench/cli.mjs tools --scale 0.01`(保留全部尺寸边界),两侧同一个二进制,
-  所以绿只说明"harness 还能驱动真实 worker、worker 两次答得一样",**不构成任何性能结论**;
-- **不阻塞**:该作业 `continue-on-error: true`,不进必需状态检查,聚合门禁不计它;
-- **artifact**:证据以 `bench-smoke-report` 上传(沿用 `tools-trial-report` 的命名),含 `bench/runs/smoke/**`
-  以及存在时的 `run.json` / `DSH-OPS Benchmark Report <UTC>.md` / `panel.html`;
-- **模型驱动的 sweep 绝不在 CI 跑**:它要断言成本方向,那是本地的人类判断。
-
-## 为什么 bench 不随包发布
-
-硬边界(设计议题 #205):**数据只存 JSON**、**HTML 只是读 JSON 的查看器**、**测试期可用但构建期不
-构建**。因此 `files` 不含 `bench/`,也不新增构建步骤;装包之后 `npm run bench:*` 会先检查 `bench/`,
-不存在就打印 "bench 只存在于仓库,不随包发布" 并以退出码 `2` 结束。
-
-## 接线现状
-
-声明了但没接线的子命令**从不静默**:目标文件不存在,或存在但没导出 `main(argv, io)`,都以退出码 `3`
-点名所属切片与目标路径。因此切片可以一个一个并入,而 CLI 的 tripwire 始终说真话:
-
-- `setup` / `report` / `panel` / `tools` 已接线,`--help` 退 `0`;
-- `ab` 已接线:整次 sweep 在**一个**子进程内完成,两臂按 `(task, repeat)` 的奇偶 **AB/BA 交错**
-  (奇数轮 base→cand,偶数轮 cand→base);`--show` 只打印逐对计划,不 spawn 任何会话;
-- 目前只剩"声明了但目标文件还没落地"这一种 pending 形态,它退 `3` 并点名切片与目标路径 ——
-  切片一个一个并入时,这条 tripwire 始终说真话。
+| `api-rename` | 12 个模块 + `core.js`（另生成 `check.mjs`），把 `parsePayload` 改名为 `decodePayload` | 符号级改名而非文本替换：定义、import、调用点一个不能漏；诱饵 `parsePayloadLegacy` / `parsePayloadAsync` 和完全不碰该符号的文件必须原样保留；判卷是 `src/` 全部文件的字节级 SHA-256 全等 + `node check.mjs` 退 0 | `ops_grep`（+`ops_glob`）搜调用点；`ops_read_files` 读文件；`ops_edit_file` / `ops_replace` 改名 |
+| `big-file-paging` | 4200 行单文件 `src/pipeline.js` | 分页读取：定位 `auditLimit('staging')` 所在行段，只读需要的两段而不是整读文件；文件里埋了过期注释和被取代的 `LEGACY_LIMIT_TABLE`，grep 一次仍要判断；`answer.txt` 等于该常量的整数 | `ops_grep` 定位；`ops_inspect_local_file`（或 `ops_read_files`）带 `offset`/`limit` 只读两段；`ops_write_file` 写答案 |
+| `config-hunt` | 3 层配置目录 + 12 个 `packages/*/config.json` 诱饵 | 层级查找与优先级判断：先 glob 出配置层，再 grep key，最后按 README 的优先级取 `MAX_UPLOAD_MB` 的有效值；只 grep key 就停下有 1/4 概率拿错答案 | `ops_glob` 找层；`ops_grep` 找 key；`ops_read_files` 读优先级文档与三层配置；`ops_write_file` 写答案 |
+| `csv-sum` | 8000 行 CSV，汇总 EU 区 `amount` 列 | 上下文控制：把聚合交给 shell 而不是把 8000 行读进上下文，`answer.txt` 只写整数和 | `ops_bash` 聚合；`ops_read_files` 只看表头确认列；`ops_write_file` 写答案 |
+| `gate-repair-loop` | 12 个 stage 模块（每个约 70 行）+ `check.js` | 迭代修复循环：门禁停在第一个坏 stage，每个 stage 只错一处绑定常量、契约写在模块自己的注释里，跑→修→再跑直到退 0；`check.js` 字节不变是 invariant | `ops_bash` 跑门禁；`ops_read_files` 读 stage；`ops_edit_file` 按契约修常量；`ops_write_file` 写 `answer.txt` |
+| `noisy-test-triage` | 2400 个测试、恰好一行 `not ok` | 精确提取：跑测试重定向到文件，在日志里只捞那一行失败测试名写入 `failure.txt`（必须精确匹配），且 runner 仍退 1 是 invariant | `ops_bash` 跑并重定向；`ops_grep` 只捞那一行（如 `^not ok`，可配 `outputMode: summary/content`）；必要时 `ops_read_files`；`ops_write_file` 写结果 |
diff --git a/bench/cli.mjs b/bench/cli.mjs
index 439e1b09..853f765c 100644
--- a/bench/cli.mjs
+++ b/bench/cli.mjs
@@ -69,7 +69,7 @@ export function abUsage() {
     '                            [--base <label>] [--cand <label>] [--show] [runner flags...]',
     '',
     'Runs the baseline side, the candidate side, then the comparison, all inside ONE',
-    'bench/runs/benchmark-test-NN group: the number is allocated once here because a',
+    'bench/runs/benchmark-YYYY-MM-DD-NN group: the name is allocated once here because a',
     'per-process default would put each side in a different group and leave nothing to pair.',
     'Flag meanings are in `--help`; the group is created by the runner (P7/P8) and the',
     'comparison by P11.',
@@ -114,15 +114,16 @@ export function parseAbArgs(argv) {
  * sharing the one group folder allocated here. Pure: it reserves the name but writes
  * nothing, so `--show` and a real run report the same plan.
  * @param {string[]} argv - the `ab` arguments, parsed by {@link parseAbArgs}.
- * @param {{runsDir?: string, repoRoot?: string}} [options] - where group folders live and
- *   the checkout the three commands run in; injectable so a suite allocates nothing real.
+ * @param {{runsDir?: string, repoRoot?: string, now?: Date}} [options] - where group folders live,
+ *   the checkout the three commands run in, and the clock the auto folder name stamps
+ *   (injectable so a suite allocates nothing real and asserts exact names).
  * @returns {{base: string, cand: string, tasks: string[], repeat: string|null, folder: string, show: boolean, extra: string[], help: boolean, allocated: boolean, commands: {label: string, target: string, args: string[], argv: string[]}[], repoRoot: string}} the plan.
  */
 export function planAb(argv, options = {}) {
   const { runsDir = RUNS_DIR, repoRoot = REPO_ROOT } = options
   const parsed = parseAbArgs(argv)
   const allocated = parsed.folder === null
-  const folder = parsed.folder ?? nextFolderName(runsDir)
+  const folder = parsed.folder ?? nextFolderName(runsDir, options.now)
   const shared = parsed.tasks.flatMap((task) => ['--task', task])
   if (parsed.repeat !== null) shared.push('--repeat', parsed.repeat)
   shared.push('--folder', folder, ...parsed.extra)
diff --git a/bench/compare.mjs b/bench/compare.mjs
index 2c4bf3d5..dd5ccf01 100644
--- a/bench/compare.mjs
+++ b/bench/compare.mjs
@@ -15,18 +15,14 @@
  * the two sides, calls it, and renders what it returned. With no noise floor the
  * report says so and abstains from every cost direction (`noise-floor-unknown`).
  *
- * The report opens with its fixed title and then the evidence a reviewer works
- * through — the per-task paired table, the pairs a failed side forced out of the cost
- * statistics, the A/A band, and the diagnostic sections #183 carried (per-task bucket
- * detail, the usage-bucket split and the token attribution), which say *why* the
- * number moved (a bigger per-request prompt is a tool-schema cost, extra steps are a
- * model-behaviour cost, fatter tool results are a context cost; the fixes are
- * opposite, so the report has to say which one it was) — and closes with the conclusion:
- * pass rate, paired token Δ, the noise band, whether a direction is readable and the
- * gate. None of the diagnostics can change the gate.
+ * The report opens with its fixed title and then the data a reviewer works
+ * through — the per-task paired table, the tool table and the diagnostic sections
+ * (per-task bucket detail, per-request overhead) which say
+ * *why* the number moved. It prints no verdict prose and no side paths: the gate's
+ * verdict travels through the exit code and the comparison document, not the markdown.
  *
- * Time is evidence only: the comparison never reads `durationMs`, and nothing here
- * turns a duration into a verdict.
+ * Durations are displayed like any other metric (the per-task table's time column);
+ * the verdict's cost basis remains paired tokens.
  *
  * @module dsh-ops/bench/compare
  */
@@ -37,7 +33,6 @@ import { fileURLToPath } from 'node:url'
 
 import {
   AGGREGATES,
-  COMPARE_FORMAT,
   FAIL_ON,
   REGRESSION_SCOPES,
   compareSummaries,
@@ -52,8 +47,8 @@ const SEALED_RUN = 'run.json'
 const LEGACY_SUMMARY = 'summary.json'
 /** The summary document's format tag. */
 const SUMMARY_FORMAT = 'dsh-ops-bench-summary-v1'
-/** The report's fixed title; the two sides are named in Evidence, not in the heading. */
-const REPORT_TITLE = '# DSH-OPS Benchmark Report'
+/** The report's fixed title, marked (beta); the two sides are named in Evidence, not in the heading. */
+const REPORT_TITLE = '# DSH-OPS Benchmark Report (beta)'
 /** The file name stem: the title's words, so the artifact is recognizable in a folder listing. */
 const REPORT_STEM = 'DSH-OPS Benchmark Report'
 /** The panel's palette: the report and `panel.html` must agree on what green and red mean. */
@@ -343,17 +338,6 @@ function signed(value) {
   return `${rounded > 0 ? '+' : rounded < 0 ? MINUS : ''}${Math.abs(rounded).toLocaleString('en-US')}`
 }
 
-/**
- * Paint every percent inside a string the core produced. Gate reasons and warnings are
- * quoted verbatim — the digits stay the core's, only the colour is added — so they read
- * in the same two colours as the percents this module formats itself.
- * @param {string} text - the core's string.
- * @returns {string} the same text, percents wrapped.
- */
-function paintPercents(text) {
-  return text.replace(/[+-]?\d+(?:\.\d+)?%/g, (whole) => color(whole, Number.parseFloat(whole)))
-}
-
 /**
  * Paint one rendered value: a drop (or no change) is green, a rise is red — the same
  * two colours `panel.html` uses, inline because a markdown file cannot carry a
@@ -373,69 +357,6 @@ function percent(value) {
   return color(`${value > 0 ? '+' : value < 0 ? MINUS : ''}${Math.abs(value).toFixed(1)}%`, value)
 }
 
-/**
- * A percent the core stated as a bare number — a band half-width, a tolerance, a share
- * of the delta. Printed verbatim (no sign is invented) and painted like every other
- * percent in the report.
- * @param {number|null} value - the number, with `%` appended as-is.
- * @returns {string} the painted text.
- */
-function rawPercent(value) {
-  if (value === null || value === undefined || !Number.isFinite(value)) return 'n/a'
-  return color(`${value}%`, value)
-}
-
-/**
- * The direction sentence — the one place the three noise outcomes are worded.
- * The core's conclusion names travel verbatim so the report and the JSON cannot drift.
- * @param {object} cost - `verdict.cost` from the comparison.
- * @returns {string} the sentence.
- */
-function directionSentence(cost) {
-  if (cost.conclusion === 'incomparable') {
-    return 'Direction: no pair passed on both sides with complete usage ⇒ cost is incomparable; no direction is read'
-  }
-  if (cost.conclusion === 'noise-floor-unknown') {
-    return `Direction: Δ ${percent(cost.pct)}, but the noise floor is unknown ⇒ abstaining, no direction is read (noise-floor-unknown); supply one with --noise-floor-pct N or --noise <base> <cand>`
-  }
-  if (cost.conclusion === 'within-noise') {
-    return `Direction: Δ ${percent(cost.pct)} sits inside the noise band ±${rawPercent(cost.noiseFloorPct)} ⇒ interval only, no direction is read (within-noise)`
-  }
-  if (cost.conclusion === 'cheaper' || cost.conclusion === 'costlier') {
-    return `Direction: Δ ${percent(cost.pct)}, beyond the noise floor ±${rawPercent(cost.noiseFloorPct)} ⇒ readable direction: ${cost.conclusion}`
-  }
-  return `Direction: Δ ${percent(cost.pct)}, no readable direction (${cost.conclusion ?? 'no-change'})`
-}
-
-/**
- * The conclusion that closes the report: pass rate, paired token Δ, noise floor, direction
- * and gate, in that order, plus the reasons the gate gave. It ends the document, so a
- * reviewer meets the verdict after the evidence instead of before it.
- * @param {object} comparison - the comparison structure.
- * @returns {string[]} the section lines.
- */
-function verdictSection(comparison) {
-  const { gate, totals, verdict, noiseFloor } = comparison
-  const passes = `${totals.basePasses}/${totals.baseRuns} → ${totals.candPasses}/${totals.candRuns}`
-  const pairs = `${gate.usablePairs}/${gate.usablePairs + gate.excludedPairs}`
-  const tokenLine = gate.tokensComparable && gate.costComparable
-    ? `💰 tokens (paired ${pairs}): ${number(totals.baseGrandTotal)} → ${number(totals.candGrandTotal)}, Δ ${percent(totals.grandTotalPct)}`
-    : `💰 tokens: incomparable (${gate.tokensComparable ? `no pair passed on both sides, ${gate.excludedPairs} pair(s) excluded` : 'usage incomplete on at least one side'})`
-  const gateLine = gate.fail ? `🚦 failed (${gate.primary})` : '🚦 passed'
-  const lines = [
-    '## Conclusion',
-    '',
-    `- pass rate: ${passes}${gate.passDropFailed ? ' (drop; decided before cost)' : totals.candPassRate > totals.basePassRate ? ' (up)' : ' (flat)'}`,
-    `- ${tokenLine.replace('💰 ', '')}`,
-    `- noise floor (A/A): ${noiseFloor.comparable ? `±${rawPercent(noiseFloor.pct)}, method \`${noiseFloor.method}\`` : 'unknown (noise-floor-unknown)'}`,
-    `- ${directionSentence(verdict.cost)}`,
-    `- gate: ${gateLine} · \`--fail-on ${gate.failOn}\` · regression scope \`${gate.regressionScope}\` · tolerance ${rawPercent(gate.tolerancePct)} · cost basis \`${gate.costBasis}\``,
-    `- basis: ${comparison.aggregate} · profile ${comparison.base.profile ?? '?'} → ${comparison.cand.profile ?? '?'} · model ${comparison.base.model ?? '?'} → ${comparison.cand.model ?? '?'}`,
-  ]
-  for (const reason of gate.reasons) lines.push(`- reason: ${paintPercents(reason)}`)
-  return lines
-}
-
 /**
  * The per-task paired table: cost, the behaviour behind it (steps, tool calls, tool
  * errors) and the pass migration, all on the row a reviewer reads first.
@@ -445,25 +366,28 @@ function verdictSection(comparison) {
 function taskSection(comparison) {
   const { totals } = comparison
   const useMin = comparison.aggregate === 'min'
-  const keys = { steps: useMin ? 'stepsMin' : 'stepsMedian', toolCalls: useMin ? 'toolCallsMin' : 'toolCallsMedian', toolErrors: useMin ? 'toolErrorsMin' : 'toolErrorsMedian' }
+  const keys = { steps: useMin ? 'stepsMin' : 'stepsMedian', toolCalls: useMin ? 'toolCallsMin' : 'toolCallsMedian', toolErrors: useMin ? 'toolErrorsMin' : 'toolErrorsMedian', duration: useMin ? 'durationMsMin' : 'durationMsMedian' }
   // The change rides inside the cell it belongs to (`1,050 (+5.0%)`, `4 → 3 (−25%)`):
   // one number per row, with its Δ% in parentheses rather than a column of its own.
   const candCell = (value, pct) => `${number(value)}${Number.isFinite(pct) ? ` (${percent(pct)})` : ''}`
   const deltaCell = (baseValue, candValue, pct) => `${count(baseValue)} → ${count(candValue)}${Number.isFinite(pct) ? ` (${percent(pct)})` : ''}`
   const countCell = (baseValue, candValue) => `${count(baseValue)} → ${count(candValue)}`
+  // Time renders like every other metric: same aggregate, same direction colouring.
+  const seconds = (ms) => (Number.isFinite(ms) ? `${(ms / 1000).toFixed(1)}s` : '—')
+  const timeCell = (baseMs, candMs, pct) => `${seconds(baseMs)} → ${seconds(candMs)}${Number.isFinite(pct) ? ` (${percent(pct)})` : ''}`
   const passCell = (side) => `${side.base.passed}/${side.base.repeats}→${side.cand.passed}/${side.cand.repeats}`
   const lines = [
     '## Per-task pairs',
     '',
-    '| task | base | cand (Δ%) | steps base→cand (Δ%) | tool calls base→cand (Δ%) | tool errors | pass |',
-    '| --- | --- | --- | --- | --- | --- | --- |',
+    '| task | base | ops (Δ%) | steps: base→ops (Δ%) | tool calls: base→ops (Δ%) | time: base→ops (Δ%) | tool errors | pass |',
+    '| --- | --- | --- | --- | --- | --- | --- | --- |',
   ]
   for (const task of comparison.tasks) {
     const pair = task.paired
-    const name = task.inBase && task.inCand ? task.id : `${task.id}${task.inBase ? '(base only)' : '(cand only)'}`
-    lines.push(`| ${name} | ${number(pair.baseValue)} | ${candCell(pair.candValue, pair.pct)} | ${deltaCell(task.base[keys.steps], task.cand[keys.steps], task.delta.stepsPct)} | ${deltaCell(task.base[keys.toolCalls], task.cand[keys.toolCalls], task.delta.toolCallsPct)} | ${countCell(task.base[keys.toolErrors], task.cand[keys.toolErrors])} | ${passCell(task)} |`)
+    const name = task.inBase && task.inCand ? task.id : `${task.id}${task.inBase ? '(base only)' : '(ops only)'}`
+    lines.push(`| ${name} | ${number(pair.baseValue)} | ${candCell(pair.candValue, pair.pct)} | ${deltaCell(task.base[keys.steps], task.cand[keys.steps], task.delta.stepsPct)} | ${deltaCell(task.base[keys.toolCalls], task.cand[keys.toolCalls], task.delta.toolCallsPct)} | ${timeCell(task.base[keys.duration], task.cand[keys.duration], task.delta.durationPct)} | ${countCell(task.base[keys.toolErrors], task.cand[keys.toolErrors])} | ${passCell(task)} |`)
   }
-  lines.push(`| **TOTAL** | ${number(totals.baseGrandTotal)} | ${candCell(totals.candGrandTotal, totals.grandTotalPct)} | ${deltaCell(totals.baseSteps, totals.candSteps, percentChange(totals.baseSteps, totals.candSteps))} | ${deltaCell(totals.baseToolCalls, totals.candToolCalls, percentChange(totals.baseToolCalls, totals.candToolCalls))} | ${countCell(totals.baseToolErrors, totals.candToolErrors)} | ${totals.basePasses}/${totals.baseRuns}→${totals.candPasses}/${totals.candRuns} |`)
+  lines.push(`| **TOTAL** | ${number(totals.baseGrandTotal)} | ${candCell(totals.candGrandTotal, totals.grandTotalPct)} | ${deltaCell(totals.baseSteps, totals.candSteps, percentChange(totals.baseSteps, totals.candSteps))} | ${deltaCell(totals.baseToolCalls, totals.candToolCalls, percentChange(totals.baseToolCalls, totals.candToolCalls))} | ${timeCell(totals.baseDurationMs, totals.candDurationMs, percentChange(totals.baseDurationMs, totals.candDurationMs))} | ${countCell(totals.baseToolErrors, totals.candToolErrors)} | ${totals.basePasses}/${totals.baseRuns}→${totals.candPasses}/${totals.candRuns} |`)
   return lines
 }
 
@@ -477,9 +401,9 @@ function bucketSection(comparison) {
   const keys = { input: useMin ? 'inputMin' : 'inputMedian', output: useMin ? 'outputMin' : 'outputMedian', cacheRead: useMin ? 'cacheReadMin' : 'cacheReadMedian' }
   const cell = (baseValue, candValue) => `${number(baseValue)} → ${number(candValue)} (${percent(percentChange(baseValue, candValue))})`
   const lines = [
-    `## Per-task bucket detail (${comparison.aggregate})`,
+    '## Per-task bucket detail',
     '',
-    '| task | input base→cand (Δ%) | output base→cand (Δ%) | cache read base→cand (Δ%) |',
+    '| task | input: base→ops (Δ%) | output: base→ops (Δ%) | cache read: base→ops (Δ%) |',
     '| --- | --- | --- | --- |',
   ]
   for (const task of comparison.tasks) {
@@ -493,53 +417,33 @@ function bucketSection(comparison) {
 }
 
 /**
- * The usage split: how the TOTAL delta divides between uncached input, output and
- * cache reads, with each bucket's share of the delta. The gate judges the total.
+ * The per-request overhead table: the first request of a run carries no history, so its
+ * delta is the fixed cost a tool surface or prompt policy adds, paid on every request.
+ * Archives without `metrics.prompt` cannot separate that request, so the section says
+ * so instead of inventing numbers.
  * @param {object} comparison - the comparison structure.
  * @returns {string[]} the section lines.
  */
-function usageSplitSection(comparison) {
-  const buckets = comparison.totals.buckets
-  const lines = [`## usage split (TOTAL, ${comparison.aggregate})`, '']
-  if (!buckets.comparable) {
-    lines.push('Skipped: at least one side lost `step_end.usage`, so per-bucket Δs would present a lower bound as a measurement.')
+function overheadSection(comparison) {
+  const lines = ['## Per-request overhead (what every request costs before any work)', '']
+  const prompted = comparison.tasks.some((task) => Number.isFinite(task.base.firstRequestPromptMedian) || Number.isFinite(task.cand.firstRequestPromptMedian))
+  if (!prompted) {
+    lines.push('Skipped: neither side recorded `metrics.prompt`, so the first request cannot be separated from the run.')
     return lines
   }
-  const row = (label, bucket) => `| ${label} | ${number(bucket.base)} | ${number(bucket.cand)} | ${signed(bucket.delta)} (${percent(percentChange(bucket.base, bucket.cand))}) | ${rawPercent(bucket.sharePct)} |`
+  const firstCell = (task) => {
+    const base = task.base.firstRequestPromptMedian
+    const cand = task.cand.firstRequestPromptMedian
+    if (!Number.isFinite(base) || !Number.isFinite(cand)) return 'n/a'
+    return `${number(base)} → ${number(cand)} (${signed(task.delta.firstRequestPromptAbs)}, ${percent(task.delta.firstRequestPromptPct)})`
+  }
   lines.push(
-    '| bucket | base | cand | Δ (Δ%) | share of Δ |',
-    '| --- | --- | --- | --- | --- |',
-    row('uncached input', buckets.input),
-    row('output', buckets.output),
-    row('cache read', buckets.cacheRead),
-    row('**TOTAL**', buckets.grandTotal),
+    '| task | first request: base→ops |',
+    '| --- | --- |',
   )
-  return lines
-}
-
-/**
- * The behaviour behind the token delta: steps and tool calls, per task and summed.
- * The extra-steps term in token attribution is this table's Δ steps at the baseline's prompt
- * size, so a cost move can be read against the behaviour that produced it. Neither
- * count can change the gate.
- * @param {object} comparison - the comparison structure.
- * @returns {string[]} the section lines.
- */
-function stepsSection(comparison) {
-  const useMin = comparison.aggregate === 'min'
-  const keys = { steps: useMin ? 'stepsMin' : 'stepsMedian', toolCalls: useMin ? 'toolCallsMin' : 'toolCallsMedian' }
-  const cell = (baseValue, candValue, pct) => `${count(baseValue)} → ${count(candValue)} (${percent(pct)})`
-  const lines = [
-    `## steps and tool calls (${comparison.aggregate})`,
-    '',
-    '| task | steps base→cand (Δ%) | tool calls base→cand (Δ%) |',
-    '| --- | --- | --- |',
-  ]
   for (const task of comparison.tasks) {
-    lines.push(`| ${task.id} | ${cell(task.base[keys.steps], task.cand[keys.steps], task.delta.stepsPct)} | ${cell(task.base[keys.toolCalls], task.cand[keys.toolCalls], task.delta.toolCallsPct)} |`)
+    lines.push(`| ${task.id} | ${firstCell(task)} |`)
   }
-  const totals = comparison.totals
-  lines.push(`| **TOTAL** | ${cell(totals.baseSteps, totals.candSteps, percentChange(totals.baseSteps, totals.candSteps))} | ${cell(totals.baseToolCalls, totals.candToolCalls, percentChange(totals.baseToolCalls, totals.candToolCalls))} |`)
   return lines
 }
 
@@ -575,7 +479,7 @@ function toolSection(comparison) {
     }
     return { id: task.id, counts }
   })
-  const lines = ['## Tool calls (per-side overlap counts)', '']
+  const lines = ['## Tool calls', '']
   if (totals.size === 0) {
     lines.push('Skipped: neither side recorded `toolCallsByName`.')
     return lines
@@ -589,7 +493,7 @@ function toolSection(comparison) {
   const cell = (name, counts) => (counts ? `${number(counts.base)} → ${cand(name, counts)}` : '—')
   const rows = [...totals.entries()].sort((left, right) => (Number(own(right[0])) - Number(own(left[0]))) || (right[1].cand - left[1].cand) || left[0].localeCompare(right[0]))
   lines.push(
-    `| tool | base | cand | ${comparison.tasks.map((task) => task.id).join(' | ')} |`,
+    `| tool | base | ops | ${comparison.tasks.map((task) => task.id).join(' | ')} |`,
     `| --- | --- | --- | ${comparison.tasks.map(() => '---').join(' | ')} |`,
   )
   for (const [name, counts] of rows) {
@@ -599,28 +503,16 @@ function toolSection(comparison) {
   return lines
 }
 
-/**
- * Every warning the core recorded (model mismatch, incomplete usage, one-sided
- * tasks, pairing leftovers) — nothing measured is allowed to disappear quietly.
- * @param {object} comparison - the comparison structure.
- * @returns {string[]} the section lines.
- */
-function warningSection(comparison) {
-  if (comparison.warnings.length === 0) return ['## Warnings', '', 'No warnings.']
-  return ['## Warnings', '', ...comparison.warnings.map((warning) => `- ${paintPercents(warning)}`)]
-}
-
 /**
  * Render the comparison as the report document — the text `reportFileName` names and
  * `main` writes.
  *
- * Pure: same comparison and sources in, byte-identical text out. No timestamps are
- * written, so the report is reproducible and diffable.
+ * Pure: same comparison in, byte-identical text out. No timestamps are written, so the
+ * report is reproducible and diffable.
  * @param {object} comparison - the structure from `compareSummaries`.
- * @param {{base?: object, cand?: object}} [sources] - the two resolved sides.
  * @returns {string} the report text (no trailing newline).
  */
-export function renderReport(comparison, sources = {}) {
+export function renderReport(comparison) {
   const lines = [
     REPORT_TITLE,
     '',
@@ -630,21 +522,7 @@ export function renderReport(comparison, sources = {}) {
     '',
     ...bucketSection(comparison),
     '',
-    ...usageSplitSection(comparison),
-    '',
-    ...stepsSection(comparison),
-    '',
-    ...warningSection(comparison),
-    '',
-    '## Evidence',
-    '',
-    `- base:${sources.base?.file ?? '?'}(spec \`${sources.base?.spec ?? '?'}\`,${sources.base?.kind ?? '?'})`,
-    `- cand:${sources.cand?.file ?? '?'}(spec \`${sources.cand?.spec ?? '?'}\`,${sources.cand?.kind ?? '?'})`,
-    `- document: format \`${comparison.format}\` · aggregate \`${comparison.aggregate}\` · tolerance ${rawPercent(comparison.tolerancePct)}`,
-    '',
-    `Time fields are evidence only: the cost basis of this report is paired tokens, and the comparison does not read duration into the verdict (${COMPARE_FORMAT} carries no time statistics).`,
-    '',
-    ...verdictSection(comparison),
+    ...overheadSection(comparison),
   ]
   return lines.join('\n')
 }
@@ -755,13 +633,9 @@ export async function main(argv, io = {}) {
     noiseFloorPct: options.noiseFloorPct ?? undefined,
     noise: noise ?? undefined,
   })
-  const sources = {
-    base: { spec: options.base, file: base.file, kind: base.kind },
-    cand: { spec: options.cand, file: cand.file, kind: cand.kind },
-  }
   const payload = options.json
     ? `${JSON.stringify(comparison, null, 2)}\n`
-    : `${renderReport(comparison, sources)}\n`
+    : `${renderReport(comparison)}\n`
   out(payload)
 
   const target = reportPath(options, cand, now())
diff --git a/bench/lib/compare-core.mjs b/bench/lib/compare-core.mjs
index 736eada4..9197c1c4 100644
--- a/bench/lib/compare-core.mjs
+++ b/bench/lib/compare-core.mjs
@@ -228,6 +228,10 @@ export function aggregateTask(metricsList = []) {
   const steps = numeric((metrics) => metrics?.steps ?? 0)
   const toolCalls = numeric((metrics) => metrics?.toolCalls ?? 0)
   const toolErrors = numeric((metrics) => metrics?.toolErrors ?? 0)
+  // Wall-clock per repeat, aggregated like steps. A failed row records 0 ms (it never
+  // ran), which drags the median down exactly the way a 0-steps row does — the pass
+  // columns are what tell the reader which rows actually measured something.
+  const durations = numeric((metrics) => metrics?.durationMs ?? 0)
   // The prompt shape: the first request (no history yet — system prompt + tool
   // schemas + task text) is the per-request fixed cost, and the per-step average
   // says how much context each subsequent request re-sent. Older archives predate
@@ -282,6 +286,8 @@ export function aggregateTask(metricsList = []) {
     stepsMin: minValue(steps),
     toolCallsMedian: median(toolCalls),
     toolCallsMin: minValue(toolCalls),
+    durationMsMedian: median(durations),
+    durationMsMin: minValue(durations),
     toolCallsByName,
     toolErrorsMedian: median(toolErrors),
     toolErrorsMin: minValue(toolErrors),
@@ -368,6 +374,7 @@ function statisticKeys(aggregate) {
     toolsKey: useMin ? 'toolCallsMin' : 'toolCallsMedian',
     errorsKey: useMin ? 'toolErrorsMin' : 'toolErrorsMedian',
     firstPromptKey: useMin ? 'firstRequestPromptMin' : 'firstRequestPromptMedian',
+    durationKey: useMin ? 'durationMsMin' : 'durationMsMedian',
     promptTotalKey: useMin ? 'promptTotalMin' : 'promptTotalMedian',
     inputKey: useMin ? 'inputMin' : 'inputMedian',
     outputKey: useMin ? 'outputMin' : 'outputMedian',
@@ -745,6 +752,7 @@ export function compareSummaries(base, cand, options = {}) {
         stepsPct: percentChange(baseSide[keys.stepsKey], candSide[keys.stepsKey]),
         toolCallsPct: percentChange(baseSide[keys.toolsKey], candSide[keys.toolsKey]),
         toolErrorsPct: percentChange(baseSide[keys.errorsKey], candSide[keys.errorsKey]),
+        durationPct: percentChange(baseSide[keys.durationKey], candSide[keys.durationKey]),
         passRateAbs: candSide.passRate - baseSide.passRate,
       },
     }
@@ -874,6 +882,8 @@ export function compareSummaries(base, cand, options = {}) {
       candToolCalls: sumStat(tasks, (task) => task.cand[keys.toolsKey]),
       baseToolErrors: sumStat(tasks, (task) => task.base[keys.errorsKey]),
       candToolErrors: sumStat(tasks, (task) => task.cand[keys.errorsKey]),
+      baseDurationMs: sumStat(tasks, (task) => task.base[keys.durationKey]),
+      candDurationMs: sumStat(tasks, (task) => task.cand[keys.durationKey]),
       basePasses,
       baseRuns: baseRunsCount,
       candPasses,
diff --git a/bench/lib/next-folder.mjs b/bench/lib/next-folder.mjs
index 59892e27..4f7b41e3 100644
--- a/bench/lib/next-folder.mjs
+++ b/bench/lib/next-folder.mjs
@@ -1,17 +1,18 @@
 #!/usr/bin/env node
 /**
- * Allocate the next free `benchmark-test-NN` group directory under `bench/runs/`.
+ * Allocate the next free date-stamped group directory under `bench/runs/`.
  *
- * `ab` allocates this **exactly once per sweep** and hands the answer to both sides
- * and to the comparison: letting each process default on its own would put the
- * baseline in `benchmark-test-01` and the candidate in `benchmark-test-02` (that
- * group exists by then), and the comparison would have nothing to pair.
+ * The default name is `benchmark-YYYY-MM-DD-NN` — the local calendar date, numbered
+ * from `-00` — and `ab` allocates it **exactly once per sweep**, handing the answer
+ * to both sides and to the comparison: letting each process default on its own would
+ * put the baseline and the candidate in two different groups, and the comparison
+ * would have nothing to pair.
  *
  * The scan is read-only and non-exclusive on purpose: two sweeps started in the same
- * instant can both see `benchmark-test-01` free, and the failure mode is two runs
- * landing in one group — visible in the report, never lost data. A number is skipped
- * when *any* entry has that name, so a leftover empty directory from a failed sweep
- * is skipped rather than reused.
+ * instant can both see `-00` free, and the failure mode is two runs landing in one
+ * group — visible in the report, never lost data. A number is skipped when *any* entry
+ * has that name, so a leftover empty directory from a failed sweep is skipped rather
+ * than reused.
  *
  * @module dsh-ops/bench/next-folder
  */
@@ -24,10 +25,23 @@ import { BENCH_DIR } from './env.mjs'
 /** Where `run.json` archives land, one directory per sweep. */
 export const RUNS_DIR = path.join(BENCH_DIR, 'runs')
 /** The group prefix both the CLI help text and this scan agree on. */
-export const FOLDER_PREFIX = 'benchmark-test-'
-/** Zero-padded to two digits; numbers past 99 simply grow (`benchmark-test-100`). */
+export const FOLDER_PREFIX = 'benchmark-'
+/** Zero-padded to two digits; numbers past 99 simply grow (`benchmark-2026-10-24-100`). */
 const WIDTH = 2
 
+/**
+ * The local calendar date of `now` as `YYYY-MM-DD`.
+ * @param {Date} [now] - the instant to stamp (default the current time).
+ * @returns {string} the zero-padded local date.
+ */
+export function dayStamp(now = new Date()) {
+  return [
+    String(now.getFullYear()).padStart(4, '0'),
+    String(now.getMonth() + 1).padStart(2, '0'),
+    String(now.getDate()).padStart(2, '0'),
+  ].join('-')
+}
+
 /**
  * The group names already present under the runs root, lower-cased so the answer
  * holds on a case-insensitive filesystem (Windows) as well as a case-sensitive one.
@@ -45,14 +59,17 @@ export function takenFolders(runsDir) {
 }
 
 /**
- * The first `benchmark-test-NN` nobody is using yet.
+ * The first `benchmark-YYYY-MM-DD-NN` nobody is using yet.
  * @param {string} [runsDir] - the runs root to scan (default {@link RUNS_DIR}).
- * @returns {string} the free group name, zero-padded to two digits.
+ * @param {Date} [now] - the instant whose local date names the group (default now);
+ *   injectable so a suite can assert exact names instead of patterns.
+ * @returns {string} the free group name, numbered from `-00` on that date.
  */
-export function nextFolderName(runsDir = RUNS_DIR) {
+export function nextFolderName(runsDir = RUNS_DIR, now = new Date()) {
   const taken = takenFolders(runsDir)
-  for (let number = 1; ; number += 1) {
-    const name = `${FOLDER_PREFIX}${String(number).padStart(WIDTH, '0')}`
+  const prefix = `${FOLDER_PREFIX}${dayStamp(now)}-`
+  for (let number = 0; ; number += 1) {
+    const name = `${prefix}${String(number).padStart(WIDTH, '0')}`
     if (!taken.has(name.toLowerCase())) return name
   }
 }
diff --git a/bench/llm.patch.example.yml b/bench/llm.patch.example.yml
index 9162da48..424feadd 100644
--- a/bench/llm.patch.example.yml
+++ b/bench/llm.patch.example.yml
@@ -1,44 +1,20 @@
-# dsh-ops benchmark —— LLM 路由 overlay 模板
-#
-# 用法（详见 bench/PLAN.md §8、bench/README.md）：
-#   1) 复制本文件为 bench/llm.patch.yml（已在 .gitignore，不进仓库）；
-#   2) 填写你的 OpenAI 兼容服务器与模型 id（下面所有 <...> 占位符）；
-#   3) 设置 apiKeyEnv 指向的环境变量（如 BENCH_SERVER_API_KEY），
-#      密钥只放环境变量或 $DSH_HOME/.credentials.yaml，**绝不写进本文件**；
-#   4) node bench/run.mjs 会自动把它以 --patch 传给每次 dsh 调用
-#      （含 dump-config 存档）→ bench-base / bench-ops 两侧
-#      provider/model 一致性由构造保证（PLAN §2.7）；
-#      换别的 overlay 用 --llm-patch <path>；确实不想用 overlay（两侧各跑
-#      各自 profile 自带的路由）用 --no-llm-patch，sweep 会把"两侧不共享
-#      任何路由"这句话说出口。文件不存在又没给 --no-llm-patch 时，
-#      runner 在 spawn 之前就拒绝（退 2），不会静默换一条路由开跑。
-#
-# 注意：
-#   - 路由名 bench-server 可自定，但 llm-pi-ai 与 agent-default-model
-#     两处必须一致；
-#   - api 按服务器协议选择，自托管（vLLM / sglang / llama.cpp 的
-#     OpenAI 兼容端点）用 openai-completions；
-#   - 服务器必须在流式响应里回报 usage（stream_options.include_usage），
-#     否则 harness 拒绝给出 token 结论（PLAN §2.6）；
-#   - contextWindow 要按模型真实窗口填：现有语料里最长的题峰值 prompt 约 2 万 token，
-#     这个值不影响它们；但填小了仍会让 compaction-basic（0.8 × contextWindow）
-#     提前触发压缩，想跑长上下文任务时尤其要注意；
-#   - patch 语义是"整段替换 config"：llm-pi-ai 的 config 只有 providers
-#     一个字段、agent-default-model 只有 provider/model，直接照抄结构即可。
+- insert:
+    - id: credentials-local
+      name: "@deepseek-ai/dsh-credentials-local"
 
 - id: llm-pi-ai
   config:
     providers:
       bench-server:
-        baseURL: https://<你的服务器>/v1
-        apiKeyEnv: BENCH_SERVER_API_KEY
+        baseURL: https://<your-server>/v1
+        apiKeyEnv: DSH_API_KEY_ENV_NAME
         api: openai-completions
         models:
-          - id: <模型id>
+          - id: <model-id>
             contextWindow: 262144
-            maxTokens: 16384
+            maxTokens: 32768
 
 - id: agent-default-model
   config:
     provider: bench-server
-    model: <模型id>
+    model: <model-id>
diff --git a/bench/run.mjs b/bench/run.mjs
index c6e66b34..84640ec9 100644
--- a/bench/run.mjs
+++ b/bench/run.mjs
@@ -8,9 +8,14 @@
  * `bench/run/schedule.mjs`. It does not spawn a child, does not aggregate and does not
  * judge: scheduling is `run/schedule.mjs`, one session is `run/session.mjs` (P7),
  * aggregation is `lib/aggregate.mjs` (P6), the verdict is `lib/compare-core.mjs`
- * (P11a), and sealing is the **injected** `io.seal` callback — `bench/run/seal.mjs`
- * (P8a) is not imported here, deliberately, so this slice lands while P8a is still in
- * flight; the wiring supplies it.
+ * (P11a), and sealing is opt-in: `--seal` writes the schema-validated `run.json` through
+ * `bench/run/seal.mjs` (P8a), while every sweep keeps each arm's `results/` and
+ * `summary.json` either way. A finished sweep also renders the markdown report from its
+ * own verdict (`compare.mjs`'s `renderReport`) into the group folder — `--no-report`
+ * skips it, and an interrupted sweep writes none, because a partial run is not a
+ * comparison. An injected `io.seal` supplies the document an embedder
+ * wants; the CLI spawns this entry as a child and cannot inject one, so the flag has to
+ * select the real seal rather than a missing slice.
  *
  * Why one process for both arms: the pre-#205 shape spawned one runner per arm, so
  * every baseline run happened before every candidate run and the machine's drift
@@ -26,14 +31,17 @@
 
 import fs from 'node:fs'
 import path from 'node:path'
+import { createHash } from 'node:crypto'
 import { spawnSync } from 'node:child_process'
 import { fileURLToPath } from 'node:url'
 
 import { EXIT, UsageError, planAb } from './cli.mjs'
-import { LLM_OVERLAY, REPO_ROOT, resolveDshEntry } from './lib/env.mjs'
+import { LLM_OVERLAY, REPO_ROOT, resolveDshEntry, spawnPlan } from './lib/env.mjs'
 import { TASKS_DIR, loadTasks, selectTasks } from './lib/tasks.mjs'
 import { RUNS_DIR } from './lib/next-folder.mjs'
 import { DEFAULT_REPEAT, armOrder, createInterrupt, planPairs, planSessions, repeatsById, runSweep } from './run/schedule.mjs'
+import { sealRun } from './run/seal.mjs'
+import { renderReport, reportFileName } from './compare.mjs'
 
 /** The runner-only flags that take a value; `--task`/`--repeat`/`--folder`/`--base`/`--cand` are parsed by the CLI. */
 const VALUE_FLAGS = ['--sleep-ms', '--out', '--heartbeat-ms', '--stall-ms', '--timeout', '--dsh', '--llm-patch', '--model']
@@ -58,7 +66,7 @@ export function abUsage() {
     '  --base <label>       baseline arm label, also its profile name (default bench-base)',
     '  --cand <label>       candidate arm label, also its profile name (default bench-ops)',
     '  --aa                 A/A mode: run the baseline twice and measure the noise floor; --cand is ignored',
-    '  --folder <name>      group directory under bench/runs (default: the next benchmark-test-NN)',
+    '  --folder <name>      group directory under bench/runs (default: the next free benchmark-YYYY-MM-DD-NN)',
     '  --out <dir>          the sweep directory outright; not with --folder',
     '  --sleep-ms N         fixed pause between pairs (default 0)',
     '  --heartbeat-ms N     per-session "still running" line (default 15000; 0 = off)',
@@ -73,12 +81,17 @@ export function abUsage() {
     '  --keep               keep each temporary workspace',
     '  --verbose            narrate every event line',
     '  --show               print the pair-by-pair plan and exit without running',
-    '  --no-seal            run without the injected seal callback (no run.json; said out loud)',
+    '  --seal               also seal the sweep into the schema-validated run.json (default:',
+    '                       every arm keeps results/ and summary.json, nothing else)',
+    '  --no-seal            explicit off; this is already the default, kept for old command lines',
+    '  --no-report          skip the markdown report a finished sweep writes into the group',
+    '                       folder (default: written; an interrupted sweep never writes one)',
     '  -h, --help           this text',
     '',
-    'Exit codes: 0 ok · 1 a failed sweep · 2 usage error · 3 sealing is not wired yet',
-    '(the caller injects P8a\'s sealRun as `io.seal`; without it, and without --no-seal,',
-    'nothing is spawned so no token is spent on an unsealable sweep).',
+    'Exit codes: 0 ok · 1 a failed sweep · 2 usage error',
+    'A finished sweep writes each arm\'s results/ and summary.json, the group folder\'s',
+    '"DSH-OPS Benchmark Report <UTC>.md", and --seal adds the schema-validated run.json',
+    'on top. `bench report` re-renders that report from the archives at any later time.',
   ].join('\n')
 }
 
@@ -109,7 +122,8 @@ export function parseRunArgs(argv, context = {}) {
     aa: false,
     verbose: false,
     keep: false,
-    noSeal: false,
+    seal: false,
+    noReport: false,
     noLlmPatch: false,
     sleepMs: 0,
     out: null,
@@ -125,7 +139,9 @@ export function parseRunArgs(argv, context = {}) {
     if (flag === '--aa') options.aa = true
     else if (flag === '--verbose' || flag === '-v') options.verbose = true
     else if (flag === '--keep') options.keep = true
-    else if (flag === '--no-seal') options.noSeal = true
+    else if (flag === '--seal') options.seal = true
+    else if (flag === '--no-seal') options.seal = false
+    else if (flag === '--no-report') options.noReport = true
     else if (flag === '--no-llm-patch') options.noLlmPatch = true
     else if (flag === '--label' || flag === '--profile') {
       throw new UsageError(`${flag} named one arm of a per-process run; \`ab\` runs both arms itself — use --base/--cand`)
@@ -192,6 +208,71 @@ export function resolveLlmPatch(options, context = {}) {
   return { path: overlay, implicit: true }
 }
 
+/**
+ * The default profile fingerprint probe: the composed configuration `dsh` reports for one
+ * profile. `setup` reads the same tree back to prove a pin really landed, so hashing it
+ * records what each arm ran rather than what its file was called.
+ * @param {{file: string, kind: 'js'|'exe'}} entry - the resolved dsh launcher.
+ * @param {string} profile - the profile name to dump.
+ * @param {{run?: Function, cwd?: string, env?: Record<string, string|undefined>}} [context] - injectable probe, directory and environment.
+ * @returns {string} the command's stdout and stderr.
+ * @throws {Error} when it cannot start or exits nonzero: an arm with no fingerprint is not evidence.
+ */
+export function dumpProfileConfig(entry, profile, context = {}) {
+  const plan = spawnPlan(entry, ['--profile', profile, '--dump-config'])
+  const result = (context.run ?? spawnSync)(plan.command, plan.args, {
+    cwd: context.cwd ?? REPO_ROOT,
+    env: context.env ?? process.env,
+    encoding: 'utf8',
+    timeout: 60_000,
+    windowsHide: true,
+    stdio: ['ignore', 'pipe', 'pipe'],
+  })
+  if (result.error) throw new Error(`could not run "dsh --profile ${profile} --dump-config": ${String(result.error.message ?? result.error)}`)
+  if (result.status !== 0) {
+    const detail = String(result.stderr ?? '').trim().split('\n').filter(Boolean).pop() ?? ''
+    throw new Error(`"dsh --profile ${profile} --dump-config" exited ${String(result.status)}${detail === '' ? '' : `: ${detail}`}`)
+  }
+  return `${result.stdout ?? ''}\n${result.stderr ?? ''}`
+}
+
+/**
+ * Fingerprint both arms: the SHA-256 of each profile's dumped configuration, which
+ * `bench/run.schema.json` records in `arms[]` and `sealRun` requires before it will seal.
+ * @param {{side: string, profile: string}[]} arms - the two arms of the sweep.
+ * @param {{entry?: object, dump?: (entry: object, profile: string, context: object) => string, env?: object}} [context] - the launcher and the injectable probe.
+ * @returns {Record<string, string>} the hex digest of each side's composed configuration.
+ * @throws {Error} when a dump prints nothing, naming the arm that has no fingerprint.
+ */
+export function profileFingerprints(arms, context = {}) {
+  const dump = context.dump ?? dumpProfileConfig
+  const hashes = {}
+  for (const arm of arms) {
+    const text = dump(context.entry, arm.profile, context)
+    if (typeof text !== 'string' || text.trim() === '') {
+      throw new Error(`"dsh --profile ${arm.profile} --dump-config" printed nothing, so the ${arm.side} arm has no profile fingerprint`)
+    }
+    hashes[arm.side] = createHash('sha256').update(text).digest('hex')
+  }
+  return hashes
+}
+
+/**
+ * The default seal: adapt the sweep's seal context to {@link sealRun}.
+ *
+ * The callback is handed the two arm directories as a `{base, cand}` map, while `sealRun`
+ * folds a list of sweep directories into one document and places `run.json` in their
+ * common parent (the group folder). Handing the map straight to `sealRun` fails on
+ * `dirs.map` — which no injected double could catch, because a double never inspects it.
+ * @param {{dirs: {base: string, cand: string}|string[], arms: object, meta?: object}} context - the seal context.
+ * @param {(options: object) => object} [seal] - the sealer, injectable so a suite can read what it is handed.
+ * @returns {object} the seal receipt.
+ */
+export function sealSweep(context, seal = sealRun) {
+  const dirs = Array.isArray(context.dirs) ? context.dirs : [context.dirs.base, context.dirs.cand]
+  return seal({ ...context, dirs })
+}
+
 /** The `<UTC stamp>-<label>` run directories, one per arm, under the sweep's group. */
 export function prepareDirs(options, arms, context = {}) {
   const runsDir = context.runsDir ?? RUNS_DIR
@@ -269,14 +350,46 @@ function printResult(out, err, result, options) {
     : `[ab] noise   : ${noise === null ? 'not measured (no --aa); cost direction withheld' : `±${noise.pct}% (${noise.method})`}`)
   if (result.compare?.gate?.fail === true) err(`[ab] verdict : FAIL — ${result.compare.gate.reasons.join('; ')}`)
   else out('[ab] verdict : pass (pass-rate gate)')
-  out(`[ab] sealed  : ${result.sealed?.path ?? (result.sealError ? `FAILED (${result.sealError})` : 'no — run.json was not written')}`)
+  out(`[ab] sealed  : ${result.sealed?.path ?? (result.sealError ? `FAILED (${result.sealError})` : 'no — not requested (--seal writes run.json)')}`)
+}
+
+/**
+ * The sweep's own report: the verdict it just computed, rendered through
+ * `compare.mjs`'s `renderReport` and written beside the arm directories — the group
+ * folder, or the `--out` sweep directory a custom one named. This is the `bench report`
+ * artifact produced without a second command; `bench report` still re-renders it later
+ * from the same summaries.
+ *
+ * An interrupted sweep writes none: the comparison of a partial run is not evidence, and
+ * a report-shaped file that looks complete while the sweep says PARTIAL would lie to a
+ * reviewer who opens it without the console.
+ * @param {object} result - the sweep result (`compare`, `arms`, `dirs`, `summaryFiles`,
+ *   `interrupted` as `runSweep` returned them).
+ * @param {{now?: Function, writeFile?: Function, mkdir?: Function}} [context] - the clock
+ *   the file name stamps and injectable sinks; defaults to the wall clock and `fs`.
+ * @returns {{target: string|null, skipped: string|null}} where the report landed, or why
+ *   it was skipped (`target: null`).
+ * @throws {Error} when rendering or writing fails — `main` reports that without turning
+ *   it into a sweep failure.
+ */
+export function sweepReport(result, context = {}) {
+  if (result.compare === null) return { target: null, skipped: 'no comparison ran' }
+  if (result.interrupted) return { target: null, skipped: 'a partial sweep is not a comparison' }
+  const now = context.now ?? Date.now
+  const write = context.writeFile ?? fs.writeFileSync
+  const mkdir = context.mkdir ?? fs.mkdirSync
+  const target = path.join(path.dirname(result.dirs.base), reportFileName(now()))
+  mkdir(path.dirname(target), { recursive: true })
+  write(target, `${renderReport(result.compare)}\n`, 'utf8')
+  return { target, skipped: null }
 }
 
 /**
  * Run the sweep. Every dependency is injectable through `io` so a test never spawns,
  * never reads `~/.dsh` and never touches a model: `io.seal`, `io.runSession`,
  * `io.sweep`, `io.observe`, `io.resolveEntry`, `io.now`, `io.sleep`, `io.kill`,
- * `io.tasksDir`, `io.runsDir`, `io.env`, `io.interrupt`, `io.profileHashes`.
+ * `io.tasksDir`, `io.runsDir`, `io.env`, `io.interrupt`, `io.profileHashes`,
+ * `io.dumpProfileConfig`.
  * @param {string[]} argv - the arguments after `ab`.
  * @param {object} [io] - the wiring and the sinks (`out`, `err`).
  * @returns {Promise<number>} the exit code.
@@ -300,8 +413,8 @@ export async function main(argv, io = {}) {
     out(abUsage())
     return EXIT.ok
   }
-  // Resolved before the seal guard and before any spawn: both are conditions under which a
-  // sweep would measure, or record, something other than what the operator asked for.
+  // Resolved before any spawn: a contradictory or absent overlay is a condition under which
+  // the sweep would measure something other than what the operator asked for.
   let patch
   try {
     patch = resolveLlmPatch(options, { overlay: io.llmOverlay, exists: io.overlayExists })
@@ -318,11 +431,11 @@ export async function main(argv, io = {}) {
     }
     patch = { path: null, implicit: false, refused: error.message }
   }
-  if (!options.show && options.noSeal !== true && typeof io.seal !== 'function') {
-    err('bench ab: sealing is not wired in this slice yet — P8a\'s bench/run/seal.mjs must be injected as io.seal.')
-    err('Nothing was spawned and no token was spent. Pass --no-seal to run an unsealed sweep (no run.json), or --show to just print the plan.')
-    return EXIT.pending
-  }
+  // Sealing is opt-in: a sweep always writes each arm's `results/` and `summary.json`, and
+  // `--seal` adds the schema-validated `run.json` on top. The CLI spawns this entry as a
+  // child and cannot inject a callback, so "sealed" means the flag plus either the injected
+  // `io.seal` (an embedder's own document) or the real seal in `bench/run/seal.mjs` (P8a).
+  const seal = options.seal !== true ? undefined : (typeof io.seal === 'function' ? io.seal : sealSweep)
 
   let tasks
   try {
@@ -332,8 +445,7 @@ export async function main(argv, io = {}) {
     return EXIT.usage
   }
   const repeats = repeatsById(tasks, { repeat: options.repeat, repeatExplicit: options.repeatExplicit })
-  const hashes = io.profileHashes ?? {}
-  const arms = buildArms(options).map((arm) => ({ ...arm, profileHash: hashes[arm.side] ?? null }))
+  const arms = buildArms(options)
   const { sweepDir, dirs } = prepareDirs(options, arms, io)
   const pairs = planPairs({ tasks, repeats })
   const sessions = planSessions({ tasks, repeats, arms })
@@ -362,8 +474,26 @@ export async function main(argv, io = {}) {
     return EXIT.failure
   }
 
+  // Before any session: an arm whose composed configuration cannot be read has no
+  // fingerprint, and a sweep that cannot be sealed is not evidence. Refusing here costs
+  // nothing; refusing after the sweep would have spent the tokens first.
+  let hashes = io.profileHashes ?? null
+  if (hashes === null && seal !== undefined) {
+    try {
+      hashes = profileFingerprints(arms, { entry, dump: io.dumpProfileConfig, env: io.env })
+    } catch (error) {
+      err(`bench ab: ${String(error?.message ?? error)}`)
+      err('nothing was spawned and no token was spent; run "node bench/cli.mjs setup" if the profiles are not prepared yet, or pass --no-seal to sweep without sealing.')
+      return EXIT.failure
+    }
+  }
+  for (const arm of arms) arm.profileHash = hashes?.[arm.side] ?? null
+  if (seal !== undefined) {
+    out(`[ab] profile : ${arms.map((arm) => `${arm.profile} ${arm.profileHash === null ? 'n/a' : arm.profileHash.slice(0, 12)}`).join('  ')}`)
+  }
+
   const interrupt = io.interrupt ?? createInterrupt()
-  const uninstall = (io.installSignals ?? true) === false ? () => {} : installSignals(interrupt, err, io)
+  const uninstall = (io.installSignals ?? true) === false ? () => { } : installSignals(interrupt, err, io)
   const log = (level, line) => (level === 'warn' ? err : out)(line)
   // The recorded command line names the overlay when the operator did not: a summary that
   // cannot say which route ran is not evidence of anything.
@@ -383,7 +513,7 @@ export async function main(argv, io = {}) {
       model: options.model,
       argv: recordedArgv,
     }, {
-      seal: options.noSeal === true ? undefined : io.seal,
+      seal,
       runSession: io.runSession,
       observe: io.observe,
       now: io.now,
@@ -405,6 +535,19 @@ export async function main(argv, io = {}) {
     uninstall()
   }
   printResult(out, err, result, options)
+  let report = { target: null, skipped: '--no-report' }
+  if (options.noReport !== true) {
+    try {
+      report = sweepReport(result, { now: io.now, writeFile: io.writeFile, mkdir: io.mkdir })
+    } catch (error) {
+      // The verdict is already computed and the summaries already written; a report that
+      // could not land is a loud note, not a failed sweep.
+      err(`[ab] report  : FAILED — ${String(error?.message ?? error)}`)
+      report = { target: null, skipped: null }
+    }
+  }
+  if (report.skipped !== null) out(`[ab] report  : not written (${report.skipped})`)
+  else if (report.target !== null) out(`[ab] report  : ${report.target}`)
   return exitFor(result)
 }
 
diff --git a/bench/run/schedule.mjs b/bench/run/schedule.mjs
index 210d4f87..bc821598 100644
--- a/bench/run/schedule.mjs
+++ b/bench/run/schedule.mjs
@@ -41,7 +41,7 @@ export const SUMMARY_FORMAT = 'dsh-ops-bench-summary-v1'
 /** The sweep document tag this module returns; the seal step turns it into run.json. */
 export const SWEEP_FORMAT = 'dsh-ops-bench-sweep-v1'
 /** Repeats per task when neither `--repeat` nor the task's own `repeat` field says. */
-export const DEFAULT_REPEAT = 3
+export const DEFAULT_REPEAT = 1
 /** The two sides an arm may play. `--aa` uses `base` twice, with distinct labels. */
 export const SIDES = ['base', 'cand']
 
@@ -450,7 +450,7 @@ export async function runSweep(spec = {}, options = {}) {
       observer.note('warn', `sealing failed: ${result.sealError} — the per-row archives and summary.json are on disk, but run.json was not written`)
     }
   } else {
-    observer.note('warn', 'no seal callback was injected: this sweep has results/ and summary.json, but no run.json')
+    observer.note('info', 'sealing was not requested: this sweep has results/ and summary.json, and no run.json')
   }
   observer.dispose?.()
   return result
diff --git a/bench/run/session.mjs b/bench/run/session.mjs
index b31f9c02..e1f01a3d 100644
--- a/bench/run/session.mjs
+++ b/bench/run/session.mjs
@@ -30,6 +30,8 @@ import { DEFAULT_TIMEOUT_MS } from '../lib/tasks.mjs'
 
 /** The five token buckets `run.schema.json $defs/usage` requires, in its order. */
 const USAGE_BUCKETS = ['inputTokens', 'outputTokens', 'cacheReadTokens', 'cacheWriteTokens', 'reasoningTokens']
+/** The buckets a step re-sends to the model: its prompt size. */
+const PROMPT_BUCKETS = ['inputTokens', 'cacheReadTokens', 'cacheWriteTokens']
 
 /** Cap on the stdout-close barrier; it matters only for a spawn that left a stream open. */
 const DEFAULT_STREAM_FLUSH_GRACE_MS = 1_000
@@ -136,9 +138,10 @@ export function toVerifyChecks(outcome) {
 /**
  * A streaming fold of the event stream into the schema's `metrics` fields, deliberately
  * narrow: steps, tool calls, tool errors, the five usage buckets, the all-or-nothing
- * `usageReported` and the last turn's end reason. Prompt-shape analysis belongs to the
- * aggregate slice; this keeps its invariant — one step without usage makes the totals a
- * lower bound.
+ * `usageReported`, the prompt shape the report's per-request overhead table reads, and
+ * the last turn's end reason. This keeps the aggregate invariant — one step without
+ * usage makes the totals a lower bound, and one step without a prompt size makes the
+ * prompt summary incomplete.
  * @returns {{push(line: string): void, finish(): object}} the fold.
  */
 function createFold() {
@@ -149,6 +152,14 @@ function createFold() {
     toolErrors: 0,
     toolCallsByName: Object.create(null),
     usage: emptyUsage(),
+    // `promptSizes` is every step that reported a size, in order; `firstPrompt` is set
+    // only by the run's **first** step, so a run whose step 1 lost its usage reports an
+    // unknown first request instead of silently promoting step 2's smaller, already-warm
+    // prompt to "the request with no history".
+    promptSizes: [],
+    firstPrompt: null,
+    firstStepSeen: false,
+    turnFirsts: [],
     turnEndReason: null,
   }
   return {
@@ -164,7 +175,20 @@ function createFold() {
       if (event.type === 'status') {
         if (event.phase === 'step_end') {
           state.steps += 1
-          if (addUsage(state, event.usage)) state.stepsWithUsage += 1
+          const firstStep = !state.firstStepSeen
+          state.firstStepSeen = true
+          if (addUsage(state, event.usage)) {
+            state.stepsWithUsage += 1
+            const size = promptTokens(event.usage)
+            if (size !== null) {
+              state.promptSizes.push(size)
+              if (firstStep) state.firstPrompt = size
+              const turn = stepIndex(event.turn)
+              if (turn !== null && !state.turnFirsts.some((entry) => entry.turn === turn)) {
+                state.turnFirsts.push({ turn, tokens: size })
+              }
+            }
+          }
           return
         }
         if (event.phase === 'turn_end') {
@@ -190,6 +214,14 @@ function createFold() {
         toolCallsByName: { ...state.toolCallsByName },
         usage: { ...state.usage },
         usageReported: state.steps > 0 && state.stepsWithUsage === state.steps,
+        prompt: {
+          reported: state.steps > 0 && state.stepsWithUsage === state.steps && state.promptSizes.length === state.steps,
+          firstStep: state.firstPrompt,
+          median: state.promptSizes.length > 0 ? medianSize(state.promptSizes) : null,
+          max: state.promptSizes.length > 0 ? Math.max(...state.promptSizes) : null,
+          total: state.promptSizes.length > 0 ? state.promptSizes.reduce((sum, value) => sum + value, 0) : null,
+          perTurn: state.turnFirsts,
+        },
         turnEndReason: state.turnEndReason,
       }
     },
@@ -212,6 +244,43 @@ function addUsage(state, usage) {
   return true
 }
 
+/**
+ * One step's prompt size: the buckets re-sent to the model (input + cacheRead +
+ * cacheWrite), falling back to `totalTokens - outputTokens` when a provider reports
+ * only a total, and `null` when nothing usable is there.
+ * @param {object} usage - the `step_end` event's usage object.
+ * @returns {number|null} the prompt token count, or null.
+ */
+function promptTokens(usage) {
+  let sum = 0
+  let seen = false
+  for (const bucket of PROMPT_BUCKETS) {
+    const value = usage[bucket]
+    if (typeof value !== 'number' || !Number.isFinite(value)) continue
+    sum += Math.max(0, Math.round(value))
+    seen = true
+  }
+  if (seen) return sum
+  const total = usage.totalTokens
+  const output = usage.outputTokens
+  if (typeof total === 'number' && Number.isFinite(total)) {
+    return Math.max(0, Math.round(total) - (typeof output === 'number' && Number.isFinite(output) ? Math.round(output) : 0))
+  }
+  return null
+}
+
+/** A numeric event field as a number, or null. */
+function stepIndex(value) {
+  return typeof value === 'number' && Number.isFinite(value) ? value : null
+}
+
+/** The median of the step prompt sizes (the midpoint of an even count halves). */
+function medianSize(sizes) {
+  const sorted = [...sizes].sort((left, right) => left - right)
+  const mid = Math.floor(sorted.length / 2)
+  return sorted.length % 2 === 1 ? sorted[mid] : (sorted[mid - 1] + sorted[mid]) / 2
+}
+
 /**
  * Run one task × repeat: fixture → one headless session → archive → verdict.
  *
@@ -490,6 +559,7 @@ export async function runSession(spec, options = {}) {
       toolErrors: counted.toolErrors,
       usage: counted.usage,
       usageReported: counted.usageReported,
+      prompt: counted.prompt,
       toolCallsByName: counted.toolCallsByName,
       turnEndReason: counted.turnEndReason,
       // Identity and archive pointers the seal step lifts into `results[]` / `archive[]`.
diff --git a/bench/tasks/api-rename.task.json b/bench/tasks/api-rename.task.json
index 09a59a2a..5f9fb4d2 100644
--- a/bench/tasks/api-rename.task.json
+++ b/bench/tasks/api-rename.task.json
@@ -1,15 +1,15 @@
 {
   "id": "api-rename",
-  "title": "Rename one exported symbol across a 60-module tree using file tools only",
+  "title": "Rename one exported symbol across a 12-module tree using file tools only",
   "prompt": "In src/core.js the exported function parsePayload has to be renamed to decodePayload: its definition, every import of it, and every call site. parsePayloadLegacy and parsePayloadAsync are different functions and keep their own names. Change no behaviour, add or remove no file under src/, and leave check.mjs alone. Use the file tools to make every change; do not modify files with a shell command such as sed or a script. When you are done, node check.mjs must exit 0.",
   "fixture": {
     "generator": "symbolTree",
-    "params": { "seed": 31, "files": 60 }
+    "params": { "seed": 31, "files": 12 }
   },
   "verify": [
     { "type": "contentHashes", "dir": "src", "expect": "final" },
     { "type": "command", "command": "node", "args": ["check.mjs"], "exitCode": 0 }
   ],
-  "repeat": 2,
+  "repeat": 1,
   "timeoutMs": 1800000
 }
diff --git a/bench/tasks/big-file-paging.task.json b/bench/tasks/big-file-paging.task.json
index b14e74dc..d842c2a5 100644
--- a/bench/tasks/big-file-paging.task.json
+++ b/bench/tasks/big-file-paging.task.json
@@ -7,6 +7,6 @@
     "params": { "seed": 23, "lines": 4200, "env": "staging" }
   },
   "verify": [{ "type": "fileEquals", "path": "answer.txt", "expect": "answer" }],
-  "repeat": 2,
+  "repeat": 1,
   "timeoutMs": 900000
 }
diff --git a/bench/tasks/config-hunt.task.json b/bench/tasks/config-hunt.task.json
index 2ab684b9..7770aed8 100644
--- a/bench/tasks/config-hunt.task.json
+++ b/bench/tasks/config-hunt.task.json
@@ -7,6 +7,6 @@
     "params": { "seed": 21, "packages": 12, "env": "production" }
   },
   "verify": [{ "type": "fileEquals", "path": "answer.txt", "expect": "answer" }],
-  "repeat": 2,
+  "repeat": 1,
   "timeoutMs": 900000
 }
diff --git a/bench/tasks/csv-sum.task.json b/bench/tasks/csv-sum.task.json
index df862667..a96570f8 100644
--- a/bench/tasks/csv-sum.task.json
+++ b/bench/tasks/csv-sum.task.json
@@ -7,6 +7,6 @@
     "params": { "seed": 7, "rows": 8000, "targetRegion": "EU", "regions": ["EU", "US", "APAC", "LATAM"] }
   },
   "verify": [{ "type": "fileEquals", "path": "answer.txt", "expect": "sum" }],
-  "repeat": 2,
+  "repeat": 1,
   "timeoutMs": 900000
 }
diff --git a/bench/tasks/gate-repair-loop.task.json b/bench/tasks/gate-repair-loop.task.json
index a0caec2d..f2ac64d3 100644
--- a/bench/tasks/gate-repair-loop.task.json
+++ b/bench/tasks/gate-repair-loop.task.json
@@ -1,16 +1,16 @@
 {
   "id": "gate-repair-loop",
-  "title": "Repair a 24-stage release gate that stops at the first broken stage",
+  "title": "Repair a 12-stage release gate that stops at the first broken stage",
   "prompt": "check.js is a generated release gate. It loads the stage modules in gates/ (gates/gate_00.js, gates/gate_01.js, and so on) in order, validates each stage against fixed golden values, and stops at the first stage that disagrees; exit code 0 means every stage passed. Run it, find the failing stage, and repair the stage modules in gates/ until the gate passes. Each stage module documents its own contract; make the code agree with it. Do not change check.js or package.json, and do not add or remove files. When the gate exits 0 it prints the pipeline's final value; write that integer, and nothing else, into answer.txt.",
   "fixture": {
     "generator": "gatePipeline",
-    "params": { "seed": 53, "gates": 24, "probes": 40, "linesPerGate": 70 }
+    "params": { "seed": 53, "gates": 12, "probes": 40, "linesPerGate": 70 }
   },
   "verify": [
     { "type": "command", "command": "node", "args": ["check.js"], "exitCode": 0 },
     { "type": "fileEquals", "path": "answer.txt", "expect": "answer" },
     { "type": "fileEquals", "path": "check.js", "expect": "checkSource", "invariant": true }
   ],
-  "repeat": 2,
+  "repeat": 1,
   "timeoutMs": 2400000
 }
diff --git a/bench/tasks/noisy-test-triage.task.json b/bench/tasks/noisy-test-triage.task.json
index 16ac5694..c1b366fb 100644
--- a/bench/tasks/noisy-test-triage.task.json
+++ b/bench/tasks/noisy-test-triage.task.json
@@ -10,6 +10,6 @@
     { "type": "fileEquals", "path": "failure.txt", "expect": "failingName" },
     { "type": "command", "command": "node", "args": ["runner.js"], "exitCode": 1, "invariant": true }
   ],
-  "repeat": 2,
+  "repeat": 1,
   "timeoutMs": 900000
 }
diff --git a/test/bench-cli.test.mjs b/test/bench-cli.test.mjs
index b54894fd..c28f5ef7 100644
--- a/test/bench-cli.test.mjs
+++ b/test/bench-cli.test.mjs
@@ -78,7 +78,7 @@ await test('ab --show prints the three commands and this suite never starts a sw
   const text = lines.join('\n')
   assert.equal(text.split('\n').filter((line) => line.startsWith('node ')).length, 3, text)
   assert.match(text, /node bench\/run\.mjs --label bench-base --profile bench-base --task csv-sum/)
-  assert.match(text, /node bench\/compare\.mjs bench-base bench-ops --folder benchmark-test-\d+/)
+  assert.match(text, /node bench\/compare\.mjs bench-base bench-ops --folder benchmark-\d{4}-\d{2}-\d{2}-\d{2}/)
   // Only assert the pending path while the runner is genuinely absent: once it lands,
   // `abMain([])` would spawn a real session, and a unit suite must never do that.
   if (!fs.existsSync(path.join(PACKAGE_ROOT, 'bench/run.mjs'))) {
@@ -98,18 +98,20 @@ await test('ab parsing defaults, repeats --task, and rejects malformed flags', (
 })
 await test('next-folder hands one group to both sides and skips anything already named', async () => {
   await withTempDir('bench-runs', (runs) => {
-    assert.equal(nextFolderName(runs), `${FOLDER_PREFIX}01`)
+    const day = new Date(2026, 9, 24, 15, 42) // mid-day local 2026-10-24; the clock must not steer the name
+    const stamp = `${FOLDER_PREFIX}2026-10-24`
+    assert.equal(nextFolderName(runs, day), `${stamp}-00`)
     const explicit = planAb(['--folder', 'ops-1'], { runsDir: runs })
     assert.equal(explicit.folder, 'ops-1')
     assert.equal(explicit.allocated, false)
     assert.deepEqual(explicit.commands.map((command) => command.args.at(-1)), ['ops-1', 'ops-1', 'ops-1'])
-    fs.mkdirSync(path.join(runs, `${FOLDER_PREFIX}01`))
-    fs.mkdirSync(path.join(runs, `${FOLDER_PREFIX}02`))
-    fs.mkdirSync(path.join(runs, `${FOLDER_PREFIX.toUpperCase()}03`)) // Windows would collide with this one
+    fs.mkdirSync(path.join(runs, `${stamp}-00`))
+    fs.mkdirSync(path.join(runs, `${stamp}-01`))
+    fs.mkdirSync(path.join(runs, `${stamp.toUpperCase()}-02`)) // Windows would collide with this one
     fs.writeFileSync(path.join(runs, 'unrelated.txt'), '')
-    assert.equal(nextFolderName(runs), `${FOLDER_PREFIX}04`)
-    assert.ok(takenFolders(runs).has(`${FOLDER_PREFIX}01`))
-    assert.equal(planAb(['--task', 'x'], { runsDir: runs }).folder, `${FOLDER_PREFIX}04`)
+    assert.equal(nextFolderName(runs, day), `${stamp}-03`)
+    assert.ok(takenFolders(runs).has(`${stamp}-00`))
+    assert.equal(planAb(['--task', 'x'], { runsDir: runs, now: day }).folder, `${stamp}-03`)
   })
 })
 await test('a good task validates, gets its timeout defaulted, and round-trips through a directory', async () => {
@@ -184,7 +186,7 @@ await test('the spawn plan never uses a shim and keeps argv verbatim', () => {
   assert.equal(exe.command, '/usr/bin/dsh')
   assert.deepEqual(exe.args, ['--version'])
 })
-await test('run.schema.json parses, describes every property with a unit, and matches the README', () => {
+await test('run.schema.json parses and describes every property with a unit', () => {
   const schema = JSON.parse(fs.readFileSync(path.join(PACKAGE_ROOT, 'bench', 'run.schema.json'), 'utf8'))
   assert.equal(schema.$schema, 'https://json-schema.org/draft/2020-12/schema')
   assert.deepEqual([...schema.required].sort(), Object.keys(schema.properties).sort())
@@ -209,13 +211,6 @@ await test('run.schema.json parses, describes every property with a unit, and ma
   walk(schema, 'run.json')
   assert.deepEqual(missing, [], 'every property documents itself')
   assert.deepEqual(units, [], 'every numeric field names its unit')
-
-  const readme = fs.readFileSync(path.join(PACKAGE_ROOT, 'bench', 'README.md'), 'utf8')
-  const section = readme.split(/^## /m).find((part) => part.startsWith('run.json 契约'))
-  assert.ok(section, 'README documents the run.json contract')
-  const documented = [...section.matchAll(/^\|\s*`([A-Za-z][A-Za-z0-9]*)`\s*\|/gm)].map((match) => match[1])
-  assert.ok(documented.length > 0, 'the contract table has rows')
-  assert.deepEqual([...documented].sort(), Object.keys(schema.properties).sort())
 })
 
 report('bench-cli')
diff --git a/test/bench-compare-core.test.mjs b/test/bench-compare-core.test.mjs
index ed2405cc..00bd19ad 100644
--- a/test/bench-compare-core.test.mjs
+++ b/test/bench-compare-core.test.mjs
@@ -26,6 +26,7 @@ import {
   FAIL_ON,
   NOISE_FORMAT,
   REGRESSION_SCOPES,
+  aggregateTask,
   compareSummaries,
   geometricMeanPct,
   median,
@@ -58,6 +59,7 @@ function run(taskId, tokens, pass, extra = {}) {
     steps: extra.steps ?? 4,
     toolCalls: extra.toolCalls ?? 6,
     toolErrors: extra.toolErrors ?? 0,
+    durationMs: extra.durationMs ?? 60_000,
     toolCallsByName: {},
     verify: { passed: pass, checks: [] },
     exitCode: 0,
@@ -131,6 +133,28 @@ await test('the vocabularies and the scalar helpers are pinned', () => {
   assert.equal(percentChange(0, 0), 0)
 })
 
+await test('durations aggregate like steps: median/min per task, totals summed, gate unchanged', () => {
+  const aggregate = aggregateTask([
+    run('csv-sum', 1000, true, { repeatIndex: 1, durationMs: 60_000 }),
+    run('csv-sum', 1000, true, { repeatIndex: 2, durationMs: 62_000 }),
+  ])
+  assert.equal(aggregate.durationMsMedian, 61_000, 'the wall-clock median follows the same aggregate as steps')
+  assert.equal(aggregate.durationMsMin, 60_000)
+
+  // 60.0s of base work against 55.0s of candidate work: the delta and the sums are
+  // evidence in the document, and the gate still judges tokens and pass rate.
+  const base = summary('bench-base', [run('csv-sum', 1000, true, { durationMs: 60_000 })])
+  const faster = compareSummaries(base, summary('bench-ops', [run('csv-sum', 1000, true, { durationMs: 55_000 })]), { noiseFloorPct: 3.1, failOn: 'both' })
+  assert.equal(faster.tasks[0].delta.durationPct, -8.3)
+  assert.equal(faster.totals.baseDurationMs, 60_000)
+  assert.equal(faster.totals.candDurationMs, 55_000)
+  assert.equal(faster.gate.fail, false, 'identical tokens and passes gate clean')
+
+  const slower = compareSummaries(base, summary('bench-ops', [run('csv-sum', 1000, true, { durationMs: 600_000 })]), { noiseFloorPct: 3.1, failOn: 'both' })
+  assert.equal(slower.tasks[0].delta.durationPct, 900)
+  assert.equal(slower.gate.fail, false, 'the gate still judges tokens and pass rate, not wall-clock')
+})
+
 await test('pass-drop outranks a token win and is the first reason given', () => {
   const base = summary('base', [run('csv-sum', 1000, true), run('csv-sum', 1000, true)])
   const cand = summary('cand', [run('csv-sum', 400, true), run('csv-sum', 400, false)])
diff --git a/test/bench-compare.test.mjs b/test/bench-compare.test.mjs
index f0d090f7..b23779ff 100644
--- a/test/bench-compare.test.mjs
+++ b/test/bench-compare.test.mjs
@@ -57,6 +57,7 @@ function metrics(taskId, tokens, pass, extra = {}) {
     steps: extra.steps ?? 4,
     toolCalls: extra.toolCalls ?? 6,
     toolErrors: extra.toolErrors ?? 0,
+    durationMs: extra.durationMs ?? 60_000,
     toolCallsByName: extra.toolCallsByName ?? { ops_read: 2, bash: 1 },
     verify: { passed: pass, checks: [] },
     exitCode: 0,
@@ -152,12 +153,6 @@ function literal(text) {
   return text.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
 }
 
-/** The two resolved sides a render needs, with stable paths. */
-const SOURCES = {
-  base: { file: '/runs/aa/base/run.json', spec: 'bench-base', kind: 'run' },
-  cand: { file: '/runs/aa/cand/run.json', spec: 'bench-ops', kind: 'run' },
-}
-
 /** The two spans the report paints every percent with: green for a drop, red for a rise. */
 const green = (text) => `<span style="color:#3fb950">${text}</span>`
 const red = (text) => `<span style="color:#f85149">${text}</span>`
@@ -165,98 +160,96 @@ const red = (text) => `<span style="color:#f85149">${text}</span>`
 /** The report is English-only: no CJK character may reach a generated artifact. */
 const assertEnglish = (text) => assert.doesNotMatch(text, /[\u3400-\u4dbf\u4e00-\u9fff\uf900-\ufaff]/, 'the report must not contain CJK characters')
 
-await test('the same comparison renders byte-identical text twice, and the closing conclusion words each noise outcome', () => {
+await test('the same comparison renders byte-identical text twice: tables first, Evidence last, no verdict prose', () => {
   const base = summary('bench-base', [metrics('csv-sum', 1000, true), metrics('csv-sum', 1000, true)])
-  const cheaper = summary('bench-ops', [metrics('csv-sum', 926, true), metrics('csv-sum', 926, true)])
+  const cheaper = summary('bench-ops', [metrics('csv-sum', 926, true, { durationMs: 55_000 }), metrics('csv-sum', 926, true, { durationMs: 55_000 })])
   const beyond = compareSummaries(base, cheaper, { noiseFloorPct: 3.1, failOn: 'both' })
-  const text = renderReport(beyond, SOURCES)
-  assert.equal(renderReport(beyond, SOURCES), text, 'rendering is a pure function of its inputs')
+  const text = renderReport(beyond)
+  assert.equal(renderReport(beyond), text, 'rendering is a pure function of its inputs')
   assertEnglish(text)
-  assert.match(text, /^# DSH-OPS Benchmark Report\n\n## Per-task pairs$/m, 'the title leads straight into the data — no summary bar')
-  assert.match(text, /^\| task \| base \| cand \(Δ%\) \| steps base→cand \(Δ%\) \| tool calls base→cand \(Δ%\) \| tool errors \| pass \|$/m, 'the first table carries cost, behaviour and pass: no pairs, exclusion or direction column')
-  assert.ok(text.includes(`| csv-sum | 1,000 | 926 (${green('\u22127.4%')}) | 4 → 4 (${green('0.0%')}) | 6 → 6 (${green('0.0%')}) | 0 → 0 | 2/2→2/2 |`), 'each cell keeps its own Δ% in parentheses, painted like every other percent')
+  assert.match(text, /^# DSH-OPS Benchmark Report \(beta\)\n\n## Per-task pairs$/m, 'the title leads straight into the data — no summary bar')
+  assert.match(text, /^\| task \| base \| ops \(Δ%\) \| steps: base→ops \(Δ%\) \| tool calls: base→ops \(Δ%\) \| time: base→ops \(Δ%\) \| tool errors \| pass \|$/m, 'the first table carries cost, behaviour, wall-clock evidence and pass: no pairs, exclusion or direction column')
+  assert.ok(text.includes(`| csv-sum | 1,000 | 926 (${green('\u22127.4%')}) | 4 → 4 (${green('0.0%')}) | 6 → 6 (${green('0.0%')}) | 60.0s → 55.0s (${green('\u22128.3%')}) | 0 → 0 | 2/2→2/2 |`), 'each cell keeps its own Δ% in parentheses, painted like every other percent — time included')
   assert.doesNotMatch(text, /geomean/, 'the table ends at TOTAL: the geomean row is gone')
   assert.doesNotMatch(text, /## Excluded pairs|## A\/A noise band|## Token attribution/, 'the report keeps to cost, calls and the verdict: the three diagnostic sections are gone')
-  assert.doesNotMatch(text, /^## (Per-task pairs|Tool calls \(per-side overlap counts\)|Per-task bucket detail \(median\)|usage split \(TOTAL, median\)|steps and tool calls \(median\))\n\n(?!\|)/m, 'a table heading leads straight into its table: no explanatory line')
-  assert.match(text, /^- base:\/runs\/aa\/base\/run\.json\(spec `bench-base`,run\)$/m, 'the compared sides stay named in Evidence')
-  assert.match(text, /^- cand:\/runs\/aa\/cand\/run\.json\(spec `bench-ops`,run\)$/m)
+  assert.doesNotMatch(text, /^## (Per-task pairs|Tool calls|Per-task bucket detail|Per-request overhead)\n\n(?!\|)/m, 'a table heading leads straight into its table: no explanatory line')
   const headings = text.split('\n').filter((line) => line.startsWith('## '))
-  assert.equal(headings[headings.length - 1], '## Conclusion', 'the conclusion closes the report')
-  assert.ok(text.includes(`- Direction: Δ ${green('\u22127.4%')}, beyond the noise floor ±${red('3.1%')} ⇒ readable direction: cheaper`), 'a drop beyond the band reads green')
-  assert.ok(text.includes(`- noise floor (A/A): ±${red('3.1%')}, method \`provided\``))
-  assert.match(text, /Time fields are evidence only/)
-
-  // Inside the band: the interval is reported, the direction is not.
-  const inside = compareSummaries(base, summary('bench-ops', [metrics('csv-sum', 975, true), metrics('csv-sum', 975, true)]), { noiseFloorPct: 3.1, failOn: 'both' })
-  const insideText = renderReport(inside, SOURCES)
-  assert.ok(insideText.includes(`- Direction: Δ ${green('\u22122.5%')} sits inside the noise band ±${red('3.1%')} ⇒ interval only, no direction is read (within-noise)`))
-  assert.doesNotMatch(insideText, /readable direction/)
-  assert.match(insideText, /- gate: 🚦 passed ·/)
-
-  // No floor at all: the report says so and withholds every direction.
-  const unknown = compareSummaries(base, summary('bench-ops', [metrics('csv-sum', 1500, true), metrics('csv-sum', 1500, true)]), { failOn: 'both' })
-  const unknownText = renderReport(unknown, SOURCES)
-  assert.match(unknownText, /- noise floor \(A\/A\): unknown \(noise-floor-unknown\)/)
-  assert.ok(unknownText.includes(`- Direction: Δ ${red('+50.0%')}, but the noise floor is unknown ⇒ abstaining, no direction is read (noise-floor-unknown)`))
-  assert.match(unknownText, /--noise-floor-pct N or --noise <base> <cand>/)
-  assert.doesNotMatch(unknownText, /readable direction/)
-  assert.match(unknownText, /- gate: 🚦 passed ·/, 'an abstaining gate is not a failed gate')
-
-  // A costlier delta beyond the band is the one case that names a regression.
+  assert.equal(headings[headings.length - 1], '## Per-request overhead (what every request costs before any work)', 'the overhead table closes the report')
+  assert.doesNotMatch(text, /## Conclusion|## Warnings|## Evidence|## Usage split|## steps and tool calls|Direction:|noise floor \(A\/A\)|- gate:/, 'no verdict, warning or evidence prose: the verdict lives in the exit code and the comparison document')
+  assert.doesNotMatch(text, /Time is reported/, 'the report is tables and nothing else')
+
+  // The gate still judges even though the report no longer prints a conclusion: a
+  // costlier delta fails the comparison document, and the CLI maps it to exit 1.
   const worse = compareSummaries(base, summary('bench-ops', [metrics('csv-sum', 1050, true), metrics('csv-sum', 1050, true)]), { noiseFloorPct: 3.1, failOn: 'both' })
-  const worseText = renderReport(worse, SOURCES)
-  assert.ok(worseText.includes(`- Direction: Δ ${red('+5.0%')}, beyond the noise floor ±${red('3.1%')} ⇒ readable direction: costlier`), 'a rise beyond the band reads red')
-  assert.match(worseText, /- gate: 🚦 failed \(regression\) ·/)
-  assert.ok(worseText.includes(`| csv-sum | 1,000 | 1,050 (${red('+5.0%')}) | 4 → 4 (${green('0.0%')}) | 6 → 6 (${green('0.0%')}) | 0 → 0 | 2/2→2/2 |`))
-  assert.ok(worseText.includes(`- reason: token regression: csv-sum 1,050 > 1,020 (base 1,000 + ${red('2%')}; noise ±${red('3.1%')})`), 'a reason quoted from the core is painted too, its digits intact')
-  for (const rendered of [insideText, unknownText, worseText]) assertEnglish(rendered)
+  const worseText = renderReport(worse)
+  assert.ok(worseText.includes(`| csv-sum | 1,000 | 1,050 (${red('+5.0%')}) | 4 → 4 (${green('0.0%')}) | 6 → 6 (${green('0.0%')}) | 60.0s → 60.0s (${green('0.0%')}) | 0 → 0 | 2/2→2/2 |`))
+  assert.equal(worse.gate.fail, true, 'the gate verdict stays in the comparison document')
+  assert.equal(worse.gate.primary, 'regression')
+  assertEnglish(worseText)
 })
 
-await test('the steps and tool calls table pairs each task, sums the totals, and reads the aggregate its title names', () => {
+await test('the first table reads the aggregate its flag names: medians, min, halved medians and raw error counts', () => {
   const base = summary('bench-base', [metrics('csv-sum', 1000, true, { steps: 5 }), metrics('csv-sum', 1000, true, { steps: 3 })])
   const cand = summary('bench-ops', [metrics('csv-sum', 900, true, { steps: 3 }), metrics('csv-sum', 900, true, { steps: 3 })])
-
-  const text = renderReport(compareSummaries(base, cand, { noiseFloorPct: 3.1, failOn: 'both' }), SOURCES)
+  const text = renderReport(compareSummaries(base, cand, { noiseFloorPct: 3.1, failOn: 'both' }))
   assertEnglish(text)
-  assert.match(text, /^## steps and tool calls \(median\)$/m)
-  assert.ok(text.includes(`| csv-sum | 4 → 3 (${green('\u221225.0%')}) | 6 → 6 (${green('0.0%')}) |`))
-  assert.ok(text.includes(`| **TOTAL** | 4 → 3 (${green('\u221225.0%')}) | 6 → 6 (${green('0.0%')}) |`), 'no change is green too')
+  assert.ok(text.includes(`| csv-sum | 1,000 | 900 (${green('\u221210.0%')}) | 4 → 3 (${green('\u221225.0%')}) | 6 → 6 (${green('0.0%')}) | 60.0s → 60.0s (${green('0.0%')}) | 0 → 0 | 2/2→2/2 |`), 'the steps and tool-call cells carry the medians with their Δ%')
 
-  // `min` must move the cells, not only the title: the same fixture reads 3 → 3.
-  const minText = renderReport(compareSummaries(base, cand, { noiseFloorPct: 3.1, failOn: 'both', aggregate: 'min' }), SOURCES)
-  assert.match(minText, /^## steps and tool calls \(min\)$/m)
-  assert.ok(minText.includes(`| csv-sum | 3 → 3 (${green('0.0%')}) | 6 → 6 (${green('0.0%')}) |`))
-  assert.ok(minText.includes(`| **TOTAL** | 3 → 3 (${green('0.0%')}) | 6 → 6 (${green('0.0%')}) |`))
+  const minText = renderReport(compareSummaries(base, cand, { noiseFloorPct: 3.1, failOn: 'both', aggregate: 'min' }))
+  assert.ok(minText.includes(`| 3 → 3 (${green('0.0%')}) | 6 → 6 (${green('0.0%')}) |`), '`min` moves the cells, not only the title')
 
   // An even repeat count halves the median: the cell has to show 12.5, not round it
   // into "13 → 13 (+4.0%)", which contradicts its own Δ%.
   const halfBase = summary('bench-base', [metrics('csv-sum', 1000, true, { toolCalls: 13 }), metrics('csv-sum', 1000, true, { toolCalls: 12 })])
   const halfCand = summary('bench-ops', [metrics('csv-sum', 900, true, { toolCalls: 13 }), metrics('csv-sum', 900, true, { toolCalls: 13 })])
-  const halfText = renderReport(compareSummaries(halfBase, halfCand, { noiseFloorPct: 3.1, failOn: 'both' }), SOURCES)
-  assert.ok(halfText.includes(`| csv-sum | 4 → 4 (${green('0.0%')}) | 12.5 → 13 (${red('+4.0%')}) |`))
+  const halfText = renderReport(compareSummaries(halfBase, halfCand, { noiseFloorPct: 3.1, failOn: 'both' }))
+  assert.ok(halfText.includes(`| 12.5 → 13 (${red('+4.0%')}) |`), 'a halved median shows 12.5, not a rounded 13')
 
   // Tool errors are raw counts in the first table, not a median ratio: 2 → 0.
   const errBase = summary('bench-base', [metrics('csv-sum', 1000, true, { toolErrors: 2 })])
   const errCand = summary('bench-ops', [metrics('csv-sum', 900, true, { toolErrors: 0 })])
-  const errText = renderReport(compareSummaries(errBase, errCand, { noiseFloorPct: 3.1, failOn: 'both' }), SOURCES)
-  assert.ok(errText.includes('| 2 → 0 | 1/1→1/1 |'), 'tool errors are counted, not percentaged')
+  const errText = renderReport(compareSummaries(errBase, errCand, { noiseFloorPct: 3.1, failOn: 'both' }))
+  assert.ok(errText.includes(`| 60.0s → 60.0s (${green('0.0%')}) | 2 → 0 | 1/1→1/1 |`), 'tool errors are counted, not percentaged')
+})
+
+await test('the per-request overhead table prices the first request and degrades without prompt data', () => {
+  const base = summary('bench-base', [
+    metrics('csv-sum', 1000, true, { steps: 6, firstStep: 6249, total: 15186 }),
+    metrics('csv-sum', 1000, true, { steps: 6, firstStep: 6249, total: 15186 }),
+  ])
+  const cand = summary('bench-ops', [
+    metrics('csv-sum', 1000, true, { steps: 6, firstStep: 8032, total: 23628 }),
+    metrics('csv-sum', 1000, true, { steps: 6, firstStep: 8032, total: 23628 }),
+  ])
+  const text = renderReport(compareSummaries(base, cand, { noiseFloorPct: 3.1, failOn: 'both' }))
+  assertEnglish(text)
+  assert.match(text, /^## Per-request overhead \(what every request costs before any work\)$/m)
+  assert.ok(text.includes(`| csv-sum | 6,249 → 8,032 (+1,783, ${red('+28.5%')}) |`), 'the row carries only the first-request delta, abs and painted pct')
+  assert.doesNotMatch(text, /prompt \/ step|Fixed per-request cost|The first request of a run carries no history/)
+
+  const noPrompt = renderReport(compareSummaries(
+    summary('bench-base', [metrics('csv-sum', 1000, true, { prompt: false })]),
+    summary('bench-ops', [metrics('csv-sum', 1000, true, { prompt: false })]),
+  ))
+  assert.match(noPrompt, /Skipped: neither side recorded `metrics\.prompt`/, 'no prompt data ⇒ the section says so instead of inventing numbers')
+  assert.doesNotMatch(noPrompt, /first request: base→ops/)
 })
 
 await test('the tool table keeps the per-side totals, splits them by task, and colours adoption', () => {
   const base = summary('bench-base', [metrics('csv-sum', 1000, true, { toolCallsByName: { ops_read: 2, bash: 1, write: 4 } })])
   const cand = summary('bench-ops', [metrics('csv-sum', 900, true, { toolCallsByName: { ops_read: 3, bash: 2, write: 4 } })])
-  const text = renderReport(compareSummaries(base, cand, { noiseFloorPct: 3.1, failOn: 'both' }), SOURCES)
-  assert.match(text, /^## Tool calls \(per-side overlap counts\)$/m)
+  const text = renderReport(compareSummaries(base, cand, { noiseFloorPct: 3.1, failOn: 'both' }))
+  assert.match(text, /^## Tool calls$/m)
   const headings = text.split('\n').filter((line) => line.startsWith('## '))
-  assert.equal(headings[1], '## Tool calls (per-side overlap counts)', 'the tool table sits directly under the per-task pair table: it is the first explanation of where the token Δ went')
-  assert.match(text, /^\| tool \| base \| cand \| csv-sum \|$/m, 'the base/cand totals stay, and each task adds a column')
+  assert.equal(headings[1], '## Tool calls', 'the tool table sits directly under the per-task pair table: it is the first explanation of where the token Δ went')
+  assert.match(text, /^\| tool \| base \| ops \| csv-sum \|$/m, 'the base/ops totals stay, and each task adds a column')
   assert.ok(text.includes(`| ops_read | 2 | ${green('3')} | 2 → ${green('3')} |`), 'an ops tool rising is green: the plugin replaced a built-in')
   assert.ok(text.includes(`| bash | 1 | ${red('2')} | 1 → ${red('2')} |`), 'a built-in rising is red: the candidate reached past the plugin')
   assert.ok(text.includes('| write | 4 | 4 | 4 → 4 |'), 'equal counts are not painted')
 
   // Falling is green for a built-in and red for an ops tool: adoption, not the sign.
   const closed = summary('bench-ops', [metrics('csv-sum', 900, true, { toolCallsByName: { ops_read: 3 } })])
-  const closedText = renderReport(compareSummaries(base, closed, { noiseFloorPct: 3.1, failOn: 'both' }), SOURCES)
+  const closedText = renderReport(compareSummaries(base, closed, { noiseFloorPct: 3.1, failOn: 'both' }))
   assert.ok(closedText.includes(`| bash | 1 | ${green('0')} | 1 → ${green('0')} |`), 'a built-in the candidate stopped calling is green')
   assert.ok(closedText.includes(`| write | 4 | ${green('0')} | 4 → ${green('0')} |`))
 
@@ -265,7 +258,7 @@ await test('the tool table keeps the per-side totals, splits them by task, and c
     summary('bench-ops', [metrics('csv-sum', 900, true, { toolCallsByName: { ops_read: 2 } })]),
     { noiseFloorPct: 3.1, failOn: 'both' },
   )
-  assert.ok(renderReport(declined, SOURCES).includes(`| ops_read | 5 | ${red('2')} | 5 → ${red('2')} |`), 'an ops tool falling is red: adoption moved backwards')
+  assert.ok(renderReport(declined).includes(`| ops_read | 5 | ${red('2')} | 5 → ${red('2')} |`), 'an ops tool falling is red: adoption moved backwards')
 
   // Each task keeps its own column; a tool nobody used in a task reads as a dash.
   const twoTasks = compareSummaries(
@@ -273,8 +266,8 @@ await test('the tool table keeps the per-side totals, splits them by task, and c
     summary('bench-ops', [metrics('csv-sum', 900, true, { toolCallsByName: { ops_read: 3 } }), metrics('api-rename', 900, true, { toolCallsByName: { ops_read: 4 } })]),
     { noiseFloorPct: 3.1, failOn: 'both' },
   )
-  const twoText = renderReport(twoTasks, SOURCES)
-  assert.match(twoText, /^\| tool \| base \| cand \| csv-sum \| api-rename \|$/m)
+  const twoText = renderReport(twoTasks)
+  assert.match(twoText, /^\| tool \| base \| ops \| csv-sum \| api-rename \|$/m)
   assert.ok(twoText.includes(`| ops_read | 3 | ${green('7')} | 1 → ${green('3')} | 2 → ${green('4')} |`), 'the count belongs to the task that made the call')
 })
 
@@ -282,18 +275,17 @@ await test('excluded pairs leave the report body but stay in the warnings, and t
   const base = summary('bench-base', [metrics('csv-sum', 1000, true), metrics('csv-sum', 1000, true), metrics('csv-sum', 1000, true)])
   const cand = summary('bench-ops', [metrics('csv-sum', 500, true), metrics('csv-sum', 100, false), metrics('csv-sum', 200, false)])
   const comparison = compareSummaries(base, cand, { noiseFloorPct: 3.1, failOn: 'pass-drop' })
-  const text = renderReport(comparison, SOURCES)
+  const text = renderReport(comparison)
   assertEnglish(text)
   assert.doesNotMatch(text, /## Excluded pairs/, 'the section is gone; the counts must not vanish with it')
   assert.ok(text.includes(`| csv-sum | 1,000 | 500 (${green('\u221250.0%')}) |`), 'the pair table still prices the one usable pair')
   assert.ok(text.includes('| 3/3→1/3 |'), 'the pass column counts every repeat, not only the usable pairs')
   assert.doesNotMatch(text, /pairs usable\/counted/, 'the usable/considered split no longer has a column')
-  assert.match(text, /- cost-pairs-excluded: 2 \(base 0, cand 2, both 0\)/, 'the warnings still carry how many pairs the cost statistics lost')
+  assert.ok(comparison.warnings.includes('cost-pairs-excluded: 2 (base 0, cand 2, both 0)'), 'the comparison document still carries how many pairs the cost statistics lost')
 
   const clean = compareSummaries(base, summary('bench-ops', base.results.map((entry) => ({ ...entry, usage: { ...entry.usage } }))), { noiseFloorPct: 3.1, failOn: 'none' })
-  const cleanText = renderReport(clean, SOURCES)
-  assert.match(cleanText, /No warnings\./, 'nothing excluded means nothing to warn about')
-  assertEnglish(cleanText)
+  assert.deepEqual(clean.warnings, [], 'nothing excluded means nothing to warn about')
+  assertEnglish(text)
 })
 
 await test('--fail-on gates individually, and a gate that cannot run abstains at exit 0', async () => {
@@ -321,7 +313,7 @@ await test('--fail-on gates individually, and a gate that cannot run abstains at
     const abstain = invoke([baseline, costlier, '--out', '-', '--fail-on', 'both'])
     assert.equal(await abstain.run(), EXIT.ok)
     assert.match(abstain.err(), /noise floor unknown ⇒ cost direction withheld/)
-    assert.match(abstain.text(), /noise-floor-unknown/)
+    assert.match(abstain.err(), /noise-floor-unknown/, 'the abstaining gate says so on stderr — the report prints no verdict prose')
   })
 })
 
@@ -409,14 +401,11 @@ await test('label, directory and file forms resolve to the same comparison', asy
     const byDir = invoke([baseDir, candDir, ...common])
     const byFile = invoke([path.join(baseDir, 'run.json'), path.join(candDir, 'run.json'), ...common])
     for (const cli of [byLabel, byDir, byFile]) assert.equal(await cli.run(), EXIT.ok)
-    // The comparison renders identically; the evidence section is the one place
-    // that echoes how each side was named (`spec`), which the caller chose.
-    const body = (text) => text.split('\n').filter((line) => !/^- (base|cand):/.test(line)).join('\n')
-    assert.equal(body(byLabel.text()), body(byDir.text()))
-    assert.equal(body(byFile.text()), body(byDir.text()), 'all three forms reach the same comparison')
-    assert.match(byLabel.text(), /- base:.*run\.json\(spec `bench-base`,run\)/)
-    assert.match(byDir.text(), /- base:.*run\.json\(spec `.*bench-base`,run\)/)
-    assert.ok(byDir.text().includes(`api-rename | 500 | 620 (${red('+24.0%')}) | 2 → 2 (${green('0.0%')}) | 1 → 1 (${green('0.0%')}) | 0 → 0 | 1/1→1/1 |`))
+    // The report carries no side paths, so the three resolution forms render
+    // byte-identically: nothing anywhere echoes how each side was named.
+    assert.equal(byLabel.text(), byDir.text())
+    assert.equal(byFile.text(), byDir.text(), 'all three forms reach the same comparison')
+    assert.ok(byDir.text().includes(`api-rename | 500 | 620 (${red('+24.0%')}) | 2 → 2 (${green('0.0%')}) | 1 → 1 (${green('0.0%')}) | 0.0s → 0.0s (${green('0.0%')}) | 0 → 0 | 1/1→1/1 |`))
 
     // A group is searched with --folder; the flat root is searched without it.
     assert.equal((await invoke(['bench-base', 'bench-ops', '--runs', runs, ...common]).run()), EXIT.ok)
@@ -484,13 +473,12 @@ await test('--noise measures the floor in the call, and a missing prompt degrade
     assert.equal(doc.noiseFloor.method, 'aa-max-abs-task-pct')
     assert.equal(doc.noiseFloor.pct, 4, '+50% clears the measured 4% floor')
     assert.equal(doc.gate.regressionFailed, true)
-    assert.match(renderReport(doc, SOURCES), /method `aa-max-abs-task-pct`/)
 
     // A row with no prompt capture cannot support attribution: the core records that,
     // and the report has no attribution section left to hedge in.
     const bare = compareSummaries(summary('bench-base', [metrics('csv-sum', 1000, true, { prompt: false })]), summary('bench-ops', [metrics('csv-sum', 900, true, { prompt: false })]), { noiseFloorPct: 3.1 })
     assert.equal(bare.overhead.comparable, false, 'the core marks the split incomparable')
-    const text = renderReport(bare, SOURCES)
+    const text = renderReport(bare)
     assert.doesNotMatch(text, /Token attribution|fixed overhead per request/)
     assertEnglish(text)
   })
diff --git a/test/bench-run-session.test.mjs b/test/bench-run-session.test.mjs
index 5ddb2111..f997b0d5 100644
--- a/test/bench-run-session.test.mjs
+++ b/test/bench-run-session.test.mjs
@@ -203,6 +203,14 @@ await test('archive + metrics + trace: NDJSON appended verbatim, usage folded, t
     assert.deepEqual(row.toolCallsByName, { read: 1 })
     assert.deepEqual(row.usage, { inputTokens: 10, outputTokens: 5, cacheReadTokens: 2, cacheWriteTokens: 1, reasoningTokens: 0 })
     assert.equal(row.usageReported, false, 'one step without usage degrades the whole row instead of understating it')
+    assert.deepEqual(row.prompt, {
+      reported: false,
+      firstStep: 13,
+      median: 13,
+      max: 13,
+      total: 13,
+      perTurn: [{ turn: 1, tokens: 13 }],
+    }, 'the first request is 10+2+1 prompt tokens; the step without usage keeps the summary incomplete')
     assert.equal(row.turnEndReason, 'completed')
     assert.equal(row.verifyPassed, false, 'the fake child wrote no answer, so the check fails')
 
@@ -224,6 +232,29 @@ await test('archive + metrics + trace: NDJSON appended verbatim, usage folded, t
   })
 })
 
+await test('the fold records the prompt shape: first request, per-step sizes, per-turn firsts', async () => {
+  await withTempDir('bench-session-prompt', async (root) => {
+    const events = [
+      { type: 'status', phase: 'step_end', step: 1, turn: 1, usage: { inputTokens: 10, outputTokens: 5, cacheReadTokens: 2, cacheWriteTokens: 1 } },
+      { type: 'status', phase: 'step_end', step: 2, turn: 1, usage: { inputTokens: 40, outputTokens: 5, cacheReadTokens: 0, cacheWriteTokens: 0 } },
+      { type: 'status', phase: 'step_end', step: 3, turn: 2, usage: { inputTokens: 100, outputTokens: 5, cacheReadTokens: 0, cacheWriteTokens: 0 } },
+    ]
+    const rig = spawnRig((child) => child.emitFrom({ events, stderr: '', exit: 0 }))
+    const row = await runSession(
+      { task: { ...TASK, verify: [{ type: 'fileExists', path: 'answer.txt' }] }, repeatIndex: 1 },
+      optionsFor(root, { spawn: rig.spawn }),
+    )
+    assert.deepEqual(row.prompt, {
+      reported: true,
+      firstStep: 13,
+      median: 40,
+      max: 100,
+      total: 153,
+      perTurn: [{ turn: 1, tokens: 13 }, { turn: 2, tokens: 100 }],
+    }, 'prompt size is input + cacheRead + cacheWrite per step; each turn contributes its first request')
+  })
+})
+
 await test('timeout: timedOut true, exit null, and the kill is recorded in the archive', async () => {
   await withTempDir('bench-session-timeout', async (root) => {
     const killed = []
diff --git a/test/bench-schedule.test.mjs b/test/bench-schedule.test.mjs
index 23814dcb..4aa37e0d 100644
--- a/test/bench-schedule.test.mjs
+++ b/test/bench-schedule.test.mjs
@@ -12,10 +12,11 @@
 
 import fs from 'node:fs'
 import path from 'node:path'
+import { createHash } from 'node:crypto'
 
 import { assert, report, test, tick, withTempDir } from './lib/harness.mjs'
 import { SUMMARY_FORMAT, armOrder, planPairs, planSessions, repeatsById, runSweep } from '../bench/run/schedule.mjs'
-import { buildArms, exitFor, main, parseRunArgs, prepareDirs } from '../bench/run.mjs'
+import { buildArms, exitFor, main, parseRunArgs, prepareDirs, profileFingerprints, sealSweep } from '../bench/run.mjs'
 import { EXIT } from '../bench/cli.mjs'
 
 const LABEL = 'bench-schedule'
@@ -27,6 +28,9 @@ const NOW = () => Date.UTC(2026, 9, 18, 3, 4, 5)
 /** A launcher that is never executed: the injected runSession stands in for P7. */
 const ENTRY = { file: path.join(path.sep, 'fake', 'node_modules', '@deepseek-ai', 'dsh', 'lib', 'bin.js'), kind: 'js' }
 
+/** The fingerprints a rigged sweep would otherwise have to dump out of a real dsh. */
+const HASHES = { base: 'a'.repeat(64), cand: 'b'.repeat(64) }
+
 /** The two arms of a normal sweep. */
 const ARMS = [
   { side: 'base', label: 'bench-base', profile: 'bench-base' },
@@ -383,7 +387,7 @@ await test('parseRunArgs reads the runner flags, keeps the CLI validation, and r
   assert.throws(() => parseRunArgs(['--out', 'x', '--folder', 'g'], { runsDir: '/tmp' }), /drop --folder/)
 
   const plain = parseRunArgs([], { runsDir: '/tmp' })
-  assert.equal(plain.repeat, 3)
+  assert.equal(plain.repeat, 1)
   assert.equal(plain.repeatExplicit, false)
   assert.equal(plain.aa, false)
   assert.deepEqual(buildArms(plain).map((arm) => arm.label), ['bench-base', 'bench-ops'])
@@ -396,7 +400,7 @@ await test('parseRunArgs reads the runner flags, keeps the CLI validation, and r
   assert.equal(dirs.dirs.cand, path.join('/tmp', 'runs', 'benchmark-test-07', '2026-10-18T03-04-05Z-bench-ops'))
 })
 
-await test('main: --show prints the flip without running; a missing seal refuses before any spawn', async () => {
+await test('main: --show prints the flip without running; a requested seal with an unreadable profile refuses before any spawn', async () => {
   await withTempDir('bench-main-flags', async (root) => {
     const tasks = tasksDir(root)
     const runsDir = path.join(root, 'runs')
@@ -408,13 +412,17 @@ await test('main: --show prints the flip without running; a missing seal refuses
     assert.equal(scripted.calls.length, 0, '--show never spawns')
     assert.equal(out.lines.out.filter((line) => line.includes('base → cand') || line.includes('bench-base → bench-ops')).length, 1)
     assert.equal(out.lines.out.filter((line) => line.includes('bench-ops → bench-base')).length, 1)
-    assert.match(out.text(), /benchmark-test-01/)
+    assert.match(out.text(), /benchmark-\d{4}-\d{2}-\d{2}-\d{2}/)
     assert.match(out.text(), /show only/)
 
-    const noSeal = sink()
-    assert.equal(await main([], { ...base, ...noSeal, seal: undefined }), EXIT.pending)
-    assert.match(noSeal.both(), /sealing is not wired in this slice yet/)
-    assert.match(noSeal.both(), /P8a/)
+    // Sealing is opt-in, so `--seal` is what asks for the fingerprint; a launcher whose dump
+    // fails is refused before any session, so a requested seal can never turn out to be
+    // impossible after the tokens are spent.
+    const refused = sink()
+    const noDump = () => { throw new Error('dump-config unavailable') }
+    assert.equal(await main(['--seal'], { ...base, ...refused, resolveEntry: () => ENTRY, dumpProfileConfig: noDump }), EXIT.failure)
+    assert.match(refused.both(), /dump-config unavailable/)
+    assert.match(refused.both(), /no token was spent/)
     assert.equal(scripted.calls.length, 0, 'an unsealable sweep spends no token')
 
     const badFlag = sink()
@@ -434,7 +442,7 @@ await test('main: a sealed A/A sweep exits 0 with the measured floor; a broken o
     const aaOut = sink()
     const overlay = overlayIn(root)
     const scripted = rig({ tokens: (spec) => (spec.arm === 'bench-base-aa' && spec.repeatIndex === 1 ? 120 : 100) })
-    const code = await main(['--aa', '--repeat', '2'], {
+    const code = await main(['--seal', '--aa', '--repeat', '2'], {
       ...aaOut,
       tasksDir: tasks,
       runsDir,
@@ -443,6 +451,7 @@ await test('main: a sealed A/A sweep exits 0 with the measured floor; a broken o
       resolveEntry: () => ENTRY,
       installSignals: false,
       now: NOW,
+      profileHashes: HASHES,
       seal: (context) => ({ path: path.join(context.dirs.base, '..', 'run.json') }),
     })
     assert.equal(code, EXIT.ok)
@@ -452,7 +461,7 @@ await test('main: a sealed A/A sweep exits 0 with the measured floor; a broken o
 
     const brokenOut = sink()
     const broken = rig({ fail: (spec) => spec.arm === 'bench-ops' })
-    const brokenCode = await main([], {
+    const brokenCode = await main(['--seal'], {
       ...brokenOut,
       tasksDir: tasks,
       runsDir,
@@ -462,6 +471,7 @@ await test('main: a sealed A/A sweep exits 0 with the measured floor; a broken o
 
       installSignals: false,
       now: NOW,
+      profileHashes: HASHES,
       seal: () => ({ path: 'run.json' }),
     })
     assert.equal(brokenCode, EXIT.failure)
@@ -475,7 +485,7 @@ await test('main: Ctrl-C during a session stops the sweep, reports it, and exits
     const interrupt = { stopped: false, child: null, pid: null }
     const out = sink()
     const scripted = rig({ onCall: () => { interrupt.stopped = true } })
-    const code = await main(['--repeat', '2'], {
+    const code = await main(['--seal', '--repeat', '2'], {
       ...out,
       tasksDir: tasks,
       runsDir: path.join(root, 'runs'),
@@ -485,19 +495,27 @@ await test('main: Ctrl-C during a session stops the sweep, reports it, and exits
       interrupt,
       installSignals: false,
       now: NOW,
+      profileHashes: HASHES,
       seal: () => ({}),
     })
     assert.equal(code, EXIT.failure)
     assert.match(out.text('err'), /interrupted/)
     assert.equal(scripted.calls.length, 1)
+    const group = path.join(root, 'runs', fs.readdirSync(path.join(root, 'runs'))[0])
+    assert.equal(
+      fs.readdirSync(group).filter((name) => name.startsWith('DSH-OPS Benchmark Report')).length, 0,
+      'an interrupted sweep writes no report: a partial run is not a comparison',
+    )
+    assert.match(out.text(), /not written \(a partial sweep is not a comparison\)/)
   })
 })
 
-await test('main --no-seal runs anyway and says out loud that no run.json was written', async () => {
+await test('main: a sweep is unsealed by default and --seal opts in', async () => {
   await withTempDir('bench-main-noseal', async (root) => {
     const out = sink()
     const scripted = rig()
-    const code = await main(['--no-seal', '--repeat', '1'], {
+    let sealed = 0
+    const code = await main(['--repeat', '1'], {
       ...out,
       tasksDir: tasksDir(root, 1),
       runsDir: path.join(root, 'runs'),
@@ -506,16 +524,72 @@ await test('main --no-seal runs anyway and says out loud that no run.json was wr
       resolveEntry: () => ENTRY,
       installSignals: false,
       now: NOW,
+      dumpProfileConfig: () => { throw new Error('the default must not fingerprint anything') },
+      seal: () => { sealed += 1; return {} },
     })
     assert.equal(code, EXIT.ok)
-    assert.match(out.text(), /no — run\.json was not written/)
+    assert.equal(sealed, 0, 'no seal was asked for, so nothing was sealed')
+    assert.match(out.text(), /no — not requested \(--seal writes run\.json\)/)
     assert.equal(scripted.calls.length, 2, 'both arms still ran')
+    const group = path.join(root, 'runs', fs.readdirSync(path.join(root, 'runs'))[0])
+    const armDir = fs.readdirSync(group).find((name) => name.endsWith('bench-base'))
+    assert.ok(fs.existsSync(path.join(group, armDir, 'summary.json')), 'the per-arm summary is the artifact the report reads')
+    assert.equal(fs.existsSync(path.join(group, 'run.json')), false, 'nothing sealed this sweep')
+    const reports = fs.readdirSync(group).filter((name) => name.startsWith('DSH-OPS Benchmark Report') && name.endsWith('.md'))
+    assert.equal(reports.length, 1, 'a finished sweep writes its own report into the group folder')
+    const report = fs.readFileSync(path.join(group, reports[0]), 'utf8')
+    assert.match(report, /^# DSH-OPS Benchmark Report/)
+    assert.match(report, /csv-sum/, 'the rendered table carries the tasks the sweep measured')
+    assert.match(out.text(), /\[ab\] report  : .*DSH-OPS Benchmark Report/)
+
+    // `--no-seal` still means off, so an old command line keeps working unchanged.
+    const explicit = sink()
+    const again = rig()
+    assert.equal(await main(['--no-seal', '--repeat', '1'], {
+      ...explicit,
+      tasksDir: tasksDir(root, 1),
+      runsDir: path.join(root, 'runs'),
+      llmOverlay: overlayIn(root),
+      runSession: again.runSession,
+      resolveEntry: () => ENTRY,
+      installSignals: false,
+      now: NOW,
+      seal: () => { throw new Error('--no-seal must never seal') },
+    }), EXIT.ok)
+    assert.match(explicit.text(), /no — not requested/)
+  })
+})
+
+await test('main: a finished sweep writes the report by default and --no-report skips it', async () => {
+  await withTempDir('bench-main-report', async (root) => {
+    const runsRoot = path.join(root, 'runs')
+    const base = { tasksDir: tasksDir(root, 1), runsDir: runsRoot, llmOverlay: overlayIn(root), resolveEntry: () => ENTRY, installSignals: false, now: NOW }
+    const groups = () => fs.readdirSync(runsRoot)
+
+    const out = sink()
+    const scripted = rig()
+    assert.equal(await main(['--repeat', '1'], { ...base, ...out, runSession: scripted.runSession }), EXIT.ok)
+    const firstName = groups()[0]
+    assert.equal(
+      fs.readdirSync(path.join(runsRoot, firstName)).filter((name) => name.startsWith('DSH-OPS Benchmark Report')).length, 1,
+      'the default sweep leaves its report in the group folder',
+    )
+
+    const off = sink()
+    const again = rig()
+    assert.equal(await main(['--repeat', '1', '--no-report'], { ...base, ...off, runSession: again.runSession }), EXIT.ok)
+    const secondName = groups().find((name) => name !== firstName)
+    assert.equal(
+      fs.readdirSync(path.join(runsRoot, secondName)).filter((name) => name.startsWith('DSH-OPS Benchmark Report')).length, 0,
+      '--no-report keeps the group folder free of reports',
+    )
+    assert.match(off.text(), /not written \(--no-report\)/)
   })
 })
 
 await test('main: the sweep injects the operator overlay by default, records it, and refuses without one', async () => {
   await withTempDir('bench-main-overlay', async (root) => {
-    const runner = { tasksDir: tasksDir(root, 1), runsDir: path.join(root, 'runs'), resolveEntry: () => ENTRY, installSignals: false, now: NOW }
+    const runner = { tasksDir: tasksDir(root, 1), runsDir: path.join(root, 'runs'), resolveEntry: () => ENTRY, installSignals: false, now: NOW, profileHashes: HASHES }
     const overlay = overlayIn(root)
 
     // The default is the file `setup` creates, every session is handed it, and the archived
@@ -523,7 +597,7 @@ await test('main: the sweep injects the operator overlay by default, records it,
     const seeded = sink()
     const scripted = rig()
     let sealed = null
-    const code = await main(['--repeat', '1'], {
+    const code = await main(['--seal', '--repeat', '1'], {
       ...runner, ...seeded, runSession: scripted.runSession, llmOverlay: overlay,
       seal: (context) => { sealed = context; return { path: 'run.json' } },
     })
@@ -575,4 +649,44 @@ await test('main: the sweep injects the operator overlay by default, records it,
   })
 })
 
+await test('main: --seal fingerprints both arms and hands them to the seal', async () => {
+  const hashes = profileFingerprints(ARMS, { entry: ENTRY, dump: (_entry, profile) => `composed ${profile}` })
+  assert.deepEqual(hashes, {
+    base: createHash('sha256').update('composed bench-base').digest('hex'),
+    cand: createHash('sha256').update('composed bench-ops').digest('hex'),
+  }, 'each arm is fingerprinted from its own dumped configuration')
+  assert.throws(() => profileFingerprints(ARMS, { entry: ENTRY, dump: () => '   ' }), /printed nothing/)
+
+  await withTempDir('bench-main-fingerprint', async (root) => {
+    const out = sink()
+    const scripted = rig()
+    let sealed = null
+    const code = await main(['--seal', '--repeat', '1'], {
+      ...out,
+      tasksDir: tasksDir(root, 1),
+      runsDir: path.join(root, 'runs'),
+      llmOverlay: overlayIn(root),
+      runSession: scripted.runSession,
+      resolveEntry: () => ENTRY,
+      installSignals: false,
+      now: NOW,
+      dumpProfileConfig: (_entry, profile) => `composed ${profile}`,
+      seal: (context) => { sealed = context; return { path: 'run.json' } },
+    })
+    assert.equal(code, EXIT.ok)
+    assert.equal(sealed.arms.base.profileHash, hashes.base, 'the seal receives the dumped fingerprint')
+    assert.equal(sealed.arms.cand.profileHash, hashes.cand)
+    assert.match(out.text(), /\[ab\] profile : bench-base [0-9a-f]{12}/, 'the sweep names both fingerprints')
+    assert.equal(scripted.calls.length, 2, 'both arms still ran')
+  })
+})
+
+await test('sealSweep hands sealRun the two arm directories as a list', async () => {
+  const context = { dirs: { base: path.join('X', 'base'), cand: path.join('X', 'cand') }, arms: { base: {}, cand: {} }, meta: { mode: 'ab' } }
+  const seen = sealSweep(context, (options) => options)
+  assert.deepEqual(seen.dirs, [path.join('X', 'base'), path.join('X', 'cand')], 'the map becomes the list sealRun folds')
+  assert.equal(seen.meta.mode, 'ab', 'the rest of the context is passed through')
+  assert.deepEqual(sealSweep({ ...context, dirs: ['a', 'b'] }, (options) => options).dirs, ['a', 'b'], 'a list stays a list')
+})
+
 report(LABEL)