diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index f53003c9..016df8d4 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -303,6 +303,9 @@ jobs:
       # Evidence, not a gate: `report.md` / `run.json` / `panel.html` are uploaded **when they exist**
       # (a tools-only smoke produces the comparison JSON and nothing else), so a dispatch that later
       # runs more of the harness still gets its report without failing on the files it did not make.
+      # A comparison writes its default artifact into the sweep's group folder, named
+      # `DSH-OPS Benchmark Report <UTC>.md`; the stamped name is globbed here as well as `report.md`
+      # so an archive produced by either naming reaches the artifact.
       - uses: actions/upload-artifact@v7
         if: always()
         with:
@@ -311,6 +314,7 @@ jobs:
             bench/runs/smoke/**
             bench/runs/*/run.json
             bench/runs/*/report.md
+            bench/runs/*/DSH-OPS Benchmark Report*.md
             bench/runs/*/panel.html
           if-no-files-found: warn
           retention-days: 7
diff --git a/bench/README.md b/bench/README.md
index 5f05fd0b..1718ae85 100644
--- a/bench/README.md
+++ b/bench/README.md
@@ -67,7 +67,7 @@ npm 包发布、不参与构建、不进 `verify:release` / `release.yml`,也从
 | --- | --- | --- |
 | `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` 渲染 `report.md` |
+| `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` | 无模型的工具级确定性对比 |
 
@@ -91,6 +91,12 @@ npm 包发布、不参与构建、不进 `verify:release` / `release.yml`,也从
 `--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` 打印将执行的三条命令并立刻退出(纯函数,不写任何东西、不跑任何会话)。组号在这里**只分配一次**:
 如果每侧各自按时间戳分配目录,两侧会落进不同的组,最后什么都配对不上。
 
@@ -98,7 +104,12 @@ npm 包发布、不参与构建、不进 `verify:release` / `release.yml`,也从
 
 两侧各自可以是 label(`bench/runs/*-<label>`,含一层组目录,最新时间戳优先)、一个 run 目录、或一个
 `run.json` / 旧版 `summary.json` 路径。`--folder` 限定组,`--runs` 换根,`--aggregate median|min`,
-`--json` 输出比较文档而不是报告,`--out <file>`(`-` 只到 stdout;默认 `<cand 目录>/report.md`)。
+`--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`
 
@@ -112,21 +123,30 @@ npm 包发布、不参与构建、不进 `verify:release` / `release.yml`,也从
 `--temp-dir`、`--scale`、`--timeout-ms`(这套旗标沿用 #103 的参数面,随接线片一并落地)。预热 1 次 +
 5 轮交替配对,同二进制两侧时它只证明"harness 没坏、输出可重复",**不是**性能基准。
 
-## 如何读 `report.md`
+## 如何读报告(`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`,在那边退化成纯文本。
 
-1. **结论**:结论条一行给通过率、配对 token Δ、噪声底、方向与门禁,顺序就是判决顺序;
-2. **每任务配对**:`task | base | cand | Δ% | 配对/考虑 | 排除 | pass(base→cand) | 方向`;`TOTAL` 行后还有
-   一行**几何均值 Δ**(每任务等权);
-3. **被排除的配对(成本不统计)**:多少对因至少一侧未通过被排除,以及 base / cand / 两侧各占多少 ——
-   通过率一变,这里就是成本口径的地基;
-4. **A/A 噪声带**:半宽、区间、方法(`measured` 来自 `--noise`,或 `provided` 来自 `--noise-floor-pct`)、
-   配对数与任务样本;未知时这一段直接说明"方向一律弃权";
-5. **token 归因(诊断,不改判决)** 与 **每任务 bucket 明细** / **usage 拆分** / **工具调用**:都是诊断,
-   把 Δ 拆成固定开销 / 额外步数 / 残差,或按 input / output / cacheRead 分桶;
-6. **警告**与**证据**:前者列出无法支撑结论的行(如某侧丢了 `step_end.usage`),后者给出 `run.json` 与
-   归档路径。
+**工具调用**表的颜色看"采用方向",不是数字本身的涨跌:`ops_*` 工具计数上升是绿(插件工具接住了),下降是红;
+其它工具上升是红(候选仍在伸手够插件没覆盖的工具),下降是绿。计数相等不标色,两侧都没调用写 `—`。
 
 ## 面板怎么读(五个标签)
 
@@ -221,7 +241,7 @@ npm 包发布、不参与构建、不进 `verify:release` / `release.yml`,也从
   所以绿只说明"harness 还能驱动真实 worker、worker 两次答得一样",**不构成任何性能结论**;
 - **不阻塞**:该作业 `continue-on-error: true`,不进必需状态检查,聚合门禁不计它;
 - **artifact**:证据以 `bench-smoke-report` 上传(沿用 `tools-trial-report` 的命名),含 `bench/runs/smoke/**`
-  以及存在时的 `run.json` / `report.md` / `panel.html`;
+  以及存在时的 `run.json` / `DSH-OPS Benchmark Report <UTC>.md` / `panel.html`;
 - **模型驱动的 sweep 绝不在 CI 跑**:它要断言成本方向,那是本地的人类判断。
 
 ## 为什么 bench 不随包发布
diff --git a/bench/cli.mjs b/bench/cli.mjs
index 28d6cc9b..439e1b09 100644
--- a/bench/cli.mjs
+++ b/bench/cli.mjs
@@ -29,7 +29,7 @@ export const COMMANDS = [
   { name: 'gates', slice: '[16/16]', target: 'bench/gates/index.mjs', summary: 'scripted real-host BM-01 through BM-05 acceptance evidence' },
   { name: 'setup', slice: 'P9/P10', target: 'bench/setup.mjs', summary: 'prepare both profiles once, idempotently' },
   { name: 'ab', slice: 'P1 (plan) + P7/P8 + P11 (run)', target: 'bench/run.mjs', summary: 'baseline then candidate then compare, one group folder' },
-  { name: 'report', slice: 'P11', target: 'bench/compare.mjs', summary: 'render report.md from a sealed run.json' },
+  { name: 'report', slice: 'P11', target: 'bench/compare.mjs', summary: 'render the timestamped report from a sealed run.json' },
   { name: 'panel', slice: 'P12', target: 'bench/report/panel.mjs', summary: 'write/open panel.html that reads run.json' },
   { name: 'tools', slice: 'P13', target: 'bench/tools/index.mjs', summary: 'model-free deterministic tool-level comparison' },
 ]
diff --git a/bench/compare.mjs b/bench/compare.mjs
index 84ef83f9..2c4bf3d5 100644
--- a/bench/compare.mjs
+++ b/bench/compare.mjs
@@ -1,6 +1,13 @@
 #!/usr/bin/env node
 /**
- * The comparison report: two archived runs in, one `report.md` out.
+ * The comparison report: two archived runs in, one timestamped markdown file out.
+ *
+ * The artifact lands where a reviewer looks for a sweep, not inside the arm directory
+ * that measured half of it: a run in `bench/runs/<group>/<stamp>-<label>` writes
+ * `bench/runs/<group>/DSH-OPS Benchmark Report <UTC>.md`, and a run with no group folder
+ * above it keeps the report in its own directory. The file name carries the write
+ * instant (the same UTC shape as a run directory) so a second comparison never
+ * overwrites the first; the rendered text stays clock-free and diffable.
  *
  * The verdict is *not* computed here. `lib/compare-core.mjs` owns every rule — pass
  * rate first, cost only over pairs that passed on both sides, and a direction only
@@ -8,14 +15,15 @@
  * 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 leads with the 结论条 a reviewer reads first (pass rate, paired token Δ,
- * the noise band and whether a direction is readable), then 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). None of the diagnostics can change the gate.
+ * 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.
  *
  * Time is evidence only: the comparison never reads `durationMs`, and nothing here
  * turns a duration into a verdict.
@@ -44,6 +52,13 @@ 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 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. */
+const GREEN = '#3fb950'
+const RED = '#f85149'
 
 /**
  * Exit codes, kept in step with `EXIT` in `bench/cli.mjs` (which forwards whatever
@@ -69,7 +84,9 @@ const USAGE = `usage: node bench/compare.mjs <base> <cand> [options]
                      direction is withheld (noise-floor-unknown)
   --noise <a> <b>    measure the A/A noise floor from two baseline runs
   --json             print the comparison document as JSON instead of the report
-  --out <file>       where the rendered artifact goes (default <cand dir>/report.md;
+  --out <file>       where the rendered artifact goes (default: the sweep's group
+                     folder, named "DSH-OPS Benchmark Report <UTC>.md" — a run with no
+                     group folder above it keeps the report in its own directory;
                      "-" is stdout only). With --json the file carries the JSON.
   --help             this text
 
@@ -307,6 +324,18 @@ function number(value) {
   return formatNumber(value)
 }
 
+/**
+ * A step or tool-call count: an integer, or one decimal when an even repeat count
+ * halves the median. Rounding 12.5 → 13 would print "13 → 13 (+4.0%)", a cell that
+ * contradicts its own Δ%.
+ * @param {number|null} value - the count.
+ * @returns {string} the display form.
+ */
+function count(value) {
+  if (value === null || value === undefined || !Number.isFinite(value)) return 'n/a'
+  return Number.isInteger(value) ? formatNumber(value) : value.toFixed(1)
+}
+
 /** A signed integer delta with grouping, for the diagnostic tables. */
 function signed(value) {
   if (value === null || value === undefined || !Number.isFinite(value)) return 'n/a'
@@ -314,23 +343,46 @@ function signed(value) {
   return `${rounded > 0 ? '+' : rounded < 0 ? MINUS : ''}${Math.abs(rounded).toLocaleString('en-US')}`
 }
 
-/** A signed percent at the module's reporting precision. */
+/**
+ * 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
+ * stylesheet. A value with no number behind it is returned unwrapped.
+ * @param {string} text - the rendered value.
+ * @param {number|null} value - the signed number behind it.
+ * @returns {string} the HTML span, or `text`.
+ */
+function color(text, value) {
+  if (value === null || value === undefined || !Number.isFinite(value)) return text
+  return `<span style="color:${value > 0 ? RED : GREEN}">${text}</span>`
+}
+
+/** A signed percent at the module's reporting precision, painted by its sign. */
 function percent(value) {
   if (value === null || value === undefined || !Number.isFinite(value)) return 'n/a'
-  return `${value > 0 ? '+' : value < 0 ? MINUS : ''}${Math.abs(value).toFixed(1)}%`
+  return color(`${value > 0 ? '+' : value < 0 ? MINUS : ''}${Math.abs(value).toFixed(1)}%`, value)
 }
 
-/** The short verdict name for one task's cost conclusion. */
-function directionLabel(cost, regressed) {
-  if (regressed) return '⚠ 回归'
-  switch (cost?.conclusion) {
-    case 'cheaper': return '更省'
-    case 'costlier': return '更贵'
-    case 'within-noise': return '噪声内'
-    case 'noise-floor-unknown': return '弃权(噪声底未知)'
-    case 'incomparable': return '不可比'
-    default: return '无变化'
-  }
+/**
+ * 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)
 }
 
 /**
@@ -341,177 +393,77 @@ function directionLabel(cost, regressed) {
  */
 function directionSentence(cost) {
   if (cost.conclusion === 'incomparable') {
-    return '方向:没有两侧都通过、且 usage 完整的配对 ⇒ 成本不可比(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 `方向:Δ ${percent(cost.pct)},但噪声底未知 ⇒ 弃权,不读方向(noise-floor-unknown);用 --noise-floor-pct N 或 --noise <base> <cand> 提供噪声底`
+    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 `方向:Δ ${percent(cost.pct)} 落在噪声带 ±${cost.noiseFloorPct}% 内 ⇒ 只报区间,不读方向(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') {
-    const name = cost.conclusion === 'cheaper' ? '更省(cheaper)' : '更贵(costlier)'
-    return `方向:Δ ${percent(cost.pct)},超过噪声底 ±${cost.noiseFloorPct}% ⇒ 可读方向:${name}`
+    return `Direction: Δ ${percent(cost.pct)}, beyond the noise floor ±${rawPercent(cost.noiseFloorPct)} ⇒ readable direction: ${cost.conclusion}`
   }
-  return `方向:Δ ${percent(cost.pct)},无可读方向(${cost.conclusion ?? 'no-change'})`
+  return `Direction: Δ ${percent(cost.pct)}, no readable direction (${cost.conclusion ?? 'no-change'})`
 }
 
 /**
- * The 结论条: pass rate, paired token Δ, noise floor, direction and gate, in that order.
+ * 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 passLine = gate.passDropFailed
-    ? `❌ 通过率下降 ${passes}`
-    : totals.candPassRate > totals.basePassRate
-      ? `✅ 通过率上升 ${passes}`
-      : `✅ 通过率持平 ${passes}`
   const pairs = `${gate.usablePairs}/${gate.usablePairs + gate.excludedPairs}`
   const tokenLine = gate.tokensComparable && gate.costComparable
-    ? `💰 token(配对 ${pairs}):${number(totals.baseGrandTotal)} → ${number(totals.candGrandTotal)},Δ ${percent(totals.grandTotalPct)}`
-    : `💰 token:不可比(${gate.tokensComparable ? `没有两侧都通过的配对,${gate.excludedPairs} 对被排除` : '至少一侧 usage 不完整'})`
-  const noiseLine = noiseFloor.comparable
-    ? `🔬 噪声底(A/A):±${noiseFloor.pct}%(${noiseFloor.method})`
-    : '🔬 噪声底(A/A):未知'
+    ? `💰 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 = [
-    `# bench compare: ${comparison.base.label ?? 'base'} → ${comparison.cand.label ?? 'cand'}`,
+    '## Conclusion',
     '',
-    `${passLine} · ${tokenLine} · ${noiseLine} · 🚦 ${gate.fail ? `门禁失败(${gate.primary})` : '门禁通过'}`,
-    '',
-    '## 结论',
-    '',
-    `- 通过率:${passes}${gate.passDropFailed ? '(下降,先于成本裁决)' : totals.candPassRate > totals.basePassRate ? '(上升)' : '(持平)'}`,
+    `- pass rate: ${passes}${gate.passDropFailed ? ' (drop; decided before cost)' : totals.candPassRate > totals.basePassRate ? ' (up)' : ' (flat)'}`,
     `- ${tokenLine.replace('💰 ', '')}`,
-    `- 噪声底(A/A):${noiseFloor.comparable ? `±${noiseFloor.pct}%,方法 \`${noiseFloor.method}\`` : '未知(noise-floor-unknown)'}`,
+    `- noise floor (A/A): ${noiseFloor.comparable ? `±${rawPercent(noiseFloor.pct)}, method \`${noiseFloor.method}\`` : 'unknown (noise-floor-unknown)'}`,
     `- ${directionSentence(verdict.cost)}`,
-    `- 门禁:\`--fail-on ${gate.failOn}\` · 回归口径 \`${gate.regressionScope}\` · 容差 ${gate.tolerancePct}% · 成本基准 \`${gate.costBasis}\``,
-    `- 口径:${comparison.aggregate} · profile ${comparison.base.profile ?? '?'} → ${comparison.cand.profile ?? '?'} · model ${comparison.base.model ?? '?'} → ${comparison.cand.model ?? '?'}`,
+    `- 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}`)
+  for (const reason of gate.reasons) lines.push(`- reason: ${paintPercents(reason)}`)
   return lines
 }
 
 /**
- * The per-task paired table: cost plus the pass migration a reviewer scans for.
+ * 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.
  * @param {object} comparison - the comparison structure.
  * @returns {string[]} the section lines.
  */
 function taskSection(comparison) {
-  const { gate, totals } = comparison
+  const { totals } = comparison
+  const useMin = comparison.aggregate === 'min'
+  const keys = { steps: useMin ? 'stepsMin' : 'stepsMedian', toolCalls: useMin ? 'toolCallsMin' : 'toolCallsMedian', toolErrors: useMin ? 'toolErrorsMin' : 'toolErrorsMedian' }
+  // 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)}`
+  const passCell = (side) => `${side.base.passed}/${side.base.repeats}→${side.cand.passed}/${side.cand.repeats}`
   const lines = [
-    '## 每任务配对',
+    '## Per-task pairs',
     '',
-    '成本只统计两侧都通过的对(`paired-both-passed`);Δ% 是配对成本的变化,不是全部重复的平均。',
-    '',
-    '| task | base | cand | Δ% | 配对 可用/计入 | 被排除 | pass base→cand | 方向 |',
-    '| --- | --- | --- | --- | --- | --- | --- | --- |',
+    '| task | base | cand (Δ%) | steps base→cand (Δ%) | tool calls base→cand (Δ%) | 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)' : '(仅 cand)'}`
-    lines.push(`| ${name} | ${number(pair.baseValue)} | ${number(pair.candValue)} | ${percent(pair.pct)} | ${pair.pairs}/${pair.considered} | ${pair.excluded.total} | ${task.base.passed}/${task.base.repeats}→${task.cand.passed}/${task.cand.repeats} | ${directionLabel(task.cost, task.regressed)} |`)
-  }
-  const totalPairs = `${gate.usablePairs}/${gate.usablePairs + gate.excludedPairs}`
-  lines.push(`| **TOTAL** | ${number(totals.baseGrandTotal)} | ${number(totals.candGrandTotal)} | ${percent(totals.grandTotalPct)} | ${totalPairs} | ${gate.excludedPairs} | ${totals.basePasses}/${totals.baseRuns}→${totals.candPasses}/${totals.candRuns} | ${directionLabel(comparison.verdict.cost, false)} |`)
-  lines.push(`| **几何均值 Δ** | — | — | ${percent(totals.grandTotalGeomeanPct)} | — | — | — | 每任务等权 |`)
-  return lines
-}
-
-/**
- * The pairs a failed side forced out of the cost statistics — the count the issue
- * requires to be visible, so a run cannot shrink its own denominator quietly.
- * @param {object} comparison - the comparison structure.
- * @returns {string[]} the section lines.
- */
-function excludedSection(comparison) {
-  const { excluded } = comparison.pairing
-  const lines = ['## 被排除的配对(成本不统计)', '']
-  if (excluded.total === 0) {
-    lines.push('没有被排除的配对:两侧都通过的配对全部参与了成本统计。')
-  } else {
-    lines.push(`共 ${excluded.total} 对因至少一侧未通过被排除:base 失败 ${excluded.baseFailed} · cand 失败 ${excluded.candFailed} · 两侧都失败 ${excluded.bothFailed}。`, '')
-    lines.push('| task | 被排除 | base 失败 | cand 失败 | 两侧失败 |', '| --- | --- | --- | --- | --- |')
-    for (const task of comparison.tasks) {
-      const counts = task.paired.excluded
-      if (counts.total === 0) continue
-      lines.push(`| ${task.id} | ${counts.total} | ${counts.baseFailed} | ${counts.candFailed} | ${counts.bothFailed} |`)
-    }
-  }
-  const counts = comparison.pairing.counts
-  lines.push(
-    '',
-    `配对合并:键 ${counts.pairs} · 缺 base ${counts.missingBase} · 缺 cand ${counts.missingCand} · 重复键 ${counts.duplicates} · 标签不符 ${counts.labelMismatches} · 行无效 ${counts.invalid};合并${comparison.pairing.complete ? '完整' : '不完整'}。`,
-  )
-  return lines
-}
-
-/**
- * The A/A band: what "nothing changed" looked like, or an explicit statement that
- * it is unknown and every direction is therefore withheld.
- * @param {object} comparison - the comparison structure.
- * @returns {string[]} the section lines.
- */
-function noiseSection(comparison) {
-  const noise = comparison.noiseFloor
-  const lines = ['## A/A 噪声带', '']
-  if (!noise.comparable) {
-    lines.push(
-      '噪声底未知 ⇒ 没有可读的区间,成本方向一律弃权(`noise-floor-unknown`);报告只给测到的 Δ,不给方向。',
-      '',
-      '提供方式:`--noise-floor-pct N` 固定一个已测量的噪声底,或 `--noise <base> <cand>` 用两次基线运行现测。',
-    )
-    return lines
-  }
-  lines.push(
-    `半宽 ±${noise.pct}% · 区间 [${percent(noise.band.low)}, ${percent(noise.band.high)}] · 方法 \`${noise.method}\` · 配对 ${noise.pairs} · 任务样本 ${noise.samples}${noise.medianAbsPct === null ? '' : ` · 中位幅度 ${noise.medianAbsPct}%`}`,
-    '',
-    'Δ 只有超过这个半宽才读方向;带内一律只报区间。',
-  )
-  if (noise.method === 'provided') lines.push('', '来源是外部提供(`--noise-floor-pct`),不是本次测量。')
-  if (noise.perTask.length > 0) {
-    lines.push('', '| task | base | cand | Δ% | 配对 |', '| --- | --- | --- | --- | --- |')
-    for (const entry of noise.perTask) lines.push(`| ${entry.id} | ${number(entry.base)} | ${number(entry.cand)} | ${percent(entry.pct)} | ${entry.pairs} |`)
-  }
-  return lines
-}
-
-/**
- * The token attribution: how the TOTAL delta splits into the per-request fixed cost,
- * the extra steps, and what neither explains. Diagnostic only — it never fails a run.
- * @param {object} comparison - the comparison structure.
- * @returns {string[]} the section lines.
- */
-function attributionSection(comparison) {
-  const overhead = comparison.overhead
-  const lines = ['## token 归因(诊断,不改判决)', '']
-  if (!overhead.comparable) {
-    lines.push('Skipped:至少一侧没有 prompt 采集(`metrics.prompt`),无法把 Δ 拆成固定开销 / 额外步数 / 残差。')
-    return lines
-  }
-  lines.push(
-    `可归因任务 ${overhead.comparableTasks}/${overhead.tasks}(首步 prompt 是唯一不带历史的请求,固定开销按它计)。`,
-    '',
-    `归因覆盖全部 ${overhead.tasks} 个有 prompt 采集的任务(含未进入成本统计的配对),所以它的合计与配对 token Δ 可能相差被排除任务的量。`,
-    '',
-    '| 项 | tokens Δ | 读法 |',
-    '| --- | --- | --- |',
-    `| 每请求固定开销 | ${signed(overhead.fixedOverheadTokens)} | 首步 prompt Δ × cand 步数:工具 schema / 提示策略 |`,
-    `| 额外步数 | ${signed(overhead.extraStepsTokens)} | Δ步数 × base 首步 prompt:模型行为 |`,
-    `| 残差 | ${signed(overhead.residualTokens)} | 上下文增长 / 工具返回等前两项未解释的部分 |`,
-    `| 输出 | ${signed(overhead.outputDelta)} | 模型输出 |`,
-    `| 合计(prompt + 输出) | ${signed(overhead.totalDelta)} | 与配对 token Δ 同向、同量级(差额来自被排除的任务) |`,
-  )
-  const rows = comparison.tasks.filter((task) => task.overhead?.comparable === true)
-  if (rows.length > 0) {
-    lines.push('', '### 每任务归因', '', '| task | 固定开销 Δ | 额外步数 Δ | 残差 Δ | 输出 Δ | 合计 Δ |', '| --- | --- | --- | --- | --- | --- |')
-    for (const task of rows) {
-      const entry = task.overhead
-      lines.push(`| ${task.id} | ${signed(entry.fixedOverheadTokens)} | ${signed(entry.extraStepsTokens)} | ${signed(entry.residualTokens)} | ${signed(entry.outputDelta)} | ${signed(entry.totalDelta)} |`)
-    }
+    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)} |`)
   }
+  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} |`)
   return lines
 }
 
