From 1748e62991a7061f019d88d8180cdbc50e725f98 Mon Sep 17 00:00:00 2001
From: Shen Haoming <167516473+Haoming9527@users.noreply.github.com>
Date: Sun, 25 Oct 2026 00:42:07 +0800
Subject: [PATCH] feat(bench): route and separate model reasoning conditions

---
 bench/README.md                |  14 +++
 bench/compare.mjs              |  31 ++++++-
 bench/lib/compare-core.mjs     |   6 ++
 bench/lib/condition.mjs        |  82 +++++++++++++++++
 bench/lib/matrix.mjs           |  58 ++++++++++++
 bench/report/panel.mjs         |   2 +
 bench/run.mjs                  |  48 ++++++++--
 bench/run.schema.json          |   3 +
 bench/run/schedule.mjs         |   3 +
 bench/run/seal.mjs             |   2 +
 bench/run/session.mjs          |   3 +-
 docs/CHANGELOG.md              |   3 +
 test/bench-compare.test.mjs    |   2 +-
 test/bench-conditions.test.mjs | 156 +++++++++++++++++++++++++++++++++
 14 files changed, 401 insertions(+), 12 deletions(-)
 create mode 100644 bench/lib/condition.mjs
 create mode 100644 bench/lib/matrix.mjs
 create mode 100644 test/bench-conditions.test.mjs

diff --git a/bench/README.md b/bench/README.md
index a196fd86..5f52c3dc 100644
--- a/bench/README.md
+++ b/bench/README.md
@@ -49,6 +49,20 @@ node bench/cli.mjs ab --task csv-sum
 - 文件夹名称格式为 `benchmark-YYYY-MM-DD-NN`（按当天日期编号，从 `-00` 起）
 - 跑完自动在组目录写 `DSH-OPS Benchmark Report <UTC>.md`
 
+## 成本 A/B 的条件 / A/B measurement conditions
+
+```console
+node bench/cli.mjs ab --model DeepSeek-V4.1-Flash --reasoning-effort high --seal
+node bench/cli.mjs ab --model model-a --model model-b --reasoning-effort low --reasoning-effort high --seal
+node bench/cli.mjs report --matrix bench/runs/benchmark-YYYY-MM-DD-NN
+```
+
+`--model` 会真实改变两臂路由；`--reasoning-effort` 只接受 `off|low|high|max`。Provider 默认取 LLM overlay 中的字面值，也可用 `--provider` 指定；请先在 overlay/provider 配置中声明要测试的模型。条件补丁作为最后一个 `--patch` 同时传入两臂，不修改原来的 `llm.patch.yml`。每臂保留实际 `dump-config.txt`，`--seal` 将同源 `{provider, model, reasoningEffort}` 写入 `run.json` 的 `meta.condition`。未指定思考等级且 overlay 也没有该值时，记录 `null`（宿主默认值未固定）。
+
+重复的模型与档位形成笛卡尔积，每个条件位于独立的 `condition-NNN` 目录；根目录的 `matrix.json` 指向各组证据。多组报告逐条件展示，**跨条件不可比，不合并 Δ**。不同条件（含已知与未知）交给 compare 会退 `2` 并列出两侧条件。不传这些旗标时仍使用原有 overlay，条件标为 `unknown`；旧 run 缺少该字段仍可读，旧 `meta.model` 标签不作为路由证据。
+
+Model flags set the actual shared route, with the condition patch applied after the provider overlay. Both arms archive their composed configuration. Repeated models and reasoning levels form independent Cartesian groups; `report --matrix` renders one section per condition and never combines deltas. Cross-condition comparisons exit 2, naming both conditions. Without new flags, routing is unchanged and the condition is `unknown`; historical labels do not prove routing. An omitted reasoning level remains `null` unless the overlay pins it. All examples are optional model-driven runs, outside CI.
+
 ## 任务一览
 
 六个任务各自压一种能力，`ops_*` 工具名来自 `publicToolName()`。每个任务的期望值都由夹具生成器现算（`derive*`），判卷在 `bench/lib/verify.mjs`。
diff --git a/bench/compare.mjs b/bench/compare.mjs
index dd5ccf01..e8b63de1 100644
--- a/bench/compare.mjs
+++ b/bench/compare.mjs
@@ -30,6 +30,8 @@
 import fs from 'node:fs'
 import path from 'node:path'
 import { fileURLToPath } from 'node:url'