@@ -525,9 +477,7 @@ 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 = [
-    `## 每任务 bucket 明细(${comparison.aggregate})`,
-    '',
-    '每格是该侧配对样本的统计量;TOTAL 行对配对求和,与每任务表"各任务统计量之和"的口径不同(重复数不等时两者不相等,判决只用后者)。',
+    `## Per-task bucket detail (${comparison.aggregate})`,
     '',
     '| task | input base→cand (Δ%) | output base→cand (Δ%) | cache read base→cand (Δ%) |',
     '| --- | --- | --- | --- |',
@@ -550,16 +500,14 @@ function bucketSection(comparison) {
  */
 function usageSplitSection(comparison) {
   const buckets = comparison.totals.buckets
-  const lines = [`## usage 拆分(TOTAL,${comparison.aggregate})`, '']
+  const lines = [`## usage split (TOTAL, ${comparison.aggregate})`, '']
   if (!buckets.comparable) {
-    lines.push('Skipped:至少一侧丢了 `step_end.usage`,per-bucket 的 Δ 会是"下界被当成测量值"。')
+    lines.push('Skipped: at least one side lost `step_end.usage`, so per-bucket Δs would present a lower bound as a measurement.')
     return lines
   }
-  const row = (label, bucket) => `| ${label} | ${number(bucket.base)} | ${number(bucket.cand)} | ${signed(bucket.delta)} (${percent(percentChange(bucket.base, bucket.cand))}) | ${bucket.sharePct === null ? 'n/a' : `${bucket.sharePct}%`} |`
+  const row = (label, bucket) => `| ${label} | ${number(bucket.base)} | ${number(bucket.cand)} | ${signed(bucket.delta)} (${percent(percentChange(bucket.base, bucket.cand))}) | ${rawPercent(bucket.sharePct)} |`
   lines.push(
-    '三个 bucket 相加是总数;Δ 落在 cache read 和落在 uncached input 是两张完全不同的账单。本节对配对求和(与每任务表的合计口径不同),判决仍只看配对的 token Δ。',
-    '',
-    '| bucket | base | cand | Δ (Δ%) | 占 Δ 的份额 |',
+    '| bucket | base | cand | Δ (Δ%) | share of Δ |',
     '| --- | --- | --- | --- | --- |',
     row('uncached input', buckets.input),
     row('output', buckets.output),
@@ -570,32 +518,84 @@ function usageSplitSection(comparison) {
 }
 
 /**
- * Tool adoption, summed over every repeat on each side: a tool called once and never
- * again is still evidence it was published and reached for, and a built-in the
- * candidate kept reaching for is the number this table exists to surface.
+ * 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)} |`)
+  }
+  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
+}
+
+/**
+ * Tool adoption, per tool and per task: a tool called once and never again is still
+ * evidence it was published and reached for. The `base` and `cand` columns keep the
+ * sweep-wide sums; each task column splits them by task, so a call can be read against
+ * the task whose Δ it explains.
+ *
+ * Colour follows adoption, not the sign: an `ops_*` tool rising is green (the plugin's
+ * tool replaced a built-in), while any other tool rising is red (the candidate kept
+ * reaching past the plugin); falling is green for a built-in and red for an `ops_*`
+ * tool. Equal counts are not painted.
+ *
+ * It renders directly under the per-task pair table: that table prices the Δ, this
+ * one shows the calls it was spent on, so the reader meets the two together.
  * @param {object} comparison - the comparison structure.
  * @returns {string[]} the section lines.
  */
 function toolSection(comparison) {
   const totals = new Map()
-  for (const task of comparison.tasks) {
+  const perTask = comparison.tasks.map((task) => {
+    const counts = new Map()
     for (const side of ['base', 'cand']) {
-      for (const [name, count] of Object.entries(task[side].toolCallsByName ?? {})) {
+      for (const [name, value] of Object.entries(task[side].toolCallsByName ?? {})) {
         const entry = totals.get(name) ?? { base: 0, cand: 0 }
-        entry[side] += count
+        entry[side] += value
         totals.set(name, entry)
+        const own = counts.get(name) ?? { base: 0, cand: 0 }
+        own[side] += value
+        counts.set(name, own)
       }
     }
-  }
-  const lines = ['## 工具调用(每侧重合计数)', '']
+    return { id: task.id, counts }
+  })
+  const lines = ['## Tool calls (per-side overlap counts)', '']
   if (totals.size === 0) {
-    lines.push('Skipped:两侧都没有记录 `toolCallsByName`。')
+    lines.push('Skipped: neither side recorded `toolCallsByName`.')
     return lines
   }
   const own = (name) => name.startsWith('ops')
+  const cand = (name, counts) => {
+    if (counts.cand === counts.base) return number(counts.cand)
+    const good = own(name) ? counts.cand > counts.base : counts.cand < counts.base
+    return `<span style="color:${good ? GREEN : RED}">${number(counts.cand)}</span>`
+  }
+  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 |', '| --- | --- | --- |')
-  for (const [name, counts] of rows) lines.push(`| ${name} | ${number(counts.base)} | ${number(counts.cand)} |`)
+  lines.push(
+    `| tool | base | cand | ${comparison.tasks.map((task) => task.id).join(' | ')} |`,
+    `| --- | --- | --- | ${comparison.tasks.map(() => '---').join(' | ')} |`,
+  )
+  for (const [name, counts] of rows) {
+    const tasks = perTask.map((task) => cell(name, task.counts.get(name))).join(' | ')
+    lines.push(`| ${name} | ${number(counts.base)} | ${cand(name, counts)} | ${tasks} |`)
+  }
   return lines
 }
 
@@ -606,12 +606,13 @@ function toolSection(comparison) {
  * @returns {string[]} the section lines.
  */
 function warningSection(comparison) {
-  if (comparison.warnings.length === 0) return ['## 警告', '', '没有警告。']
-  return ['## 警告', '', ...comparison.warnings.map((warning) => `- ${warning}`)]
+  if (comparison.warnings.length === 0) return ['## Warnings', '', 'No warnings.']
+  return ['## Warnings', '', ...comparison.warnings.map((warning) => `- ${paintPercents(warning)}`)]
 }
 
 /**
- * Render the comparison as `report.md`.
+ * 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.
@@ -621,46 +622,87 @@ function warningSection(comparison) {
  */
 export function renderReport(comparison, sources = {}) {
   const lines = [
-    ...verdictSection(comparison),
+    REPORT_TITLE,
     '',
     ...taskSection(comparison),
     '',
-    ...excludedSection(comparison),
-    '',
-    ...noiseSection(comparison),
-    '',
-    ...attributionSection(comparison),
+    ...toolSection(comparison),
     '',
     ...bucketSection(comparison),
     '',
     ...usageSplitSection(comparison),
     '',
-    ...toolSection(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 ?? '?'})`,
-    `- 文档:format \`${comparison.format}\` · aggregate \`${comparison.aggregate}\` · 容差 ${comparison.tolerancePct}%`,
+    `- 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).`,
     '',
-    `时间字段只作证据:本报告的成本口径是配对的 token,对比不读取时长的判决(${COMPARE_FORMAT} 不含时间统计)。`,
+    ...verdictSection(comparison),
   ]
   return lines.join('\n')
 }
 
+/**
+ * The write instant in the shape a run directory carries it: `2026-10-20T12-36-38Z`.
+ * Colons and dots become dashes so the name is legal on every filesystem, and the
+ * seconds are UTC so two comparisons never share a name across time zones.
+ * @param {number|Date} [now] - the instant; defaults to the wall clock.
+ * @returns {string} the stamp.
+ */
+export function reportStamp(now = Date.now()) {
+  return `${new Date(now).toISOString().replace(/[:.]/g, '-').slice(0, 19)}Z`
+}
+
+/**
+ * The report's file name: the title's words plus the write instant, so a folder of
+ * sweeps reads as reports rather than as `report.md` repeated.
+ * @param {number|Date} [now] - the instant; defaults to the wall clock.
+ * @returns {string} the file name, `.md` included.
+ */
+export function reportFileName(now = Date.now()) {
+  return `${REPORT_STEM} ${reportStamp(now)}.md`
+}
+
+/**
+ * The directory the report belongs to: the group folder a sweep shares, not the arm
+ * directory that measured half of it. A comparison is about the sweep, so a reviewer
+ * opening `bench/runs/full-sweep-4/` should find the report there.
+ *
+ * Only the shape this harness writes is promoted — a run directory one level below the
+ * runs root. A run directly under the root has no group folder to promote to, and
+ * anything deeper is some other layout, so both keep the report beside `run.json`.
+ * @param {Options} options - the parsed options.
+ * @param {{dir: string}} cand - the resolved candidate side.
+ * @returns {string} the absolute directory.
+ */
+function reportDir(options, cand) {
+  const runsDir = path.resolve(options.runsDir ?? RUNS_DIR)
+  const dir = path.resolve(cand.dir)
+  const parent = path.dirname(dir)
+  const group = path.relative(runsDir, parent)
+  const nested = group !== '' && !group.startsWith('..') && !path.isAbsolute(group) && !/[\\/]/.test(group)
+  return nested ? parent : dir
+}
+
 /**
  * Where the rendered artifact goes.
  * @param {Options} options - the parsed options.
  * @param {{dir: string}} cand - the resolved candidate side.
+ * @param {number} now - the instant the default file name carries.
  * @returns {string|null} the absolute path, or null to write no file.
  */
-function reportPath(options, cand) {
+function reportPath(options, cand, now) {
   if (options.out === '-') return null
   if (options.out !== null) return path.resolve(options.out)
   if (options.json) return null
-  return path.join(cand.dir, 'report.md')
+  return path.join(reportDir(options, cand), reportFileName(now))
 }
 
 /**
@@ -670,12 +712,14 @@ function reportPath(options, cand) {
  * and maps the gate to an exit code. A cost gate that could not run (no noise floor,
  * incomplete usage, no both-passed pair) abstains — it does not fail the run.
  * @param {string[]} argv - the arguments after the script name.
- * @param {{out?: Function, err?: Function}} [io] - output sinks; defaults to the console.
+ * @param {{out?: Function, err?: Function, now?: Function}} [io] - output sinks and the
+ *   clock the default file name reads; defaults to the console and the wall clock.
  * @returns {Promise<number>} the process exit code.
  */
 export async function main(argv, io = {}) {
   const out = io.out ?? ((line) => console.log(line))
   const err = io.err ?? ((line) => console.error(line))
+  const now = io.now ?? (() => Date.now())
   let options
   try {
     options = parseArgs(argv)
@@ -720,7 +764,7 @@ export async function main(argv, io = {}) {
     : `${renderReport(comparison, sources)}\n`
   out(payload)
 
-  const target = reportPath(options, cand)
+  const target = reportPath(options, cand, now())
   if (target !== null) {
     try {
       fs.mkdirSync(path.dirname(target), { recursive: true })
@@ -737,9 +781,9 @@ export async function main(argv, io = {}) {
     return EXIT.failure
   }
   if (options.failOn !== 'none') {
-    if (!comparison.gate.tokensComparable) err('compare: 成本门禁未运行(至少一侧 usage 不完整);只跑了 pass-drop。')
-    else if (!comparison.gate.costComparable) err(`compare: 成本门禁未运行(没有两侧都通过的配对,${comparison.gate.excludedPairs} 对被排除);只跑了 pass-drop。`)
-    else if (!comparison.noiseFloor.comparable) err('compare: 噪声底未知 ⇒ 成本方向弃权(noise-floor-unknown);用 --noise-floor-pct 或 --noise 提供。')
+    if (!comparison.gate.tokensComparable) err('compare: cost gate did not run (usage incomplete on at least one side); only the pass-drop gate ran.')
+    else if (!comparison.gate.costComparable) err(`compare: cost gate did not run (no pair passed on both sides; ${comparison.gate.excludedPairs} pair(s) excluded); only the pass-drop gate ran.`)
+    else if (!comparison.noiseFloor.comparable) err('compare: noise floor unknown ⇒ cost direction withheld (noise-floor-unknown); supply one with --noise-floor-pct or --noise.')
   }
   return EXIT.ok
 }
diff --git a/bench/lib/env.mjs b/bench/lib/env.mjs
index a6982ece..c8099450 100644
--- a/bench/lib/env.mjs
+++ b/bench/lib/env.mjs
@@ -19,6 +19,14 @@ import { fileURLToPath } from 'node:url'
 export const BENCH_DIR = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..')
 /** The repository root this checkout is, `bench/`'s parent. */
 export const REPO_ROOT = path.dirname(BENCH_DIR)
+/**
+ * The LLM overlay every dsh call is given, and the committed template it is filled in from.
+ * The filled-in file is gitignored: it names the operator's bench server and model. `setup`
+ * creates it and the runner injects it, and both read this one definition — the same path
+ * spelled in two modules is how the runner came to inject nothing while `setup` promised it.
+ */
+export const LLM_OVERLAY = path.join(BENCH_DIR, 'llm.patch.yml')
+export const LLM_OVERLAY_EXAMPLE = path.join(BENCH_DIR, 'llm.patch.example.yml')
 /**
  * The `<platform>-<arch>` tag the run contract records and reports key on.
  * @param {string} [platform] - the platform to tag (default the host).
diff --git a/bench/llm.patch.example.yml b/bench/llm.patch.example.yml
index 1840e95f..9162da48 100644
--- a/bench/llm.patch.example.yml
+++ b/bench/llm.patch.example.yml
@@ -7,7 +7,11 @@
 #      密钥只放环境变量或 $DSH_HOME/.credentials.yaml，**绝不写进本文件**；
 #   4) node bench/run.mjs 会自动把它以 --patch 传给每次 dsh 调用
 #      （含 dump-config 存档）→ bench-base / bench-ops 两侧
-#      provider/model 一致性由构造保证（PLAN §2.7）。
+#      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
diff --git a/bench/run.mjs b/bench/run.mjs
index 398a7acd..c6e66b34 100644
--- a/bench/run.mjs
+++ b/bench/run.mjs
@@ -24,12 +24,13 @@
  * @module dsh-ops/bench/run
  */
 
+import fs from 'node:fs'
 import path from 'node:path'
 import { spawnSync } from 'node:child_process'
 import { fileURLToPath } from 'node:url'
 
 import { EXIT, UsageError, planAb } from './cli.mjs'
-import { REPO_ROOT, resolveDshEntry } from './lib/env.mjs'
+import { LLM_OVERLAY, REPO_ROOT, resolveDshEntry } 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'
@@ -64,7 +65,10 @@ export function abUsage() {
     '  --stall-ms N         per-session silence that escalates a warning (default 60000)',
     '  --timeout MS         override each task\'s timeoutMs',
     '  --dsh <path>         dsh\'s JS entry (lib/bin.js); default: resolved from PATH',
-    '  --llm-patch <path>   overlay the session injects with --patch',
+    '  --llm-patch <path>   the overlay every dsh call is given with --patch',
+    '                       (default: bench/llm.patch.yml, the file `setup` creates)',
+    '  --no-llm-patch       run on the profiles\' own routes instead of the overlay;',
+    '                       the two sides then share no route and the sweep says so',
     '  --model <id>         model id recorded for the run',
     '  --keep               keep each temporary workspace',
     '  --verbose            narrate every event line',
@@ -106,6 +110,7 @@ export function parseRunArgs(argv, context = {}) {
     verbose: false,
     keep: false,
     noSeal: false,
+    noLlmPatch: false,
     sleepMs: 0,
     out: null,
     heartbeatMs: null,
@@ -121,6 +126,7 @@ export function parseRunArgs(argv, context = {}) {
     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 === '--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`)
     } else if (VALUE_FLAGS.includes(flag)) {
@@ -152,6 +158,40 @@ export function buildArms(options) {
   ]
 }
 
+/**
+ * Which LLM overlay this sweep hands to every dsh call.
+ *
+ * The overlay is the one file naming the bench server, the model and the environment
+ * variable holding the key, and `setup` is what creates it. A sweep that quietly ran
+ * without it would exercise the profiles' own routes instead — identical on both sides,
+ * so the report could not show the difference and the run would still look complete. The
+ * default is therefore the overlay, `--no-llm-patch` is how an operator says the profiles'
+ * own routes are what they mean, and anything else is refused before a token is spent.
+ * @param {{llmPatch: string|null, noLlmPatch: boolean}} options - the parsed flags.
+ * @param {{overlay?: string, exists?: (file: string) => boolean}} [context] - the default
+ *   overlay and the existence probe; injectable so a suite never reads the real file.
+ * @returns {{path: string|null, implicit: boolean}} the overlay to inject — null when the
+ *   sweep runs without one — and whether it came from the default rather than the flags.
+ * @throws {UsageError} when the two flags contradict, when a named overlay is missing, or
+ *   when there is no overlay to default to and `--no-llm-patch` did not say that is fine.
+ */
+export function resolveLlmPatch(options, context = {}) {
+  const overlay = context.overlay ?? LLM_OVERLAY
+  const exists = context.exists ?? ((file) => fs.existsSync(file))
+  if (options.llmPatch !== null && options.noLlmPatch) {
+    throw new UsageError('--llm-patch names the overlay to inject and --no-llm-patch removes it; pass one of them')
+  }
+  if (options.llmPatch !== null) {
+    if (!exists(options.llmPatch)) throw new UsageError(`--llm-patch names a file that does not exist: ${options.llmPatch}`)
+    return { path: options.llmPatch, implicit: false }
+  }
+  if (options.noLlmPatch) return { path: null, implicit: false }
+  if (!exists(overlay)) {
+    throw new UsageError(`there is no ${overlay}, so both arms would run on their profiles' own routes — run "node bench/cli.mjs setup" to create it, or pass --no-llm-patch to run that way on purpose`)
+  }
+  return { path: overlay, implicit: true }
+}
+
 /** 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
@@ -260,6 +300,24 @@ 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.
+  let patch
+  try {
+    patch = resolveLlmPatch(options, { overlay: io.llmOverlay, exists: io.overlayExists })
+  } catch (error) {
+    if (!(error instanceof UsageError)) throw error
+    // A contradictory or absent *named* overlay is a usage error whatever else is asked for;
+    // only a missing default is something `--show` may still print a plan around, because
+    // that plan is exactly how an operator sees that `setup` has not run yet.
+    const operatorNamed = options.llmPatch !== null || options.noLlmPatch
+    if (operatorNamed || options.show !== true) {
+      err(`bench ab: ${error.message}`)
+      err(abUsage())
+      return EXIT.usage
+    }
+    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.')
@@ -282,6 +340,7 @@ export async function main(argv, io = {}) {
 
   out(`[ab] base    : ${arms[0].label} (profile ${arms[0].profile})`)
   out(`[ab] cand    : ${arms[1].label} (profile ${arms[1].profile})${options.aa ? '  [A/A: the baseline run twice]' : ''}`)
+  out(`[ab] patch   : ${patch.path ?? 'none (--no-llm-patch) — the two sides share no route'}`)
   out(`[ab] pairs   : ${pairs.length} pair(s) = ${sessions.length} session(s), serial, AB/BA-interleaved${options.repeatExplicit ? ` (--repeat ${options.repeat})` : ' (per-task repeat budgets)'}`)
   if (options.out === null) out(`[ab] group   : bench/runs/${options.folder}${options.allocated ? ' [auto]' : ''}`)
   out(`[ab] out     : ${sweepDir}`)
@@ -290,6 +349,7 @@ export async function main(argv, io = {}) {
     for (const [index, pair] of pairs.entries()) {
       out(`[ab] ${String(index + 1).padStart(3)}/${pairs.length} ${pair.task.id} r${pair.repeatIndex}: ${armOrder(pair.repeatIndex, arms).map((arm) => arm.label).join(' → ')}`)
     }
+    if (patch.refused !== undefined) err(`[ab] patch   : ${patch.refused} — this plan cannot run as it stands`)
     out(`[ab] show only: nothing was spawned.`)
     return EXIT.ok
   }
@@ -305,6 +365,9 @@ export async function main(argv, io = {}) {
   const interrupt = io.interrupt ?? createInterrupt()
   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.
+  const recordedArgv = patch.implicit ? ['bench/run.mjs', ...argv, '--llm-patch', patch.path] : ['bench/run.mjs', ...argv]
   let result
   try {
     result = await (io.sweep ?? runSweep)({
@@ -315,10 +378,10 @@ export async function main(argv, io = {}) {
       dirs,
       folder: options.out === null ? options.folder : null,
       entry,
-      llmPatch: options.llmPatch,
+      llmPatch: patch.path,
       timeoutMs: options.timeoutMs,
       model: options.model,
-      argv: ['bench/run.mjs', ...argv],
+      argv: recordedArgv,
     }, {
       seal: options.noSeal === true ? undefined : io.seal,
       runSession: io.runSession,
diff --git a/bench/run/schedule.mjs b/bench/run/schedule.mjs
index 6d33119e..210d4f87 100644
--- a/bench/run/schedule.mjs
+++ b/bench/run/schedule.mjs
@@ -158,6 +158,7 @@ function failedRow(arm, pair, error, clock, spec) {
     timedOut: false,
     steps: 0,
     toolCalls: 0,
+    toolErrors: 0,
     usage: null,
     usageReported: false,
     toolCallsByName: {},
diff --git a/bench/run/session.mjs b/bench/run/session.mjs
index b548c7ea..b31f9c02 100644
--- a/bench/run/session.mjs
+++ b/bench/run/session.mjs
@@ -135,9 +135,10 @@ export function toVerifyChecks(outcome) {
 
 /**
  * A streaming fold of the event stream into the schema's `metrics` fields, deliberately
- * narrow: steps, tool calls, 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.
+ * 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.
  * @returns {{push(line: string): void, finish(): object}} the fold.
  */
 function createFold() {
@@ -145,6 +146,7 @@ function createFold() {
     steps: 0,
     stepsWithUsage: 0,
     toolCalls: 0,
+    toolErrors: 0,
     toolCallsByName: Object.create(null),
     usage: emptyUsage(),
     turnEndReason: null,
@@ -175,13 +177,16 @@ function createFold() {
         state.toolCalls += 1
         const name = typeof event.tool === 'string' && event.tool !== '' ? event.tool : '<unknown>'
         state.toolCallsByName[name] = (state.toolCallsByName[name] ?? 0) + 1
+        return
       }
+      if (event.type === 'tool_result' && event.status === 'error') state.toolErrors += 1
     },
     finish() {
       return {
         steps: state.steps,
         stepsWithUsage: state.stepsWithUsage,
         toolCalls: state.toolCalls,
+        toolErrors: state.toolErrors,
         toolCallsByName: { ...state.toolCallsByName },
         usage: { ...state.usage },
         usageReported: state.steps > 0 && state.stepsWithUsage === state.steps,
@@ -306,6 +311,7 @@ export async function runSession(spec, options = {}) {
       timedOut: facts.timedOut,
       steps: 0,
       toolCalls: 0,
+      toolErrors: 0,
       usage: emptyUsage(),
       usageReported: false,
       toolCallsByName: {},
@@ -481,6 +487,7 @@ export async function runSession(spec, options = {}) {
       timedOut: facts.timedOut,
       steps: counted.steps,
       toolCalls: counted.toolCalls,
+      toolErrors: counted.toolErrors,
       usage: counted.usage,
       usageReported: counted.usageReported,
       toolCallsByName: counted.toolCallsByName,
diff --git a/bench/setup/profile.mjs b/bench/setup/profile.mjs
index ccd39d93..ddb6ca75 100644
--- a/bench/setup/profile.mjs
+++ b/bench/setup/profile.mjs
@@ -51,7 +51,7 @@ import os from 'node:os'
 import path from 'node:path'
 import { spawnSync } from 'node:child_process'
 
-import { BENCH_DIR, REPO_ROOT } from '../lib/env.mjs'
+import { LLM_OVERLAY, LLM_OVERLAY_EXAMPLE, REPO_ROOT } from '../lib/env.mjs'
 
 /** The plugin under test — the only package this module ever installs, and the name every
  * install failure has to carry so "failed" never means "something, somewhere". */
@@ -72,9 +72,9 @@ export const PERMISSION_MODES = ['danger-full-access', 'workspace-write', 'read-
  * profile after one would make `--from-default-profile` read its own output. */
 export const SHIPPED_PROFILES = ['headless', 'web', 'tui', 'acp', 'sdk', 'sdk-minimal', 'dsh-tui']
 /** The overlay every dsh call is given, and the committed template it is filled in from.
- * The filled-in file is gitignored: it names the operator's bench server. */
-export const LLM_OVERLAY = path.join(BENCH_DIR, 'llm.patch.yml')
-export const LLM_OVERLAY_EXAMPLE = path.join(BENCH_DIR, 'llm.patch.example.yml')
+ * The filled-in file is gitignored: it names the operator's bench server. Defined next to
+ * the other shared paths, because the runner injects the very file this module creates. */
+export { LLM_OVERLAY, LLM_OVERLAY_EXAMPLE }
 
 /** The `setup` help text for the flags this half owns; setup B appends its own. */
 export const USAGE = `usage: node bench/cli.mjs setup [options]
diff --git a/test/bench-ci.test.mjs b/test/bench-ci.test.mjs
index 2c16d644..9811100d 100644
--- a/test/bench-ci.test.mjs
+++ b/test/bench-ci.test.mjs
@@ -87,6 +87,7 @@ await test('the smoke uploads report.md / run.json / panel.html when they exist'
   for (const name of ['run.json', 'report.md', 'panel.html']) {
     assert.ok(paths.includes(name), `the artifact path list includes ${name}`)
   }
+  assert.match(paths, /bench\/runs\/\*\/DSH-OPS Benchmark Report\*\.md/u, 'the default stamped report name is globbed too, so a group-level report is not silently left behind')
 })
 
 await test('.gitignore keeps bench evidence and the operator overlay out of the repository', () => {
diff --git a/test/bench-compare.test.mjs b/test/bench-compare.test.mjs
index ccb01e53..f0d090f7 100644
--- a/test/bench-compare.test.mjs
+++ b/test/bench-compare.test.mjs
@@ -1,15 +1,18 @@
 /**
  * The report layer: `bench/compare.mjs`, the slice that turns two archived runs into
- * the `report.md` a change review reads.
+ * the timestamped report a change review reads.
  *
  * The judgement itself is `compare-core.mjs` and is pinned by its own suite; what is
  * pinned here is the rendering and the wiring around it:
  *
- * 1. **Rendering is stable.** The same comparison and sources render byte-identical
- *    text twice — no clock, no random order — so a report is diffable.
- * 2. **The 结论条 has three wordings.** A delta beyond the A/A band reads a direction,
- *    a delta inside it reports the band only, and a comparison with no floor abstains
- *    (`noise-floor-unknown`) instead of reading noise as a result. The core's
+ * 1. **Rendering is stable, and the layout is fixed.** The same comparison and sources
+ *    render byte-identical text twice — no clock, no random order — so a report is
+ *    diffable; the title is a constant, the conclusion is the report's last section, and
+ *    every percent is painted by its sign (a drop or no change green, a rise red, in
+ *    `panel.html`'s palette).
+ * 2. **The closing conclusion has three wordings.** A delta beyond the A/A band reads a
+ *    direction, a delta inside it reports the band only, and a comparison with no floor
+ *    abstains (`noise-floor-unknown`) instead of reading noise as a result. The core's
  *    conclusion names travel verbatim into the text.
  * 3. **Excluded pairs are visible.** Pairs a failed side forced out of the cost
  *    statistics are counted, per task and in total.
@@ -30,7 +33,7 @@ import fs from 'node:fs'
 import path from 'node:path'
 import { assert, report, test, withTempDir } from './lib/harness.mjs'
 
-import { EXIT, main, parseArgs, renderReport, resolveSide } from '../bench/compare.mjs'
+import { EXIT, main, parseArgs, renderReport, reportFileName, reportStamp, resolveSide } from '../bench/compare.mjs'
 import { COMPARE_FORMAT, compareSummaries } from '../bench/lib/compare-core.mjs'
 
 const LABEL = 'bench-compare'
@@ -52,9 +55,9 @@ function metrics(taskId, tokens, pass, extra = {}) {
     usage: { inputTokens: input, outputTokens: tokens - input, cacheReadTokens: 0, cacheWriteTokens: 0, grandTotal: tokens },
     usageReported: true,
     steps: extra.steps ?? 4,
-    toolCalls: 6,
-    toolErrors: 0,
-    toolCallsByName: { ops_read: 2, bash: 1 },
+    toolCalls: extra.toolCalls ?? 6,
+    toolErrors: extra.toolErrors ?? 0,
+    toolCallsByName: extra.toolCallsByName ?? { ops_read: 2, bash: 1 },
     verify: { passed: pass, checks: [] },
     exitCode: 0,
     timedOut: false,
@@ -134,70 +137,163 @@ function writeRun(root, name, doc, fileName = 'run.json') {
 }
 
 /** A CLI invocation with the report and the diagnostics captured apart. */
-function invoke(argv) {
+function invoke(argv, extra = {}) {
   const out = []
   const err = []
   return {
-    run: () => main(argv, { out: (line) => out.push(line), err: (line) => err.push(line) }),
+    run: () => main(argv, { out: (line) => out.push(line), err: (line) => err.push(line), ...extra }),
     text: () => out.join('\n'),
     err: () => err.join('\n'),
   }
 }
 
+/** A literal path, escaped so it can be matched against a regex. */
+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' },
 }
 
-await test('the same comparison renders byte-identical text twice, and the verdict bar words each noise outcome', () => {
+/** 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>`
+
+/** 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', () => {
   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 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')
-  assert.match(text, /^# bench compare: bench-base → bench-ops$/m)
-  assert.match(text, /- 方向:Δ \u22127\.4%,超过噪声底 ±3\.1% ⇒ 可读方向:更省\(cheaper\)/)
-  assert.match(text, /🔬 噪声底\(A\/A\):±3\.1%\(provided\)/)
-  assert.match(text, /时间字段只作证据/)
+  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.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)
+  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.match(insideText, /- 方向:Δ \u22122\.5% 落在噪声带 ±3\.1% 内 ⇒ 只报区间,不读方向\(within-noise\)/)
-  assert.doesNotMatch(insideText, /可读方向/)
-  assert.match(insideText, /🚦 门禁通过/)
+  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, /- 噪声底\(A\/A\):未知\(noise-floor-unknown\)/)
-  assert.match(unknownText, /- 方向:Δ \+50\.0%,但噪声底未知 ⇒ 弃权,不读方向\(noise-floor-unknown\)/)
-  assert.match(unknownText, /--noise-floor-pct N 或 --noise <base> <cand>/)
-  assert.doesNotMatch(unknownText, /可读方向/)
-  assert.match(unknownText, /🚦 门禁通过/, 'an abstaining gate is not a failed gate')
+  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.
   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.match(worseText, /- 方向:Δ \+5\.0%,超过噪声底 ±3\.1% ⇒ 可读方向:更贵\(costlier\)/)
-  assert.match(worseText, /🚦 门禁失败\(regression\)/)
-  assert.match(worseText, /\| csv-sum \| 1,000 \| 1,050 \| \+5\.0% \| 2\/2 \| 0 \| 2\/2→2\/2 \| ⚠ 回归 \|/)
+  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)
 })
 
-await test('excluded pairs are counted per task and in total, and their absence is said out loud', () => {
+await test('the steps and tool calls table pairs each task, sums the totals, and reads the aggregate its title names', () => {
+  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)
+  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')
+
+  // `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%')}) |`))
+
+  // 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%')}) |`))
+
+  // 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')
+})
+
+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 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.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)
+  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')} |`))
+
+  const declined = compareSummaries(
+    summary('bench-base', [metrics('csv-sum', 1000, true, { toolCallsByName: { ops_read: 5 } })]),
+    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')
+
+  // Each task keeps its own column; a tool nobody used in a task reads as a dash.
+  const twoTasks = compareSummaries(
+    summary('bench-base', [metrics('csv-sum', 1000, true, { toolCallsByName: { ops_read: 1 } }), metrics('api-rename', 1000, true, { toolCallsByName: { ops_read: 2 } })]),
+    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)
+  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')
+})
+
+await test('excluded pairs leave the report body but stay in the warnings, and the pair table prices only usable pairs', () => {
   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)
-  assert.match(text, /## 被排除的配对\(成本不统计\)/)
-  assert.match(text, /共 2 对因至少一侧未通过被排除:base 失败 0 · cand 失败 2 · 两侧都失败 0。/)
-  assert.match(text, /\| csv-sum \| 2 \| 0 \| 2 \| 0 \|/)
-  assert.match(text, /1\/3 \| 2 \| 3\/3→1\/3 \|/, 'the pair table shows the usable/considered split next to the exclusion count')
-  assert.match(text, /- cost-pairs-excluded: 2 \(base 0, cand 2, both 0\)/)
+  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')
 
   const clean = compareSummaries(base, summary('bench-ops', base.results.map((entry) => ({ ...entry, usage: { ...entry.usage } }))), { noiseFloorPct: 3.1, failOn: 'none' })
-  assert.match(renderReport(clean, SOURCES), /没有被排除的配对:两侧都通过的配对全部参与了成本统计。/)
+  const cleanText = renderReport(clean, SOURCES)
+  assert.match(cleanText, /No warnings\./, 'nothing excluded means nothing to warn about')
+  assertEnglish(cleanText)
 })
 
 await test('--fail-on gates individually, and a gate that cannot run abstains at exit 0', async () => {
@@ -224,7 +320,7 @@ await test('--fail-on gates individually, and a gate that cannot run abstains at
     // No noise floor: the same +10% is measured but not judged — abstain, exit 0.
     const abstain = invoke([baseline, costlier, '--out', '-', '--fail-on', 'both'])
     assert.equal(await abstain.run(), EXIT.ok)
-    assert.match(abstain.err(), /噪声底未知 ⇒ 成本方向弃权/)
+    assert.match(abstain.err(), /noise floor unknown ⇒ cost direction withheld/)
     assert.match(abstain.text(), /noise-floor-unknown/)
   })
 })
@@ -248,7 +344,7 @@ await test('--json prints the compare-core document itself, not a re-derived sha
       { noiseFloorPct: 3.1 },
     )
     assert.deepEqual(doc, JSON.parse(JSON.stringify(expected)), 'the JSON is the core document verbatim')
-    assert.equal(fs.existsSync(path.join(candDir, 'report.md')), false, 'JSON mode writes no markdown unless --out names a file')
+    assert.equal(fs.readdirSync(candDir).sort().join(), 'run.json', 'JSON mode writes no markdown unless --out names a file')
 
     // …and --out writes the JSON where asked.
     const target = path.join(root, 'out', 'comparison.json')
@@ -258,25 +354,47 @@ await test('--json prints the compare-core document itself, not a re-derived sha
   })
 })
 
-await test('the default artifact is <cand>/report.md, and --out - writes nothing', async () => {
+await test('the default artifact lands in the sweep folder, named by the write instant', async () => {
+  assert.equal(reportStamp(new Date('2026-10-20T12:36:38.123Z')), '2026-10-20T12-36-38Z', 'the name carries a filesystem-safe UTC stamp')
+  assert.equal(reportFileName(new Date('2026-10-20T12:36:38.123Z')), 'DSH-OPS Benchmark Report 2026-10-20T12-36-38Z.md')
   await withTempDir('bench-compare-out', async (root) => {
-    const baseDir = writeRun(root, 'base', sealedRun('bench-base', [row('csv-sum', 1, 700, true)]))
-    const candDir = writeRun(root, 'cand', sealedRun('bench-ops', [row('csv-sum', 1, 500, true)]))
-    const cli = invoke([baseDir, candDir, '--noise-floor-pct', '3.1'])
+    const runs = path.join(root, 'runs')
+    const group = path.join(runs, 'benchmark-test-07')
+    const baseDir = writeRun(group, '2026-10-18T00-00-00Z-bench-base', sealedRun('bench-base', [row('csv-sum', 1, 700, true)]))
+    const candDir = writeRun(group, '2026-10-18T00-00-01Z-bench-ops', sealedRun('bench-ops', [row('csv-sum', 1, 500, true)]))
+    const instant = Date.parse('2026-10-20T12:36:38.123Z')
+    const sides = ['bench-base', 'bench-ops', '--runs', runs, '--folder', 'benchmark-test-07', '--noise-floor-pct', '3.1']
+    const cli = invoke(sides, { now: () => instant })
     assert.equal(await cli.run(), EXIT.ok)
-    const reportFile = path.join(candDir, 'report.md')
-    assert.ok(fs.existsSync(reportFile), 'the report lands beside the candidate run.json')
+    const reportFile = path.join(group, 'DSH-OPS Benchmark Report 2026-10-20T12-36-38Z.md')
+    assert.ok(fs.existsSync(reportFile), 'the report lands in the sweep folder, not inside the arm that measured half of it')
+    assert.equal(fs.readdirSync(candDir).sort().join(), 'run.json', 'the arm directory keeps its own evidence only')
     assert.equal(fs.readFileSync(reportFile, 'utf8'), cli.text())
-    assert.match(cli.err(), new RegExp(`compare: wrote ${reportFile.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}`))
+    assert.match(cli.err(), new RegExp(`compare: wrote ${literal(reportFile)}`))
+
+    // A second comparison is a second artifact: the instant in the name stops one sweep
+    // from overwriting the report of another that ran a second earlier.
+    const later = invoke(sides, { now: () => instant + 1000 })
+    assert.equal(await later.run(), EXIT.ok)
+    assert.ok(fs.existsSync(reportFile) && fs.existsSync(path.join(group, 'DSH-OPS Benchmark Report 2026-10-20T12-36-39Z.md')))
+
+    // The same placement holds when the sides are given as directories rather than labels.
+    const byDir = invoke([baseDir, candDir, '--runs', runs, '--noise-floor-pct', '3.1'], { now: () => instant + 2000 })
+    assert.equal(await byDir.run(), EXIT.ok)
+    assert.ok(fs.existsSync(path.join(group, 'DSH-OPS Benchmark Report 2026-10-20T12-36-40Z.md')), 'a run directory inside a sweep folder is promoted too')
+
+    // A run directory directly under the runs root has no sweep folder to promote to.
+    const flatDir = writeRun(runs, '2026-10-18T00-00-02Z-bench-ops', sealedRun('bench-ops', [row('csv-sum', 1, 500, true)]))
+    assert.equal(await invoke([baseDir, flatDir, '--runs', runs, '--noise-floor-pct', '3.1'], { now: () => instant }).run(), EXIT.ok)
+    assert.ok(fs.existsSync(path.join(flatDir, 'DSH-OPS Benchmark Report 2026-10-20T12-36-38Z.md')), 'no group folder ⇒ the report stays beside run.json')
 
-    const stdoutOnly = invoke([baseDir, candDir, '--noise-floor-pct', '3.1', '--out', '-'])
+    const stdoutOnly = invoke([baseDir, candDir, '--noise-floor-pct', '3.1', '--out', '-'], { now: () => instant })
     assert.equal(await stdoutOnly.run(), EXIT.ok)
-    assert.equal(fs.existsSync(path.join(root, 'report.md')), false)
-    assert.equal(fs.readFileSync(reportFile, 'utf8'), stdoutOnly.text(), '--out - renders the same text without touching disk')
+    assert.equal(fs.readdirSync(candDir).sort().join(), 'run.json', '--out - writes nothing')
 
     const explicit = path.join(root, 'elsewhere', 'r.md')
-    assert.equal(await invoke([baseDir, candDir, '--noise-floor-pct', '3.1', '--out', explicit]).run(), EXIT.ok)
-    assert.equal(fs.readFileSync(explicit, 'utf8'), cli.text())
+    assert.equal(await invoke([baseDir, candDir, '--noise-floor-pct', '3.1', '--out', explicit], { now: () => instant }).run(), EXIT.ok)
+    assert.equal(fs.readFileSync(explicit, 'utf8'), stdoutOnly.text())
   })
 })
 
@@ -298,7 +416,7 @@ await test('label, directory and file forms resolve to the same comparison', asy
     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.match(byDir.text(), /api-rename \| 500 \| 620 \| \+24\.0% \| 1\/1 \| 0 \| 1\/1→1\/1 \| ⚠ 回归 \|/)
+    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 |`))
 
     // 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)
@@ -366,14 +484,15 @@ 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), /方法 `aa-max-abs-task-pct`/)
-
-    // A row with no duration/prompt capture cannot support attribution, and the
-    // report says "Skipped" rather than presenting a guess.
-    const bare = summary('bench-base', [{ ...metrics('csv-sum', 1000, true, { prompt: false }) }])
-    const text = renderReport(compareSummaries(bare, summary('bench-ops', [metrics('csv-sum', 900, true, { prompt: false })]), { noiseFloorPct: 3.1 }), SOURCES)
-    assert.match(text, /Skipped:至少一侧没有 prompt 采集/)
-    assert.doesNotMatch(text, /每请求固定开销 \|/)
+    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)
+    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 61b0c0dd..5ddb2111 100644
--- a/test/bench-run-session.test.mjs
+++ b/test/bench-run-session.test.mjs
@@ -177,6 +177,7 @@ await test('archive + metrics + trace: NDJSON appended verbatim, usage folded, t
       { type: 'status', phase: 'step_end', step: 1, turn: 1, usage: { inputTokens: 10, outputTokens: 5, cacheReadTokens: 2, cacheWriteTokens: 1 } },
       { type: 'tool_call', tool: 'read', input: { path: 'src' } },
       { type: 'tool_result', status: 'ok', result: 'ok' },
+      { type: 'tool_result', status: 'error', result: 'boom' },
       { type: 'status', phase: 'step_end', step: 2, turn: 1 },
       { type: 'status', phase: 'turn_end', turn: 1, reason: { kind: 'completed' } },
       { type: 'final', text: 'done' },
@@ -198,6 +199,7 @@ await test('archive + metrics + trace: NDJSON appended verbatim, usage folded, t
 
     assert.equal(row.steps, 2)
     assert.equal(row.toolCalls, 1)
+    assert.equal(row.toolErrors, 1, 'a tool result whose status is error is counted as a tool error')
     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')
diff --git a/test/bench-schedule.test.mjs b/test/bench-schedule.test.mjs
index e3393ab1..23814dcb 100644
--- a/test/bench-schedule.test.mjs
+++ b/test/bench-schedule.test.mjs
@@ -92,7 +92,7 @@ function rig({ tokens = () => 100, pass = () => true, fail = null, onCall = null
     running += 1
     high = Math.max(high, running)
     const index = calls.length
-    calls.push({ taskId: spec.task.id, repeatIndex: spec.repeatIndex, arm: spec.arm, profile: options.profile, outDir: options.outDir })
+    calls.push({ taskId: spec.task.id, repeatIndex: spec.repeatIndex, arm: spec.arm, profile: options.profile, outDir: options.outDir, llmPatch: options.llmPatch ?? null })
     await tick()
     running -= 1
     if (onCall) await onCall({ spec, options, index, calls })
@@ -137,6 +137,13 @@ function tasksDir(root, repeat = 2) {
   return dir
 }
 
+/** An overlay file inside a temp root: what `setup` would have created for a real sweep. */
+function overlayIn(root, name = 'llm.patch.yml') {
+  const file = path.join(root, name)
+  fs.writeFileSync(file, '- id: agent-default-model\n  config:\n    provider: bench-server\n')
+  return file
+}
+
 await test('armOrder flips with the parity of the repeat, and rejects a repeat of zero', () => {
   assert.deepEqual(armOrder(1, ARMS).map((arm) => arm.side), ['base', 'cand'])
   assert.deepEqual(armOrder(2, ARMS).map((arm) => arm.side), ['cand', 'base'])
@@ -394,7 +401,7 @@ await test('main: --show prints the flip without running; a missing seal refuses
     const tasks = tasksDir(root)
     const runsDir = path.join(root, 'runs')
     const scripted = rig()
-    const base = { tasksDir: tasks, runsDir, runSession: scripted.runSession, installSignals: false, now: NOW }
+    const base = { tasksDir: tasks, runsDir, runSession: scripted.runSession, installSignals: false, now: NOW, llmOverlay: overlayIn(root) }
 
     const out = sink()
     assert.equal(await main(['--show'], { ...base, ...out }), EXIT.ok)
@@ -425,11 +432,13 @@ await test('main: a sealed A/A sweep exits 0 with the measured floor; a broken o
     const tasks = tasksDir(root, 2)
     const runsDir = path.join(root, 'runs')
     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'], {
       ...aaOut,
       tasksDir: tasks,
       runsDir,
+      llmOverlay: overlay,
       runSession: scripted.runSession,
       resolveEntry: () => ENTRY,
       installSignals: false,
@@ -447,6 +456,7 @@ await test('main: a sealed A/A sweep exits 0 with the measured floor; a broken o
       ...brokenOut,
       tasksDir: tasks,
       runsDir,
+      llmOverlay: overlay,
       runSession: broken.runSession,
       resolveEntry: () => ENTRY,
 
@@ -469,6 +479,7 @@ await test('main: Ctrl-C during a session stops the sweep, reports it, and exits
       ...out,
       tasksDir: tasks,
       runsDir: path.join(root, 'runs'),
+      llmOverlay: overlayIn(root),
       runSession: scripted.runSession,
       resolveEntry: () => ENTRY,
       interrupt,
@@ -490,6 +501,7 @@ await test('main --no-seal runs anyway and says out loud that no run.json was wr
       ...out,
       tasksDir: tasksDir(root, 1),
       runsDir: path.join(root, 'runs'),
+      llmOverlay: overlayIn(root),
       runSession: scripted.runSession,
       resolveEntry: () => ENTRY,
       installSignals: false,
@@ -501,4 +513,66 @@ await test('main --no-seal runs anyway and says out loud that no run.json was wr
   })
 })
 
+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 overlay = overlayIn(root)
+
+    // The default is the file `setup` creates, every session is handed it, and the archived
+    // command line names it — the operator never typed the flag that made the run valid.
+    const seeded = sink()
+    const scripted = rig()
+    let sealed = null
+    const code = await main(['--repeat', '1'], {
+      ...runner, ...seeded, runSession: scripted.runSession, llmOverlay: overlay,
+      seal: (context) => { sealed = context; return { path: 'run.json' } },
+    })
+    assert.equal(code, EXIT.ok)
+    assert.deepEqual(scripted.calls.map((call) => call.llmPatch), [overlay, overlay], 'both arms get the overlay')
+    assert.deepEqual(sealed.meta.argv.slice(-2), ['--llm-patch', overlay], 'the summary records the overlay the operator did not type')
+    assert.match(seeded.text(), /\[ab\] patch   : .*llm\.patch\.yml/)
+
+    // `--no-llm-patch` is how an operator says the profiles' own routes are what they mean.
+    const optedOut = sink()
+    const noPatch = rig()
+    assert.equal(await main(['--repeat', '1', '--no-llm-patch'], {
+      ...runner, ...optedOut, runSession: noPatch.runSession, llmOverlay: overlay, seal: () => ({}),
+    }), EXIT.ok)
+    assert.deepEqual(noPatch.calls.map((call) => call.llmPatch), [null, null], 'no overlay is injected')
+    assert.match(optedOut.text(), /none \(--no-llm-patch\)/)
+
+    // No overlay and no opt-out: refused before anything is spawned, naming both ways out.
+    const missing = sink()
+    const untouched = rig()
+    const absent = path.join(root, 'nope.yml')
+    assert.equal(await main(['--repeat', '1'], {
+      ...runner, ...missing, runSession: untouched.runSession, llmOverlay: absent, seal: () => ({}),
+    }), EXIT.usage)
+    assert.match(missing.both(), /there is no .*nope\.yml/)
+    assert.match(missing.both(), /--no-llm-patch/)
+    assert.equal(untouched.calls.length, 0, 'a refused sweep spends no token')
+
+    // The two flags contradict, and an overlay named by the operator has to exist.
+    const both = sink()
+    assert.equal(await main(['--llm-patch', overlay, '--no-llm-patch'], { ...runner, ...both, seal: () => ({}) }), EXIT.usage)
+    assert.match(both.both(), /pass one of them/)
+    const ghost = sink()
+    assert.equal(await main(['--llm-patch', path.join(root, 'ghost.yml')], { ...runner, ...ghost, seal: () => ({}) }), EXIT.usage)
+    assert.match(ghost.both(), /does not exist/)
+
+    // `--show` still prints a plan, and says out loud when that plan cannot run as it stands.
+    const plan = sink()
+    assert.equal(await main(['--show'], { ...runner, ...plan, llmOverlay: absent }), EXIT.ok)
+    assert.match(plan.text(), /\[ab\] patch   : none/)
+    assert.match(plan.text('err'), /cannot run as it stands/)
+    // A flag the operator typed wrong is a usage error even in that plan-only mode.
+    const planClash = sink()
+    assert.equal(await main(['--show', '--llm-patch', overlay, '--no-llm-patch'], { ...runner, ...planClash }), EXIT.usage)
+    assert.match(planClash.both(), /pass one of them/)
+    const planGhost = sink()
+    assert.equal(await main(['--show', '--llm-patch', path.join(root, 'ghost.yml')], { ...runner, ...planGhost }), EXIT.usage)
+    assert.match(planGhost.both(), /does not exist/)
+  })
+})
+
 report(LABEL)