+import { ConditionError, describeCondition } from './lib/condition.mjs'
+import { matrixComparisons, renderMatrix } from './lib/matrix.mjs'
 
 import {
   AGGREGATES,
@@ -62,6 +64,7 @@ const RED = '#f85149'
 export const EXIT = { ok: 0, failure: 1, usage: 2 }
 
 const USAGE = `usage: node bench/compare.mjs <base> <cand> [options]
+       node bench/compare.mjs --matrix <group-directory> [options]
 
   <base> <cand>      each side is one of:
                        <label>   a run label, matched against bench/runs/*-<label>
@@ -115,6 +118,7 @@ export function parseArgs(argv) {
   const options = {
     base: null,
     cand: null,
+    matrix: null,
     folder: null,
     runsDir: RUNS_DIR,
     aggregate: 'median',
@@ -159,6 +163,7 @@ export function parseArgs(argv) {
       } else if (name === '--out') options.out = take()
       else if (name === '--folder') options.folder = assertFolderName(take(), '--folder')
       else if (name === '--runs') options.runsDir = path.resolve(take())
+      else if (name === '--matrix') options.matrix = path.resolve(take())
       else throw new Error(`unknown option "${name}"`)
       continue
     }
@@ -173,6 +178,10 @@ export function parseArgs(argv) {
     throw new Error('--noise-floor-pct must be a non-negative number')
   }
   if (options.help) return options
+  if (options.matrix !== null) {
+    if (positional.length || options.folder !== null || options.noise !== null) throw new Error('--matrix takes its groups from matrix.json; do not pass side labels, --folder or --noise')
+    return options
+  }
   if (positional.length !== 2) throw new Error('expected exactly two sides: <base> <cand>')
   options.base = positional[0]
   options.cand = positional[1]
@@ -516,6 +525,8 @@ export function renderReport(comparison) {
   const lines = [
     REPORT_TITLE,
     '',
+    `Condition: ${describeCondition(comparison.condition)}`,
+    '',
     ...taskSection(comparison),
     '',
     ...toolSection(comparison),
@@ -610,6 +621,17 @@ export async function main(argv, io = {}) {
     out(USAGE)
     return EXIT.ok
   }
+  if (options.matrix !== null) {
+    try {
+      const comparisons = matrixComparisons(options.matrix, options, { resolveSide, compare: compareSummaries })
+      const payload = options.json ? JSON.stringify({ format: 'dsh-ops-bench-matrix-report-v1', comparableAcrossConditions: false, comparisons }, null, 2) : renderMatrix(comparisons, renderReport)
+      out(payload)
+      const target = options.out ? path.resolve(options.out) : path.join(options.matrix, reportFileName(now()))
+      fs.writeFileSync(target, payload + '\n')
+      err(`compare matrix: wrote ${target}`)
+      return comparisons.some(value => value.gate.fail) ? EXIT.failure : EXIT.ok
+    } catch (error) { err(`compare matrix: ${error.message}`); return EXIT.usage }
+  }
 
   let base
   let cand
@@ -625,14 +647,19 @@ export async function main(argv, io = {}) {
     return EXIT.usage
   }
 
-  const comparison = compareSummaries(base.doc, cand.doc, {
+  let comparison
+  try { comparison = compareSummaries(base.doc, cand.doc, {
     aggregate: options.aggregate,
     tolerancePct: options.tolerancePct,
     failOn: options.failOn,
     regressionScope: options.regressionScope,
     noiseFloorPct: options.noiseFloorPct ?? undefined,
     noise: noise ?? undefined,
-  })
+  }) } catch (error) {
+    if (!(error instanceof ConditionError)) throw error
+    err(`compare: ${error.message}`)
+    return EXIT.usage
+  }
   const payload = options.json
     ? `${JSON.stringify(comparison, null, 2)}\n`
     : `${renderReport(comparison)}\n`
diff --git a/bench/lib/compare-core.mjs b/bench/lib/compare-core.mjs
index 9197c1c4..92910406 100644
--- a/bench/lib/compare-core.mjs
+++ b/bench/lib/compare-core.mjs
@@ -33,6 +33,7 @@
  */
 
 import { CORE_BUCKETS, median, minValue, pairMetrics } from './aggregate.mjs'
+import { assertSameCondition } from './condition.mjs'
 
 export { median, minValue }
 
@@ -481,6 +482,7 @@ export function classifyExcluded(pairs, taskId = null) {
  * @returns {object} the noise-floor document; `pct: null` when nothing could be paired.
  */
 export function noiseFloor(baseA, baseB, options = {}) {
+  assertSameCondition(baseA, baseB)
   const aggregate = AGGREGATES.includes(options.aggregate) ? options.aggregate : 'median'
   const merged = pairMetrics(normalizeResults(baseA), normalizeResults(baseB))
   const usablePairs = merged.pairs.filter((pair) => passed(pair.base) && passed(pair.cand))
@@ -547,6 +549,8 @@ export function resolveNoiseFloor(options = {}, base = null, cand = null) {
   }
   const noise = options.noise
   if (noise && typeof noise === 'object' && !Array.isArray(noise) && (noise.base || noise.cand)) {
+    assertSameCondition(base, noise.base ?? base)
+    assertSameCondition(base, noise.cand ?? base)
     return noiseFloor(noise.base ?? base, noise.cand ?? base, { aggregate: options.aggregate })
   }
   return {
@@ -702,6 +706,7 @@ export function formatNumber(value) {
  * @returns {object} the comparison structure, including the gate and the verdict.
  */
 export function compareSummaries(base, cand, options = {}) {
+  const condition = assertSameCondition(base, cand)
   const aggregate = AGGREGATES.includes(options.aggregate) ? options.aggregate : 'median'
   const tolerancePct = isNumber(options.tolerancePct) ? options.tolerancePct : 2
   const failOn = FAIL_ON.includes(options.failOn) ? options.failOn : 'both'
@@ -853,6 +858,7 @@ export function compareSummaries(base, cand, options = {}) {
 
   return {
     format: COMPARE_FORMAT,
+    condition,
     base: { label: sideLabel(base, 'base'), profile: sideProfile(base, 'base'), model: baseModel, dshVersion: sideDshVersion(base, 'base') },
     cand: { label: sideLabel(cand, 'cand'), profile: sideProfile(cand, 'cand'), model: candModel, dshVersion: sideDshVersion(cand, 'cand') },
     aggregate,
diff --git a/bench/lib/condition.mjs b/bench/lib/condition.mjs
new file mode 100644
index 00000000..91f7b5db
--- /dev/null
+++ b/bench/lib/condition.mjs
@@ -0,0 +1,82 @@
+/** Explicit, reproducible model routing; unknown historical conditions stay unknown. */
+import fs from 'node:fs'
+import path from 'node:path'
+import { parse, stringify } from 'yaml'
+
+export const REASONING_EFFORTS = Object.freeze(['off', 'low', 'high', 'max'])
+export class ConditionError extends Error {}
+const literal = value => typeof value === 'string' && value.trim() !== '' && !/[\x00-\x1f]/u.test(value)
+
+export function reasoningEffort(value) {
+  if (!REASONING_EFFORTS.includes(value)) throw new ConditionError(`--reasoning-effort must be one of ${REASONING_EFFORTS.join(', ')}; got ${JSON.stringify(value)}`)
+  return value
+}
+
+export function conditionOf(run) {
+  const value = Object.hasOwn(run?.meta ?? {}, 'condition') ? run.meta.condition : run?.condition ?? null
+  if (value === null) return null
+  if (!literal(value.provider) || !literal(value.model)
+    || value.reasoningEffort !== null && !REASONING_EFFORTS.includes(value.reasoningEffort)) {
+    throw new ConditionError(`Invalid recorded condition: ${JSON.stringify(value)}`)
+  }
+  return { provider: value.provider, model: value.model, reasoningEffort: value.reasoningEffort }
+}
+
+export function describeCondition(value) {
+  return value === null || value === undefined ? 'unknown' : JSON.stringify(conditionOf({ condition: value }))
+}
+
+export function assertSameCondition(base, cand) {
+  const left = conditionOf(base), right = conditionOf(cand)
+  if (JSON.stringify(left) !== JSON.stringify(right)) {
+    throw new ConditionError(`Conditions differ; base=${describeCondition(left)}; ops=${describeCondition(right)}. Cross-condition pairing is refused.`)
+  }
+  return left
+}
+
+/** Refuse to spend tokens when the composed host profile did not apply the requested route. */
+export function assertEffectiveCondition(text, expected) {
+  if (expected === null || expected === undefined) return
+  const rows = parse(text, { customTags: [{ tag: 'tag:yaml.org,2002:js', resolve: value => ({ expression: value }) }] })
+  const entries = Array.isArray(rows) ? rows.filter(row => row?.id === 'agent-default-model' && row.disabled !== true) : []
+  const actual = entries.length === 1 ? entries[0].config : null
+  if (!actual || actual.provider !== expected.provider || actual.model !== expected.model
+    || expected.reasoningEffort !== null && actual.reasoningEffort !== expected.reasoningEffort) {
+    throw new ConditionError(`Composed agent-default-model route does not match requested condition ${describeCondition(expected)}; nothing was run.`)
+  }
+}
+
+/** The overlay's literal route supplies omitted CLI fields; no expression is evaluated. */
+export function planConditions(options, patch, read = file => fs.readFileSync(file, 'utf8')) {
+  if (!options.models.length && !options.reasoningEfforts.length && options.provider === null) return [null]
+  let route = {}
+  if (patch !== null) {
+    const rows = parse(read(patch), { customTags: [{ tag: 'tag:yaml.org,2002:js', resolve: value => ({ expression: value }) }] })
+    if (!Array.isArray(rows)) throw new ConditionError('The LLM overlay must be a list of patch entries')
+    for (const row of rows) if (row?.id === 'agent-default-model') route = row.config ?? {}
+  }
+  const provider = options.provider ?? route.provider
+  const models = options.models.length ? options.models : [route.model]
+  const efforts = options.reasoningEfforts.length ? options.reasoningEfforts : [route.reasoningEffort ?? null]
+  if (!literal(provider)) throw new ConditionError('Explicit conditions need a literal provider in the LLM overlay or --provider <id>')
+  if (models.some(model => !literal(model))) throw new ConditionError('Explicit conditions need --model <id> or a literal model in the LLM overlay')
+  for (const effort of efforts) if (effort !== null) reasoningEffort(effort)
+  return [...new Set(models)].flatMap(model => [...new Set(efforts)].map(reasoningEffort => ({ provider, model, reasoningEffort })))
+}
+
+/** Both arms receive the identical final patch after the original provider overlay. */
+export function writeConditionPatch(dir, condition) {
+  if (condition === null) return null
+  const { provider, model, reasoningEffort } = conditionOf({ condition })
+  fs.mkdirSync(dir, { recursive: true })
+  const target = path.join(dir, 'condition.patch.yml')
+  const text = stringify([{ id: 'agent-default-model', config: {
+    provider, model, ...(reasoningEffort === null ? {} : { reasoningEffort }),
+  } }])
+  fs.writeFileSync(target, text, { flag: 'wx', mode: 0o600 })
+  return target
+}
+
+export function patchArgs(llmPatch, conditionPatch) {
+  return [llmPatch, conditionPatch].filter(Boolean).flatMap(file => ['--patch', file])
+}
diff --git a/bench/lib/matrix.mjs b/bench/lib/matrix.mjs
new file mode 100644
index 00000000..a208901d
--- /dev/null
+++ b/bench/lib/matrix.mjs
@@ -0,0 +1,58 @@
+/** Separate condition groups; there is deliberately no cross-condition aggregate. */
+import fs from 'node:fs'
+import path from 'node:path'
+import { describeCondition, assertSameCondition } from './condition.mjs'
+
+export const MATRIX_FORMAT = 'dsh-ops-bench-matrix-v1'
+export const MATRIX_FILE = 'matrix.json'
+
+export async function runMatrix({ conditions, root, argv, options, io, run }) {
+  const out = io.out ?? console.log
+  const manifest = { format: MATRIX_FORMAT, groups: [] }
+  if (!options.show) {
+    fs.mkdirSync(root, { recursive: true })
+    fs.writeFileSync(path.join(root, MATRIX_FILE), JSON.stringify(manifest, null, 2), { flag: 'wx' })
+  }
+  let exit = 0
+  for (const [index, condition] of conditions.entries()) {
+    const directory = `condition-${String(index + 1).padStart(3, '0')}`
+    const group = { directory, condition, base: null, cand: null, exitCode: null }
+    manifest.groups.push(group)
+    out(`[matrix] ${index + 1}/${conditions.length}: ${describeCondition(condition)}`)
+    const code = await run(argv, { ...io, conditionOverride: condition, groupOverride: path.join(root, directory),
+      onResult(result) {
+        for (const side of ['base', 'cand']) if (result.summaryFiles?.[side]) group[side] = path.relative(root, result.summaryFiles[side]).split(path.sep).join('/')
+        io.onResult?.(result)
+      },
+    })
+    group.exitCode = code
+    if (!options.show) fs.writeFileSync(path.join(root, MATRIX_FILE), JSON.stringify(manifest, null, 2) + '\n')
+    if (code !== 0) exit = code === 2 ? 2 : exit || 1
+    if (code === 2 || io.interrupt?.stopped) break
+  }
+  out('[matrix] Cross-condition results are not comparable; no combined delta is computed.')
+  return exit
+}
+
+export function matrixComparisons(root, options, { resolveSide, compare }) {
+  const dir = path.resolve(root), manifest = JSON.parse(fs.readFileSync(path.join(dir, MATRIX_FILE), 'utf8'))
+  if (manifest.format !== MATRIX_FORMAT || !Array.isArray(manifest.groups) || !manifest.groups.length) throw new Error('Not a populated benchmark matrix')
+  const side = file => {
+    if (typeof file !== 'string') throw new Error('Matrix group has no completed side summaries')
+    const target = path.resolve(dir, file), relative = path.relative(dir, target)
+    if (path.isAbsolute(relative) || relative.startsWith(`..${path.sep}`) || relative === '..') throw new Error('Matrix summary escapes its group root')
+    return resolveSide(target, options).doc
+  }
+  return manifest.groups.map(group => {
+    const base = side(group.base), cand = side(group.cand)
+    assertSameCondition(base, { condition: group.condition })
+    assertSameCondition(cand, { condition: group.condition })
+    return compare(base, cand, options)
+  })
+}
+
+export function renderMatrix(comparisons, render) {
+  return ['# Benchmark condition matrix', '', 'Cross-condition results are not comparable. Each section is independent; deltas are never combined.', '',
+    ...comparisons.flatMap((comparison, index) => [`## Condition ${index + 1}: ${describeCondition(comparison.condition)}`, '', render(comparison), '']),
+  ].join('\n')
+}
diff --git a/bench/report/panel.mjs b/bench/report/panel.mjs
index a90d83cf..2f79a68c 100644
--- a/bench/report/panel.mjs
+++ b/bench/report/panel.mjs
@@ -375,6 +375,8 @@ function renderConclusion() {
     : '噪声底(A/A)±' + SUMMARY.noise.pct.toFixed(1) + '% → ' + (SUMMARY.readable ? '超过噪声 ⇒ 可读方向' : '落在噪声内 ⇒ 只报区间,不报方向')
 }
 function renderOverview(node) {
+  const condition = obj(RUN.meta).condition
+  node.appendChild(el('p', 'mono', 'Condition: ' + (condition === undefined || condition === null ? 'unknown' : j(condition))))
   const keys = pairKeys()
   const taskRows = SUMMARY.tasks.map((task) => {
     const base = task.arms[keys[0]]
diff --git a/bench/run.mjs b/bench/run.mjs
index 84640ec9..8e0eea28 100644
--- a/bench/run.mjs
+++ b/bench/run.mjs
@@ -42,9 +42,11 @@ 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'
+import { reasoningEffort, planConditions, writeConditionPatch, patchArgs, describeCondition, assertEffectiveCondition } from './lib/condition.mjs'
+import { runMatrix } from './lib/matrix.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']
+const VALUE_FLAGS = ['--sleep-ms', '--out', '--heartbeat-ms', '--stall-ms', '--timeout', '--dsh', '--llm-patch', '--model', '--reasoning-effort', '--provider']
 /** The integer-valued flags, by option name. */
 const INTEGER_FLAGS = { '--sleep-ms': 'sleepMs', '--heartbeat-ms': 'heartbeatMs', '--stall-ms': 'stallMs', '--timeout': 'timeoutMs' }
 /** The string-valued flags, by option name. */
@@ -77,7 +79,9 @@ export function abUsage() {
     '                       (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',
+    '  --model <id>         actual model route for both arms (repeatable)',
+    '  --reasoning-effort E off | low | high | max (repeatable; Cartesian model × effort matrix)',
+    '  --provider <id>      override the overlay provider for explicit conditions',
     '  --keep               keep each temporary workspace',
     '  --verbose            narrate every event line',
     '  --show               print the pair-by-pair plan and exit without running',
@@ -97,6 +101,12 @@ export function abUsage() {
 
 /** Apply one runner-only flag with a value to the parsed options. */
 function applyRunFlag(options, flag, value) {
+  if (flag === '--model') { options.models.push(value); options.model = value; return }
+  if (flag === '--reasoning-effort') {
+    try { options.reasoningEfforts.push(reasoningEffort(value)); return }
+    catch (error) { throw new UsageError(error.message) }
+  }
+  if (flag === '--provider') { options.provider = value; return }
   if (Object.hasOwn(INTEGER_FLAGS, flag)) {
     const number = Number(value)
     if (!Number.isInteger(number) || number < 0) throw new UsageError(`${flag} needs a non-negative integer, got ${value}`)
@@ -133,6 +143,7 @@ export function parseRunArgs(argv, context = {}) {
     dsh: null,
     llmPatch: null,
     model: null,
+    models: [], reasoningEfforts: [], provider: null,
   }
   for (let index = 0; index < plan.extra.length; index += 1) {
     const flag = plan.extra[index]
@@ -147,7 +158,7 @@ export function parseRunArgs(argv, context = {}) {
       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)) {
       const value = plan.extra[index + 1]
-      if (value === undefined || value === '') throw new UsageError(`this flag needs a value: ${flag}`)
+      if (value === undefined || value === '' || value.startsWith('--')) throw new UsageError(`this flag needs a value: ${flag}`)
       applyRunFlag(options, flag, value)
       index += 1
     } else if (flag.startsWith('-')) {
@@ -219,7 +230,7 @@ export function resolveLlmPatch(options, context = {}) {
  * @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 plan = spawnPlan(entry, ['--profile', profile, ...patchArgs(context.llmPatch, context.conditionPatch), '--dump-config'])
   const result = (context.run ?? spawnSync)(plan.command, plan.args, {
     cwd: context.cwd ?? REPO_ROOT,
     env: context.env ?? process.env,
@@ -233,7 +244,7 @@ export function dumpProfileConfig(entry, profile, context = {}) {
     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 ?? ''}`
+  return String(result.stdout ?? '')
 }
 
 /**
@@ -252,7 +263,12 @@ export function profileFingerprints(arms, 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`)
     }
+    assertEffectiveCondition(text, context.condition)
     hashes[arm.side] = createHash('sha256').update(text).digest('hex')
+    if (context.dirs?.[arm.side]) {
+      fs.mkdirSync(context.dirs[arm.side], { recursive: true })
+      fs.writeFileSync(path.join(context.dirs[arm.side], 'dump-config.txt'), text, { mode: 0o600 })
+    }
   }
   return hashes
 }
@@ -413,6 +429,7 @@ export async function main(argv, io = {}) {
     out(abUsage())
     return EXIT.ok
   }
+  if (io.groupOverride) options.out = io.groupOverride
   // 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
@@ -431,6 +448,16 @@ export async function main(argv, io = {}) {
     }
     patch = { path: null, implicit: false, refused: error.message }
   }
+  let conditions
+  try { conditions = Object.hasOwn(io, 'conditionOverride') ? [io.conditionOverride] : planConditions(options, patch.path, io.readOverlay) }
+  catch (error) { err(`bench ab: ${error.message}`); return EXIT.usage }
+  if (conditions.length > 1) {
+    const root = options.out === null ? path.join(io.runsDir ?? RUNS_DIR, options.folder) : path.resolve(options.out)
+    try { return await runMatrix({ conditions, root, argv, options, io, run: main }) }
+    catch (error) { err(`bench matrix: ${error.message}`); return EXIT.failure }
+  }
+  const condition = conditions[0]
+  options.model = condition?.model ?? null
   // 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
@@ -453,6 +480,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] condition: ${describeCondition(condition)}`)
   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}`)
@@ -477,10 +505,12 @@ export async function main(argv, io = {}) {
   // 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) {
+  let hashes = io.profileHashes ?? null, conditionPatch = null
+  if (condition !== null || hashes === null && seal !== undefined) {
     try {
-      hashes = profileFingerprints(arms, { entry, dump: io.dumpProfileConfig, env: io.env })
+      conditionPatch = writeConditionPatch(sweepDir, condition)
+      hashes = profileFingerprints(arms, { entry, dump: io.dumpProfileConfig, env: io.env,
+        llmPatch: patch.path, conditionPatch, condition, dirs })
     } 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.')
@@ -509,6 +539,7 @@ export async function main(argv, io = {}) {
       folder: options.out === null ? options.folder : null,
       entry,
       llmPatch: patch.path,
+      conditionPatch, condition,
       timeoutMs: options.timeoutMs,
       model: options.model,
       argv: recordedArgv,
@@ -535,6 +566,7 @@ export async function main(argv, io = {}) {
     uninstall()
   }
   printResult(out, err, result, options)
+  io.onResult?.(result)
   let report = { target: null, skipped: '--no-report' }
   if (options.noReport !== true) {
     try {
diff --git a/bench/run.schema.json b/bench/run.schema.json
index 494ee664..792c20ae 100644
--- a/bench/run.schema.json
+++ b/bench/run.schema.json
@@ -17,6 +17,9 @@
         "node": { "description": "Node.js version the runner ran on, e.g. v24.21.0.", "type": "string" },
         "dsh": { "description": "Version of the dsh launcher both arms were measured with, or null when unknown.", "type": ["string", "null"] },
         "model": { "description": "Model id both arms used, or null for the model-free mode.", "type": ["string", "null"] },
+        "condition": { "description": "Explicit shared routing condition; absent/null means unknown for historical or unconfigured runs. Null reasoning effort means the host default was not pinned.", "type": ["object", "null"], "additionalProperties": false, "required": ["provider", "model", "reasoningEffort"], "properties": {
+          "provider": { "description": "Configured provider identifier shared by both arms.", "type": "string" }, "model": { "description": "Configured model identifier shared by both arms.", "type": "string" }, "reasoningEffort": { "description": "Pinned reasoning level, or null when the host default was not explicitly pinned.", "enum": ["off", "low", "high", "max", null] }
+        } },
         "gitSha": { "description": "Commit the checkout was on, or null when it could not be read.", "type": ["string", "null"] },
         "gitBranch": { "description": "Branch the checkout was on, or null when it could not be read.", "type": ["string", "null"] },
         "argv": { "description": "The command line that produced this document, one array element per argv entry.", "type": "array", "items": { "type": "string" } },
diff --git a/bench/run/schedule.mjs b/bench/run/schedule.mjs
index bc821598..4dd6e537 100644
--- a/bench/run/schedule.mjs
+++ b/bench/run/schedule.mjs
@@ -186,6 +186,7 @@ function sessionOptions(arm, pair, spec, options, ctx) {
     entry: spec.entry,
     profile: arm.profile,
     llmPatch: spec.llmPatch ?? null,
+    conditionPatch: spec.conditionPatch ?? null,
     workspaceRoot: spec.workspaceRoot,
     timeoutMs: spec.timeoutMs ?? null,
     keep: options.keep === true,
@@ -209,6 +210,7 @@ function buildSummary(arm, rows, ctx) {
     profile: arm.profile,
     aa: ctx.spec.aa === true,
     model: ctx.spec.model ?? null,
+    condition: ctx.spec.condition ?? null,
     argv: ctx.spec.argv ?? [],
     dir: ctx.dirs[arm.side],
     startedAt: ctx.startedAt,
@@ -259,6 +261,7 @@ function sealContext(result, spec, summaryFile) {
       ...(spec.meta ?? {}),
       mode: 'ab',
       model: spec.model ?? null,
+      condition: spec.condition ?? null,
       argv: spec.argv ?? [],
       startedAt: result.startedAt,
       endedAt: result.endedAt,
diff --git a/bench/run/seal.mjs b/bench/run/seal.mjs
index c29c1785..79076427 100644
--- a/bench/run/seal.mjs
+++ b/bench/run/seal.mjs
@@ -37,6 +37,7 @@ import path from 'node:path'
 import { createHash } from 'node:crypto'
 import { aggregateLines } from '../lib/aggregate.mjs'
 import { REPO_ROOT, platformTag } from '../lib/env.mjs'
+import { conditionOf } from '../lib/condition.mjs'
 
 /** The four per-row archive files the session driver writes, by suffix. */
 export const ROW_SUFFIXES = {
@@ -533,6 +534,7 @@ function buildMeta(options, arms, results, sealedAt) {
     node: typeof provided.node === 'string' ? provided.node : process.version,
     dsh: textOrNull(provided.dsh),
     model: textOrNull(provided.model),
+    condition: conditionOf({ meta: provided }),
     gitSha: textOrNull(provided.gitSha),
     gitBranch: textOrNull(provided.gitBranch),
     argv: Array.isArray(provided.argv) ? provided.argv.map(String) : [],
diff --git a/bench/run/session.mjs b/bench/run/session.mjs
index e1f01a3d..47666598 100644
--- a/bench/run/session.mjs
+++ b/bench/run/session.mjs
@@ -27,6 +27,7 @@ import { verifyWorkspace } from '../lib/verify.mjs'
 import { createObserver } from '../lib/observe.mjs'
 import { spawnPlan } from '../lib/env.mjs'
 import { DEFAULT_TIMEOUT_MS } from '../lib/tasks.mjs'
+import { patchArgs } from '../lib/condition.mjs'
 
 /** The five token buckets `run.schema.json $defs/usage` requires, in its order. */
 const USAGE_BUCKETS = ['inputTokens', 'outputTokens', 'cacheReadTokens', 'cacheWriteTokens', 'reasoningTokens']
@@ -432,7 +433,7 @@ export async function runSession(spec, options = {}) {
     observer.note('detail', `workspace ${workspace} — ${fixture.files.length} fixture file(s) written`)
 
     const args = ['--profile', options.profile]
-    if (options.llmPatch) args.push('--patch', options.llmPatch)
+    args.push(...patchArgs(options.llmPatch, options.conditionPatch))
     args.push('--json', task.prompt)
     const plan = spawnPlan(entry, args)
     const fold = createFold()
diff --git a/docs/CHANGELOG.md b/docs/CHANGELOG.md
index 0ec16497..45c465f8 100644
--- a/docs/CHANGELOG.md
+++ b/docs/CHANGELOG.md
@@ -7,6 +7,9 @@ this package adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.htm
 
 ## [Unreleased]
 
+- Make benchmark model/reasoning selections actual shared routing conditions, archive composed configuration, and record the condition in sealed evidence. Repeated selections produce separate condition groups and reports; cross-condition pairing is refused, while historical runs remain readable as unknown (#294).
+- 将 benchmark 的模型与思考档位选择用于两臂实际路由，归档合成配置并在封存证据中记录条件。重复选项生成独立条件组和分组报告，拒绝跨条件配对；历史运行仍可按未知条件读取（#294）。
+
 - Make the Windows CI leg non-blocking while keeping it running on every event (#316): split `validate` into blocking `validate-posix` (Linux x64, macOS arm64) and `continue-on-error` `validate-windows`, and keep `ci-required` from depending on any `continue-on-error` job, so the aggregate neither waits for nor fails with the slowest leg. On `main` after #307 the Windows leg takes 527 / 529 s — up from 482 s before #307, because `npm ci` now downloads the 411 MB Windows Bash payload — against 136–139 s (Linux) and 168–182 s (macOS). `scripts/check-workflows.mjs` now enforces "every blocking job in the aggregate, no non-blocking job in it" and that the aggregate's failure loop names exactly the blocking jobs, so a job cannot stay in `needs` but escape judgement; the Windows result is a signal to act on, not a merge gate.
 - 将 CI 的 Windows 腿改为非阻塞、但仍每次触发都运行（#316）：把 `validate` 拆成阻塞的 `validate-posix`（Linux x64、macOS arm64）与 `continue-on-error` 的 `validate-windows`，并让 `ci-required` 不依赖任何 `continue-on-error` job，聚合既不等待也不随最慢的一腿失败。`main` 在 #307 合入后实测 Windows 腿 527 / 529 秒（#307 之前 482 秒，因为 `npm ci` 现在要拉 411 MB 的 Windows Bash 载荷），Linux 136–139 秒、macOS 168–182 秒。`scripts/check-workflows.mjs` 现在强制“每个阻塞 job 都在聚合里、聚合里没有非阻塞 job”，并要求失败判定循环里的 job 集合与阻塞集合完全相等，避免 job 留在 `needs` 却逃过判定；Windows 结果是待处理的信号，不是合并门禁。
 - Bound each `ops_replace` output to the same 32 MiB UTF-8 byte ceiling as file writes. Check expansion with overflow-safe arithmetic for the entire plan before constructing replacement content or publishing any file, including dry runs; an over-limit target returns `OUTPUT_LIMIT` with no file changes (#330).
diff --git a/test/bench-compare.test.mjs b/test/bench-compare.test.mjs
index b23779ff..1c60df7f 100644
--- a/test/bench-compare.test.mjs
+++ b/test/bench-compare.test.mjs
@@ -167,7 +167,7 @@ await test('the same comparison renders byte-identical text twice: tables first,
   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 \(beta\)\n\n## Per-task pairs$/m, 'the title leads straight into the data — no summary bar')
+  assert.match(text, /^# DSH-OPS Benchmark Report \(beta\)\n\nCondition: unknown\n\n## Per-task pairs$/m, 'the header identifies the measurement condition before the tables')
   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')
diff --git a/test/bench-conditions.test.mjs b/test/bench-conditions.test.mjs
new file mode 100644
index 00000000..7226a934
--- /dev/null
+++ b/test/bench-conditions.test.mjs
@@ -0,0 +1,156 @@
+/** Conditions govern actual routing, archives and pairing; no model request is made. */
+import fs from 'node:fs'
+import path from 'node:path'
+import { EventEmitter } from 'node:events'
+import { PassThrough } from 'node:stream'
+import { parse } from 'yaml'
+import { JSDOM } from 'jsdom'
+import { renderConfigDump } from '@deepseek-ai/dsh-app-boot'
+import { assert, test, report, withTempDir, waitFor } from './lib/harness.mjs'
+import { main as runMain, parseRunArgs, dumpProfileConfig } from '../bench/run.mjs'
+import { main as compareMain, renderReport } from '../bench/compare.mjs'
+import { compareSummaries } from '../bench/lib/compare-core.mjs'
+import { planConditions, conditionOf, writeConditionPatch, assertEffectiveCondition } from '../bench/lib/condition.mjs'
+import { runSession } from '../bench/run/session.mjs'
+import { validateRun } from '../bench/run/seal.mjs'
+import { renderPanel } from '../bench/report/panel.mjs'
+
+const route = { provider: 'bench-server', model: 'old-model', reasoningEffort: 'off' }
+const overlayText = JSON.stringify([{ id: 'agent-default-model', config: route }])
+const entry = { kind: 'js', file: path.join(path.sep, 'fake', 'dsh.js') }
+const task = { id: 'condition-fixture', title: 'condition fixture', prompt: 'Write answer.txt', repeat: 1, timeoutMs: 1000,
+  fixture: { generator: 'grepTree', params: { dirs: 1, filesPerDir: 1, linesPerFile: 1, needleFiles: 1 } },
+  verify: [{ type: 'fileExists', path: 'answer.txt' }] }
+const json = file => JSON.parse(fs.readFileSync(file, 'utf8'))
+const sink = () => { const lines = []; return { lines, out: line => lines.push(line), err: line => lines.push(line) } }
+
+await test('repeatable CLI flags form a Cartesian matrix and malformed efforts fail before work', () => {
+  const options = parseRunArgs(['--model', 'a', '--model', 'b', '--reasoning-effort', 'low', '--reasoning-effort', 'high'])
+  const values = planConditions(options, 'overlay', () => overlayText)
+  assert.deepEqual(values.map(value => [value.model, value.reasoningEffort]), [['a', 'low'], ['a', 'high'], ['b', 'low'], ['b', 'high']])
+  assert.ok(values.every(value => value.provider === route.provider))
+  assert.throws(() => parseRunArgs(['--reasoning-effort', 'medium']), /off, low, high, max/)
+  assert.throws(() => parseRunArgs(['--model', '--reasoning-effort', 'high']), /needs a value/)
+  assert.deepEqual(planConditions(parseRunArgs([]), null, () => { throw new Error('must not read'); }), [null])
+  assert.equal(conditionOf({ meta: { model: 'legacy-label' } }), null)
+  const expected = { ...route, reasoningEffort: 'high' }
+  assert.throws(() => assertEffectiveCondition(overlayText, expected), /does not match requested/)
+  assert.throws(() => assertEffectiveCondition(JSON.stringify([{ id: 'agent-default-model', disabled: true, config: expected }]), expected), /does not match requested/)
+  assert.doesNotThrow(() => assertEffectiveCondition(JSON.stringify([{ id: 'agent-default-model', config: expected }]), expected))
+})
+
+await test('the final patch replaces the complete route while preserving the input overlay', () => withTempDir('conditions-patch', root => {
+  const overlay = path.join(root, 'llm.patch.yml')
+  fs.writeFileSync(overlay, overlayText)
+  const condition = planConditions(parseRunArgs(['--model', 'DeepSeek-V4.1-Flash', '--reasoning-effort', 'high']), overlay)[0]
+  const file = writeConditionPatch(path.join(root, 'run'), condition)
+  assert.deepEqual(parse(fs.readFileSync(file, 'utf8')), [{ id: 'agent-default-model', config: condition }])
+  assert.equal(fs.readFileSync(overlay, 'utf8'), overlayText)
+  assert.throws(() => writeConditionPatch(path.join(root, 'run'), condition), /EEXIST/)
+  assert.throws(() => planConditions(parseRunArgs(['--model', 'x']), null), /provider/)
+}))
+
+await test('an unapplied condition is refused before a measured session starts', () => withTempDir('conditions-refuse', async root => {
+  const tasksDir = path.join(root, 'tasks'), overlay = path.join(root, 'llm.yml'), output = sink()
+  fs.mkdirSync(tasksDir); fs.writeFileSync(path.join(tasksDir, 'condition.task.json'), JSON.stringify(task)); fs.writeFileSync(overlay, overlayText)
+  let sessions = 0
+  const code = await runMain(['--out', path.join(root, 'run'), '--llm-patch', overlay, '--model', 'new-model', '--reasoning-effort', 'high'], {
+    ...output, tasksDir, installSignals: false, resolveEntry: () => entry,
+    dumpProfileConfig: () => overlayText,
+    runSession: () => { sessions++; throw new Error('must not run') },
+  })
+  assert.equal(code, 1)
+  assert.equal(sessions, 0)
+  assert.match(output.lines.join('\n'), /Composed agent-default-model route does not match requested condition/)
+}))
+
+await test('matrix show prints every condition without allocating output or invoking a host', () => withTempDir('conditions-show', async root => {
+  const tasksDir = path.join(root, 'tasks'), out = path.join(root, 'matrix'), output = sink()
+  fs.mkdirSync(tasksDir); fs.writeFileSync(path.join(tasksDir, 'condition.task.json'), JSON.stringify(task))
+  assert.equal(await runMain(['--show', '--out', out, '--no-llm-patch', '--provider', 'p', '--model', 'a', '--model', 'b', '--reasoning-effort', 'high'], {
+    ...output, tasksDir, resolveEntry: () => { throw new Error('must not invoke host') },
+  }), 0)
+  assert.equal(fs.existsSync(out), false)
+  assert.equal(output.lines.filter(line => line.startsWith('[matrix] ') && /\/2:/.test(line)).length, 2)
+}))
+
+await test('a complete matrix uses identical routing patches in both arms and archives each condition', () => withTempDir('conditions-matrix', async root => {
+  const tasksDir = path.join(root, 'tasks'), out = path.join(root, 'matrix'), overlay = path.join(root, 'llm.yml')
+  fs.mkdirSync(tasksDir); fs.writeFileSync(path.join(tasksDir, 'condition.task.json'), JSON.stringify(task)); fs.writeFileSync(overlay, overlayText)
+  const baseConfig = path.join(root, 'base.yml')
+  fs.writeFileSync(baseConfig, JSON.stringify([{ id: 'agent-default-model', name: 'fixture-router', config: route }]))
+  const calls = [], dumps = [], output = sink()
+  const patches = args => args.flatMap((arg, index) => arg === '--patch' ? [args[index + 1]] : [])
+  const run = await runMain(['--out', out, '--llm-patch', overlay, '--model', 'a', '--model', 'b', '--reasoning-effort', 'low', '--reasoning-effort', 'high', '--seal'], {
+    ...output, tasksDir, installSignals: false, resolveEntry: () => entry, now: () => Date.UTC(2026, 9, 25),
+    dumpProfileConfig: (entry, profile, context) => dumpProfileConfig(entry, profile, { ...context, run(_command, args) {
+      const files = patches(args)
+      assert.equal(files.length, 2)
+      assert.equal(files[0], overlay)
+      const stdout = renderConfigDump('dsh', baseConfig, files.map(file => ({ label: path.basename(file), patches: parse(fs.readFileSync(file, 'utf8')) })), line => { throw new Error(line) })
+      const config = parse(stdout)[0].config
+      dumps.push({ profile, files, config })
+      return { status: 0, stdout, stderr: 'diagnostic is not configuration' }
+    } }),
+    runSession: (spec, options) => runSession(spec, { ...options, workspaceRoot: root, spawn(_command, args, processOptions) {
+      const files = patches(args), config = parse(fs.readFileSync(files[1], 'utf8'))[0].config
+      calls.push({ arm: spec.arm, files, config })
+      const child = new EventEmitter(); child.stdout = new PassThrough(); child.stderr = new PassThrough(); child.pid = 123
+      setImmediate(() => {
+        fs.writeFileSync(path.join(processOptions.cwd, 'answer.txt'), 'done')
+        child.stdout.end(JSON.stringify({ type: 'status', phase: 'step_end', step: 1, usage: { inputTokens: 10, outputTokens: 1, cacheReadTokens: 0, cacheWriteTokens: 0 } }) + '\n')
+        child.stderr.end(); setImmediate(() => child.emit('close', 0))
+      })
+      return child
+    } }),
+  })
+  assert.equal(run, 0, output.lines.join('\n'))
+  assert.equal(calls.length, 8); assert.equal(dumps.length, 8)
+  const manifest = json(path.join(out, 'matrix.json'))
+  assert.equal(manifest.groups.length, 4)
+  for (const [index, group] of manifest.groups.entries()) {
+    const left = calls[index * 2], right = calls[index * 2 + 1]
+    assert.deepEqual(left.files, right.files)
+    assert.deepEqual(left.config, group.condition)
+    assert.deepEqual(left.files, dumps[index * 2].files)
+    const sealed = json(path.join(out, group.directory, 'run.json'))
+    assert.deepEqual(sealed.meta.condition, group.condition)
+    assert.equal(sealed.meta.model, group.condition.model)
+    assert.equal(validateRun(sealed).ok, true)
+    for (const side of ['base', 'cand']) {
+      assert.deepEqual(json(path.join(out, group[side])).condition, group.condition)
+      const dump = fs.readFileSync(path.join(path.dirname(path.join(out, group[side])), 'dump-config.txt'), 'utf8')
+      assert.deepEqual(parse(dump)[0].config, group.condition)
+    }
+    const paths = ['base', 'cand'].map(side => path.join(path.dirname(path.join(out, group[side])), 'dump-config.txt'))
+    assert.deepEqual(fs.readFileSync(paths[0]), fs.readFileSync(paths[1]))
+  }
+  const reportOut = sink()
+  assert.equal(await compareMain(['--matrix', out, '--json'], reportOut), 0)
+  const combined = JSON.parse(reportOut.lines[0])
+  assert.equal(combined.comparableAcrossConditions, false)
+  assert.equal(combined.comparisons.length, 4)
+  assert.equal(combined.totals, undefined)
+  const markdown = sink()
+  assert.equal(await compareMain(['--matrix', out], markdown), 0)
+  assert.match(markdown.lines[0], /Cross-condition results are not comparable/)
+  assert.equal(markdown.lines[0].match(/^## Condition /gm).length, 4)
+  const mismatch = sink()
+  assert.equal(await compareMain([path.join(out, manifest.groups[0].base), path.join(out, manifest.groups[1].cand)], mismatch), 2)
+  assert.match(mismatch.lines.join('\n'), /"reasoningEffort":"low"/)
+  assert.match(mismatch.lines.join('\n'), /"reasoningEffort":"high"/)
+  const left = json(path.join(out, manifest.groups[0].base)), right = json(path.join(out, manifest.groups[0].cand))
+  delete left.condition; delete right.condition
+  assert.equal(compareSummaries(left, right).condition, null)
+  assert.match(renderReport(compareSummaries(left, right)), /Condition: unknown/)
+  assert.throws(() => compareSummaries(left, { ...right, condition: manifest.groups[0].condition }), /Conditions differ.*unknown/)
+  const docPath = path.join(out, manifest.groups[0].directory, 'run.json')
+  const panel = renderPanel({ runJsonPath: docPath, outDir: path.dirname(docPath) })
+  const dom = new JSDOM(fs.readFileSync(panel.htmlPath, 'utf8'), { runScripts: 'dangerously', beforeParse(window) {
+    window.fetch = async () => ({ ok: true, json: async () => json(docPath) })
+  } })
+  try { await waitFor(() => dom.window.document.body.textContent.includes('"reasoningEffort":"low"')); }
+  finally { dom.window.close() }
+}))
+
+report('bench-conditions')