From 08c7c3f83644ccfdb2bdad0673cbecb98f7f35c0 Mon Sep 17 00:00:00 2001
From: Richeir <richeir@outlook.com>
Date: Sat, 24 Oct 2026 14:49:53 +0800
Subject: [PATCH 01/10] feat(bench): make A/B sealing opt-in and wire it to the
 runner

bench/cli.mjs spawns bench/run.mjs as a child and cannot inject a callback, so the runner's requirement of an injected io.seal made every interactive sweep exit 3 before spawning anything unless --no-seal was passed. Sealing is now opt-in with --seal, and every sweep - sealed or not - keeps each arm's results/ and summary.json, which bench report renders the report from.

--seal resolves bench/run/seal.mjs (an injected io.seal still wins), fingerprints both arms by hashing \dsh --profile <name> --dump-config\ into the arms[].profileHash that sealRun requires, and refuses before any session when a fingerprint cannot be read. sealSweep adapts the seal context's {base, cand} directory map to the directory list sealRun folds; that mismatch was invisible to the injected doubles and only a real sweep could expose it.
---
 bench/run.mjs                | 134 +++++++++++++++++++++++++++++------
 bench/run/schedule.mjs       |   2 +-
 test/bench-schedule.test.mjs | 103 +++++++++++++++++++++++----
 3 files changed, 202 insertions(+), 37 deletions(-)

diff --git a/bench/run.mjs b/bench/run.mjs
index c6e66b34..07480359 100644
--- a/bench/run.mjs
+++ b/bench/run.mjs
@@ -8,9 +8,11 @@
  * `bench/run/schedule.mjs`. It does not spawn a child, does not aggregate and does not
  * judge: scheduling is `run/schedule.mjs`, one session is `run/session.mjs` (P7),
  * aggregation is `lib/aggregate.mjs` (P6), the verdict is `lib/compare-core.mjs`
- * (P11a), and sealing is the **injected** `io.seal` callback — `bench/run/seal.mjs`
- * (P8a) is not imported here, deliberately, so this slice lands while P8a is still in
- * flight; the wiring supplies it.
+ * (P11a), and sealing is opt-in: `--seal` writes the schema-validated `run.json` through
+ * `bench/run/seal.mjs` (P8a), while every sweep keeps each arm's `results/` and
+ * `summary.json` either way. An injected `io.seal` supplies the document an embedder
+ * wants; the CLI spawns this entry as a child and cannot inject one, so the flag has to
+ * select the real seal rather than a missing slice.
  *
  * Why one process for both arms: the pre-#205 shape spawned one runner per arm, so
  * every baseline run happened before every candidate run and the machine's drift
@@ -26,14 +28,16 @@
 
 import fs from 'node:fs'
 import path from 'node:path'
+import { createHash } from 'node:crypto'
 import { spawnSync } from 'node:child_process'
 import { fileURLToPath } from 'node:url'
 
 import { EXIT, UsageError, planAb } from './cli.mjs'
-import { LLM_OVERLAY, REPO_ROOT, resolveDshEntry } from './lib/env.mjs'
+import { LLM_OVERLAY, REPO_ROOT, resolveDshEntry, spawnPlan } from './lib/env.mjs'
 import { TASKS_DIR, loadTasks, selectTasks } from './lib/tasks.mjs'
 import { RUNS_DIR } from './lib/next-folder.mjs'
 import { DEFAULT_REPEAT, armOrder, createInterrupt, planPairs, planSessions, repeatsById, runSweep } from './run/schedule.mjs'
+import { sealRun } from './run/seal.mjs'
 
 /** 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']
@@ -73,12 +77,14 @@ export function abUsage() {
     '  --keep               keep each temporary workspace',
     '  --verbose            narrate every event line',
     '  --show               print the pair-by-pair plan and exit without running',
-    '  --no-seal            run without the injected seal callback (no run.json; said out loud)',
+    '  --seal               also seal the sweep into the schema-validated run.json (default:',
+    '                       every arm keeps results/ and summary.json, nothing else)',
+    '  --no-seal            explicit off; this is already the default, kept for old command lines',
     '  -h, --help           this text',
     '',
-    'Exit codes: 0 ok · 1 a failed sweep · 2 usage error · 3 sealing is not wired yet',
-    '(the caller injects P8a\'s sealRun as `io.seal`; without it, and without --no-seal,',
-    'nothing is spawned so no token is spent on an unsealable sweep).',
+    'Exit codes: 0 ok · 1 a failed sweep · 2 usage error',
+    'Sealing is opt-in: without --seal a sweep writes each arm\'s results/ and summary.json,',
+    'and `bench report` renders the report from those summaries.',
   ].join('\n')
 }
 
@@ -109,7 +115,7 @@ export function parseRunArgs(argv, context = {}) {
     aa: false,
     verbose: false,
     keep: false,
-    noSeal: false,
+    seal: false,
     noLlmPatch: false,
     sleepMs: 0,
     out: null,
@@ -125,7 +131,8 @@ export function parseRunArgs(argv, context = {}) {
     if (flag === '--aa') options.aa = true
     else if (flag === '--verbose' || flag === '-v') options.verbose = true
     else if (flag === '--keep') options.keep = true
-    else if (flag === '--no-seal') options.noSeal = true
+    else if (flag === '--seal') options.seal = true
+    else if (flag === '--no-seal') options.seal = false
     else if (flag === '--no-llm-patch') options.noLlmPatch = true
     else if (flag === '--label' || flag === '--profile') {
       throw new UsageError(`${flag} named one arm of a per-process run; \`ab\` runs both arms itself — use --base/--cand`)
@@ -192,6 +199,71 @@ export function resolveLlmPatch(options, context = {}) {
   return { path: overlay, implicit: true }
 }
 
+/**
+ * The default profile fingerprint probe: the composed configuration `dsh` reports for one
+ * profile. `setup` reads the same tree back to prove a pin really landed, so hashing it
+ * records what each arm ran rather than what its file was called.
+ * @param {{file: string, kind: 'js'|'exe'}} entry - the resolved dsh launcher.
+ * @param {string} profile - the profile name to dump.
+ * @param {{run?: Function, cwd?: string, env?: Record<string, string|undefined>}} [context] - injectable probe, directory and environment.
+ * @returns {string} the command's stdout and stderr.
+ * @throws {Error} when it cannot start or exits nonzero: an arm with no fingerprint is not evidence.
+ */
+export function dumpProfileConfig(entry, profile, context = {}) {
+  const plan = spawnPlan(entry, ['--profile', profile, '--dump-config'])
+  const result = (context.run ?? spawnSync)(plan.command, plan.args, {
+    cwd: context.cwd ?? REPO_ROOT,
+    env: context.env ?? process.env,
+    encoding: 'utf8',
+    timeout: 60_000,
+    windowsHide: true,
+    stdio: ['ignore', 'pipe', 'pipe'],
+  })
+  if (result.error) throw new Error(`could not run "dsh --profile ${profile} --dump-config": ${String(result.error.message ?? result.error)}`)
+  if (result.status !== 0) {
+    const detail = String(result.stderr ?? '').trim().split('\n').filter(Boolean).pop() ?? ''
+    throw new Error(`"dsh --profile ${profile} --dump-config" exited ${String(result.status)}${detail === '' ? '' : `: ${detail}`}`)
+  }
+  return `${result.stdout ?? ''}\n${result.stderr ?? ''}`
+}
+
+/**
+ * Fingerprint both arms: the SHA-256 of each profile's dumped configuration, which
+ * `bench/run.schema.json` records in `arms[]` and `sealRun` requires before it will seal.
+ * @param {{side: string, profile: string}[]} arms - the two arms of the sweep.
+ * @param {{entry?: object, dump?: (entry: object, profile: string, context: object) => string, env?: object}} [context] - the launcher and the injectable probe.
+ * @returns {Record<string, string>} the hex digest of each side's composed configuration.
+ * @throws {Error} when a dump prints nothing, naming the arm that has no fingerprint.
+ */
+export function profileFingerprints(arms, context = {}) {
+  const dump = context.dump ?? dumpProfileConfig
+  const hashes = {}
+  for (const arm of arms) {
+    const text = dump(context.entry, arm.profile, context)
+    if (typeof text !== 'string' || text.trim() === '') {
+      throw new Error(`"dsh --profile ${arm.profile} --dump-config" printed nothing, so the ${arm.side} arm has no profile fingerprint`)
+    }
+    hashes[arm.side] = createHash('sha256').update(text).digest('hex')
+  }
+  return hashes
+}
+
+/**
+ * The default seal: adapt the sweep's seal context to {@link sealRun}.
+ *
+ * The callback is handed the two arm directories as a `{base, cand}` map, while `sealRun`
+ * folds a list of sweep directories into one document and places `run.json` in their
+ * common parent (the group folder). Handing the map straight to `sealRun` fails on
+ * `dirs.map` — which no injected double could catch, because a double never inspects it.
+ * @param {{dirs: {base: string, cand: string}|string[], arms: object, meta?: object}} context - the seal context.
+ * @param {(options: object) => object} [seal] - the sealer, injectable so a suite can read what it is handed.
+ * @returns {object} the seal receipt.
+ */
+export function sealSweep(context, seal = sealRun) {
+  const dirs = Array.isArray(context.dirs) ? context.dirs : [context.dirs.base, context.dirs.cand]
+  return seal({ ...context, dirs })
+}
+
 /** The `<UTC stamp>-<label>` run directories, one per arm, under the sweep's group. */
 export function prepareDirs(options, arms, context = {}) {
   const runsDir = context.runsDir ?? RUNS_DIR
@@ -269,14 +341,15 @@ function printResult(out, err, result, options) {
     : `[ab] noise   : ${noise === null ? 'not measured (no --aa); cost direction withheld' : `±${noise.pct}% (${noise.method})`}`)
   if (result.compare?.gate?.fail === true) err(`[ab] verdict : FAIL — ${result.compare.gate.reasons.join('; ')}`)
   else out('[ab] verdict : pass (pass-rate gate)')
-  out(`[ab] sealed  : ${result.sealed?.path ?? (result.sealError ? `FAILED (${result.sealError})` : 'no — run.json was not written')}`)
+  out(`[ab] sealed  : ${result.sealed?.path ?? (result.sealError ? `FAILED (${result.sealError})` : 'no — not requested (--seal writes run.json)')}`)
 }
 
 /**
  * Run the sweep. Every dependency is injectable through `io` so a test never spawns,
  * never reads `~/.dsh` and never touches a model: `io.seal`, `io.runSession`,
  * `io.sweep`, `io.observe`, `io.resolveEntry`, `io.now`, `io.sleep`, `io.kill`,
- * `io.tasksDir`, `io.runsDir`, `io.env`, `io.interrupt`, `io.profileHashes`.
+ * `io.tasksDir`, `io.runsDir`, `io.env`, `io.interrupt`, `io.profileHashes`,
+ * `io.dumpProfileConfig`.
  * @param {string[]} argv - the arguments after `ab`.
  * @param {object} [io] - the wiring and the sinks (`out`, `err`).
  * @returns {Promise<number>} the exit code.
@@ -300,8 +373,8 @@ export async function main(argv, io = {}) {
     out(abUsage())
     return EXIT.ok
   }
-  // Resolved before the seal guard and before any spawn: both are conditions under which a
-  // sweep would measure, or record, something other than what the operator asked for.
+  // Resolved before any spawn: a contradictory or absent overlay is a condition under which
+  // the sweep would measure something other than what the operator asked for.
   let patch
   try {
     patch = resolveLlmPatch(options, { overlay: io.llmOverlay, exists: io.overlayExists })
@@ -318,11 +391,11 @@ export async function main(argv, io = {}) {
     }
     patch = { path: null, implicit: false, refused: error.message }
   }
-  if (!options.show && options.noSeal !== true && typeof io.seal !== 'function') {
-    err('bench ab: sealing is not wired in this slice yet — P8a\'s bench/run/seal.mjs must be injected as io.seal.')
-    err('Nothing was spawned and no token was spent. Pass --no-seal to run an unsealed sweep (no run.json), or --show to just print the plan.')
-    return EXIT.pending
-  }
+  // Sealing is opt-in: a sweep always writes each arm's `results/` and `summary.json`, and
+  // `--seal` adds the schema-validated `run.json` on top. The CLI spawns this entry as a
+  // child and cannot inject a callback, so "sealed" means the flag plus either the injected
+  // `io.seal` (an embedder's own document) or the real seal in `bench/run/seal.mjs` (P8a).
+  const seal = options.seal !== true ? undefined : (typeof io.seal === 'function' ? io.seal : sealSweep)
 
   let tasks
   try {
@@ -332,8 +405,7 @@ export async function main(argv, io = {}) {
     return EXIT.usage
   }
   const repeats = repeatsById(tasks, { repeat: options.repeat, repeatExplicit: options.repeatExplicit })
-  const hashes = io.profileHashes ?? {}
-  const arms = buildArms(options).map((arm) => ({ ...arm, profileHash: hashes[arm.side] ?? null }))
+  const arms = buildArms(options)
   const { sweepDir, dirs } = prepareDirs(options, arms, io)
   const pairs = planPairs({ tasks, repeats })
   const sessions = planSessions({ tasks, repeats, arms })
@@ -362,6 +434,24 @@ export async function main(argv, io = {}) {
     return EXIT.failure
   }
 
+  // Before any session: an arm whose composed configuration cannot be read has no
+  // fingerprint, and a sweep that cannot be sealed is not evidence. Refusing here costs
+  // nothing; refusing after the sweep would have spent the tokens first.
+  let hashes = io.profileHashes ?? null
+  if (hashes === null && seal !== undefined) {
+    try {
+      hashes = profileFingerprints(arms, { entry, dump: io.dumpProfileConfig, env: io.env })
+    } catch (error) {
+      err(`bench ab: ${String(error?.message ?? error)}`)
+      err('nothing was spawned and no token was spent; run "node bench/cli.mjs setup" if the profiles are not prepared yet, or pass --no-seal to sweep without sealing.')
+      return EXIT.failure
+    }
+  }
+  for (const arm of arms) arm.profileHash = hashes?.[arm.side] ?? null
+  if (seal !== undefined) {
+    out(`[ab] profile : ${arms.map((arm) => `${arm.profile} ${arm.profileHash === null ? 'n/a' : arm.profileHash.slice(0, 12)}`).join('  ')}`)
+  }
+
   const interrupt = io.interrupt ?? createInterrupt()
   const uninstall = (io.installSignals ?? true) === false ? () => {} : installSignals(interrupt, err, io)
   const log = (level, line) => (level === 'warn' ? err : out)(line)
@@ -383,7 +473,7 @@ export async function main(argv, io = {}) {
       model: options.model,
       argv: recordedArgv,
     }, {
-      seal: options.noSeal === true ? undefined : io.seal,
+      seal,
       runSession: io.runSession,
       observe: io.observe,
       now: io.now,
diff --git a/bench/run/schedule.mjs b/bench/run/schedule.mjs
index 210d4f87..18799d45 100644
--- a/bench/run/schedule.mjs
+++ b/bench/run/schedule.mjs
@@ -450,7 +450,7 @@ export async function runSweep(spec = {}, options = {}) {
       observer.note('warn', `sealing failed: ${result.sealError} — the per-row archives and summary.json are on disk, but run.json was not written`)
     }
   } else {
-    observer.note('warn', 'no seal callback was injected: this sweep has results/ and summary.json, but no run.json')
+    observer.note('info', 'sealing was not requested: this sweep has results/ and summary.json, and no run.json')
   }
   observer.dispose?.()
   return result
diff --git a/test/bench-schedule.test.mjs b/test/bench-schedule.test.mjs
index 23814dcb..a3f3e414 100644
--- a/test/bench-schedule.test.mjs
+++ b/test/bench-schedule.test.mjs
@@ -12,10 +12,11 @@
 
 import fs from 'node:fs'
 import path from 'node:path'
+import { createHash } from 'node:crypto'
 
 import { assert, report, test, tick, withTempDir } from './lib/harness.mjs'
 import { SUMMARY_FORMAT, armOrder, planPairs, planSessions, repeatsById, runSweep } from '../bench/run/schedule.mjs'
-import { buildArms, exitFor, main, parseRunArgs, prepareDirs } from '../bench/run.mjs'
+import { buildArms, exitFor, main, parseRunArgs, prepareDirs, profileFingerprints, sealSweep } from '../bench/run.mjs'
 import { EXIT } from '../bench/cli.mjs'
 
 const LABEL = 'bench-schedule'
@@ -27,6 +28,9 @@ const NOW = () => Date.UTC(2026, 9, 18, 3, 4, 5)
 /** A launcher that is never executed: the injected runSession stands in for P7. */
 const ENTRY = { file: path.join(path.sep, 'fake', 'node_modules', '@deepseek-ai', 'dsh', 'lib', 'bin.js'), kind: 'js' }
 
+/** The fingerprints a rigged sweep would otherwise have to dump out of a real dsh. */
+const HASHES = { base: 'a'.repeat(64), cand: 'b'.repeat(64) }
+
 /** The two arms of a normal sweep. */
 const ARMS = [
   { side: 'base', label: 'bench-base', profile: 'bench-base' },
@@ -396,7 +400,7 @@ await test('parseRunArgs reads the runner flags, keeps the CLI validation, and r
   assert.equal(dirs.dirs.cand, path.join('/tmp', 'runs', 'benchmark-test-07', '2026-10-18T03-04-05Z-bench-ops'))
 })
 
-await test('main: --show prints the flip without running; a missing seal refuses before any spawn', async () => {
+await test('main: --show prints the flip without running; a requested seal with an unreadable profile refuses before any spawn', async () => {
   await withTempDir('bench-main-flags', async (root) => {
     const tasks = tasksDir(root)
     const runsDir = path.join(root, 'runs')
@@ -411,10 +415,14 @@ await test('main: --show prints the flip without running; a missing seal refuses
     assert.match(out.text(), /benchmark-test-01/)
     assert.match(out.text(), /show only/)
 
-    const noSeal = sink()
-    assert.equal(await main([], { ...base, ...noSeal, seal: undefined }), EXIT.pending)
-    assert.match(noSeal.both(), /sealing is not wired in this slice yet/)
-    assert.match(noSeal.both(), /P8a/)
+    // Sealing is opt-in, so `--seal` is what asks for the fingerprint; a launcher whose dump
+    // fails is refused before any session, so a requested seal can never turn out to be
+    // impossible after the tokens are spent.
+    const refused = sink()
+    const noDump = () => { throw new Error('dump-config unavailable') }
+    assert.equal(await main(['--seal'], { ...base, ...refused, resolveEntry: () => ENTRY, dumpProfileConfig: noDump }), EXIT.failure)
+    assert.match(refused.both(), /dump-config unavailable/)
+    assert.match(refused.both(), /no token was spent/)
     assert.equal(scripted.calls.length, 0, 'an unsealable sweep spends no token')
 
     const badFlag = sink()
@@ -434,7 +442,7 @@ await test('main: a sealed A/A sweep exits 0 with the measured floor; a broken o
     const aaOut = sink()
     const overlay = overlayIn(root)
     const scripted = rig({ tokens: (spec) => (spec.arm === 'bench-base-aa' && spec.repeatIndex === 1 ? 120 : 100) })
-    const code = await main(['--aa', '--repeat', '2'], {
+    const code = await main(['--seal', '--aa', '--repeat', '2'], {
       ...aaOut,
       tasksDir: tasks,
       runsDir,
@@ -443,6 +451,7 @@ await test('main: a sealed A/A sweep exits 0 with the measured floor; a broken o
       resolveEntry: () => ENTRY,
       installSignals: false,
       now: NOW,
+      profileHashes: HASHES,
       seal: (context) => ({ path: path.join(context.dirs.base, '..', 'run.json') }),
     })
     assert.equal(code, EXIT.ok)
@@ -452,7 +461,7 @@ await test('main: a sealed A/A sweep exits 0 with the measured floor; a broken o
 
     const brokenOut = sink()
     const broken = rig({ fail: (spec) => spec.arm === 'bench-ops' })
-    const brokenCode = await main([], {
+    const brokenCode = await main(['--seal'], {
       ...brokenOut,
       tasksDir: tasks,
       runsDir,
@@ -462,6 +471,7 @@ await test('main: a sealed A/A sweep exits 0 with the measured floor; a broken o
 
       installSignals: false,
       now: NOW,
+      profileHashes: HASHES,
       seal: () => ({ path: 'run.json' }),
     })
     assert.equal(brokenCode, EXIT.failure)
@@ -475,7 +485,7 @@ await test('main: Ctrl-C during a session stops the sweep, reports it, and exits
     const interrupt = { stopped: false, child: null, pid: null }
     const out = sink()
     const scripted = rig({ onCall: () => { interrupt.stopped = true } })
-    const code = await main(['--repeat', '2'], {
+    const code = await main(['--seal', '--repeat', '2'], {
       ...out,
       tasksDir: tasks,
       runsDir: path.join(root, 'runs'),
@@ -485,6 +495,7 @@ await test('main: Ctrl-C during a session stops the sweep, reports it, and exits
       interrupt,
       installSignals: false,
       now: NOW,
+      profileHashes: HASHES,
       seal: () => ({}),
     })
     assert.equal(code, EXIT.failure)
@@ -493,11 +504,12 @@ await test('main: Ctrl-C during a session stops the sweep, reports it, and exits
   })
 })
 
-await test('main --no-seal runs anyway and says out loud that no run.json was written', async () => {
+await test('main: a sweep is unsealed by default and --seal opts in', async () => {
   await withTempDir('bench-main-noseal', async (root) => {
     const out = sink()
     const scripted = rig()
-    const code = await main(['--no-seal', '--repeat', '1'], {
+    let sealed = 0
+    const code = await main(['--repeat', '1'], {
       ...out,
       tasksDir: tasksDir(root, 1),
       runsDir: path.join(root, 'runs'),
@@ -506,16 +518,39 @@ await test('main --no-seal runs anyway and says out loud that no run.json was wr
       resolveEntry: () => ENTRY,
       installSignals: false,
       now: NOW,
+      dumpProfileConfig: () => { throw new Error('the default must not fingerprint anything') },
+      seal: () => { sealed += 1; return {} },
     })
     assert.equal(code, EXIT.ok)
-    assert.match(out.text(), /no — run\.json was not written/)
+    assert.equal(sealed, 0, 'no seal was asked for, so nothing was sealed')
+    assert.match(out.text(), /no — not requested \(--seal writes run\.json\)/)
     assert.equal(scripted.calls.length, 2, 'both arms still ran')
+    const group = path.join(root, 'runs', fs.readdirSync(path.join(root, 'runs'))[0])
+    const armDir = fs.readdirSync(group).find((name) => name.endsWith('bench-base'))
+    assert.ok(fs.existsSync(path.join(group, armDir, 'summary.json')), 'the per-arm summary is the artifact the report reads')
+    assert.equal(fs.existsSync(path.join(group, 'run.json')), false, 'nothing sealed this sweep')
+
+    // `--no-seal` still means off, so an old command line keeps working unchanged.
+    const explicit = sink()
+    const again = rig()
+    assert.equal(await main(['--no-seal', '--repeat', '1'], {
+      ...explicit,
+      tasksDir: tasksDir(root, 1),
+      runsDir: path.join(root, 'runs'),
+      llmOverlay: overlayIn(root),
+      runSession: again.runSession,
+      resolveEntry: () => ENTRY,
+      installSignals: false,
+      now: NOW,
+      seal: () => { throw new Error('--no-seal must never seal') },
+    }), EXIT.ok)
+    assert.match(explicit.text(), /no — not requested/)
   })
 })
 
 await test('main: the sweep injects the operator overlay by default, records it, and refuses without one', async () => {
   await withTempDir('bench-main-overlay', async (root) => {
-    const runner = { tasksDir: tasksDir(root, 1), runsDir: path.join(root, 'runs'), resolveEntry: () => ENTRY, installSignals: false, now: NOW }
+    const runner = { tasksDir: tasksDir(root, 1), runsDir: path.join(root, 'runs'), resolveEntry: () => ENTRY, installSignals: false, now: NOW, profileHashes: HASHES }
     const overlay = overlayIn(root)
 
     // The default is the file `setup` creates, every session is handed it, and the archived
@@ -523,7 +558,7 @@ await test('main: the sweep injects the operator overlay by default, records it,
     const seeded = sink()
     const scripted = rig()
     let sealed = null
-    const code = await main(['--repeat', '1'], {
+    const code = await main(['--seal', '--repeat', '1'], {
       ...runner, ...seeded, runSession: scripted.runSession, llmOverlay: overlay,
       seal: (context) => { sealed = context; return { path: 'run.json' } },
     })
@@ -575,4 +610,44 @@ await test('main: the sweep injects the operator overlay by default, records it,
   })
 })
 
+await test('main: --seal fingerprints both arms and hands them to the seal', async () => {
+  const hashes = profileFingerprints(ARMS, { entry: ENTRY, dump: (_entry, profile) => `composed ${profile}` })
+  assert.deepEqual(hashes, {
+    base: createHash('sha256').update('composed bench-base').digest('hex'),
+    cand: createHash('sha256').update('composed bench-ops').digest('hex'),
+  }, 'each arm is fingerprinted from its own dumped configuration')
+  assert.throws(() => profileFingerprints(ARMS, { entry: ENTRY, dump: () => '   ' }), /printed nothing/)
+
+  await withTempDir('bench-main-fingerprint', async (root) => {
+    const out = sink()
+    const scripted = rig()
+    let sealed = null
+    const code = await main(['--seal', '--repeat', '1'], {
+      ...out,
+      tasksDir: tasksDir(root, 1),
+      runsDir: path.join(root, 'runs'),
+      llmOverlay: overlayIn(root),
+      runSession: scripted.runSession,
+      resolveEntry: () => ENTRY,
+      installSignals: false,
+      now: NOW,
+      dumpProfileConfig: (_entry, profile) => `composed ${profile}`,
+      seal: (context) => { sealed = context; return { path: 'run.json' } },
+    })
+    assert.equal(code, EXIT.ok)
+    assert.equal(sealed.arms.base.profileHash, hashes.base, 'the seal receives the dumped fingerprint')
+    assert.equal(sealed.arms.cand.profileHash, hashes.cand)
+    assert.match(out.text(), /\[ab\] profile : bench-base [0-9a-f]{12}/, 'the sweep names both fingerprints')
+    assert.equal(scripted.calls.length, 2, 'both arms still ran')
+  })
+})
+
+await test('sealSweep hands sealRun the two arm directories as a list', async () => {
+  const context = { dirs: { base: path.join('X', 'base'), cand: path.join('X', 'cand') }, arms: { base: {}, cand: {} }, meta: { mode: 'ab' } }
+  const seen = sealSweep(context, (options) => options)
+  assert.deepEqual(seen.dirs, [path.join('X', 'base'), path.join('X', 'cand')], 'the map becomes the list sealRun folds')
+  assert.equal(seen.meta.mode, 'ab', 'the rest of the context is passed through')
+  assert.deepEqual(sealSweep({ ...context, dirs: ['a', 'b'] }, (options) => options).dirs, ['a', 'b'], 'a list stays a list')
+})
+
 report(LABEL)

From 4500ad83ed1670c36139c31ea2683293486b100b Mon Sep 17 00:00:00 2001
From: Richeir <richeir@outlook.com>
Date: Sat, 24 Oct 2026 14:49:59 +0800
Subject: [PATCH 02/10] docs(bench): document the current workflow and rewrite
 the overlay template

Add bench/README-NEW.md (preparation, full and single-task sweeps, reports, every task and gate with the ops_* tools they exercise, and where temporary files land) and bench/README-mini.md (the short preparation path).

Rewrite bench/llm.patch.example.yml's header in English and add the credentials-local insert the working copy needs, since the base/headless bundles ship no credentials service.
---
 bench/README-NEW.md         | 403 ++++++++++++++++++++++++++++++++++++
 bench/README-mini.md        |  54 +++++
 bench/llm.patch.example.yml |  40 +---
 3 files changed, 465 insertions(+), 32 deletions(-)
 create mode 100644 bench/README-NEW.md
 create mode 100644 bench/README-mini.md

diff --git a/bench/README-NEW.md b/bench/README-NEW.md
new file mode 100644
index 00000000..6503c380
--- /dev/null
+++ b/bench/README-NEW.md
@@ -0,0 +1,403 @@
+# bench 使用说明（按当前代码）
+
+`bench/` 是仓库自带的测量工装：**只在 checkout 里跑、不随 npm 包发布、不进默认门禁**。
+所有路径都从模块位置解析，在哪个工作目录下调用都一样；每个子进程都不经过 shell，参数原样传递。
+模型驱动的部分需要一个可用的 dsh 与 LLM 路由，脚本门禁复用仓库已有的 devDependencies（`js-tiktoken`、`@deepseek-ai/*`）。
+
+本文按仓库当前源码写成，覆盖：跑之前的准备、怎么跑全量、怎么只跑一个任务、怎么出报告、
+每个测试用例的含义（以及各自主要考察哪些 `ops_*` 工具）、临时文件与证据落在哪里。
+同目录的 `bench/README.md` 描述的是更早的形态（例如 seal 已接线、语料里还有后来删掉的任务），
+两者冲突时以本文与源码为准。
+
+---
+
+## 0. 三套工装，先分清
+
+| 套件 | 入口 | 用模型 | 断言什么 | 主要产物 |
+| --- | --- | --- | --- | --- |
+| 模型驱动 A/B | `node bench/cli.mjs ab` → `report` → `panel` | 是 | **通过率先行**；成本方向只在有 A/A 噪声底时才读 | 每臂 `bench/runs/<组>/<UTC>-<label>/` 下的 `summary.json` + `results/`、报告 `.md`；加 `--seal` 另有组目录 `run.json` |
+| 脚本验收门禁 | `node bench/cli.mjs gates` | 否（确定性 provider 脚本） | BM-01…BM-05 的固定工作负载：字节、schema token、CAS 冲突、权限拒绝 | `--output <新文件>.json` + 同名 `.md` |
+| 工具级确定性对比 | `node bench/cli.mjs tools` | 否 | 只有 `MATCH` / `EXPECTED_DIFFERENCE` / `EXPECTED_REJECTION` 算通过 | `--out <新文件>.json` |
+
+三条共同底线：
+
+1. **永不裁决时间**。median / 耗时只打印，只作人类证据，进不了任何门禁。
+2. **证据独占创建**。`gates` 的 `--output`、`tools` 的 `--out` 都必须是不存在的文件，重跑不会覆盖上一次的证据。
+3. **失败要响**。`report` / `gates` / `tools` 的退出码就是裁决；弃权（如噪声底未知）明确说出口，不伪装成通过。
+
+### 当前接线状态（这一段能省半小时）
+
+| 命令 | 状态 |
+| --- | --- |
+| `setup` / `report` / `panel` / `tools` / `gates` | 已接线，`--help` 退 `0` |
+| `ab` | 已接线：一个进程跑完两臂（按 `(task, repeat)` 奇偶 AB/BA 交错）；默认只写每臂 `results/` + `summary.json`，**加 `--seal` 才写组目录下的 `run.json`** |
+
+带 `--seal` 时，runner 会先用 `dsh --profile <名> --dump-config` 取两侧 profile 的指纹（各一次，几百毫秒），
+写进 `arms[].profileHash`；取不到指纹就在 spawn 任何会话之前拒绝，不花 token。`sealRun` 随后把两臂的
+`results/` 折成组目录下的 `run.json`（`schemaVersion: 1`，契约见 `bench/run.schema.json`）。
+
+不带 `--seal` 就是普通跑：`results/` 与 `summary.json` 一样写，`report` 与 `panel` 都读得了 `summary.json`
+（`panel` 会提示 `schemaVersion n/a`）。`--no-seal` 仍然表示"不要封存"，也就是默认值。
+
+---
+
+## 1. 跑之前的准备
+
+### 1.1 三种套件都要：装依赖 + 构建
+
+```console
+npm ci --ignore-scripts
+npm run build          # src/ -> lib/（gates 直接 import lib/ 与 lib/components/*）
+npm run build:ptc      # 构建并 stage 原生 worker（gates 的 --worker 默认指向它）
+node --version         # 需要 ^22.19 || >=24
+```
+
+`gates` 默认使用 `native/target/release/dsh-ops-worker`（Windows 下是 `dsh-ops-worker.exe`）；
+`setup` 的 preflight 会跑 `node bin/native-runtime.mjs check --platform <platform>-<arch>` 校验
+`runtime/<tag>/` 里的 worker 与来源凭据，缺了就**在碰 profile 之前**拒绝。
+
+### 1.2 只跑 A/B（模型驱动）还要：dsh + 两个 profile + LLM overlay
+
+```console
+npm i -g @deepseek-ai/dsh        # 或者稍后给 --dsh <...>/lib/bin.js
+node bench/cli.mjs setup --dry-run    # 先看计划：打印每一步写入与命令，什么也不改
+node bench/cli.mjs setup              # 真跑：preflight 通过后创建两个 profile
+```
+
+`setup` 的顺序是故意的：先 preflight（权限组合、`PSModulePath`、本地构建），**检查失败就在碰 profile
+之前拒绝**；一套注定会"量的是权限模式"或"跑的是旧构建"的配置，改 profile 也修不好。
+
+preflight 之后它会：
+
+- 把 `bench/llm.patch.example.yml` 复制成 `bench/llm.patch.yml`（仅当后者不存在；存在就一字不改，它是操作员的）；
+- 从模板（默认 `headless`）克隆出两个 profile：`bench-base`（基线）与 `bench-ops`（候选，默认装本 checkout 的本地构建）。
+  profile 写在 `$DSH_HOME/profiles/<标签>/cordis.patch.yml`（没设 `DSH_HOME` 就是 `~/.dsh`；`--dsh-home` 可隔离到别处）；
+- 把两侧的 shell 引擎（默认 5.1 `powershell.exe`）与权限模式（默认 `danger-full-access`）钉进各自的 patch 层，
+  再用 `dsh --dump-config` 读回来确认——写进文件和"真的生效"是两件事；
+- 打印跑 sweep 的那一条命令。
+
+常用旗标（完整列表看 `node bench/cli.mjs setup --help`）：`--dsh-home <dir>` 隔离 DSH_HOME、
+`--plugin <spec>`（`local` / npm spec / `none`）、`--reinstall`、`--no-build-check`、`--force`、`--dry-run`。
+
+**填 overlay**（A/B 跑之前必须做一次）：把服务器、模型 id、`apiKeyEnv` 填进 `bench/llm.patch.yml`。
+
+- 密钥只放环境变量或 `~/.dsh/.credentials.yaml`，**绝不写进这个文件**；
+- 默认 overlay 是隐式注入的，归档里会把 `--llm-patch <path>` 补进命令行；
+- 确实要让两侧各跑各自 profile 自带的路由，用 `--no-llm-patch`（runner 会把"两侧不共享任何路由"说出口）；
+- 默认 overlay 缺失又没给 `--no-llm-patch` 时，runner 在 spawn 之前退 `2` 并点名文件与两条出路。
+
+**噪声底**：A/A 是"基线跟自己对"。默认未知 ⇒ 成本门弃权，报告只给 Δ、不给方向。
+
+```console
+node bench/cli.mjs ab --aa --repeat 2 --folder aa-noise-01
+```
+
+之后比较时二选一：`--noise-floor-pct N`（固定已测半宽）或 `--noise <base> <cand>`（用两次基线跑现测）。
+
+### 1.3 只跑 gates（脚本门禁）还要：0.3.1 基线树 + 基线 worker
+
+BM-01 的权威比较对象是 **OPS 0.3.1**（提交 `4b51b6333213c376c8b7c173c12f35b408fdec2d`）。缺基线不是跳过，是失败。
+
+```console
+git fetch --unshallow                          # 浅克隆必须先补历史，否则拿不到 0.3.1 的 blob
+node bench/gates/prepare-baseline.mjs baseline-031   # 拒绝覆盖已存在的目录
+cargo build --release --locked --manifest-path baseline-031/native/Cargo.toml
+# Windows: --baseline-worker 指向 ...\dsh-ops-worker.exe
+```
+
+`prepare-baseline.mjs` 直接按 Git blob 落盘（不经过 checkout 的换行转换、不依赖 tar），
+`provenance.mjs` 随后逐 blob 复算 SHA-1、并校验基线 worker 自报 `dsh-ops-worker 0.3.1`。
+
+**BM-03 的 Windows Bash**：完整 bash 契约需要一个可选夹具。在专用临时 `DSH_HOME` 里
+`node bin/dsh-ops.mjs bash-runtime install`，再把 `DSH_OPS_TEST_BASH` 指到校验过的绝对路径。
+全新目录没有 Bash 时，BM-03 正确**阻塞**，而不是只数文件工具的小分数。
+
+**输出文件名**：`--output` 与它的 `.md` 都拒绝覆盖，重跑换一个新名字。
+
+### 1.4 只跑 tools 还要：两个 worker 可执行文件
+
+```console
+node bench/cli.mjs tools --baseline <worker-a> --candidate <worker-b> --out bench/runs/<新目录>/tools-01.json
+```
+
+两侧可以指向同一个二进制——那只证明"harness 还能驱动真实 worker、两轮答案一致"，**不构成任何性能结论**。
+
+---
+
+## 2. 怎么跑全量
+
+### 2.1 A/B 全量（模型驱动）：6 任务 × 2 次 × 2 臂 = 12 对 24 个会话
+
+```console
+node bench/cli.mjs ab --folder full-sweep-34
+# 想先看它会怎么跑（纯函数，不 spawn、不花钱）：
+node bench/cli.mjs ab --show
+```
+
+- 默认语料是 `bench/tasks/*.task.json` 的全部任务；每个任务自带 `repeat` 预算（当前都是 `2`）；
+- 每次 dsh 调用都带 `--patch bench/llm.patch.yml`（除非 `--no-llm-patch`）；
+- 一个进程跑完两臂，奇数轮 base→cand、偶数轮 cand→base，**串行**，一次一个会话；
+- 组目录只分配一次：`bench/runs/<folder>`；不给 `--folder` 时自动取下一个空闲的 `benchmark-test-NN`；
+- 常用附加旗标：`--seal`（额外写 `run.json`）、`--sleep-ms`、`--heartbeat-ms`、`--stall-ms`、`--timeout <ms>`、
+  `--model <id>`、`--verbose`、`--keep`（保留每个临时工作区）、`--dsh <path>`。
+  `--label` / `--profile` 属于旧的"每臂一个进程"形态，runner 会直接拒绝。
+
+跑完的屏幕摘要是：会话数/配对数、每侧通过数、两侧 token 与 Δ、配对数、噪声底、门禁结论、seal 结果
+（`--seal` 时写进哪个 `run.json`；没封存就明确说 "not requested"）。
+
+真实例子：`bench/runs/full-sweep-33`（2026-10-21）base 臂 13:02:34Z 起跑，组目录里的报告时间戳是
+13:15:32Z，全量约 13 分钟。
+
+### 2.2 gates 全量：BM-01…BM-05
+
+```console
+node bench/cli.mjs gates \
+  --baseline-source baseline-031 \
+  --baseline-worker baseline-031/native/target/release/dsh-ops-worker \
+  --output bench-evidence/2026-10-24-windows.json
+```
+
+不给 `--task` 就是五项全跑。判据：
+
+- 全部选中项 `passed` → 退 `0`；
+- 任一项 `failed` 或不可用（如 BM-03 缺 Bash、BM-04 没有已集成的 PDF 能力）→ 退 `1`；
+- 参数错误或缺少构建输入 → 退 `2`。
+- 选中项成功**不等于**五项都过：报告里 `Selected gates passed` 与 `All five gates accepted` 是两个字段。
+
+### 2.3 tools 全量
+
+```console
+node bench/cli.mjs tools --baseline <worker> --candidate <worker> --out bench/runs/<新目录>/tools-full.json
+```
+
+默认语料是 5 个尺寸边界族，其中 `small-files` 与 `deep-tree` **各有 10000 个 4 KiB 文件**（全量会真的建两万个文件，
+先留好时间与磁盘）。先热身 1 次、再 5 轮交替配对；同二进制时它只证明 harness 没坏。**冒烟用 `--scale 0.01`**：
+缩放只作用于文件**数量**，33 MiB 拒绝、8 MiB hex 窗口、1 MiB 行边界永远保留。
+
+---
+
+## 3. 怎么只跑某一个任务
+
+| 套件 | 单任务开关 | 备注 |
+| --- | --- | --- |
+| A/B | `--task csv-sum` | 可重复传多个；默认 `--repeat` 用任务自带预算，可用 `--repeat 1` 覆盖 |
+| gates | `--task BM-02` | 只接受 `BM-01`…`BM-05`；可重复传 |
+| tools | `--scale 0.01` | 语料没有"单个用例"的开关，缩放文件数即可快速冒烟 |
+
+A/B 单任务（先计划后执行）：
+
+```console
+node bench/cli.mjs ab --task big-file-paging --repeat 1 --show
+node bench/cli.mjs ab --task big-file-paging --repeat 1 --folder probe-paging
+```
+
+- 任务 id 写错会在跑之前退 `2`，并列出已知 id；
+- `--folder` 与 `--out <dir>` 二选一：`--out` 直接指定本次 sweep 的目录，不能再给 `--folder`；
+- 想固定两侧标签（默认 `bench-base` / `bench-ops`）用 `--base` / `--cand`，标签同时是 profile 名。
+
+门禁单任务：
+
+```console
+node bench/cli.mjs gates --task BM-02 --worker native/target/release/dsh-ops-worker --output bench-evidence/bm02.json
+```
+
+BM-02 / BM-03 / BM-04 / BM-05 不需要基线；只有 BM-01 要 `--baseline-source` + `--baseline-worker`，
+缺了不是跳过，而是把 BM-01 记成 `failed`（`BM-01 requires --baseline-source and --baseline-worker; missing baseline is not a pass`）。
+
+---
+
+## 4. 怎么生成测试报告
+
+### 4.1 A/B 报告（模型驱动）
+
+```console
+node bench/cli.mjs report bench-base bench-ops --folder full-sweep-34
+# 只要机器可读的比较文档：
+node bench/cli.mjs report bench-base bench-ops --folder full-sweep-34 --json --out -
+```
+
+- 两侧可以写 label（在 `bench/runs/*-<label>` 与 `bench/runs/<folder>/*-<label>` 里找，最新时间戳优先）、
+  一个 run 目录，或者 `run.json` / `summary.json` 的路径；
+- 默认落点是**当次跑的组目录**，文件名带写入时刻：`bench/runs/<组>/DSH-OPS Benchmark Report <UTC>.md`
+  （UTC 形如 `2026-10-21T13-15-32Z`，冒号换横线）。重跑一次就是一份新报告，不覆盖上一份；
+- 直接挂在 `bench/runs/` 下、没有组目录的跑，报告留在自己的 run 目录里；
+- **注意**：`--seal` 出来的 `<组>/run.json` 是**两臂合在一起**的文档，别把它当"一侧"传给 `report`；比较照旧用两个
+  label 或两个 arm 目录（它们读各自的 `summary.json`），`run.json` 是给 `panel` 和归档用的；
+- `--out <file>` 指定落点，`-` 只到 stdout；`--json` 让文件/标准输出承载比较文档而不是报告。
+
+判决旗标（**跑报告就等于跑门禁**）：
+
+| 旗标 | 含义 |
+| --- | --- |
+| `--fail-on both`（默认） | 先判通过率，再判 token |
+| `--fail-on pass-drop` / `regression` / `none` | 只判通过率 / 只判 token / 只出报告 |
+| `--regression-scope task\|total\|both` | token 回归判每个任务、判总量还是都判（默认 `task`） |
+| `--tolerance-pct N` | 回归容忍带，默认 `2` |
+| `--aggregate median\|min` | Δ 比较用的统计量（默认 median） |
+| `--noise-floor-pct N` / `--noise <a> <b>` | 给噪声底；不给就弃权（`noise-floor-unknown`） |
+
+退出码：`0` 正常或成本门弃权 · `1` 门禁失败 · `2` 用法/输入错误。
+
+**怎么读报告**（顺序别跳，正文与标题是英文）：
+
+1. `Per-task pairs`：`task | base | cand(Δ%) | steps | tool calls | tool errors | pass`，数值单元格自带括号 Δ%，
+   以 `TOTAL` 行收尾；
+2. `Tool calls (per-side overlap counts)`：每个工具一行，`base`/`cand` 是整轮合计，后面每个任务一列，格子是 `base → cand`。
+   **`ops_*` 计数上升标绿、下降标红；其它工具相反**；两侧都没调用写 `—`，相等不标色；
+3. `Per-task bucket detail` / `usage split` / `steps and tool calls`：诊断用，不改判决；
+4. `Warnings` 与 `Evidence`：列出无法支撑结论的行，以及 `run.json` / 归档路径；
+5. `Conclusion`（最后一段）：通过率、配对 token Δ、噪声底、方向、门禁与判定理由——顺序就是判决顺序。
+
+着色只是包一层 `<span style="color:…">`，数字不改写；GitHub 会剥掉 `style`，在那边退化成纯文本。
+
+### 4.2 门禁报告（gates）
+
+`--output <file>.json` 写 JSON，同名的 `<file>.json.md` 写 Markdown，**两个都独占创建**。
+Markdown 的结构：平台/host/Node 一行 → `Selected gates passed` / `All five gates accepted` → 门禁状态表 →
+BM-01 逐案例字节表（候选 / 0.3.1 / 官方读取器 / 两个节省比例）→ 主案例的轮数表 →
+无损下界（源码自身字节 vs 40% 目标）→ 每个门禁的 schema token 明细 → BM-05 的 gates JSON。
+
+JSON 里保留了精确输入、夹具哈希、规范化结果、模型可见文本、请求 schema 与比较来源，便于复核。
+
+### 4.3 工具级报告（tools）
+
+`--out <新文件>.json` 独占创建，控制台打印表格；时间只作为证据打印，**不参与判定**。
+只有 `MATCH`、`EXPECTED_DIFFERENCE`、`EXPECTED_REJECTION` 是"预期结果"，其余状态（含 `MISMATCH`、
+`UNSTABLE`、`TIMEOUT`、`ERROR`、`WORKER_ERROR`）都退 `1`。
+
+> 名字对照：设计议题里曾把不匹配写作 `UNEXPECTED_DIFFERENCE`，代码里的名字是 `MISMATCH`。
+
+### 4.4 面板（panel）
+
+```console
+node bench/cli.mjs panel --out bench/runs/<组>/<UTC>-bench-ops bench/runs/<组>/<UTC>-bench-ops/summary.json
+node bench/cli.mjs panel --serve bench/runs/<组>/<UTC>-bench-ops --port 0
+```
+
+- `panel.html` **不内联数据**：它只带数据文件的*名字*，查看时 `fetch` 同目录的 JSON，所以要把 HTML 写在数据文件旁边；
+- 支持 `run.json`（加 `--seal` 才有），也支持默认跑出来的 `summary.json`（提示 `schemaVersion n/a`）；
+- `--serve` 只绑 `127.0.0.1`、只服务那一个目录、不常驻、不发请求、不写 `~/.dsh`；
+- `file://` 双击时浏览器会拦 `fetch`，页面提供文件选择/拖拽回退；
+- 五个标签：概览 / 对话 / 轨迹 / 判卷 / 原始 JSON。
+
+---
+
+## 5. 测试用例含义（以及主要考察哪些 `ops_*` 工具）
+
+### 5.1 模型语料：`bench/tasks/*.task.json`（6 个）
+
+字段白名单是 `id / title / prompt / fixture / verify / repeat / timeoutMs`，多一个字段就是拼写错误并点名文件与字段。
+`prompt` 是模型唯一看到的东西。判卷类型只有 8 种：`fileExists / fileMissing / fileEquals / fileContains /
+fileLines / countFiles / contentHashes / command`。几个容易写错的语义：
+
+- `fileEquals` **两侧都 `trim()`**，行尾换行不算差异；`fileLines` 逐行 `trim()`、丢空行、折叠 CRLF；
+- `contentHashes` **只看直接子项**（不递归），逐个比对名字与原字节 SHA-256，并拒绝任何多出来的文件
+  （候选写下的 `.dsh-ops-update-*.lock` 边车被排除）。它是"改名而不是重写"的判据：删掉重建或截断能骗过
+  `countFiles`，骗不过它；
+- `invariant: true` 标记"任务开始前就必须成立的护栏"（防篡改/防改题），例如 `check.js` 的字节不变、runner 仍然失败。
+
+| 用例 | 工作量 | 判卷 | 主要考察的 `ops_*` 工具 |
+| --- | --- | --- | --- |
+| `api-rename` | `src/` 下 60 个模块 + `src/core.js`（另生成 `check.mjs`）；`repeat 2`，30 min | `contentHashes(dir: src)` 全等（61 个直接子项的名字与原字节 SHA-256）+ `node check.mjs` 退 `0` | 搜调用点：`ops_grep`（+`ops_glob`）；读文件：`ops_read_files`；改名：`ops_edit_file` 或 `ops_replace`。诱饵 `parsePayloadLegacy` / `parsePayloadAsync` 与一个完全不碰该符号的文件必须原样保留 |
+| `big-file-paging` | `src/pipeline.js` 4200 行；`repeat 2`，15 min | `answer.txt` 等于 `auditLimit('staging')` 的整数 | 定位：`ops_grep`；只读两段：`ops_inspect_local_file`（或 `ops_read_files`）带 `offset`/`limit`；写答案：`ops_write_file`。文件里还留着过期注释与被取代的 `LEGACY_LIMIT_TABLE`，grep 一次仍要判断 |
+| `config-hunt` | `README.md` + 3 层 JSON + 12 个 `packages/*/config.json` 诱饵；`repeat 2`，15 min | `answer.txt` 等于 `MAX_UPLOAD_MB` 的有效值 | 找层：`ops_glob`；找 key：`ops_grep`；读优先级文档与三层：`ops_read_files`；写答案：`ops_write_file`。只 grep key 就停下会拿到 1/4 概率的错答案 |
+| `csv-sum` | `data.csv` 8000 行；`repeat 2`，15 min | `answer.txt` 等于 EU 金额整数和 | 别把 8000 行进上下文：`ops_bash`（聚合）、`ops_read_files`（只看表头）、`ops_write_file`。语料跑在 Native 面，PTC 是另一套投影，不在本套语料路径上 |
+| `gate-repair-loop` | 24 个 stage 模块（每个约 70 行）+ `check.js`；`repeat 2`，40 min | `node check.js` 退 `0` + `answer.txt` 等于最终值 + `check.js` 字节不变（invariant） | 跑门禁：`ops_bash`；读 stage：`ops_read_files`；按契约修那个常量：`ops_edit_file`；写答案：`ops_write_file`。每个 stage 只错一处绑定常量，契约写在模块自己的注释里 |
+| `noisy-test-triage` | `runner.js` 2400 个测试、恰好一行 `not ok`；`repeat 2`，15 min | `failure.txt` 等于失败测试名 + runner 仍退 `1`（invariant） | 跑并落盘：`ops_bash`（重定向到文件）；在日志里只捞那一行：`ops_grep`（如 `^not ok`、`outputMode: summary/content`）；必要时 `ops_read_files`；写结果：`ops_write_file`。答案必须精确，猜不中 |
+
+同一份报告里的 `Tool calls` 表就是这条设计的实测镜像：插件工具接住了 → `ops_*` 计数**上升**是绿；
+候选还在伸手够插件没覆盖的工具 → 其它工具上升是红。
+
+### 5.2 脚本门禁：BM-01…BM-05（`bench/gates/`）
+
+跑在固定的真实 host（DSH `0.2.0-rc.2` 的 AgentLoop / Session / 工具派发 / 权限服务）上，
+模型响应是确定性脚本——**不发网络模型请求、不产生计费 token**。测的是工具行为、文本与轮数，不是模型质量。
+
+| 门禁 | 测什么 | 主要考察的 `ops_*` 工具 |
+| --- | --- | --- |
+| BM-01 | 三个 70/80/90 行的 TS 文件各取**前 50 行**：一次 `read_files` 对比 OPS 0.3.1 与官方 `read`；先断言规范化数据与模型可见文本都完整保留请求行，再比字节。判据：一个带工具的 provider 轮次 + 相对 0.3.1 至少省 40%（官方读取器单列、不决定验收） | `ops_read_files`（多文件多区间一次调用）对比 `ops_inspect_local_file`、官方 `read`；敏感性网格另有 8/1/32 行、约 600 字符长行、转义 Unicode |
+| BM-02 | 单文件五处编辑一次提交成功；随后两次外部改动造成的**旧 CAS 冲突**必须全部拒绝（`REVISION_CONFLICT`）且文件字节不变；回执不许复读整文件 | `ops_edit_file`（`expectedRevision` + 多个 hunk） |
+| BM-03 | 真实第一次 provider 请求的默认 Native 面 schema：精确清单（含发现入口；Windows 还要求完整 Bash 契约与 jobs 服务），缺失/重复/意外工具都**阻塞**；用 `js-tiktoken@1.0.21` 的 `cl100k_base` 数紧凑 `name/description/parameters` JSON。已批准的 ≤400 token 只作用于文件/发现小计，Bash 仍常驻、完整总数单列 | `ops_read_files` + `ops_discover_tools`（小计），`ops_bash`（另列），整份启动消息 JSON 再单列 |
+| BM-04 | 真实单页 Helvetica/Flate PDF：初始无 PDF schema → 第一次发现后，**所属** provider 的下一次请求必须可见，兄弟 agent 不可见，然后验证抽取文本 | `ops_discover_tools` → `ops_read_pdf`。目录里还没有受评审的 PDF 读取器时，该门禁是 `blocked` |
+| BM-05 | 工作区外的凭据围栏读取与越界写入都必须 `rejected`、`effectState: none`、文件不变，且不泄露被拒父路径或秘密正文；同时要求"普通可读的外部文件"这个允许对照成功。固定 host 不提供全面的工作区读取围栏，报告里明说 | `ops_read_files`（`CREDENTIAL_DENIED`）与 `ops_write_file`（`POLICY_DENIED`） |
+
+### 5.3 工具级语料：`bench/tools/index.mjs`（无模型）
+
+固定尺寸边界，`SEED = 870016`，改它就让所有归档报告失去基线。五个夹具族：
+
+| 族 | 边界 / 用例 |
+| --- | --- |
+| `small-files` / `deep-tree` | 10000 个 4 KiB 文件；`grep` 无命中（summary）、`glob` 带排除与分页；目录里还埋了 `node_modules`、`.hidden`、`target`、`.venv`，以及一条 31 层 `d/` 的深树 |
+| `big-file` | 33 MiB 文件必须被拒（`OUTPUT_LIMIT`）、8 MiB 文件的 hex 窗口必须能读；`grep` 在混合目录下仍要命中 |
+| `dense-hits` | 200 个"每行多命中 + 中文"的文件；`summary` / `count` / `content` 三种输出模式与带 offset/context 的分页 |
+| `edge-text` | 1 MiB 单行、带 BOM/引号/反斜杠/制表符/NUL 的 Unicode、非法 UTF-8、4095 字节处正好断在中文前的边界 |
+| 两个 worker | 同一套用例分别喂给 `--baseline` 与 `--candidate`，逐项比对状态、输出与错误信封 |
+
+### 5.4 想加一个任务
+
+把 `bench/tasks/<id>.task.json` 放进目录即可（`loadTasks` 按文件名排序读全量）：
+
+- `fixture.generator` 必须是 `bench/lib/fixtures/index.mjs` 注册表里的名字之一
+  （当前 11 个：`grepTree / renameTree / largeCsv / brokenProject / logStats / configTree / deepModule /
+  deepCorpus / noisySuite / symbolTree / gatePipeline`）；
+- `verify` 非空，检查项的 `expect` 命名的是 fixture 导出的期望值，键写错会直接抛
+  `fixture exports have no key "..." (known: ...)`，不会静默失败；
+- `prompt` 不能以 `-` 开头（headless launcher 会当选项）、不能以空白开头、不能含 NUL；
+- `repeat` 是每任务预算（`1..100`），`timeoutMs` 默认 900000，合法区间 `1000..86400000`。
+
+---
+
+## 6. 临时文件与证据落在哪
+
+`bench/runs/` 与 `bench/llm.patch.yml` 都在 `.gitignore` 里：一次跑的数据是"某台机器上发生过什么"，不是源码。
+
+| 位置 | 谁写的 | 生命周期 |
+| --- | --- | --- |
+| `%TEMP%\dsh-ops-bench-<task>-r<n>-XXXXXX`（POSIX 为 `$TMPDIR`） | `bench/run/session.mjs`，`mkdtemp` 在每个会话自己的根下 | 夹具写在这里，dsh 以这里为 cwd 跑；验证读完就删。`--keep` 保留，路径记在行的 `workspace` 字段里 |
+| `bench/runs/<组>/<UTC>-<label>/results/<task>-r<n>.events.ndjson` | 会话驱动 | 事件流，写入期按 NDJSON 追加（崩溃安全） |
+| `…/results/<task>-r<n>.stderr.log` | 同上 | dsh 子进程的 stderr |
+| `…/results/<task>-r<n>.trace.ndjson` | 同上 | 时间线：`tool_call` / `tool_result` / 里程碑 / 心跳 / stall |
+| `…/results/<task>-r<n>.metrics.json` | 同上 | 该行的汇总：exit / steps / toolCalls / durationMs / usage 分桶 / 逐项 verify / 归档指针 |
+| `bench/runs/<组>/<UTC>-<label>/summary.json` | `bench/run/schedule.mjs` | 每臂聚合 + 配对 + 门禁结论。**先写摘要再封存**：被 Ctrl-C 打断的 sweep 也留下可读的记录 |
+| `bench/runs/<组>/run.json` | `bench/run/seal.mjs` 的 `sealRun`（**只在带 `--seal` 时**） | 两臂合体的封存文档，`schemaVersion: 1`；读者遇到未知版本必须拒绝 |
+| `bench/runs/<组>/DSH-OPS Benchmark Report <UTC>.md` | `bench/compare.mjs` | 报告默认落点；一次运行一份，不覆盖 |
+| `<--out 指定的目录>/panel.html` | `bench/report/panel.mjs` | 查看器，不内联数据 |
+| `%TEMP%\ops-bm040-XXXXXX\` | `bench/gates/index.mjs`，`mkdtemp` + `realpath` | 门禁的独占夹具目录，内含 `dsh-home/`（只改这一个 `DSH_HOME`，绝不动操作员的 HOME/profile）与每个门禁一个子目录（BM-01 的 `typescript-first-50`、`typescript-8`、`typescript-1`、`typescript-32`、`long-lines-8`、`unicode-json-8`，BM-02 `five-edits`，BM-03 `startup`，BM-04 `pdf-discovery`，BM-05 `authority-workspace` + `outside`）。**故意保留**供检查，脚本不做广泛清理 |
+| `%TEMP%\dsh-ops-file-bench-XXXXXX`（可换 `--temp-dir`） | `bench/tools/index.mjs` | 工具级夹具；生成在计时之外，跑完先**整树盘点**再删除，遇到不是自己创建的内容就报错并保留现场 |
+
+清理建议：`bench/runs/` 只增不减（现在已经有几十个历史组），报告与 `summary.json` 都是证据，删之前先确认
+里面没有你要引用的那一次；临时目录里的 `ops-bm040-*` 是故意留的，看过就能删。
+
+---
+
+## 7. 命令速查
+
+```console
+# 准备
+npm ci --ignore-scripts && npm run build && npm run build:ptc
+node bench/cli.mjs setup --dry-run
+node bench/cli.mjs setup
+
+# 全量
+node bench/cli.mjs ab --folder full-sweep-34            # 默认：只写每臂 summary.json + results/
+node bench/cli.mjs ab --seal --folder full-sweep-34     # 额外封存组目录的 run.json
+node bench/cli.mjs gates --baseline-source baseline-031 --baseline-worker baseline-031/native/target/release/dsh-ops-worker --output bench-evidence/<new>.json
+node bench/cli.mjs tools --baseline <worker> --candidate <worker> --out bench/runs/<new>/tools.json
+
+# 单任务
+node bench/cli.mjs ab --task csv-sum --repeat 1 --show
+node bench/cli.mjs gates --task BM-02 --output bench-evidence/bm02.json
+
+# 报告
+node bench/cli.mjs report bench-base bench-ops --folder full-sweep-34
+node bench/cli.mjs report bench-base bench-ops --folder full-sweep-34 --json --out -
+node bench/cli.mjs panel --out <数据文件所在目录> <run.json|summary.json>
+
+# 帮助 / 版本
+node bench/cli.mjs --help
+node bench/cli.mjs <setup|ab|report|panel|tools|gates> --help
+node bench/cli.mjs --version
+```
+
+退出码：`0` 正常（或成本门弃权）· `1` 失败/门禁失败 · `2` 用法与输入错误 · `3` 声明了但目标未接线
+（缺文件，或文件存在但没导出 `main(argv, io)`——绝不静默成功）。
\ No newline at end of file
diff --git a/bench/README-mini.md b/bench/README-mini.md
new file mode 100644
index 00000000..91495798
--- /dev/null
+++ b/bench/README-mini.md
@@ -0,0 +1,54 @@
+# Benchmark
+
+## 测试前的准备
+
+```console
+npm ci --ignore-scripts
+npm run build && npm run build:ptc     # lib/ + 原生 worker
+```
+
+### 再准备 dsh + 两个 profile
+
+```console
+npm i -g @deepseek-ai/dsh
+node bench/cli.mjs setup              # 先加 --dry-run 看计划；检查失败会在碰 profile 之前拒绝
+```
+
+### 配 LLM 路由 overlay
+
+跑 `node bench/cli.mjs setup` 会在副本不存在时自动复制一份（存在就一字不改）；想自己重来一份就手动复制，会覆盖已有的：
+
+```console
+cp bench/llm.patch.example.yml bench/llm.patch.yml           # bash
+```
+
+填 `bench/llm.patch.yml`：
+
+- `baseURL`：服务器地址，如 `https://host/v1`
+- `<model-id>` ：模型 id，两处必须一致
+- `apiKeyEnv`：放密钥的环境变量名，如 `BENCH_SERVER_API_KEY`
+- `contextWindow` / `maxTokens`：模型真实窗口 / 单次输出上限（默认最大 256K 上下文，单次最大 32K 输出）
+
+密钥只放在 `~/.dsh/.credentials.yaml` 的 `ref` 节点下面的环境变量里面，这样避免出现在项目源文件、对话的上下文
+
+## 怎么跑全量
+
+```console
+node bench/cli.mjs ab --folder full-sweep-34
+node bench/cli.mjs ab --show        # 只看计划：打印每对的顺序，不 spawn、不花钱
+```
+
+- 全量 = `bench/tasks/` 下 6 个任务 × 每个 2 次 × 2 臂 = 12 对 24 个会话，一个进程串行跑完，奇数轮 base→cand、偶数轮 cand→base；
+- 不给 `--folder` 会自动取下一个空闲的 `benchmark-test-NN`；Ctrl-C 中断时已跑完的会话照样写成摘要，不丢；
+- 默认不写 `run.json`：每臂留 `results/` + `summary.json`，报告用 `report` 生成（见下节）；要那份封存文档才加 `--seal`（它会先 dump 两侧 profile 做指纹，约 0.4s，取不到就在 spawn 之前拒绝）。
+
+## 怎么跑单个 task
+
+```console
+node bench/cli.mjs ab --task csv-sum --repeat 1 --folder probe-csv-sum
+```
+
+- `--task` 可重复传多个，只跑点名的那些；id 写错会在跑之前退 2，并把已知 id 列出来；
+- 不给 `--repeat` 就用任务自带的预算（当前 6 个都是 2），`--repeat 1` 只跑一轮；
+- 现成的 6 个 id：`api-rename`、`big-file-paging`、`config-hunt`、`csv-sum`、`gate-repair-loop`、`noisy-test-triage`；
+- 加 `--show` 先确认要跑哪几对，再摘掉它真跑。
\ No newline at end of file
diff --git a/bench/llm.patch.example.yml b/bench/llm.patch.example.yml
index 9162da48..424feadd 100644
--- a/bench/llm.patch.example.yml
+++ b/bench/llm.patch.example.yml
@@ -1,44 +1,20 @@
-# dsh-ops benchmark —— LLM 路由 overlay 模板
-#
-# 用法（详见 bench/PLAN.md §8、bench/README.md）：
-#   1) 复制本文件为 bench/llm.patch.yml（已在 .gitignore，不进仓库）；
-#   2) 填写你的 OpenAI 兼容服务器与模型 id（下面所有 <...> 占位符）；
-#   3) 设置 apiKeyEnv 指向的环境变量（如 BENCH_SERVER_API_KEY），
-#      密钥只放环境变量或 $DSH_HOME/.credentials.yaml，**绝不写进本文件**；
-#   4) node bench/run.mjs 会自动把它以 --patch 传给每次 dsh 调用
-#      （含 dump-config 存档）→ bench-base / bench-ops 两侧
-#      provider/model 一致性由构造保证（PLAN §2.7）；
-#      换别的 overlay 用 --llm-patch <path>；确实不想用 overlay（两侧各跑
-#      各自 profile 自带的路由）用 --no-llm-patch，sweep 会把"两侧不共享
-#      任何路由"这句话说出口。文件不存在又没给 --no-llm-patch 时，
-#      runner 在 spawn 之前就拒绝（退 2），不会静默换一条路由开跑。
-#
-# 注意：
-#   - 路由名 bench-server 可自定，但 llm-pi-ai 与 agent-default-model
-#     两处必须一致；
-#   - api 按服务器协议选择，自托管（vLLM / sglang / llama.cpp 的
-#     OpenAI 兼容端点）用 openai-completions；
-#   - 服务器必须在流式响应里回报 usage（stream_options.include_usage），
-#     否则 harness 拒绝给出 token 结论（PLAN §2.6）；
-#   - contextWindow 要按模型真实窗口填：现有语料里最长的题峰值 prompt 约 2 万 token，
-#     这个值不影响它们；但填小了仍会让 compaction-basic（0.8 × contextWindow）
-#     提前触发压缩，想跑长上下文任务时尤其要注意；
-#   - patch 语义是"整段替换 config"：llm-pi-ai 的 config 只有 providers
-#     一个字段、agent-default-model 只有 provider/model，直接照抄结构即可。
+- insert:
+    - id: credentials-local
+      name: "@deepseek-ai/dsh-credentials-local"
 
 - id: llm-pi-ai
   config:
     providers:
       bench-server:
-        baseURL: https://<你的服务器>/v1
-        apiKeyEnv: BENCH_SERVER_API_KEY
+        baseURL: https://<your-server>/v1
+        apiKeyEnv: DSH_API_KEY_ENV_NAME
         api: openai-completions
         models:
-          - id: <模型id>
+          - id: <model-id>
             contextWindow: 262144
-            maxTokens: 16384
+            maxTokens: 32768
 
 - id: agent-default-model
   config:
     provider: bench-server
-    model: <模型id>
+    model: <model-id>

From b1594ce2a7e77aafc593b4f6fd7085b95a0c5a1c Mon Sep 17 00:00:00 2001
From: Richeir <richeir@outlook.com>
Date: Sat, 24 Oct 2026 14:57:55 +0800
Subject: [PATCH 03/10] feat(bench): default the sweep to one repeat per task

DEFAULT_REPEAT drops 3 -> 1 and every task in bench/tasks/ declares
"repeat": 1, so an ab sweep without --repeat now runs each task once
per arm (12 sessions, 6 interleaved pairs) instead of twice per arm.
--repeat N still overrides everything; the default only covers a task
with no repeat field of its own. The default-value assertion in
test/bench-schedule.test.mjs follows so reverting the constant fails
the suite.
---
 bench/run/schedule.mjs                  | 2 +-
 bench/tasks/api-rename.task.json        | 2 +-
 bench/tasks/big-file-paging.task.json   | 2 +-
 bench/tasks/config-hunt.task.json       | 2 +-
 bench/tasks/csv-sum.task.json           | 2 +-
 bench/tasks/gate-repair-loop.task.json  | 2 +-
 bench/tasks/noisy-test-triage.task.json | 2 +-
 test/bench-schedule.test.mjs            | 2 +-
 8 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/bench/run/schedule.mjs b/bench/run/schedule.mjs
index 18799d45..bc821598 100644
--- a/bench/run/schedule.mjs
+++ b/bench/run/schedule.mjs
@@ -41,7 +41,7 @@ export const SUMMARY_FORMAT = 'dsh-ops-bench-summary-v1'
 /** The sweep document tag this module returns; the seal step turns it into run.json. */
 export const SWEEP_FORMAT = 'dsh-ops-bench-sweep-v1'
 /** Repeats per task when neither `--repeat` nor the task's own `repeat` field says. */
-export const DEFAULT_REPEAT = 3
+export const DEFAULT_REPEAT = 1
 /** The two sides an arm may play. `--aa` uses `base` twice, with distinct labels. */
 export const SIDES = ['base', 'cand']
 
diff --git a/bench/tasks/api-rename.task.json b/bench/tasks/api-rename.task.json
index 09a59a2a..e92b0dfa 100644
--- a/bench/tasks/api-rename.task.json
+++ b/bench/tasks/api-rename.task.json
@@ -10,6 +10,6 @@
     { "type": "contentHashes", "dir": "src", "expect": "final" },
     { "type": "command", "command": "node", "args": ["check.mjs"], "exitCode": 0 }
   ],
-  "repeat": 2,
+  "repeat": 1,
   "timeoutMs": 1800000
 }
diff --git a/bench/tasks/big-file-paging.task.json b/bench/tasks/big-file-paging.task.json
index b14e74dc..d842c2a5 100644
--- a/bench/tasks/big-file-paging.task.json
+++ b/bench/tasks/big-file-paging.task.json
@@ -7,6 +7,6 @@
     "params": { "seed": 23, "lines": 4200, "env": "staging" }
   },
   "verify": [{ "type": "fileEquals", "path": "answer.txt", "expect": "answer" }],
-  "repeat": 2,
+  "repeat": 1,
   "timeoutMs": 900000
 }
diff --git a/bench/tasks/config-hunt.task.json b/bench/tasks/config-hunt.task.json
index 2ab684b9..7770aed8 100644
--- a/bench/tasks/config-hunt.task.json
+++ b/bench/tasks/config-hunt.task.json
@@ -7,6 +7,6 @@
     "params": { "seed": 21, "packages": 12, "env": "production" }
   },
   "verify": [{ "type": "fileEquals", "path": "answer.txt", "expect": "answer" }],
-  "repeat": 2,
+  "repeat": 1,
   "timeoutMs": 900000
 }
diff --git a/bench/tasks/csv-sum.task.json b/bench/tasks/csv-sum.task.json
index df862667..a96570f8 100644
--- a/bench/tasks/csv-sum.task.json
+++ b/bench/tasks/csv-sum.task.json
@@ -7,6 +7,6 @@
     "params": { "seed": 7, "rows": 8000, "targetRegion": "EU", "regions": ["EU", "US", "APAC", "LATAM"] }
   },
   "verify": [{ "type": "fileEquals", "path": "answer.txt", "expect": "sum" }],
-  "repeat": 2,
+  "repeat": 1,
   "timeoutMs": 900000
 }
diff --git a/bench/tasks/gate-repair-loop.task.json b/bench/tasks/gate-repair-loop.task.json
index a0caec2d..a687af96 100644
--- a/bench/tasks/gate-repair-loop.task.json
+++ b/bench/tasks/gate-repair-loop.task.json
@@ -11,6 +11,6 @@
     { "type": "fileEquals", "path": "answer.txt", "expect": "answer" },
     { "type": "fileEquals", "path": "check.js", "expect": "checkSource", "invariant": true }
   ],
-  "repeat": 2,
+  "repeat": 1,
   "timeoutMs": 2400000
 }
diff --git a/bench/tasks/noisy-test-triage.task.json b/bench/tasks/noisy-test-triage.task.json
index 16ac5694..c1b366fb 100644
--- a/bench/tasks/noisy-test-triage.task.json
+++ b/bench/tasks/noisy-test-triage.task.json
@@ -10,6 +10,6 @@
     { "type": "fileEquals", "path": "failure.txt", "expect": "failingName" },
     { "type": "command", "command": "node", "args": ["runner.js"], "exitCode": 1, "invariant": true }
   ],
-  "repeat": 2,
+  "repeat": 1,
   "timeoutMs": 900000
 }
diff --git a/test/bench-schedule.test.mjs b/test/bench-schedule.test.mjs
index a3f3e414..a4e4b67f 100644
--- a/test/bench-schedule.test.mjs
+++ b/test/bench-schedule.test.mjs
@@ -387,7 +387,7 @@ await test('parseRunArgs reads the runner flags, keeps the CLI validation, and r
   assert.throws(() => parseRunArgs(['--out', 'x', '--folder', 'g'], { runsDir: '/tmp' }), /drop --folder/)
 
   const plain = parseRunArgs([], { runsDir: '/tmp' })
-  assert.equal(plain.repeat, 3)
+  assert.equal(plain.repeat, 1)
   assert.equal(plain.repeatExplicit, false)
   assert.equal(plain.aa, false)
   assert.deepEqual(buildArms(plain).map((arm) => arm.label), ['bench-base', 'bench-ops'])

From eaec3e169c5bc0b99e9d288f20be6d4ac01f8c0b Mon Sep 17 00:00:00 2001
From: Richeir <richeir@outlook.com>
Date: Sat, 24 Oct 2026 15:30:55 +0800
Subject: [PATCH 04/10] feat(bench): date-stamp the default group folder and
 auto-write the sweep report
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The default group folder is now benchmark-YYYY-MM-DD-NN — the local calendar
date, numbered from -00, incrementing past anything already present — instead
of the ever-growing benchmark-test-NN. Allocation still happens exactly once
per sweep, still skips any same-named entry case-insensitively, and the clock
is injectable so suites assert exact names.

A finished sweep now renders its own verdict through compare.mjs's
renderReport and writes "DSH-OPS Benchmark Report <UTC>.md" into the group
folder (or the --out directory) — the bench report artifact without a second
command, re-renderable at any time. --no-report skips it; an interrupted
sweep writes none, because a partial run is not a comparison; a failed write
is a loud note, not a failed sweep. The ab help text and the three bench
READMEs follow, along with the repeat-2-to-1 leftovers in README-NEW's task
table.

api-rename's corpus shrinks to one fifth: symbolTree files 60 -> 12 (seed
unchanged, all five module shapes present, the look-alike-only decoys
included), so the model searches, reads and edits 11 touched files instead
of 51. The task's title and the README-NEW row follow.
---
 bench/README-NEW.md              | 21 ++++++-----
 bench/README-mini.md             |  9 +++--
 bench/README.md                  |  6 ++-
 bench/cli.mjs                    |  9 +++--
 bench/lib/next-folder.mjs        | 49 ++++++++++++++++--------
 bench/run.mjs                    | 65 ++++++++++++++++++++++++++++++--
 bench/tasks/api-rename.task.json |  4 +-
 test/bench-cli.test.mjs          | 18 +++++----
 test/bench-schedule.test.mjs     | 41 +++++++++++++++++++-
 9 files changed, 172 insertions(+), 50 deletions(-)

diff --git a/bench/README-NEW.md b/bench/README-NEW.md
index 6503c380..6ffdf5f2 100644
--- a/bench/README-NEW.md
+++ b/bench/README-NEW.md
@@ -134,16 +134,17 @@ node bench/cli.mjs ab --folder full-sweep-34
 node bench/cli.mjs ab --show
 ```
 
-- 默认语料是 `bench/tasks/*.task.json` 的全部任务；每个任务自带 `repeat` 预算（当前都是 `2`）；
+- 默认语料是 `bench/tasks/*.task.json` 的全部任务；每个任务自带 `repeat` 预算（当前都是 `1`）；
 - 每次 dsh 调用都带 `--patch bench/llm.patch.yml`（除非 `--no-llm-patch`）；
 - 一个进程跑完两臂，奇数轮 base→cand、偶数轮 cand→base，**串行**，一次一个会话；
-- 组目录只分配一次：`bench/runs/<folder>`；不给 `--folder` 时自动取下一个空闲的 `benchmark-test-NN`；
-- 常用附加旗标：`--seal`（额外写 `run.json`）、`--sleep-ms`、`--heartbeat-ms`、`--stall-ms`、`--timeout <ms>`、
+- 组目录只分配一次：`bench/runs/<folder>`；不给 `--folder` 时自动取下一个空闲的 `benchmark-YYYY-MM-DD-NN`（按当天日期编号，从 `-00` 起）；
+- 常用附加旗标：`--seal`（额外写 `run.json`）、`--no-report`（关掉跑完自动写的 md 报告）、`--sleep-ms`、`--heartbeat-ms`、`--stall-ms`、`--timeout <ms>`、
   `--model <id>`、`--verbose`、`--keep`（保留每个临时工作区）、`--dsh <path>`。
   `--label` / `--profile` 属于旧的"每臂一个进程"形态，runner 会直接拒绝。
 
 跑完的屏幕摘要是：会话数/配对数、每侧通过数、两侧 token 与 Δ、配对数、噪声底、门禁结论、seal 结果
-（`--seal` 时写进哪个 `run.json`；没封存就明确说 "not requested"）。
+（`--seal` 时写进哪个 `run.json`；没封存就明确说 "not requested"）、报告落点
+（`DSH-OPS Benchmark Report <UTC>.md` 写进组目录；`--no-report` 或 sweep 被打断时明确说没写）。
 
 真实例子：`bench/runs/full-sweep-33`（2026-10-21）base 臂 13:02:34Z 起跑，组目录里的报告时间戳是
 13:15:32Z，全量约 13 分钟。
@@ -298,12 +299,12 @@ fileLines / countFiles / contentHashes / command`。几个容易写错的语义
 
 | 用例 | 工作量 | 判卷 | 主要考察的 `ops_*` 工具 |
 | --- | --- | --- | --- |
-| `api-rename` | `src/` 下 60 个模块 + `src/core.js`（另生成 `check.mjs`）；`repeat 2`，30 min | `contentHashes(dir: src)` 全等（61 个直接子项的名字与原字节 SHA-256）+ `node check.mjs` 退 `0` | 搜调用点：`ops_grep`（+`ops_glob`）；读文件：`ops_read_files`；改名：`ops_edit_file` 或 `ops_replace`。诱饵 `parsePayloadLegacy` / `parsePayloadAsync` 与一个完全不碰该符号的文件必须原样保留 |
-| `big-file-paging` | `src/pipeline.js` 4200 行；`repeat 2`，15 min | `answer.txt` 等于 `auditLimit('staging')` 的整数 | 定位：`ops_grep`；只读两段：`ops_inspect_local_file`（或 `ops_read_files`）带 `offset`/`limit`；写答案：`ops_write_file`。文件里还留着过期注释与被取代的 `LEGACY_LIMIT_TABLE`，grep 一次仍要判断 |
-| `config-hunt` | `README.md` + 3 层 JSON + 12 个 `packages/*/config.json` 诱饵；`repeat 2`，15 min | `answer.txt` 等于 `MAX_UPLOAD_MB` 的有效值 | 找层：`ops_glob`；找 key：`ops_grep`；读优先级文档与三层：`ops_read_files`；写答案：`ops_write_file`。只 grep key 就停下会拿到 1/4 概率的错答案 |
-| `csv-sum` | `data.csv` 8000 行；`repeat 2`，15 min | `answer.txt` 等于 EU 金额整数和 | 别把 8000 行进上下文：`ops_bash`（聚合）、`ops_read_files`（只看表头）、`ops_write_file`。语料跑在 Native 面，PTC 是另一套投影，不在本套语料路径上 |
-| `gate-repair-loop` | 24 个 stage 模块（每个约 70 行）+ `check.js`；`repeat 2`，40 min | `node check.js` 退 `0` + `answer.txt` 等于最终值 + `check.js` 字节不变（invariant） | 跑门禁：`ops_bash`；读 stage：`ops_read_files`；按契约修那个常量：`ops_edit_file`；写答案：`ops_write_file`。每个 stage 只错一处绑定常量，契约写在模块自己的注释里 |
-| `noisy-test-triage` | `runner.js` 2400 个测试、恰好一行 `not ok`；`repeat 2`，15 min | `failure.txt` 等于失败测试名 + runner 仍退 `1`（invariant） | 跑并落盘：`ops_bash`（重定向到文件）；在日志里只捞那一行：`ops_grep`（如 `^not ok`、`outputMode: summary/content`）；必要时 `ops_read_files`；写结果：`ops_write_file`。答案必须精确，猜不中 |
+| `api-rename` | `src/` 下 12 个模块 + `src/core.js`（另生成 `check.mjs`）；`repeat 1`，30 min | `contentHashes(dir: src)` 全等（13 个直接子项的名字与原字节 SHA-256）+ `node check.mjs` 退 `0` | 搜调用点：`ops_grep`（+`ops_glob`）；读文件：`ops_read_files`；改名：`ops_edit_file` 或 `ops_replace`。诱饵 `parsePayloadLegacy` / `parsePayloadAsync` 与完全不碰该符号的文件必须原样保留 |
+| `big-file-paging` | `src/pipeline.js` 4200 行；`repeat 1`，15 min | `answer.txt` 等于 `auditLimit('staging')` 的整数 | 定位：`ops_grep`；只读两段：`ops_inspect_local_file`（或 `ops_read_files`）带 `offset`/`limit`；写答案：`ops_write_file`。文件里还留着过期注释与被取代的 `LEGACY_LIMIT_TABLE`，grep 一次仍要判断 |
+| `config-hunt` | `README.md` + 3 层 JSON + 12 个 `packages/*/config.json` 诱饵；`repeat 1`，15 min | `answer.txt` 等于 `MAX_UPLOAD_MB` 的有效值 | 找层：`ops_glob`；找 key：`ops_grep`；读优先级文档与三层：`ops_read_files`；写答案：`ops_write_file`。只 grep key 就停下会拿到 1/4 概率的错答案 |
+| `csv-sum` | `data.csv` 8000 行；`repeat 1`，15 min | `answer.txt` 等于 EU 金额整数和 | 别把 8000 行进上下文：`ops_bash`（聚合）、`ops_read_files`（只看表头）、`ops_write_file`。语料跑在 Native 面，PTC 是另一套投影，不在本套语料路径上 |
+| `gate-repair-loop` | 24 个 stage 模块（每个约 70 行）+ `check.js`；`repeat 1`，40 min | `node check.js` 退 `0` + `answer.txt` 等于最终值 + `check.js` 字节不变（invariant） | 跑门禁：`ops_bash`；读 stage：`ops_read_files`；按契约修那个常量：`ops_edit_file`；写答案：`ops_write_file`。每个 stage 只错一处绑定常量，契约写在模块自己的注释里 |
+| `noisy-test-triage` | `runner.js` 2400 个测试、恰好一行 `not ok`；`repeat 1`，15 min | `failure.txt` 等于失败测试名 + runner 仍退 `1`（invariant） | 跑并落盘：`ops_bash`（重定向到文件）；在日志里只捞那一行：`ops_grep`（如 `^not ok`、`outputMode: summary/content`）；必要时 `ops_read_files`；写结果：`ops_write_file`。答案必须精确，猜不中 |
 
 同一份报告里的 `Tool calls` 表就是这条设计的实测镜像：插件工具接住了 → `ops_*` 计数**上升**是绿；
 候选还在伸手够插件没覆盖的工具 → 其它工具上升是红。
diff --git a/bench/README-mini.md b/bench/README-mini.md
index 91495798..a0517394 100644
--- a/bench/README-mini.md
+++ b/bench/README-mini.md
@@ -38,9 +38,10 @@ node bench/cli.mjs ab --folder full-sweep-34
 node bench/cli.mjs ab --show        # 只看计划：打印每对的顺序，不 spawn、不花钱
 ```
 
-- 全量 = `bench/tasks/` 下 6 个任务 × 每个 2 次 × 2 臂 = 12 对 24 个会话，一个进程串行跑完，奇数轮 base→cand、偶数轮 cand→base；
-- 不给 `--folder` 会自动取下一个空闲的 `benchmark-test-NN`；Ctrl-C 中断时已跑完的会话照样写成摘要，不丢；
-- 默认不写 `run.json`：每臂留 `results/` + `summary.json`，报告用 `report` 生成（见下节）；要那份封存文档才加 `--seal`（它会先 dump 两侧 profile 做指纹，约 0.4s，取不到就在 spawn 之前拒绝）。
+- 全量 = `bench/tasks/` 下 6 个任务 × 每个 1 次 × 2 臂 = 6 对 12 个会话，一个进程串行跑完，奇数轮 base→cand、偶数轮 cand→base；
+- 不给 `--folder` 会自动取下一个空闲的 `benchmark-YYYY-MM-DD-NN`（按当天日期编号，从 `-00` 起）；Ctrl-C 中断时已跑完的会话照样写成摘要，不丢；
+- 跑完自动在组目录写 `DSH-OPS Benchmark Report <UTC>.md`（`--no-report` 关闭，被打断的 sweep 不写）；
+- 默认不写 `run.json`：每臂留 `results/` + `summary.json`；要那份封存文档才加 `--seal`（它会先 dump 两侧 profile 做指纹，约 0.4s，取不到就在 spawn 之前拒绝）。
 
 ## 怎么跑单个 task
 
@@ -49,6 +50,6 @@ node bench/cli.mjs ab --task csv-sum --repeat 1 --folder probe-csv-sum
 ```
 
 - `--task` 可重复传多个，只跑点名的那些；id 写错会在跑之前退 2，并把已知 id 列出来；
-- 不给 `--repeat` 就用任务自带的预算（当前 6 个都是 2），`--repeat 1` 只跑一轮；
+- 不给 `--repeat` 就用任务自带的预算（当前 6 个都是 1），`--repeat N` 覆盖一切；
 - 现成的 6 个 id：`api-rename`、`big-file-paging`、`config-hunt`、`csv-sum`、`gate-repair-loop`、`noisy-test-triage`；
 - 加 `--show` 先确认要跑哪几对，再摘掉它真跑。
\ No newline at end of file
diff --git a/bench/README.md b/bench/README.md
index 1718ae85..d708d895 100644
--- a/bench/README.md
+++ b/bench/README.md
@@ -66,7 +66,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` 组目录 |
+| `ab` | `bench/run.mjs` → `bench/compare.mjs` | 先基线、再候选、再比较,三步共用**一个** `bench/runs/benchmark-YYYY-MM-DD-NN` 组目录(默认按当天日期取下一个空闲编号,从 `-00` 起);跑完自动在组目录写报告 |
 | `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` | 无模型的工具级确定性对比 |
@@ -100,6 +100,10 @@ npm 包发布、不参与构建、不进 `verify:release` / `release.yml`,也从
 `--show` 打印将执行的三条命令并立刻退出(纯函数,不写任何东西、不跑任何会话)。组号在这里**只分配一次**:
 如果每侧各自按时间戳分配目录,两侧会落进不同的组,最后什么都配对不上。
 
+sweep 正常跑完会**自动**用自己算出的判决渲染 `DSH-OPS Benchmark Report <UTC>.md` 写进组目录
+(`--no-report` 关闭;被打断的 sweep 不写 —— 部分结果不是比较)。报告写出失败只报错,不改变
+sweep 的退出码;`report` 子命令之后仍可随时从归档重渲染。
+
 ### `report`
 
 两侧各自可以是 label(`bench/runs/*-<label>`,含一层组目录,最新时间戳优先)、一个 run 目录、或一个
diff --git a/bench/cli.mjs b/bench/cli.mjs
index 439e1b09..853f765c 100644
--- a/bench/cli.mjs
+++ b/bench/cli.mjs
@@ -69,7 +69,7 @@ export function abUsage() {
     '                            [--base <label>] [--cand <label>] [--show] [runner flags...]',
     '',
     'Runs the baseline side, the candidate side, then the comparison, all inside ONE',
-    'bench/runs/benchmark-test-NN group: the number is allocated once here because a',
+    'bench/runs/benchmark-YYYY-MM-DD-NN group: the name is allocated once here because a',
     'per-process default would put each side in a different group and leave nothing to pair.',
     'Flag meanings are in `--help`; the group is created by the runner (P7/P8) and the',
     'comparison by P11.',
@@ -114,15 +114,16 @@ export function parseAbArgs(argv) {
  * sharing the one group folder allocated here. Pure: it reserves the name but writes
  * nothing, so `--show` and a real run report the same plan.
  * @param {string[]} argv - the `ab` arguments, parsed by {@link parseAbArgs}.
- * @param {{runsDir?: string, repoRoot?: string}} [options] - where group folders live and
- *   the checkout the three commands run in; injectable so a suite allocates nothing real.
+ * @param {{runsDir?: string, repoRoot?: string, now?: Date}} [options] - where group folders live,
+ *   the checkout the three commands run in, and the clock the auto folder name stamps
+ *   (injectable so a suite allocates nothing real and asserts exact names).
  * @returns {{base: string, cand: string, tasks: string[], repeat: string|null, folder: string, show: boolean, extra: string[], help: boolean, allocated: boolean, commands: {label: string, target: string, args: string[], argv: string[]}[], repoRoot: string}} the plan.
  */
 export function planAb(argv, options = {}) {
   const { runsDir = RUNS_DIR, repoRoot = REPO_ROOT } = options
   const parsed = parseAbArgs(argv)
   const allocated = parsed.folder === null
-  const folder = parsed.folder ?? nextFolderName(runsDir)
+  const folder = parsed.folder ?? nextFolderName(runsDir, options.now)
   const shared = parsed.tasks.flatMap((task) => ['--task', task])
   if (parsed.repeat !== null) shared.push('--repeat', parsed.repeat)
   shared.push('--folder', folder, ...parsed.extra)
diff --git a/bench/lib/next-folder.mjs b/bench/lib/next-folder.mjs
index 59892e27..4f7b41e3 100644
--- a/bench/lib/next-folder.mjs
+++ b/bench/lib/next-folder.mjs
@@ -1,17 +1,18 @@
 #!/usr/bin/env node
 /**
- * Allocate the next free `benchmark-test-NN` group directory under `bench/runs/`.
+ * Allocate the next free date-stamped group directory under `bench/runs/`.
  *
- * `ab` allocates this **exactly once per sweep** and hands the answer to both sides
- * and to the comparison: letting each process default on its own would put the
- * baseline in `benchmark-test-01` and the candidate in `benchmark-test-02` (that
- * group exists by then), and the comparison would have nothing to pair.
+ * The default name is `benchmark-YYYY-MM-DD-NN` — the local calendar date, numbered
+ * from `-00` — and `ab` allocates it **exactly once per sweep**, handing the answer
+ * to both sides and to the comparison: letting each process default on its own would
+ * put the baseline and the candidate in two different groups, and the comparison
+ * would have nothing to pair.
  *
  * The scan is read-only and non-exclusive on purpose: two sweeps started in the same
- * instant can both see `benchmark-test-01` free, and the failure mode is two runs
- * landing in one group — visible in the report, never lost data. A number is skipped
- * when *any* entry has that name, so a leftover empty directory from a failed sweep
- * is skipped rather than reused.
+ * instant can both see `-00` free, and the failure mode is two runs landing in one
+ * group — visible in the report, never lost data. A number is skipped when *any* entry
+ * has that name, so a leftover empty directory from a failed sweep is skipped rather
+ * than reused.
  *
  * @module dsh-ops/bench/next-folder
  */
@@ -24,10 +25,23 @@ import { BENCH_DIR } from './env.mjs'
 /** Where `run.json` archives land, one directory per sweep. */
 export const RUNS_DIR = path.join(BENCH_DIR, 'runs')
 /** The group prefix both the CLI help text and this scan agree on. */
-export const FOLDER_PREFIX = 'benchmark-test-'
-/** Zero-padded to two digits; numbers past 99 simply grow (`benchmark-test-100`). */
+export const FOLDER_PREFIX = 'benchmark-'
+/** Zero-padded to two digits; numbers past 99 simply grow (`benchmark-2026-10-24-100`). */
 const WIDTH = 2
 
+/**
+ * The local calendar date of `now` as `YYYY-MM-DD`.
+ * @param {Date} [now] - the instant to stamp (default the current time).
+ * @returns {string} the zero-padded local date.
+ */
+export function dayStamp(now = new Date()) {
+  return [
+    String(now.getFullYear()).padStart(4, '0'),
+    String(now.getMonth() + 1).padStart(2, '0'),
+    String(now.getDate()).padStart(2, '0'),
+  ].join('-')
+}
+
 /**
  * The group names already present under the runs root, lower-cased so the answer
  * holds on a case-insensitive filesystem (Windows) as well as a case-sensitive one.
@@ -45,14 +59,17 @@ export function takenFolders(runsDir) {
 }
 
 /**
- * The first `benchmark-test-NN` nobody is using yet.
+ * The first `benchmark-YYYY-MM-DD-NN` nobody is using yet.
  * @param {string} [runsDir] - the runs root to scan (default {@link RUNS_DIR}).
- * @returns {string} the free group name, zero-padded to two digits.
+ * @param {Date} [now] - the instant whose local date names the group (default now);
+ *   injectable so a suite can assert exact names instead of patterns.
+ * @returns {string} the free group name, numbered from `-00` on that date.
  */
-export function nextFolderName(runsDir = RUNS_DIR) {
+export function nextFolderName(runsDir = RUNS_DIR, now = new Date()) {
   const taken = takenFolders(runsDir)
-  for (let number = 1; ; number += 1) {
-    const name = `${FOLDER_PREFIX}${String(number).padStart(WIDTH, '0')}`
+  const prefix = `${FOLDER_PREFIX}${dayStamp(now)}-`
+  for (let number = 0; ; number += 1) {
+    const name = `${prefix}${String(number).padStart(WIDTH, '0')}`
     if (!taken.has(name.toLowerCase())) return name
   }
 }
diff --git a/bench/run.mjs b/bench/run.mjs
index 07480359..31a71a17 100644
--- a/bench/run.mjs
+++ b/bench/run.mjs
@@ -10,7 +10,10 @@
  * aggregation is `lib/aggregate.mjs` (P6), the verdict is `lib/compare-core.mjs`
  * (P11a), and sealing is opt-in: `--seal` writes the schema-validated `run.json` through
  * `bench/run/seal.mjs` (P8a), while every sweep keeps each arm's `results/` and
- * `summary.json` either way. An injected `io.seal` supplies the document an embedder
+ * `summary.json` either way. A finished sweep also renders the markdown report from its
+ * own verdict (`compare.mjs`'s `renderReport`) into the group folder — `--no-report`
+ * skips it, and an interrupted sweep writes none, because a partial run is not a
+ * comparison. An injected `io.seal` supplies the document an embedder
  * wants; the CLI spawns this entry as a child and cannot inject one, so the flag has to
  * select the real seal rather than a missing slice.
  *
@@ -38,6 +41,7 @@ import { TASKS_DIR, loadTasks, selectTasks } from './lib/tasks.mjs'
 import { RUNS_DIR } from './lib/next-folder.mjs'
 import { DEFAULT_REPEAT, armOrder, createInterrupt, planPairs, planSessions, repeatsById, runSweep } from './run/schedule.mjs'
 import { sealRun } from './run/seal.mjs'
+import { renderReport, reportFileName } from './compare.mjs'
 
 /** The runner-only flags that take a value; `--task`/`--repeat`/`--folder`/`--base`/`--cand` are parsed by the CLI. */
 const VALUE_FLAGS = ['--sleep-ms', '--out', '--heartbeat-ms', '--stall-ms', '--timeout', '--dsh', '--llm-patch', '--model']
@@ -62,7 +66,7 @@ export function abUsage() {
     '  --base <label>       baseline arm label, also its profile name (default bench-base)',
     '  --cand <label>       candidate arm label, also its profile name (default bench-ops)',
     '  --aa                 A/A mode: run the baseline twice and measure the noise floor; --cand is ignored',
-    '  --folder <name>      group directory under bench/runs (default: the next benchmark-test-NN)',
+    '  --folder <name>      group directory under bench/runs (default: the next free benchmark-YYYY-MM-DD-NN)',
     '  --out <dir>          the sweep directory outright; not with --folder',
     '  --sleep-ms N         fixed pause between pairs (default 0)',
     '  --heartbeat-ms N     per-session "still running" line (default 15000; 0 = off)',
@@ -80,11 +84,14 @@ export function abUsage() {
     '  --seal               also seal the sweep into the schema-validated run.json (default:',
     '                       every arm keeps results/ and summary.json, nothing else)',
     '  --no-seal            explicit off; this is already the default, kept for old command lines',
+    '  --no-report          skip the markdown report a finished sweep writes into the group',
+    '                       folder (default: written; an interrupted sweep never writes one)',
     '  -h, --help           this text',
     '',
     'Exit codes: 0 ok · 1 a failed sweep · 2 usage error',
-    'Sealing is opt-in: without --seal a sweep writes each arm\'s results/ and summary.json,',
-    'and `bench report` renders the report from those summaries.',
+    'A finished sweep writes each arm\'s results/ and summary.json, the group folder\'s',
+    '"DSH-OPS Benchmark Report <UTC>.md", and --seal adds the schema-validated run.json',
+    'on top. `bench report` re-renders that report from the archives at any later time.',
   ].join('\n')
 }
 
@@ -116,6 +123,7 @@ export function parseRunArgs(argv, context = {}) {
     verbose: false,
     keep: false,
     seal: false,
+    noReport: false,
     noLlmPatch: false,
     sleepMs: 0,
     out: null,
@@ -133,6 +141,7 @@ export function parseRunArgs(argv, context = {}) {
     else if (flag === '--keep') options.keep = true
     else if (flag === '--seal') options.seal = true
     else if (flag === '--no-seal') options.seal = false
+    else if (flag === '--no-report') options.noReport = true
     else if (flag === '--no-llm-patch') options.noLlmPatch = true
     else if (flag === '--label' || flag === '--profile') {
       throw new UsageError(`${flag} named one arm of a per-process run; \`ab\` runs both arms itself — use --base/--cand`)
@@ -344,6 +353,41 @@ function printResult(out, err, result, options) {
   out(`[ab] sealed  : ${result.sealed?.path ?? (result.sealError ? `FAILED (${result.sealError})` : 'no — not requested (--seal writes run.json)')}`)
 }
 
+/**
+ * The sweep's own report: the verdict it just computed, rendered through
+ * `compare.mjs`'s `renderReport` and written beside the arm directories — the group
+ * folder, or the `--out` sweep directory a custom one named. This is the `bench report`
+ * artifact produced without a second command; `bench report` still re-renders it later
+ * from the same summaries.
+ *
+ * An interrupted sweep writes none: the comparison of a partial run is not evidence, and
+ * a report-shaped file that looks complete while the sweep says PARTIAL would lie to a
+ * reviewer who opens it without the console.
+ * @param {object} result - the sweep result (`compare`, `arms`, `dirs`, `summaryFiles`,
+ *   `interrupted` as `runSweep` returned them).
+ * @param {{now?: Function, writeFile?: Function, mkdir?: Function}} [context] - the clock
+ *   the file name stamps and injectable sinks; defaults to the wall clock and `fs`.
+ * @returns {{target: string|null, skipped: string|null}} where the report landed, or why
+ *   it was skipped (`target: null`).
+ * @throws {Error} when rendering or writing fails — `main` reports that without turning
+ *   it into a sweep failure.
+ */
+export function sweepReport(result, context = {}) {
+  if (result.compare === null) return { target: null, skipped: 'no comparison ran' }
+  if (result.interrupted) return { target: null, skipped: 'a partial sweep is not a comparison' }
+  const now = context.now ?? Date.now
+  const write = context.writeFile ?? fs.writeFileSync
+  const mkdir = context.mkdir ?? fs.mkdirSync
+  const sources = {
+    base: { spec: result.arms[0].label, file: result.summaryFiles.base, kind: 'summary' },
+    cand: { spec: result.arms[1].label, file: result.summaryFiles.cand, kind: 'summary' },
+  }
+  const target = path.join(path.dirname(result.dirs.base), reportFileName(now()))
+  mkdir(path.dirname(target), { recursive: true })
+  write(target, `${renderReport(result.compare, sources)}\n`, 'utf8')
+  return { target, skipped: null }
+}
+
 /**
  * Run the sweep. Every dependency is injectable through `io` so a test never spawns,
  * never reads `~/.dsh` and never touches a model: `io.seal`, `io.runSession`,
@@ -495,6 +539,19 @@ export async function main(argv, io = {}) {
     uninstall()
   }
   printResult(out, err, result, options)
+  let report = { target: null, skipped: '--no-report' }
+  if (options.noReport !== true) {
+    try {
+      report = sweepReport(result, { now: io.now, writeFile: io.writeFile, mkdir: io.mkdir })
+    } catch (error) {
+      // The verdict is already computed and the summaries already written; a report that
+      // could not land is a loud note, not a failed sweep.
+      err(`[ab] report  : FAILED — ${String(error?.message ?? error)}`)
+      report = { target: null, skipped: null }
+    }
+  }
+  if (report.skipped !== null) out(`[ab] report  : not written (${report.skipped})`)
+  else if (report.target !== null) out(`[ab] report  : ${report.target}`)
   return exitFor(result)
 }
 
diff --git a/bench/tasks/api-rename.task.json b/bench/tasks/api-rename.task.json
index e92b0dfa..5f9fb4d2 100644
--- a/bench/tasks/api-rename.task.json
+++ b/bench/tasks/api-rename.task.json
@@ -1,10 +1,10 @@
 {
   "id": "api-rename",
-  "title": "Rename one exported symbol across a 60-module tree using file tools only",
+  "title": "Rename one exported symbol across a 12-module tree using file tools only",
   "prompt": "In src/core.js the exported function parsePayload has to be renamed to decodePayload: its definition, every import of it, and every call site. parsePayloadLegacy and parsePayloadAsync are different functions and keep their own names. Change no behaviour, add or remove no file under src/, and leave check.mjs alone. Use the file tools to make every change; do not modify files with a shell command such as sed or a script. When you are done, node check.mjs must exit 0.",
   "fixture": {
     "generator": "symbolTree",
-    "params": { "seed": 31, "files": 60 }
+    "params": { "seed": 31, "files": 12 }
   },
   "verify": [
     { "type": "contentHashes", "dir": "src", "expect": "final" },
diff --git a/test/bench-cli.test.mjs b/test/bench-cli.test.mjs
index b54894fd..e92c44fc 100644
--- a/test/bench-cli.test.mjs
+++ b/test/bench-cli.test.mjs
@@ -78,7 +78,7 @@ await test('ab --show prints the three commands and this suite never starts a sw
   const text = lines.join('\n')
   assert.equal(text.split('\n').filter((line) => line.startsWith('node ')).length, 3, text)
   assert.match(text, /node bench\/run\.mjs --label bench-base --profile bench-base --task csv-sum/)
-  assert.match(text, /node bench\/compare\.mjs bench-base bench-ops --folder benchmark-test-\d+/)
+  assert.match(text, /node bench\/compare\.mjs bench-base bench-ops --folder benchmark-\d{4}-\d{2}-\d{2}-\d{2}/)
   // Only assert the pending path while the runner is genuinely absent: once it lands,
   // `abMain([])` would spawn a real session, and a unit suite must never do that.
   if (!fs.existsSync(path.join(PACKAGE_ROOT, 'bench/run.mjs'))) {
@@ -98,18 +98,20 @@ await test('ab parsing defaults, repeats --task, and rejects malformed flags', (
 })
 await test('next-folder hands one group to both sides and skips anything already named', async () => {
   await withTempDir('bench-runs', (runs) => {
-    assert.equal(nextFolderName(runs), `${FOLDER_PREFIX}01`)
+    const day = new Date(2026, 9, 24, 15, 42) // mid-day local 2026-10-24; the clock must not steer the name
+    const stamp = `${FOLDER_PREFIX}2026-10-24`
+    assert.equal(nextFolderName(runs, day), `${stamp}-00`)
     const explicit = planAb(['--folder', 'ops-1'], { runsDir: runs })
     assert.equal(explicit.folder, 'ops-1')
     assert.equal(explicit.allocated, false)
     assert.deepEqual(explicit.commands.map((command) => command.args.at(-1)), ['ops-1', 'ops-1', 'ops-1'])
-    fs.mkdirSync(path.join(runs, `${FOLDER_PREFIX}01`))
-    fs.mkdirSync(path.join(runs, `${FOLDER_PREFIX}02`))
-    fs.mkdirSync(path.join(runs, `${FOLDER_PREFIX.toUpperCase()}03`)) // Windows would collide with this one
+    fs.mkdirSync(path.join(runs, `${stamp}-00`))
+    fs.mkdirSync(path.join(runs, `${stamp}-01`))
+    fs.mkdirSync(path.join(runs, `${stamp.toUpperCase()}-02`)) // Windows would collide with this one
     fs.writeFileSync(path.join(runs, 'unrelated.txt'), '')
-    assert.equal(nextFolderName(runs), `${FOLDER_PREFIX}04`)
-    assert.ok(takenFolders(runs).has(`${FOLDER_PREFIX}01`))
-    assert.equal(planAb(['--task', 'x'], { runsDir: runs }).folder, `${FOLDER_PREFIX}04`)
+    assert.equal(nextFolderName(runs, day), `${stamp}-03`)
+    assert.ok(takenFolders(runs).has(`${stamp}-00`))
+    assert.equal(planAb(['--task', 'x'], { runsDir: runs, now: day }).folder, `${stamp}-03`)
   })
 })
 await test('a good task validates, gets its timeout defaulted, and round-trips through a directory', async () => {
diff --git a/test/bench-schedule.test.mjs b/test/bench-schedule.test.mjs
index a4e4b67f..4aa37e0d 100644
--- a/test/bench-schedule.test.mjs
+++ b/test/bench-schedule.test.mjs
@@ -412,7 +412,7 @@ await test('main: --show prints the flip without running; a requested seal with
     assert.equal(scripted.calls.length, 0, '--show never spawns')
     assert.equal(out.lines.out.filter((line) => line.includes('base → cand') || line.includes('bench-base → bench-ops')).length, 1)
     assert.equal(out.lines.out.filter((line) => line.includes('bench-ops → bench-base')).length, 1)
-    assert.match(out.text(), /benchmark-test-01/)
+    assert.match(out.text(), /benchmark-\d{4}-\d{2}-\d{2}-\d{2}/)
     assert.match(out.text(), /show only/)
 
     // Sealing is opt-in, so `--seal` is what asks for the fingerprint; a launcher whose dump
@@ -501,6 +501,12 @@ await test('main: Ctrl-C during a session stops the sweep, reports it, and exits
     assert.equal(code, EXIT.failure)
     assert.match(out.text('err'), /interrupted/)
     assert.equal(scripted.calls.length, 1)
+    const group = path.join(root, 'runs', fs.readdirSync(path.join(root, 'runs'))[0])
+    assert.equal(
+      fs.readdirSync(group).filter((name) => name.startsWith('DSH-OPS Benchmark Report')).length, 0,
+      'an interrupted sweep writes no report: a partial run is not a comparison',
+    )
+    assert.match(out.text(), /not written \(a partial sweep is not a comparison\)/)
   })
 })
 
@@ -529,6 +535,12 @@ await test('main: a sweep is unsealed by default and --seal opts in', async () =
     const armDir = fs.readdirSync(group).find((name) => name.endsWith('bench-base'))
     assert.ok(fs.existsSync(path.join(group, armDir, 'summary.json')), 'the per-arm summary is the artifact the report reads')
     assert.equal(fs.existsSync(path.join(group, 'run.json')), false, 'nothing sealed this sweep')
+    const reports = fs.readdirSync(group).filter((name) => name.startsWith('DSH-OPS Benchmark Report') && name.endsWith('.md'))
+    assert.equal(reports.length, 1, 'a finished sweep writes its own report into the group folder')
+    const report = fs.readFileSync(path.join(group, reports[0]), 'utf8')
+    assert.match(report, /^# DSH-OPS Benchmark Report/)
+    assert.match(report, /csv-sum/, 'the rendered table carries the tasks the sweep measured')
+    assert.match(out.text(), /\[ab\] report  : .*DSH-OPS Benchmark Report/)
 
     // `--no-seal` still means off, so an old command line keeps working unchanged.
     const explicit = sink()
@@ -548,6 +560,33 @@ await test('main: a sweep is unsealed by default and --seal opts in', async () =
   })
 })
 
+await test('main: a finished sweep writes the report by default and --no-report skips it', async () => {
+  await withTempDir('bench-main-report', async (root) => {
+    const runsRoot = path.join(root, 'runs')
+    const base = { tasksDir: tasksDir(root, 1), runsDir: runsRoot, llmOverlay: overlayIn(root), resolveEntry: () => ENTRY, installSignals: false, now: NOW }
+    const groups = () => fs.readdirSync(runsRoot)
+
+    const out = sink()
+    const scripted = rig()
+    assert.equal(await main(['--repeat', '1'], { ...base, ...out, runSession: scripted.runSession }), EXIT.ok)
+    const firstName = groups()[0]
+    assert.equal(
+      fs.readdirSync(path.join(runsRoot, firstName)).filter((name) => name.startsWith('DSH-OPS Benchmark Report')).length, 1,
+      'the default sweep leaves its report in the group folder',
+    )
+
+    const off = sink()
+    const again = rig()
+    assert.equal(await main(['--repeat', '1', '--no-report'], { ...base, ...off, runSession: again.runSession }), EXIT.ok)
+    const secondName = groups().find((name) => name !== firstName)
+    assert.equal(
+      fs.readdirSync(path.join(runsRoot, secondName)).filter((name) => name.startsWith('DSH-OPS Benchmark Report')).length, 0,
+      '--no-report keeps the group folder free of reports',
+    )
+    assert.match(off.text(), /not written \(--no-report\)/)
+  })
+})
+
 await test('main: the sweep injects the operator overlay by default, records it, and refuses without one', async () => {
   await withTempDir('bench-main-overlay', async (root) => {
     const runner = { tasksDir: tasksDir(root, 1), runsDir: path.join(root, 'runs'), resolveEntry: () => ENTRY, installSignals: false, now: NOW, profileHashes: HASHES }

From 9aa1703db5b303a23eda6acbdcb5e2b1fea43073 Mon Sep 17 00:00:00 2001
From: Richeir <richeir@outlook.com>
Date: Sat, 24 Oct 2026 15:49:57 +0800
Subject: [PATCH 05/10] feat(bench): show each task's wall-clock in the
 report's first table
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Durations were already recorded per session; compare-core now aggregates
them like steps — durationMsMedian / durationMsMin under the same
--aggregate median|min, per-task delta.durationPct, and totals summed over
the task medians. The per-task pairs table gains a
"time base→cand (Δ%)" column (seconds, one decimal, — when unmeasured),
and its Δ% is painted like every other percent.

The bench docs' "never judge time" principle statements are gone, and the
report footer now says time is reported like any other metric. The gate
itself is unchanged: it judges pass rate and paired tokens, and duration
stays out of every verdict — the new core assertions pin that gate
outcomes do not move with duration.
---
 bench/README-NEW.md              |  11 +-
 bench/README.md                  | 289 +++++--------------------------
 bench/compare.mjs                |  19 +-
 bench/lib/compare-core.mjs       |  10 ++
 test/bench-compare-core.test.mjs |  24 +++
 test/bench-compare.test.mjs      |  15 +-
 6 files changed, 97 insertions(+), 271 deletions(-)

diff --git a/bench/README-NEW.md b/bench/README-NEW.md
index 6ffdf5f2..f9f10129 100644
--- a/bench/README-NEW.md
+++ b/bench/README-NEW.md
@@ -19,11 +19,10 @@
 | 脚本验收门禁 | `node bench/cli.mjs gates` | 否（确定性 provider 脚本） | BM-01…BM-05 的固定工作负载：字节、schema token、CAS 冲突、权限拒绝 | `--output <新文件>.json` + 同名 `.md` |
 | 工具级确定性对比 | `node bench/cli.mjs tools` | 否 | 只有 `MATCH` / `EXPECTED_DIFFERENCE` / `EXPECTED_REJECTION` 算通过 | `--out <新文件>.json` |
 
-三条共同底线：
+两条共同底线：
 
-1. **永不裁决时间**。median / 耗时只打印，只作人类证据，进不了任何门禁。
-2. **证据独占创建**。`gates` 的 `--output`、`tools` 的 `--out` 都必须是不存在的文件，重跑不会覆盖上一次的证据。
-3. **失败要响**。`report` / `gates` / `tools` 的退出码就是裁决；弃权（如噪声底未知）明确说出口，不伪装成通过。
+1. **证据独占创建**。`gates` 的 `--output`、`tools` 的 `--out` 都必须是不存在的文件，重跑不会覆盖上一次的证据。
+2. **失败要响**。`report` / `gates` / `tools` 的退出码就是裁决；弃权（如噪声底未知）明确说出口，不伪装成通过。
 
 ### 当前接线状态（这一段能省半小时）
 
@@ -241,8 +240,8 @@ node bench/cli.mjs report bench-base bench-ops --folder full-sweep-34 --json --o
 
 **怎么读报告**（顺序别跳，正文与标题是英文）：
 
-1. `Per-task pairs`：`task | base | cand(Δ%) | steps | tool calls | tool errors | pass`，数值单元格自带括号 Δ%，
-   以 `TOTAL` 行收尾；
+1. `Per-task pairs`：`task | base | cand(Δ%) | steps | tool calls | time | tool errors | pass`，数值单元格自带括号 Δ%，
+   以 `TOTAL` 行收尾。`time` 列（如 `60.0s → 55.0s (−8.3%)`）取同样的聚合（median/min），Δ% 与其它列同一套着色；
 2. `Tool calls (per-side overlap counts)`：每个工具一行，`base`/`cand` 是整轮合计，后面每个任务一列，格子是 `base → cand`。
    **`ops_*` 计数上升标绿、下降标红；其它工具相反**；两侧都没调用写 `—`，相等不标色；
 3. `Per-task bucket detail` / `usage split` / `steps and tool calls`：诊断用，不改判决；
diff --git a/bench/README.md b/bench/README.md
index d708d895..a0517394 100644
--- a/bench/README.md
+++ b/bench/README.md
@@ -1,266 +1,55 @@
-# bench
+# Benchmark
 
-轻量、零依赖、自包含的测量工装:一套入口、两种测量模式、一份数据契约。它**只在仓库里跑** —— 不随
-npm 包发布、不参与构建、不进 `verify:release` / `release.yml`,也从不成为默认门禁(设计议题 #205)。
+## 测试前的准备
 
-本套收编了两份来源:**#103(@OldLigant)** 的无模型工具级确定性对比,和 **#183(@Richeir)** 的模型
-驱动 token A/B 骨架;口径对齐 **#173** 的意图 —— 本地性能测量只作人类证据,不进 CI。归属记录见
-`docs/CHANGELOG.md`。
+```console
+npm ci --ignore-scripts
+npm run build && npm run build:ptc     # lib/ + 原生 worker
+```
 
-## 三种入口形态
+### 再准备 dsh + 两个 profile
 
-| 形态 | 命令 | 用途 |
-| --- | --- | --- |
-| 唯一跨平台入口 | `node bench/cli.mjs <command>` | 全部子命令: `setup \| ab \| report \| panel \| tools` |
-| npm scripts | `npm run bench:ab` 等 | 日常使用;装包后 `bench/` 不存在,脚本给出明确报错而不是 ENOENT |
-| 底层单脚本 | `node bench/setup.mjs` / `bench/compare.mjs` / `bench/report/panel.mjs` / `bench/tools/index.mjs` | 排障与单步重跑;`ab` 只是按顺序把 runner 与 compare 连起来 |
+```console
+npm i -g @deepseek-ai/dsh
+node bench/cli.mjs setup              # 先加 --dry-run 看计划；检查失败会在碰 profile 之前拒绝
+```
 
-`node bench/cli.mjs --help` 列出全部子命令,`<command> --help` 给出该命令自己的旗标。任何路径都从
-模块位置解析(在哪个工作目录下调用都一样),且**不经过 shell** —— `.cmd`/`.ps1` shim 无法被 Node 管道,
-而 shell 会重新解释每个参数。
+### 配 LLM 路由 overlay
 
-## 退出码
+跑 `node bench/cli.mjs setup` 会在副本不存在时自动复制一份（存在就一字不改）；想自己重来一份就手动复制，会覆盖已有的：
 
-| 码 | 含义 |
-| --- | --- |
-| `0` | 正常;或一个**弃权**的成本门(噪声底未知 ⇒ 不读方向) |
-| `1` | 失败:`report` 的判决门失败 · `tools` 出现被接受状态之外的项 · `setup` 的某个检查或步骤失败 |
-| `2` | 用法/输入错误:未知命令、未知旗标、缺值、越界参数;装包后缺 `bench/` 也走这里 |
-| `3` | **已声明但尚未接线**:目标文件不存在,或存在但没导出 `main(argv, io)` —— 打印所属切片与目标路径,绝不静默成功 |
+```console
+cp bench/llm.patch.example.yml bench/llm.patch.yml           # bash
+```
 
-`report`(以及 `ab` 的最后一步)的退出码**就是裁决**:`1` 表示门禁失败;一个没能跑起来的成本门
-(噪声底未知等)弃权并退 `0`。
+填 `bench/llm.patch.yml`：
 
-## 两种测量模式(以及各自不该断言什么)
+- `baseURL`：服务器地址，如 `https://host/v1`
+- `<model-id>` ：模型 id，两处必须一致
+- `apiKeyEnv`：放密钥的环境变量名，如 `BENCH_SERVER_API_KEY`
+- `contextWindow` / `maxTokens`：模型真实窗口 / 单次输出上限（默认最大 256K 上下文，单次最大 32K 输出）
 
-| 模式 | 入口 | 用模型 | 断言什么 | 不该断言什么 |
-| --- | --- | --- | --- | --- |
-| 成本 A/B | `bench ab` → `bench report` | 是 | **通过率先行**(任一任务 ✅→❌ 就是回归);只有**两侧都通过**的配对参与成本统计;方向必须超过 A/A 噪声底 | 时间;落在噪声带内的 Δ;没有噪声底时的任何方向 |
-| 工具级确定性对比 | `bench tools` | 否 | 只有 `MATCH / EXPECTED_DIFFERENCE / EXPECTED_REJECTION` 算通过,其余状态(含 `MISMATCH` / `UNSTABLE`)都退 `1` | 时间;同二进制两侧的"提速";任何性能结论 |
-| 本地性能(#173 的意图) | 各命令打印的 median | 否 | **什么都不裁决** —— median 只作人类证据 | 进 CI、进门禁、进任何性能回归判定 |
+密钥只放在 `~/.dsh/.credentials.yaml` 的 `ref` 节点下面的环境变量里面，这样避免出现在项目源文件、对话的上下文
 
-三者共同的一条:**永不裁决时间**。
+## 怎么跑全量
 
-### 成本 A/B 的口径
+```console
+node bench/cli.mjs ab --folder full-sweep-34
+node bench/cli.mjs ab --show        # 只看计划：打印每对的顺序，不 spawn、不花钱
+```
 
-1. **通过率先行**:`--fail-on both`(默认)先判通过率,任一任务从 ✅ 变 ❌ 即失败;`--fail-on pass-drop`
-   只判通过率,`regression` 只判 token,`none` 只出报告;
-2. **配对**:按 `task × repeat` 配对;`--regression-scope task|total|both` 决定 token 回归判每个任务、
-   判总量还是两者都判;`--tolerance-pct N`(默认 `2`)是回归容忍带;
-3. **只有两侧都通过的配对参与成本统计** —— 一侧失败的配对连 token 一起被排除,并在报告里单列;
-4. **A/A 噪声底**:没有噪声底时,所有成本方向弃权(`noise-floor-unknown`),报告只给测到的 Δ。
+- 全量 = `bench/tasks/` 下 6 个任务 × 每个 1 次 × 2 臂 = 6 对 12 个会话，一个进程串行跑完，奇数轮 base→cand、偶数轮 cand→base；
+- 不给 `--folder` 会自动取下一个空闲的 `benchmark-YYYY-MM-DD-NN`（按当天日期编号，从 `-00` 起）；Ctrl-C 中断时已跑完的会话照样写成摘要，不丢；
+- 跑完自动在组目录写 `DSH-OPS Benchmark Report <UTC>.md`（`--no-report` 关闭，被打断的 sweep 不写）；
+- 默认不写 `run.json`：每臂留 `results/` + `summary.json`；要那份封存文档才加 `--seal`（它会先 dump 两侧 profile 做指纹，约 0.4s，取不到就在 spawn 之前拒绝）。
 
-### 工具级确定性对比的口径
+## 怎么跑单个 task
 
-- `tools/measure.mjs` 的 `compare()` **判断顺序本身就是语义**:`TIMEOUT → ERROR → UNSTABLE →
-  (!sameAsBaseline ? (expectedDifference ? EXPECTED_DIFFERENCE : MISMATCH)) → expectedError 命中 ?
-  EXPECTED_REJECTION → (!eligible ? WORKER_ERROR) → MATCH`。其中"两侧返回同一个 error 信封"若不在
-  任务里显式声明为 `expectedError`,必须落 `WORKER_ERROR`,**不能**当成 `MATCH`(否则一次崩溃会被报告成提速);
-- `speedup` 只在 `MATCH` 且 candidate median > 0 时才有意义;任一轮超时或不稳定,整项不给方向;
-- 夹具在**计时之外**用 `mkdtemp` 生成,跑完删除;删除**之前**先整树盘点,遇到不是自己创建的内容就报错并保留现场;
-- 报告**独占创建**(`flag: 'wx'`):重跑不覆盖上一次的证据,而是退 `1` 并提示 `Refusing to overwrite`;
-- 每次调用都显式带 `outputMode`(native 默认是 content):省略参数两侧就不可比。
+```console
+node bench/cli.mjs ab --task csv-sum --repeat 1 --folder probe-csv-sum
+```
 
-## 子命令
-
-| 子命令 | 目标 | 做什么 |
-| --- | --- | --- |
-| `setup` | `bench/setup.mjs` | 自检 + 幂等准备两侧 profile(`bench-base` / `bench-ops`),打印跑 sweep 的那一条命令 |
-| `ab` | `bench/run.mjs` → `bench/compare.mjs` | 先基线、再候选、再比较,三步共用**一个** `bench/runs/benchmark-YYYY-MM-DD-NN` 组目录(默认按当天日期取下一个空闲编号,从 `-00` 起);跑完自动在组目录写报告 |
-| `report` | `bench/compare.mjs` | 从已封存的 `run.json` 渲染报告(`DSH-OPS Benchmark Report <UTC>.md`) |
-| `panel` | `bench/report/panel.mjs` | 生成/打开一个只读 `run.json` 的 `panel.html` |
-| `tools` | `bench/tools/index.mjs` | 无模型的工具级确定性对比 |
-
-### `setup`
-
-`--base-profile` / `--cand-profile` / `--template`(默认 `headless`),`--pin-shell <path>` / `--no-pin`,
-`--permission-mode <mode>` / `--no-permission-mode`(`danger-full-access`(默认)/ `workspace-write` /
-`read-only` / `none`),`--plugin <spec>`(`local` 默认装本 checkout 的本地构建 / npm spec / `none`),
-`--reinstall`,`--dsh-home <dir>`,`--dsh <path>`,`--force`,`--dry-run`,`--no-build-check`。
-
-顺序是故意的:先跑 preflight(权限组合、`PSModulePath`、本地构建),**检查失败就在碰 profile 之前拒绝**;
-一套配置一旦会被写成"量的是权限模式"或"跑的是旧构建",改 profile 也修不好,只会在下一次运行里让报错更难读。
-`--dry-run` 打印每一步写入与命令,什么也不改。
-
-`setup` 会把 `bench/llm.patch.example.yml` 复制成 `bench/llm.patch.yml`(仅当后者不存在),之后的每次 dsh
-调用都以 `--patch` 带上它;把服务器、模型 id 与 `apiKeyEnv` 填进副本即可,**密钥只放环境变量或
-`~/.dsh/.credentials.yaml`,绝不写进这个文件**。副本是操作员的,存在就一字不改。
-
-### `ab`
-
-`--task <id>`(可重复)、`--repeat <N>`、`--folder <name>`、`--base <label>` / `--cand <label>`
-(默认 `bench-base` / `bench-ops`)、`--show`,其余旗标原样交给 runner。
-
-每次 dsh 调用默认带上 `bench/llm.patch.yml`:换文件用 `--llm-patch <path>`,确实不要 overlay(两侧各跑
-各自 profile 自带的路由)用 `--no-llm-patch`,sweep 会把"两侧不共享任何路由"这句说出口。默认 overlay
-不存在、又没给 `--no-llm-patch` 时,runner 在 spawn 之前退 `2` 并点名文件和两条出路 —— 静默换一条路由
-开跑的代价是:两臂一模一样,报告里根本看不出来。默认 overlay 是隐式选中的,所以归档的 `argv` 会把
-`--llm-patch <path>` 补进去,免得一份说不清走了哪条路由的 summary 被当成证据。
-
-`--show` 打印将执行的三条命令并立刻退出(纯函数,不写任何东西、不跑任何会话)。组号在这里**只分配一次**:
-如果每侧各自按时间戳分配目录,两侧会落进不同的组,最后什么都配对不上。
-
-sweep 正常跑完会**自动**用自己算出的判决渲染 `DSH-OPS Benchmark Report <UTC>.md` 写进组目录
-(`--no-report` 关闭;被打断的 sweep 不写 —— 部分结果不是比较)。报告写出失败只报错,不改变
-sweep 的退出码;`report` 子命令之后仍可随时从归档重渲染。
-
-### `report`
-
-两侧各自可以是 label(`bench/runs/*-<label>`,含一层组目录,最新时间戳优先)、一个 run 目录、或一个
-`run.json` / 旧版 `summary.json` 路径。`--folder` 限定组,`--runs` 换根,`--aggregate median|min`,
-`--json` 输出比较文档而不是报告,`--out <file>`(`-` 只到 stdout)。默认落点是**当次跑的组目录**,
-文件名带写入时刻:一次 `bench/runs/<组>/<stamp>-<label>` 里的跑,报告写成
-`bench/runs/<组>/DSH-OPS Benchmark Report <UTC>.md`(UTC 与目录名同形,冒号换横线,如
-`2026-10-20T12-36-38Z`),所以 `full-sweep-4` 的报告就在 `bench/runs/full-sweep-4/`,不在某个 arm 目录里;
-重跑一次就是一份新报告,不覆盖上一份。不在组目录下的跑(直接挂在 `bench/runs/` 下)没有可上提的组,
-报告留在自己的 run 目录里。
-
-### `panel`
-
-`panel --out <dir> <run.json>` 写 `panel.html`;`panel --serve <dir> [--port <n>]` 起一个零依赖
-`node:http` 静态服务(只绑 `127.0.0.1`,默认端口 `0` 由系统分配)。只读:不发请求、不写 `~/.dsh`、
-不常驻、不注册 DSH 插件。`file://` 双击时浏览器的 `fetch` 会被 CORS 拦下,页面用文件选择/拖拽回退。
-
-### `tools`
-
-`--baseline` / `--candidate`(两个 worker 可执行文件)、`--out`(报告路径,**必须不存在**)、
-`--temp-dir`、`--scale`、`--timeout-ms`(这套旗标沿用 #103 的参数面,随接线片一并落地)。预热 1 次 +
-5 轮交替配对,同二进制两侧时它只证明"harness 没坏、输出可重复",**不是**性能基准。
-
-## 如何读报告(`DSH-OPS Benchmark Report <UTC>.md`)
-
-按这个顺序读,不要跳(报告正文与标题都是英文,小节名照英文读):
-
-1. **`Per-task pairs`**:`task | base | cand(Δ%) | steps base→cand(Δ%) | tool calls base→cand(Δ%) | tool errors | pass`;
-   数值单元格自带括号 Δ%,不单列;steps / tool calls 取该侧全部 repeat 的中位数(`--aggregate min` 时取最小值),
-   tool errors 与 pass 统计全部 repeat,配对可用数/排除数不再进这张表(它们留在 JSON 与门禁理由里);
-   表格以 `TOTAL` 行收尾,没有单独的 geomean 行(几何均值仍在 JSON 里);
-2. **`Tool calls (per-side overlap counts)`**:紧跟第一个表 —— 每个工具一行,`base` / `cand` 是整轮合计,
-   后面每个 task 一列,格子写成 `base → cand`;`ops_*` 工具计数上升标绿、下降标红,
-   其它工具相反(下降绿、上升红);两侧都没调用的格子写 `—`,相等不标色;
-3. **`Per-task bucket detail`** / **`usage split`** / **`steps and tool calls`**(都是诊断,不改判决):
-   按 input / output / cacheRead 分桶看 Δ,或给出每任务的步数与工具调用数;
-4. **`Warnings`**与**`Evidence`**:前者列出无法支撑结论的行(如某侧丢了 `step_end.usage`),后者给出 `run.json` 与
-   归档路径;
-5. **`Conclusion`**(报告的最后一段):通过率、配对 token Δ、噪声底、方向、门禁与判定理由,顺序就是判决顺序。
-
-标题下没有汇总行:判决只写在结尾的 **`Conclusion`** 里,标题之后直接进数据。
-
-所有百分数按方向着色:**小于等于 0 绿、大于 0 红**(与 `panel.html` 同一套色,写成行内 `style`)。
-着色只是包一层 `<span>`,数字本身不被改写;GitHub 会剥掉 `style`,在那边退化成纯文本。
-
-**工具调用**表的颜色看"采用方向",不是数字本身的涨跌:`ops_*` 工具计数上升是绿(插件工具接住了),下降是红;
-其它工具上升是红(候选仍在伸手够插件没覆盖的工具),下降是绿。计数相等不标色,两侧都没调用写 `—`。
-
-## 面板怎么读(五个标签)
-
-| 标签 | 内容 |
-| --- | --- |
-| 概览 | 结论条 + 每任务配对表 + 噪声带 + token 归因 |
-| 对话 | 左 base / 右 cand 同任务同 repeat 并排,标出首个分歧点 |
-| 轨迹 | 时间线:`tool_call` / `tool_result` / 里程碑 / 心跳 / stall |
-| 判卷 | verifier 明细:检查项 / 期望 / 实际 / 证据路径 |
-| 原始 JSON | 只读视图 + 复制 + 下载 |
-
-页面**从不内联数据**:它只带数据文件的*名字*,在查看时 `fetch` 同目录的 JSON;每个值都用 `textContent`
-写入,所以 transcript 里的 `<script>` 会被显示而不是解析,勾选「纯文本模式」可把任何标签降级成纯文本。
-面板只认 `schemaVersion 1`,遇到未知版本直接拒绝而不是猜。
-
-## A/A 噪声底、配对口径与"永不裁决时间"
-
-- A/A 噪声底是"基线与自身对照"得到的区间。**默认未知** ⇒ 成本门弃权,报告只给 Δ、不给方向;
-- 要给噪声底,二选一:`--noise-floor-pct N`(固定一个已测量的半宽)或 `--noise <base> <cand>`
-  (用两次基线运行现测);
-- 成本**只统计两侧都通过的配对**:一侧通过、另一侧失败的配对既不能证明变快也不能证明变慢;
-- 任何模式都**不裁决时间**:共享 runner 上的时间不可比,时序只打印、只作人类证据。
-
-## 任务编写语义
-
-任务文件是 `bench/tasks/*.task.json`,字段白名单是 `id` / `title` / `prompt` / `fixture` / `verify` /
-`repeat` / `timeoutMs`(多一个字段就是拼写错误,直接报错并点名文件与字段)。`prompt` 是模型唯一看到的东西,
-不能以 `-` 开头(headless launcher 会把它当选项)、不能以空白开头、不能含 NUL;`timeoutMs` 默认 900000
-(15 min),合法区间 `1000 .. 86400000`;`repeat` 是每任务预算,`1 .. 100`,runner 的 `--repeat N` 仍可覆盖。
-
-判卷(`lib/verify.mjs`)里几个容易写错的语义:
-
-- `fileEquals` **两侧都 `trim()`**(行尾换行不算差异);`fileLines` 逐行 `trim()` 且丢掉空行、折叠 CRLF;
-- `countFiles` **递归**计数,可按 `prefix` / `suffix` / `extension` 过滤;
-- `contentHashes` **只看直接子项**(不递归),逐个比对名字与原字节的 sha256,并拒绝任何多出来的文件;
-  它是"改名而不是重写"的判据 —— 删掉重建或截断再写能骗过 `countFiles`,骗不过它;
-- `expect` 命名的是 fixture 导出的期望值;键写错会直接抛 `fixture exports have no key "..." (known: ...)`,
-  不是静默失败;
-- `fileContains` 对**空文件恒失败**(`actual !== ''` 是前置条件),即"读不到内容"不等于"包含"。
-
-## 两套语料的分工
-
-| 语料 | 位置 | 产出 | 谁用 |
-| --- | --- | --- | --- |
-| 模型任务语料 | `bench/lib/fixtures/**`(`csv` / `log` / `tree` / `symbol` / `corpus` / `deep` / `repair`) | 每个生成器建一个任务工作区,并以 `derive*` 重新算出期望值 | `bench ab`(模型驱动) |
-| 工具级尺寸边界语料 | `bench/tools/index.mjs`(`createToolFixtures`,`SEED = 870016`) | 固定尺寸边界:`33 MiB` 拒绝、`8 MiB` hex 窗口、`1 MiB` 行边界 | `bench tools`(无模型) |
-
-两套不要混:`tools/` 的语料靠着它喂养的那次运行,`lib/fixtures/**` 是另一个目录,产出的是任务工作区。
-`--scale` 只缩放**文件数**(small / deep / dense),尺寸边界永远保留,所以 `--scale 0.01` 仍能冒烟到每一条边界。
-真要搬家,必须保持 `SEED` 与五个夹具族逐字节不变,否则比较就丢了基线。
-
-## run.json 契约
-
-`runs/<stamp>-<label>/run.json` 是**唯一数据源**:写入期事件追加为 NDJSON(崩溃安全),封存时归并
-进它,面板/报告/比较都读它,不额外落 CSV 或散文件。本表被 `test/bench-cli.test.mjs` 交叉校验。
-
-| 字段 | 含义 |
-| --- | --- |
-| `schemaVersion` | 契约版本号,`1`;读者遇到未知版本必须拒绝 |
-| `meta` | 采集环境事实:harness 版本、模式、平台、node、dsh、模型、git sha/branch、命令行、起止时间,以及两侧 arm 的标签与 profile 指纹 |
-| `arms` | 两侧 arm 的完整描述:label、profile、profileHash(单变量校验的指纹)、dsh 路径/版本、环境覆盖 |
-| `results` | 每 `task`×`repeat`×`arm` 一行:该行 metrics(exit / steps / toolCalls / durationMs / usage 分桶)、verify 逐检查项、events 引用 |
-| `verify` | 全量检查项汇总:checks / passed / failed / degraded(是否出现无法支撑成本结论的行)、notes |
-| `events` | 事件归档方式:写入期 NDJSON、封存时归并;含文件清单、事件数、哈希与合并时间 |
-| `archive` | 归档清单:每个文件的相对路径、字节数、sha256 与 role |
-
-三条数据纪律(硬边界 #205 §1):
-
-1. **数据只存 JSON**:原始数据只落 `run.json`,不内联、不额外落 CSV/散文件;
-2. **轨迹落独立文件**:事件与 stderr 是 `results/<task>-r<n>.events.ndjson`、`.stderr.ndjson`,
-   轨迹是独立的 `results/<task>-r<n>.trace.ndjson`,只在 `archive[]` 里登记 —— 它们不进 `run.json` 的正文;
-3. **HTML 不内联数据**:`panel.html` 只是"读同目录 JSON 的查看器"。
-
-## 有界兜底(P7)
-
-单发会话的两道超时都是有界的,坏掉的子进程不会把 sweep 挂死:`spawnErrorGraceMs` 默认 `1000`(spawn 立刻
-失败时,等 1 s 让 close 事件落地再结算,而不是把"没有 pid"当成没跑过);`killGraceMs` 默认 `5000`(kill 之后
-最多等 5 s 收尸,超时就从已归档的文件里记录这一行)。两者都可被调用方覆盖。
-
-## 状态名对照
-
-本议题 #205 曾把工具级对比的不匹配写作 `UNEXPECTED_DIFFERENCE`,代码里的名字是 **`MISMATCH`**。完整集合:
-`MATCH` / `MISMATCH` / `EXPECTED_DIFFERENCE` / `EXPECTED_REJECTION` / `UNSTABLE` / `TIMEOUT` / `ERROR` /
-`WORKER_ERROR`;只有 `MATCH`、`EXPECTED_DIFFERENCE`、`EXPECTED_REJECTION` 是"预期结果",其余都退 `1`。
-
-## CI 里怎么跑
-
-- **默认不跑**:`push` / `pull_request` / `merge_group` 里没有 `workflow_dispatch` 的 `inputs`,bench 作业
-  整段跳过,这些运行逐字节不变;
-- **opt-in**:手动触发时给一个布尔输入 `bench`(默认 `false`)才跑 `bench-smoke`;
-- **同二进制两侧**:CI 跑的是 `bench/cli.mjs tools --scale 0.01`(保留全部尺寸边界),两侧同一个二进制,
-  所以绿只说明"harness 还能驱动真实 worker、worker 两次答得一样",**不构成任何性能结论**;
-- **不阻塞**:该作业 `continue-on-error: true`,不进必需状态检查,聚合门禁不计它;
-- **artifact**:证据以 `bench-smoke-report` 上传(沿用 `tools-trial-report` 的命名),含 `bench/runs/smoke/**`
-  以及存在时的 `run.json` / `DSH-OPS Benchmark Report <UTC>.md` / `panel.html`;
-- **模型驱动的 sweep 绝不在 CI 跑**:它要断言成本方向,那是本地的人类判断。
-
-## 为什么 bench 不随包发布
-
-硬边界(设计议题 #205):**数据只存 JSON**、**HTML 只是读 JSON 的查看器**、**测试期可用但构建期不
-构建**。因此 `files` 不含 `bench/`,也不新增构建步骤;装包之后 `npm run bench:*` 会先检查 `bench/`,
-不存在就打印 "bench 只存在于仓库,不随包发布" 并以退出码 `2` 结束。
-
-## 接线现状
-
-声明了但没接线的子命令**从不静默**:目标文件不存在,或存在但没导出 `main(argv, io)`,都以退出码 `3`
-点名所属切片与目标路径。因此切片可以一个一个并入,而 CLI 的 tripwire 始终说真话:
-
-- `setup` / `report` / `panel` / `tools` 已接线,`--help` 退 `0`;
-- `ab` 已接线:整次 sweep 在**一个**子进程内完成,两臂按 `(task, repeat)` 的奇偶 **AB/BA 交错**
-  (奇数轮 base→cand,偶数轮 cand→base);`--show` 只打印逐对计划,不 spawn 任何会话;
-- 目前只剩"声明了但目标文件还没落地"这一种 pending 形态,它退 `3` 并点名切片与目标路径 ——
-  切片一个一个并入时,这条 tripwire 始终说真话。
+- `--task` 可重复传多个，只跑点名的那些；id 写错会在跑之前退 2，并把已知 id 列出来；
+- 不给 `--repeat` 就用任务自带的预算（当前 6 个都是 1），`--repeat N` 覆盖一切；
+- 现成的 6 个 id：`api-rename`、`big-file-paging`、`config-hunt`、`csv-sum`、`gate-repair-loop`、`noisy-test-triage`；
+- 加 `--show` 先确认要跑哪几对，再摘掉它真跑。
\ No newline at end of file
diff --git a/bench/compare.mjs b/bench/compare.mjs
index 2c4bf3d5..43c021f5 100644
--- a/bench/compare.mjs
+++ b/bench/compare.mjs
@@ -25,8 +25,8 @@
  * 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.
+ * Durations are displayed like any other metric (the per-task table's time column);
+ * the verdict's cost basis remains paired tokens.
  *
  * @module dsh-ops/bench/compare
  */
@@ -445,25 +445,28 @@ function verdictSection(comparison) {
 function taskSection(comparison) {
   const { totals } = comparison
   const useMin = comparison.aggregate === 'min'
-  const keys = { steps: useMin ? 'stepsMin' : 'stepsMedian', toolCalls: useMin ? 'toolCallsMin' : 'toolCallsMedian', toolErrors: useMin ? 'toolErrorsMin' : 'toolErrorsMedian' }
+  const keys = { steps: useMin ? 'stepsMin' : 'stepsMedian', toolCalls: useMin ? 'toolCallsMin' : 'toolCallsMedian', toolErrors: useMin ? 'toolErrorsMin' : 'toolErrorsMedian', duration: useMin ? 'durationMsMin' : 'durationMsMedian' }
   // The change rides inside the cell it belongs to (`1,050 (+5.0%)`, `4 → 3 (−25%)`):
   // one number per row, with its Δ% in parentheses rather than a column of its own.
   const candCell = (value, pct) => `${number(value)}${Number.isFinite(pct) ? ` (${percent(pct)})` : ''}`
   const deltaCell = (baseValue, candValue, pct) => `${count(baseValue)} → ${count(candValue)}${Number.isFinite(pct) ? ` (${percent(pct)})` : ''}`
   const countCell = (baseValue, candValue) => `${count(baseValue)} → ${count(candValue)}`
+  // Time renders like every other metric: same aggregate, same direction colouring.
+  const seconds = (ms) => (Number.isFinite(ms) ? `${(ms / 1000).toFixed(1)}s` : '—')
+  const timeCell = (baseMs, candMs, pct) => `${seconds(baseMs)} → ${seconds(candMs)}${Number.isFinite(pct) ? ` (${percent(pct)})` : ''}`
   const passCell = (side) => `${side.base.passed}/${side.base.repeats}→${side.cand.passed}/${side.cand.repeats}`
   const lines = [
     '## Per-task pairs',
     '',
-    '| task | base | cand (Δ%) | steps base→cand (Δ%) | tool calls base→cand (Δ%) | tool errors | pass |',
-    '| --- | --- | --- | --- | --- | --- | --- |',
+    '| task | base | cand (Δ%) | steps base→cand (Δ%) | tool calls base→cand (Δ%) | time 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 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(`| ${name} | ${number(pair.baseValue)} | ${candCell(pair.candValue, pair.pct)} | ${deltaCell(task.base[keys.steps], task.cand[keys.steps], task.delta.stepsPct)} | ${deltaCell(task.base[keys.toolCalls], task.cand[keys.toolCalls], task.delta.toolCallsPct)} | ${timeCell(task.base[keys.duration], task.cand[keys.duration], task.delta.durationPct)} | ${countCell(task.base[keys.toolErrors], task.cand[keys.toolErrors])} | ${passCell(task)} |`)
   }
-  lines.push(`| **TOTAL** | ${number(totals.baseGrandTotal)} | ${candCell(totals.candGrandTotal, totals.grandTotalPct)} | ${deltaCell(totals.baseSteps, totals.candSteps, percentChange(totals.baseSteps, totals.candSteps))} | ${deltaCell(totals.baseToolCalls, totals.candToolCalls, percentChange(totals.baseToolCalls, totals.candToolCalls))} | ${countCell(totals.baseToolErrors, totals.candToolErrors)} | ${totals.basePasses}/${totals.baseRuns}→${totals.candPasses}/${totals.candRuns} |`)
+  lines.push(`| **TOTAL** | ${number(totals.baseGrandTotal)} | ${candCell(totals.candGrandTotal, totals.grandTotalPct)} | ${deltaCell(totals.baseSteps, totals.candSteps, percentChange(totals.baseSteps, totals.candSteps))} | ${deltaCell(totals.baseToolCalls, totals.candToolCalls, percentChange(totals.baseToolCalls, totals.candToolCalls))} | ${timeCell(totals.baseDurationMs, totals.candDurationMs, percentChange(totals.baseDurationMs, totals.candDurationMs))} | ${countCell(totals.baseToolErrors, totals.candToolErrors)} | ${totals.basePasses}/${totals.baseRuns}→${totals.candPasses}/${totals.candRuns} |`)
   return lines
 }
 
@@ -642,7 +645,7 @@ export function renderReport(comparison, sources = {}) {
     `- cand:${sources.cand?.file ?? '?'}(spec \`${sources.cand?.spec ?? '?'}\`,${sources.cand?.kind ?? '?'})`,
     `- document: format \`${comparison.format}\` · aggregate \`${comparison.aggregate}\` · tolerance ${rawPercent(comparison.tolerancePct)}`,
     '',
-    `Time fields are evidence only: the cost basis of this report is paired tokens, and the comparison does not read duration into the verdict (${COMPARE_FORMAT} carries no time statistics).`,
+    `Time is reported like any other metric: the time column shows each task's wall-clock (${comparison.aggregate}), and the cost basis of the verdict remains paired tokens (${COMPARE_FORMAT}).`,
     '',
     ...verdictSection(comparison),
   ]
diff --git a/bench/lib/compare-core.mjs b/bench/lib/compare-core.mjs
index 736eada4..9197c1c4 100644
--- a/bench/lib/compare-core.mjs
+++ b/bench/lib/compare-core.mjs
@@ -228,6 +228,10 @@ export function aggregateTask(metricsList = []) {
   const steps = numeric((metrics) => metrics?.steps ?? 0)
   const toolCalls = numeric((metrics) => metrics?.toolCalls ?? 0)
   const toolErrors = numeric((metrics) => metrics?.toolErrors ?? 0)
+  // Wall-clock per repeat, aggregated like steps. A failed row records 0 ms (it never
+  // ran), which drags the median down exactly the way a 0-steps row does — the pass
+  // columns are what tell the reader which rows actually measured something.
+  const durations = numeric((metrics) => metrics?.durationMs ?? 0)
   // The prompt shape: the first request (no history yet — system prompt + tool
   // schemas + task text) is the per-request fixed cost, and the per-step average
   // says how much context each subsequent request re-sent. Older archives predate
@@ -282,6 +286,8 @@ export function aggregateTask(metricsList = []) {
     stepsMin: minValue(steps),
     toolCallsMedian: median(toolCalls),
     toolCallsMin: minValue(toolCalls),
+    durationMsMedian: median(durations),
+    durationMsMin: minValue(durations),
     toolCallsByName,
     toolErrorsMedian: median(toolErrors),
     toolErrorsMin: minValue(toolErrors),
@@ -368,6 +374,7 @@ function statisticKeys(aggregate) {
     toolsKey: useMin ? 'toolCallsMin' : 'toolCallsMedian',
     errorsKey: useMin ? 'toolErrorsMin' : 'toolErrorsMedian',
     firstPromptKey: useMin ? 'firstRequestPromptMin' : 'firstRequestPromptMedian',
+    durationKey: useMin ? 'durationMsMin' : 'durationMsMedian',
     promptTotalKey: useMin ? 'promptTotalMin' : 'promptTotalMedian',
     inputKey: useMin ? 'inputMin' : 'inputMedian',
     outputKey: useMin ? 'outputMin' : 'outputMedian',
@@ -745,6 +752,7 @@ export function compareSummaries(base, cand, options = {}) {
         stepsPct: percentChange(baseSide[keys.stepsKey], candSide[keys.stepsKey]),
         toolCallsPct: percentChange(baseSide[keys.toolsKey], candSide[keys.toolsKey]),
         toolErrorsPct: percentChange(baseSide[keys.errorsKey], candSide[keys.errorsKey]),
+        durationPct: percentChange(baseSide[keys.durationKey], candSide[keys.durationKey]),
         passRateAbs: candSide.passRate - baseSide.passRate,
       },
     }
@@ -874,6 +882,8 @@ export function compareSummaries(base, cand, options = {}) {
       candToolCalls: sumStat(tasks, (task) => task.cand[keys.toolsKey]),
       baseToolErrors: sumStat(tasks, (task) => task.base[keys.errorsKey]),
       candToolErrors: sumStat(tasks, (task) => task.cand[keys.errorsKey]),
+      baseDurationMs: sumStat(tasks, (task) => task.base[keys.durationKey]),
+      candDurationMs: sumStat(tasks, (task) => task.cand[keys.durationKey]),
       basePasses,
       baseRuns: baseRunsCount,
       candPasses,
diff --git a/test/bench-compare-core.test.mjs b/test/bench-compare-core.test.mjs
index ed2405cc..00bd19ad 100644
--- a/test/bench-compare-core.test.mjs
+++ b/test/bench-compare-core.test.mjs
@@ -26,6 +26,7 @@ import {
   FAIL_ON,
   NOISE_FORMAT,
   REGRESSION_SCOPES,
+  aggregateTask,
   compareSummaries,
   geometricMeanPct,
   median,
@@ -58,6 +59,7 @@ function run(taskId, tokens, pass, extra = {}) {
     steps: extra.steps ?? 4,
     toolCalls: extra.toolCalls ?? 6,
     toolErrors: extra.toolErrors ?? 0,
+    durationMs: extra.durationMs ?? 60_000,
     toolCallsByName: {},
     verify: { passed: pass, checks: [] },
     exitCode: 0,
@@ -131,6 +133,28 @@ await test('the vocabularies and the scalar helpers are pinned', () => {
   assert.equal(percentChange(0, 0), 0)
 })
 
+await test('durations aggregate like steps: median/min per task, totals summed, gate unchanged', () => {
+  const aggregate = aggregateTask([
+    run('csv-sum', 1000, true, { repeatIndex: 1, durationMs: 60_000 }),
+    run('csv-sum', 1000, true, { repeatIndex: 2, durationMs: 62_000 }),
+  ])
+  assert.equal(aggregate.durationMsMedian, 61_000, 'the wall-clock median follows the same aggregate as steps')
+  assert.equal(aggregate.durationMsMin, 60_000)
+
+  // 60.0s of base work against 55.0s of candidate work: the delta and the sums are
+  // evidence in the document, and the gate still judges tokens and pass rate.
+  const base = summary('bench-base', [run('csv-sum', 1000, true, { durationMs: 60_000 })])
+  const faster = compareSummaries(base, summary('bench-ops', [run('csv-sum', 1000, true, { durationMs: 55_000 })]), { noiseFloorPct: 3.1, failOn: 'both' })
+  assert.equal(faster.tasks[0].delta.durationPct, -8.3)
+  assert.equal(faster.totals.baseDurationMs, 60_000)
+  assert.equal(faster.totals.candDurationMs, 55_000)
+  assert.equal(faster.gate.fail, false, 'identical tokens and passes gate clean')
+
+  const slower = compareSummaries(base, summary('bench-ops', [run('csv-sum', 1000, true, { durationMs: 600_000 })]), { noiseFloorPct: 3.1, failOn: 'both' })
+  assert.equal(slower.tasks[0].delta.durationPct, 900)
+  assert.equal(slower.gate.fail, false, 'the gate still judges tokens and pass rate, not wall-clock')
+})
+
 await test('pass-drop outranks a token win and is the first reason given', () => {
   const base = summary('base', [run('csv-sum', 1000, true), run('csv-sum', 1000, true)])
   const cand = summary('cand', [run('csv-sum', 400, true), run('csv-sum', 400, false)])
diff --git a/test/bench-compare.test.mjs b/test/bench-compare.test.mjs
index f0d090f7..7d9d03f1 100644
--- a/test/bench-compare.test.mjs
+++ b/test/bench-compare.test.mjs
@@ -57,6 +57,7 @@ function metrics(taskId, tokens, pass, extra = {}) {
     steps: extra.steps ?? 4,
     toolCalls: extra.toolCalls ?? 6,
     toolErrors: extra.toolErrors ?? 0,
+    durationMs: extra.durationMs ?? 60_000,
     toolCallsByName: extra.toolCallsByName ?? { ops_read: 2, bash: 1 },
     verify: { passed: pass, checks: [] },
     exitCode: 0,
@@ -167,14 +168,14 @@ const assertEnglish = (text) => assert.doesNotMatch(text, /[\u3400-\u4dbf\u4e00-
 
 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 cheaper = summary('bench-ops', [metrics('csv-sum', 926, true, { durationMs: 55_000 }), metrics('csv-sum', 926, true, { durationMs: 55_000 })])
   const beyond = compareSummaries(base, cheaper, { noiseFloorPct: 3.1, failOn: 'both' })
   const text = renderReport(beyond, SOURCES)
   assert.equal(renderReport(beyond, SOURCES), text, 'rendering is a pure function of its inputs')
   assertEnglish(text)
   assert.match(text, /^# DSH-OPS Benchmark Report\n\n## Per-task pairs$/m, 'the title leads straight into the data — no summary bar')
-  assert.match(text, /^\| task \| base \| cand \(Δ%\) \| steps base→cand \(Δ%\) \| tool calls base→cand \(Δ%\) \| tool errors \| pass \|$/m, 'the first table carries cost, behaviour and pass: no pairs, exclusion or direction column')
-  assert.ok(text.includes(`| csv-sum | 1,000 | 926 (${green('\u22127.4%')}) | 4 → 4 (${green('0.0%')}) | 6 → 6 (${green('0.0%')}) | 0 → 0 | 2/2→2/2 |`), 'each cell keeps its own Δ% in parentheses, painted like every other percent')
+  assert.match(text, /^\| task \| base \| cand \(Δ%\) \| steps base→cand \(Δ%\) \| tool calls base→cand \(Δ%\) \| time base→cand \(Δ%\) \| tool errors \| pass \|$/m, 'the first table carries cost, behaviour, wall-clock evidence and pass: no pairs, exclusion or direction column')
+  assert.ok(text.includes(`| csv-sum | 1,000 | 926 (${green('\u22127.4%')}) | 4 → 4 (${green('0.0%')}) | 6 → 6 (${green('0.0%')}) | 60.0s → 55.0s (${green('\u22128.3%')}) | 0 → 0 | 2/2→2/2 |`), 'each cell keeps its own Δ% in parentheses, painted like every other percent — time included')
   assert.doesNotMatch(text, /geomean/, 'the table ends at TOTAL: the geomean row is gone')
   assert.doesNotMatch(text, /## Excluded pairs|## A\/A noise band|## Token attribution/, 'the report keeps to cost, calls and the verdict: the three diagnostic sections are gone')
   assert.doesNotMatch(text, /^## (Per-task pairs|Tool calls \(per-side overlap counts\)|Per-task bucket detail \(median\)|usage split \(TOTAL, median\)|steps and tool calls \(median\))\n\n(?!\|)/m, 'a table heading leads straight into its table: no explanatory line')
@@ -184,7 +185,7 @@ await test('the same comparison renders byte-identical text twice, and the closi
   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/)
+  assert.match(text, /Time is reported like any other metric/)
 
   // 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' })
@@ -207,7 +208,7 @@ await test('the same comparison renders byte-identical text twice, and the closi
   const worseText = renderReport(worse, SOURCES)
   assert.ok(worseText.includes(`- Direction: Δ ${red('+5.0%')}, beyond the noise floor ±${red('3.1%')} ⇒ readable direction: costlier`), 'a rise beyond the band reads red')
   assert.match(worseText, /- gate: 🚦 failed \(regression\) ·/)
-  assert.ok(worseText.includes(`| csv-sum | 1,000 | 1,050 (${red('+5.0%')}) | 4 → 4 (${green('0.0%')}) | 6 → 6 (${green('0.0%')}) | 0 → 0 | 2/2→2/2 |`))
+  assert.ok(worseText.includes(`| csv-sum | 1,000 | 1,050 (${red('+5.0%')}) | 4 → 4 (${green('0.0%')}) | 6 → 6 (${green('0.0%')}) | 60.0s → 60.0s (${green('0.0%')}) | 0 → 0 | 2/2→2/2 |`))
   assert.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)
 })
@@ -239,7 +240,7 @@ await test('the steps and tool calls table pairs each task, sums the totals, and
   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')
+  assert.ok(errText.includes(`| 60.0s → 60.0s (${green('0.0%')}) | 2 → 0 | 1/1→1/1 |`), 'tool errors are counted, not percentaged')
 })
 
 await test('the tool table keeps the per-side totals, splits them by task, and colours adoption', () => {
@@ -416,7 +417,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.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 |`))
+    assert.ok(byDir.text().includes(`api-rename | 500 | 620 (${red('+24.0%')}) | 2 → 2 (${green('0.0%')}) | 1 → 1 (${green('0.0%')}) | 0.0s → 0.0s (${green('0.0%')}) | 0 → 0 | 1/1→1/1 |`))
 
     // A group is searched with --folder; the flat root is searched without it.
     assert.equal((await invoke(['bench-base', 'bench-ops', '--runs', runs, ...common]).run()), EXIT.ok)

From a598ee9dd1ac4938b4f49de513f5bd7a8ffa70c9 Mon Sep 17 00:00:00 2001
From: Richeir <richeir@outlook.com>
Date: Sat, 24 Oct 2026 15:53:50 +0800
Subject: [PATCH 06/10] docs(bench): fold the bench docs into one short README

README-NEW.md and README-mini.md are gone: bench/README.md now carries the
short preparation-and-usage guide on its own. No script, manifest or doc
referenced the two removed files.
---
 bench/README-NEW.md  | 403 -------------------------------------------
 bench/README-mini.md |  55 ------
 2 files changed, 458 deletions(-)
 delete mode 100644 bench/README-NEW.md
 delete mode 100644 bench/README-mini.md

diff --git a/bench/README-NEW.md b/bench/README-NEW.md
deleted file mode 100644
index f9f10129..00000000
--- a/bench/README-NEW.md
+++ /dev/null
@@ -1,403 +0,0 @@
-# bench 使用说明（按当前代码）
-
-`bench/` 是仓库自带的测量工装：**只在 checkout 里跑、不随 npm 包发布、不进默认门禁**。
-所有路径都从模块位置解析，在哪个工作目录下调用都一样；每个子进程都不经过 shell，参数原样传递。
-模型驱动的部分需要一个可用的 dsh 与 LLM 路由，脚本门禁复用仓库已有的 devDependencies（`js-tiktoken`、`@deepseek-ai/*`）。
-
-本文按仓库当前源码写成，覆盖：跑之前的准备、怎么跑全量、怎么只跑一个任务、怎么出报告、
-每个测试用例的含义（以及各自主要考察哪些 `ops_*` 工具）、临时文件与证据落在哪里。
-同目录的 `bench/README.md` 描述的是更早的形态（例如 seal 已接线、语料里还有后来删掉的任务），
-两者冲突时以本文与源码为准。
-
----
-
-## 0. 三套工装，先分清
-
-| 套件 | 入口 | 用模型 | 断言什么 | 主要产物 |
-| --- | --- | --- | --- | --- |
-| 模型驱动 A/B | `node bench/cli.mjs ab` → `report` → `panel` | 是 | **通过率先行**；成本方向只在有 A/A 噪声底时才读 | 每臂 `bench/runs/<组>/<UTC>-<label>/` 下的 `summary.json` + `results/`、报告 `.md`；加 `--seal` 另有组目录 `run.json` |
-| 脚本验收门禁 | `node bench/cli.mjs gates` | 否（确定性 provider 脚本） | BM-01…BM-05 的固定工作负载：字节、schema token、CAS 冲突、权限拒绝 | `--output <新文件>.json` + 同名 `.md` |
-| 工具级确定性对比 | `node bench/cli.mjs tools` | 否 | 只有 `MATCH` / `EXPECTED_DIFFERENCE` / `EXPECTED_REJECTION` 算通过 | `--out <新文件>.json` |
-
-两条共同底线：
-
-1. **证据独占创建**。`gates` 的 `--output`、`tools` 的 `--out` 都必须是不存在的文件，重跑不会覆盖上一次的证据。
-2. **失败要响**。`report` / `gates` / `tools` 的退出码就是裁决；弃权（如噪声底未知）明确说出口，不伪装成通过。
-
-### 当前接线状态（这一段能省半小时）
-
-| 命令 | 状态 |
-| --- | --- |
-| `setup` / `report` / `panel` / `tools` / `gates` | 已接线，`--help` 退 `0` |
-| `ab` | 已接线：一个进程跑完两臂（按 `(task, repeat)` 奇偶 AB/BA 交错）；默认只写每臂 `results/` + `summary.json`，**加 `--seal` 才写组目录下的 `run.json`** |
-
-带 `--seal` 时，runner 会先用 `dsh --profile <名> --dump-config` 取两侧 profile 的指纹（各一次，几百毫秒），
-写进 `arms[].profileHash`；取不到指纹就在 spawn 任何会话之前拒绝，不花 token。`sealRun` 随后把两臂的
-`results/` 折成组目录下的 `run.json`（`schemaVersion: 1`，契约见 `bench/run.schema.json`）。
-
-不带 `--seal` 就是普通跑：`results/` 与 `summary.json` 一样写，`report` 与 `panel` 都读得了 `summary.json`
-（`panel` 会提示 `schemaVersion n/a`）。`--no-seal` 仍然表示"不要封存"，也就是默认值。
-
----
-
-## 1. 跑之前的准备
-
-### 1.1 三种套件都要：装依赖 + 构建
-
-```console
-npm ci --ignore-scripts
-npm run build          # src/ -> lib/（gates 直接 import lib/ 与 lib/components/*）
-npm run build:ptc      # 构建并 stage 原生 worker（gates 的 --worker 默认指向它）
-node --version         # 需要 ^22.19 || >=24
-```
-
-`gates` 默认使用 `native/target/release/dsh-ops-worker`（Windows 下是 `dsh-ops-worker.exe`）；
-`setup` 的 preflight 会跑 `node bin/native-runtime.mjs check --platform <platform>-<arch>` 校验
-`runtime/<tag>/` 里的 worker 与来源凭据，缺了就**在碰 profile 之前**拒绝。
-
-### 1.2 只跑 A/B（模型驱动）还要：dsh + 两个 profile + LLM overlay
-
-```console
-npm i -g @deepseek-ai/dsh        # 或者稍后给 --dsh <...>/lib/bin.js
-node bench/cli.mjs setup --dry-run    # 先看计划：打印每一步写入与命令，什么也不改
-node bench/cli.mjs setup              # 真跑：preflight 通过后创建两个 profile
-```
-
-`setup` 的顺序是故意的：先 preflight（权限组合、`PSModulePath`、本地构建），**检查失败就在碰 profile
-之前拒绝**；一套注定会"量的是权限模式"或"跑的是旧构建"的配置，改 profile 也修不好。
-
-preflight 之后它会：
-
-- 把 `bench/llm.patch.example.yml` 复制成 `bench/llm.patch.yml`（仅当后者不存在；存在就一字不改，它是操作员的）；
-- 从模板（默认 `headless`）克隆出两个 profile：`bench-base`（基线）与 `bench-ops`（候选，默认装本 checkout 的本地构建）。
-  profile 写在 `$DSH_HOME/profiles/<标签>/cordis.patch.yml`（没设 `DSH_HOME` 就是 `~/.dsh`；`--dsh-home` 可隔离到别处）；
-- 把两侧的 shell 引擎（默认 5.1 `powershell.exe`）与权限模式（默认 `danger-full-access`）钉进各自的 patch 层，
-  再用 `dsh --dump-config` 读回来确认——写进文件和"真的生效"是两件事；
-- 打印跑 sweep 的那一条命令。
-
-常用旗标（完整列表看 `node bench/cli.mjs setup --help`）：`--dsh-home <dir>` 隔离 DSH_HOME、
-`--plugin <spec>`（`local` / npm spec / `none`）、`--reinstall`、`--no-build-check`、`--force`、`--dry-run`。
-
-**填 overlay**（A/B 跑之前必须做一次）：把服务器、模型 id、`apiKeyEnv` 填进 `bench/llm.patch.yml`。
-
-- 密钥只放环境变量或 `~/.dsh/.credentials.yaml`，**绝不写进这个文件**；
-- 默认 overlay 是隐式注入的，归档里会把 `--llm-patch <path>` 补进命令行；
-- 确实要让两侧各跑各自 profile 自带的路由，用 `--no-llm-patch`（runner 会把"两侧不共享任何路由"说出口）；
-- 默认 overlay 缺失又没给 `--no-llm-patch` 时，runner 在 spawn 之前退 `2` 并点名文件与两条出路。
-
-**噪声底**：A/A 是"基线跟自己对"。默认未知 ⇒ 成本门弃权，报告只给 Δ、不给方向。
-
-```console
-node bench/cli.mjs ab --aa --repeat 2 --folder aa-noise-01
-```
-
-之后比较时二选一：`--noise-floor-pct N`（固定已测半宽）或 `--noise <base> <cand>`（用两次基线跑现测）。
-
-### 1.3 只跑 gates（脚本门禁）还要：0.3.1 基线树 + 基线 worker
-
-BM-01 的权威比较对象是 **OPS 0.3.1**（提交 `4b51b6333213c376c8b7c173c12f35b408fdec2d`）。缺基线不是跳过，是失败。
-
-```console
-git fetch --unshallow                          # 浅克隆必须先补历史，否则拿不到 0.3.1 的 blob
-node bench/gates/prepare-baseline.mjs baseline-031   # 拒绝覆盖已存在的目录
-cargo build --release --locked --manifest-path baseline-031/native/Cargo.toml
-# Windows: --baseline-worker 指向 ...\dsh-ops-worker.exe
-```
-
-`prepare-baseline.mjs` 直接按 Git blob 落盘（不经过 checkout 的换行转换、不依赖 tar），
-`provenance.mjs` 随后逐 blob 复算 SHA-1、并校验基线 worker 自报 `dsh-ops-worker 0.3.1`。
-
-**BM-03 的 Windows Bash**：完整 bash 契约需要一个可选夹具。在专用临时 `DSH_HOME` 里
-`node bin/dsh-ops.mjs bash-runtime install`，再把 `DSH_OPS_TEST_BASH` 指到校验过的绝对路径。
-全新目录没有 Bash 时，BM-03 正确**阻塞**，而不是只数文件工具的小分数。
-
-**输出文件名**：`--output` 与它的 `.md` 都拒绝覆盖，重跑换一个新名字。
-
-### 1.4 只跑 tools 还要：两个 worker 可执行文件
-
-```console
-node bench/cli.mjs tools --baseline <worker-a> --candidate <worker-b> --out bench/runs/<新目录>/tools-01.json
-```
-
-两侧可以指向同一个二进制——那只证明"harness 还能驱动真实 worker、两轮答案一致"，**不构成任何性能结论**。
-
----
-
-## 2. 怎么跑全量
-
-### 2.1 A/B 全量（模型驱动）：6 任务 × 2 次 × 2 臂 = 12 对 24 个会话
-
-```console
-node bench/cli.mjs ab --folder full-sweep-34
-# 想先看它会怎么跑（纯函数，不 spawn、不花钱）：
-node bench/cli.mjs ab --show
-```
-
-- 默认语料是 `bench/tasks/*.task.json` 的全部任务；每个任务自带 `repeat` 预算（当前都是 `1`）；
-- 每次 dsh 调用都带 `--patch bench/llm.patch.yml`（除非 `--no-llm-patch`）；
-- 一个进程跑完两臂，奇数轮 base→cand、偶数轮 cand→base，**串行**，一次一个会话；
-- 组目录只分配一次：`bench/runs/<folder>`；不给 `--folder` 时自动取下一个空闲的 `benchmark-YYYY-MM-DD-NN`（按当天日期编号，从 `-00` 起）；
-- 常用附加旗标：`--seal`（额外写 `run.json`）、`--no-report`（关掉跑完自动写的 md 报告）、`--sleep-ms`、`--heartbeat-ms`、`--stall-ms`、`--timeout <ms>`、
-  `--model <id>`、`--verbose`、`--keep`（保留每个临时工作区）、`--dsh <path>`。
-  `--label` / `--profile` 属于旧的"每臂一个进程"形态，runner 会直接拒绝。
-
-跑完的屏幕摘要是：会话数/配对数、每侧通过数、两侧 token 与 Δ、配对数、噪声底、门禁结论、seal 结果
-（`--seal` 时写进哪个 `run.json`；没封存就明确说 "not requested"）、报告落点
-（`DSH-OPS Benchmark Report <UTC>.md` 写进组目录；`--no-report` 或 sweep 被打断时明确说没写）。
-
-真实例子：`bench/runs/full-sweep-33`（2026-10-21）base 臂 13:02:34Z 起跑，组目录里的报告时间戳是
-13:15:32Z，全量约 13 分钟。
-
-### 2.2 gates 全量：BM-01…BM-05
-
-```console
-node bench/cli.mjs gates \
-  --baseline-source baseline-031 \
-  --baseline-worker baseline-031/native/target/release/dsh-ops-worker \
-  --output bench-evidence/2026-10-24-windows.json
-```
-
-不给 `--task` 就是五项全跑。判据：
-
-- 全部选中项 `passed` → 退 `0`；
-- 任一项 `failed` 或不可用（如 BM-03 缺 Bash、BM-04 没有已集成的 PDF 能力）→ 退 `1`；
-- 参数错误或缺少构建输入 → 退 `2`。
-- 选中项成功**不等于**五项都过：报告里 `Selected gates passed` 与 `All five gates accepted` 是两个字段。
-
-### 2.3 tools 全量
-
-```console
-node bench/cli.mjs tools --baseline <worker> --candidate <worker> --out bench/runs/<新目录>/tools-full.json
-```
-
-默认语料是 5 个尺寸边界族，其中 `small-files` 与 `deep-tree` **各有 10000 个 4 KiB 文件**（全量会真的建两万个文件，
-先留好时间与磁盘）。先热身 1 次、再 5 轮交替配对；同二进制时它只证明 harness 没坏。**冒烟用 `--scale 0.01`**：
-缩放只作用于文件**数量**，33 MiB 拒绝、8 MiB hex 窗口、1 MiB 行边界永远保留。
-
----
-
-## 3. 怎么只跑某一个任务
-
-| 套件 | 单任务开关 | 备注 |
-| --- | --- | --- |
-| A/B | `--task csv-sum` | 可重复传多个；默认 `--repeat` 用任务自带预算，可用 `--repeat 1` 覆盖 |
-| gates | `--task BM-02` | 只接受 `BM-01`…`BM-05`；可重复传 |
-| tools | `--scale 0.01` | 语料没有"单个用例"的开关，缩放文件数即可快速冒烟 |
-
-A/B 单任务（先计划后执行）：
-
-```console
-node bench/cli.mjs ab --task big-file-paging --repeat 1 --show
-node bench/cli.mjs ab --task big-file-paging --repeat 1 --folder probe-paging
-```
-
-- 任务 id 写错会在跑之前退 `2`，并列出已知 id；
-- `--folder` 与 `--out <dir>` 二选一：`--out` 直接指定本次 sweep 的目录，不能再给 `--folder`；
-- 想固定两侧标签（默认 `bench-base` / `bench-ops`）用 `--base` / `--cand`，标签同时是 profile 名。
-
-门禁单任务：
-
-```console
-node bench/cli.mjs gates --task BM-02 --worker native/target/release/dsh-ops-worker --output bench-evidence/bm02.json
-```
-
-BM-02 / BM-03 / BM-04 / BM-05 不需要基线；只有 BM-01 要 `--baseline-source` + `--baseline-worker`，
-缺了不是跳过，而是把 BM-01 记成 `failed`（`BM-01 requires --baseline-source and --baseline-worker; missing baseline is not a pass`）。
-
----
-
-## 4. 怎么生成测试报告
-
-### 4.1 A/B 报告（模型驱动）
-
-```console
-node bench/cli.mjs report bench-base bench-ops --folder full-sweep-34
-# 只要机器可读的比较文档：
-node bench/cli.mjs report bench-base bench-ops --folder full-sweep-34 --json --out -
-```
-
-- 两侧可以写 label（在 `bench/runs/*-<label>` 与 `bench/runs/<folder>/*-<label>` 里找，最新时间戳优先）、
-  一个 run 目录，或者 `run.json` / `summary.json` 的路径；
-- 默认落点是**当次跑的组目录**，文件名带写入时刻：`bench/runs/<组>/DSH-OPS Benchmark Report <UTC>.md`
-  （UTC 形如 `2026-10-21T13-15-32Z`，冒号换横线）。重跑一次就是一份新报告，不覆盖上一份；
-- 直接挂在 `bench/runs/` 下、没有组目录的跑，报告留在自己的 run 目录里；
-- **注意**：`--seal` 出来的 `<组>/run.json` 是**两臂合在一起**的文档，别把它当"一侧"传给 `report`；比较照旧用两个
-  label 或两个 arm 目录（它们读各自的 `summary.json`），`run.json` 是给 `panel` 和归档用的；
-- `--out <file>` 指定落点，`-` 只到 stdout；`--json` 让文件/标准输出承载比较文档而不是报告。
-
-判决旗标（**跑报告就等于跑门禁**）：
-
-| 旗标 | 含义 |
-| --- | --- |
-| `--fail-on both`（默认） | 先判通过率，再判 token |
-| `--fail-on pass-drop` / `regression` / `none` | 只判通过率 / 只判 token / 只出报告 |
-| `--regression-scope task\|total\|both` | token 回归判每个任务、判总量还是都判（默认 `task`） |
-| `--tolerance-pct N` | 回归容忍带，默认 `2` |
-| `--aggregate median\|min` | Δ 比较用的统计量（默认 median） |
-| `--noise-floor-pct N` / `--noise <a> <b>` | 给噪声底；不给就弃权（`noise-floor-unknown`） |
-
-退出码：`0` 正常或成本门弃权 · `1` 门禁失败 · `2` 用法/输入错误。
-
-**怎么读报告**（顺序别跳，正文与标题是英文）：
-
-1. `Per-task pairs`：`task | base | cand(Δ%) | steps | tool calls | time | tool errors | pass`，数值单元格自带括号 Δ%，
-   以 `TOTAL` 行收尾。`time` 列（如 `60.0s → 55.0s (−8.3%)`）取同样的聚合（median/min），Δ% 与其它列同一套着色；
-2. `Tool calls (per-side overlap counts)`：每个工具一行，`base`/`cand` 是整轮合计，后面每个任务一列，格子是 `base → cand`。
-   **`ops_*` 计数上升标绿、下降标红；其它工具相反**；两侧都没调用写 `—`，相等不标色；
-3. `Per-task bucket detail` / `usage split` / `steps and tool calls`：诊断用，不改判决；
-4. `Warnings` 与 `Evidence`：列出无法支撑结论的行，以及 `run.json` / 归档路径；
-5. `Conclusion`（最后一段）：通过率、配对 token Δ、噪声底、方向、门禁与判定理由——顺序就是判决顺序。
-
-着色只是包一层 `<span style="color:…">`，数字不改写；GitHub 会剥掉 `style`，在那边退化成纯文本。
-
-### 4.2 门禁报告（gates）
-
-`--output <file>.json` 写 JSON，同名的 `<file>.json.md` 写 Markdown，**两个都独占创建**。
-Markdown 的结构：平台/host/Node 一行 → `Selected gates passed` / `All five gates accepted` → 门禁状态表 →
-BM-01 逐案例字节表（候选 / 0.3.1 / 官方读取器 / 两个节省比例）→ 主案例的轮数表 →
-无损下界（源码自身字节 vs 40% 目标）→ 每个门禁的 schema token 明细 → BM-05 的 gates JSON。
-
-JSON 里保留了精确输入、夹具哈希、规范化结果、模型可见文本、请求 schema 与比较来源，便于复核。
-
-### 4.3 工具级报告（tools）
-
-`--out <新文件>.json` 独占创建，控制台打印表格；时间只作为证据打印，**不参与判定**。
-只有 `MATCH`、`EXPECTED_DIFFERENCE`、`EXPECTED_REJECTION` 是"预期结果"，其余状态（含 `MISMATCH`、
-`UNSTABLE`、`TIMEOUT`、`ERROR`、`WORKER_ERROR`）都退 `1`。
-
-> 名字对照：设计议题里曾把不匹配写作 `UNEXPECTED_DIFFERENCE`，代码里的名字是 `MISMATCH`。
-
-### 4.4 面板（panel）
-
-```console
-node bench/cli.mjs panel --out bench/runs/<组>/<UTC>-bench-ops bench/runs/<组>/<UTC>-bench-ops/summary.json
-node bench/cli.mjs panel --serve bench/runs/<组>/<UTC>-bench-ops --port 0
-```
-
-- `panel.html` **不内联数据**：它只带数据文件的*名字*，查看时 `fetch` 同目录的 JSON，所以要把 HTML 写在数据文件旁边；
-- 支持 `run.json`（加 `--seal` 才有），也支持默认跑出来的 `summary.json`（提示 `schemaVersion n/a`）；
-- `--serve` 只绑 `127.0.0.1`、只服务那一个目录、不常驻、不发请求、不写 `~/.dsh`；
-- `file://` 双击时浏览器会拦 `fetch`，页面提供文件选择/拖拽回退；
-- 五个标签：概览 / 对话 / 轨迹 / 判卷 / 原始 JSON。
-
----
-
-## 5. 测试用例含义（以及主要考察哪些 `ops_*` 工具）
-
-### 5.1 模型语料：`bench/tasks/*.task.json`（6 个）
-
-字段白名单是 `id / title / prompt / fixture / verify / repeat / timeoutMs`，多一个字段就是拼写错误并点名文件与字段。
-`prompt` 是模型唯一看到的东西。判卷类型只有 8 种：`fileExists / fileMissing / fileEquals / fileContains /
-fileLines / countFiles / contentHashes / command`。几个容易写错的语义：
-
-- `fileEquals` **两侧都 `trim()`**，行尾换行不算差异；`fileLines` 逐行 `trim()`、丢空行、折叠 CRLF；
-- `contentHashes` **只看直接子项**（不递归），逐个比对名字与原字节 SHA-256，并拒绝任何多出来的文件
-  （候选写下的 `.dsh-ops-update-*.lock` 边车被排除）。它是"改名而不是重写"的判据：删掉重建或截断能骗过
-  `countFiles`，骗不过它；
-- `invariant: true` 标记"任务开始前就必须成立的护栏"（防篡改/防改题），例如 `check.js` 的字节不变、runner 仍然失败。
-
-| 用例 | 工作量 | 判卷 | 主要考察的 `ops_*` 工具 |
-| --- | --- | --- | --- |
-| `api-rename` | `src/` 下 12 个模块 + `src/core.js`（另生成 `check.mjs`）；`repeat 1`，30 min | `contentHashes(dir: src)` 全等（13 个直接子项的名字与原字节 SHA-256）+ `node check.mjs` 退 `0` | 搜调用点：`ops_grep`（+`ops_glob`）；读文件：`ops_read_files`；改名：`ops_edit_file` 或 `ops_replace`。诱饵 `parsePayloadLegacy` / `parsePayloadAsync` 与完全不碰该符号的文件必须原样保留 |
-| `big-file-paging` | `src/pipeline.js` 4200 行；`repeat 1`，15 min | `answer.txt` 等于 `auditLimit('staging')` 的整数 | 定位：`ops_grep`；只读两段：`ops_inspect_local_file`（或 `ops_read_files`）带 `offset`/`limit`；写答案：`ops_write_file`。文件里还留着过期注释与被取代的 `LEGACY_LIMIT_TABLE`，grep 一次仍要判断 |
-| `config-hunt` | `README.md` + 3 层 JSON + 12 个 `packages/*/config.json` 诱饵；`repeat 1`，15 min | `answer.txt` 等于 `MAX_UPLOAD_MB` 的有效值 | 找层：`ops_glob`；找 key：`ops_grep`；读优先级文档与三层：`ops_read_files`；写答案：`ops_write_file`。只 grep key 就停下会拿到 1/4 概率的错答案 |
-| `csv-sum` | `data.csv` 8000 行；`repeat 1`，15 min | `answer.txt` 等于 EU 金额整数和 | 别把 8000 行进上下文：`ops_bash`（聚合）、`ops_read_files`（只看表头）、`ops_write_file`。语料跑在 Native 面，PTC 是另一套投影，不在本套语料路径上 |
-| `gate-repair-loop` | 24 个 stage 模块（每个约 70 行）+ `check.js`；`repeat 1`，40 min | `node check.js` 退 `0` + `answer.txt` 等于最终值 + `check.js` 字节不变（invariant） | 跑门禁：`ops_bash`；读 stage：`ops_read_files`；按契约修那个常量：`ops_edit_file`；写答案：`ops_write_file`。每个 stage 只错一处绑定常量，契约写在模块自己的注释里 |
-| `noisy-test-triage` | `runner.js` 2400 个测试、恰好一行 `not ok`；`repeat 1`，15 min | `failure.txt` 等于失败测试名 + runner 仍退 `1`（invariant） | 跑并落盘：`ops_bash`（重定向到文件）；在日志里只捞那一行：`ops_grep`（如 `^not ok`、`outputMode: summary/content`）；必要时 `ops_read_files`；写结果：`ops_write_file`。答案必须精确，猜不中 |
-
-同一份报告里的 `Tool calls` 表就是这条设计的实测镜像：插件工具接住了 → `ops_*` 计数**上升**是绿；
-候选还在伸手够插件没覆盖的工具 → 其它工具上升是红。
-
-### 5.2 脚本门禁：BM-01…BM-05（`bench/gates/`）
-
-跑在固定的真实 host（DSH `0.2.0-rc.2` 的 AgentLoop / Session / 工具派发 / 权限服务）上，
-模型响应是确定性脚本——**不发网络模型请求、不产生计费 token**。测的是工具行为、文本与轮数，不是模型质量。
-
-| 门禁 | 测什么 | 主要考察的 `ops_*` 工具 |
-| --- | --- | --- |
-| BM-01 | 三个 70/80/90 行的 TS 文件各取**前 50 行**：一次 `read_files` 对比 OPS 0.3.1 与官方 `read`；先断言规范化数据与模型可见文本都完整保留请求行，再比字节。判据：一个带工具的 provider 轮次 + 相对 0.3.1 至少省 40%（官方读取器单列、不决定验收） | `ops_read_files`（多文件多区间一次调用）对比 `ops_inspect_local_file`、官方 `read`；敏感性网格另有 8/1/32 行、约 600 字符长行、转义 Unicode |
-| BM-02 | 单文件五处编辑一次提交成功；随后两次外部改动造成的**旧 CAS 冲突**必须全部拒绝（`REVISION_CONFLICT`）且文件字节不变；回执不许复读整文件 | `ops_edit_file`（`expectedRevision` + 多个 hunk） |
-| BM-03 | 真实第一次 provider 请求的默认 Native 面 schema：精确清单（含发现入口；Windows 还要求完整 Bash 契约与 jobs 服务），缺失/重复/意外工具都**阻塞**；用 `js-tiktoken@1.0.21` 的 `cl100k_base` 数紧凑 `name/description/parameters` JSON。已批准的 ≤400 token 只作用于文件/发现小计，Bash 仍常驻、完整总数单列 | `ops_read_files` + `ops_discover_tools`（小计），`ops_bash`（另列），整份启动消息 JSON 再单列 |
-| BM-04 | 真实单页 Helvetica/Flate PDF：初始无 PDF schema → 第一次发现后，**所属** provider 的下一次请求必须可见，兄弟 agent 不可见，然后验证抽取文本 | `ops_discover_tools` → `ops_read_pdf`。目录里还没有受评审的 PDF 读取器时，该门禁是 `blocked` |
-| BM-05 | 工作区外的凭据围栏读取与越界写入都必须 `rejected`、`effectState: none`、文件不变，且不泄露被拒父路径或秘密正文；同时要求"普通可读的外部文件"这个允许对照成功。固定 host 不提供全面的工作区读取围栏，报告里明说 | `ops_read_files`（`CREDENTIAL_DENIED`）与 `ops_write_file`（`POLICY_DENIED`） |
-
-### 5.3 工具级语料：`bench/tools/index.mjs`（无模型）
-
-固定尺寸边界，`SEED = 870016`，改它就让所有归档报告失去基线。五个夹具族：
-
-| 族 | 边界 / 用例 |
-| --- | --- |
-| `small-files` / `deep-tree` | 10000 个 4 KiB 文件；`grep` 无命中（summary）、`glob` 带排除与分页；目录里还埋了 `node_modules`、`.hidden`、`target`、`.venv`，以及一条 31 层 `d/` 的深树 |
-| `big-file` | 33 MiB 文件必须被拒（`OUTPUT_LIMIT`）、8 MiB 文件的 hex 窗口必须能读；`grep` 在混合目录下仍要命中 |
-| `dense-hits` | 200 个"每行多命中 + 中文"的文件；`summary` / `count` / `content` 三种输出模式与带 offset/context 的分页 |
-| `edge-text` | 1 MiB 单行、带 BOM/引号/反斜杠/制表符/NUL 的 Unicode、非法 UTF-8、4095 字节处正好断在中文前的边界 |
-| 两个 worker | 同一套用例分别喂给 `--baseline` 与 `--candidate`，逐项比对状态、输出与错误信封 |
-
-### 5.4 想加一个任务
-
-把 `bench/tasks/<id>.task.json` 放进目录即可（`loadTasks` 按文件名排序读全量）：
-
-- `fixture.generator` 必须是 `bench/lib/fixtures/index.mjs` 注册表里的名字之一
-  （当前 11 个：`grepTree / renameTree / largeCsv / brokenProject / logStats / configTree / deepModule /
-  deepCorpus / noisySuite / symbolTree / gatePipeline`）；
-- `verify` 非空，检查项的 `expect` 命名的是 fixture 导出的期望值，键写错会直接抛
-  `fixture exports have no key "..." (known: ...)`，不会静默失败；
-- `prompt` 不能以 `-` 开头（headless launcher 会当选项）、不能以空白开头、不能含 NUL；
-- `repeat` 是每任务预算（`1..100`），`timeoutMs` 默认 900000，合法区间 `1000..86400000`。
-
----
-
-## 6. 临时文件与证据落在哪
-
-`bench/runs/` 与 `bench/llm.patch.yml` 都在 `.gitignore` 里：一次跑的数据是"某台机器上发生过什么"，不是源码。
-
-| 位置 | 谁写的 | 生命周期 |
-| --- | --- | --- |
-| `%TEMP%\dsh-ops-bench-<task>-r<n>-XXXXXX`（POSIX 为 `$TMPDIR`） | `bench/run/session.mjs`，`mkdtemp` 在每个会话自己的根下 | 夹具写在这里，dsh 以这里为 cwd 跑；验证读完就删。`--keep` 保留，路径记在行的 `workspace` 字段里 |
-| `bench/runs/<组>/<UTC>-<label>/results/<task>-r<n>.events.ndjson` | 会话驱动 | 事件流，写入期按 NDJSON 追加（崩溃安全） |
-| `…/results/<task>-r<n>.stderr.log` | 同上 | dsh 子进程的 stderr |
-| `…/results/<task>-r<n>.trace.ndjson` | 同上 | 时间线：`tool_call` / `tool_result` / 里程碑 / 心跳 / stall |
-| `…/results/<task>-r<n>.metrics.json` | 同上 | 该行的汇总：exit / steps / toolCalls / durationMs / usage 分桶 / 逐项 verify / 归档指针 |
-| `bench/runs/<组>/<UTC>-<label>/summary.json` | `bench/run/schedule.mjs` | 每臂聚合 + 配对 + 门禁结论。**先写摘要再封存**：被 Ctrl-C 打断的 sweep 也留下可读的记录 |
-| `bench/runs/<组>/run.json` | `bench/run/seal.mjs` 的 `sealRun`（**只在带 `--seal` 时**） | 两臂合体的封存文档，`schemaVersion: 1`；读者遇到未知版本必须拒绝 |
-| `bench/runs/<组>/DSH-OPS Benchmark Report <UTC>.md` | `bench/compare.mjs` | 报告默认落点；一次运行一份，不覆盖 |
-| `<--out 指定的目录>/panel.html` | `bench/report/panel.mjs` | 查看器，不内联数据 |
-| `%TEMP%\ops-bm040-XXXXXX\` | `bench/gates/index.mjs`，`mkdtemp` + `realpath` | 门禁的独占夹具目录，内含 `dsh-home/`（只改这一个 `DSH_HOME`，绝不动操作员的 HOME/profile）与每个门禁一个子目录（BM-01 的 `typescript-first-50`、`typescript-8`、`typescript-1`、`typescript-32`、`long-lines-8`、`unicode-json-8`，BM-02 `five-edits`，BM-03 `startup`，BM-04 `pdf-discovery`，BM-05 `authority-workspace` + `outside`）。**故意保留**供检查，脚本不做广泛清理 |
-| `%TEMP%\dsh-ops-file-bench-XXXXXX`（可换 `--temp-dir`） | `bench/tools/index.mjs` | 工具级夹具；生成在计时之外，跑完先**整树盘点**再删除，遇到不是自己创建的内容就报错并保留现场 |
-
-清理建议：`bench/runs/` 只增不减（现在已经有几十个历史组），报告与 `summary.json` 都是证据，删之前先确认
-里面没有你要引用的那一次；临时目录里的 `ops-bm040-*` 是故意留的，看过就能删。
-
----
-
-## 7. 命令速查
-
-```console
-# 准备
-npm ci --ignore-scripts && npm run build && npm run build:ptc
-node bench/cli.mjs setup --dry-run
-node bench/cli.mjs setup
-
-# 全量
-node bench/cli.mjs ab --folder full-sweep-34            # 默认：只写每臂 summary.json + results/
-node bench/cli.mjs ab --seal --folder full-sweep-34     # 额外封存组目录的 run.json
-node bench/cli.mjs gates --baseline-source baseline-031 --baseline-worker baseline-031/native/target/release/dsh-ops-worker --output bench-evidence/<new>.json
-node bench/cli.mjs tools --baseline <worker> --candidate <worker> --out bench/runs/<new>/tools.json
-
-# 单任务
-node bench/cli.mjs ab --task csv-sum --repeat 1 --show
-node bench/cli.mjs gates --task BM-02 --output bench-evidence/bm02.json
-
-# 报告
-node bench/cli.mjs report bench-base bench-ops --folder full-sweep-34
-node bench/cli.mjs report bench-base bench-ops --folder full-sweep-34 --json --out -
-node bench/cli.mjs panel --out <数据文件所在目录> <run.json|summary.json>
-
-# 帮助 / 版本
-node bench/cli.mjs --help
-node bench/cli.mjs <setup|ab|report|panel|tools|gates> --help
-node bench/cli.mjs --version
-```
-
-退出码：`0` 正常（或成本门弃权）· `1` 失败/门禁失败 · `2` 用法与输入错误 · `3` 声明了但目标未接线
-（缺文件，或文件存在但没导出 `main(argv, io)`——绝不静默成功）。
\ No newline at end of file
diff --git a/bench/README-mini.md b/bench/README-mini.md
deleted file mode 100644
index a0517394..00000000
--- a/bench/README-mini.md
+++ /dev/null
@@ -1,55 +0,0 @@
-# Benchmark
-
-## 测试前的准备
-
-```console
-npm ci --ignore-scripts
-npm run build && npm run build:ptc     # lib/ + 原生 worker
-```
-
-### 再准备 dsh + 两个 profile
-
-```console
-npm i -g @deepseek-ai/dsh
-node bench/cli.mjs setup              # 先加 --dry-run 看计划；检查失败会在碰 profile 之前拒绝
-```
-
-### 配 LLM 路由 overlay
-
-跑 `node bench/cli.mjs setup` 会在副本不存在时自动复制一份（存在就一字不改）；想自己重来一份就手动复制，会覆盖已有的：
-
-```console
-cp bench/llm.patch.example.yml bench/llm.patch.yml           # bash
-```
-
-填 `bench/llm.patch.yml`：
-
-- `baseURL`：服务器地址，如 `https://host/v1`
-- `<model-id>` ：模型 id，两处必须一致
-- `apiKeyEnv`：放密钥的环境变量名，如 `BENCH_SERVER_API_KEY`
-- `contextWindow` / `maxTokens`：模型真实窗口 / 单次输出上限（默认最大 256K 上下文，单次最大 32K 输出）
-
-密钥只放在 `~/.dsh/.credentials.yaml` 的 `ref` 节点下面的环境变量里面，这样避免出现在项目源文件、对话的上下文
-
-## 怎么跑全量
-
-```console
-node bench/cli.mjs ab --folder full-sweep-34
-node bench/cli.mjs ab --show        # 只看计划：打印每对的顺序，不 spawn、不花钱
-```
-
-- 全量 = `bench/tasks/` 下 6 个任务 × 每个 1 次 × 2 臂 = 6 对 12 个会话，一个进程串行跑完，奇数轮 base→cand、偶数轮 cand→base；
-- 不给 `--folder` 会自动取下一个空闲的 `benchmark-YYYY-MM-DD-NN`（按当天日期编号，从 `-00` 起）；Ctrl-C 中断时已跑完的会话照样写成摘要，不丢；
-- 跑完自动在组目录写 `DSH-OPS Benchmark Report <UTC>.md`（`--no-report` 关闭，被打断的 sweep 不写）；
-- 默认不写 `run.json`：每臂留 `results/` + `summary.json`；要那份封存文档才加 `--seal`（它会先 dump 两侧 profile 做指纹，约 0.4s，取不到就在 spawn 之前拒绝）。
-
-## 怎么跑单个 task
-
-```console
-node bench/cli.mjs ab --task csv-sum --repeat 1 --folder probe-csv-sum
-```
-
-- `--task` 可重复传多个，只跑点名的那些；id 写错会在跑之前退 2，并把已知 id 列出来；
-- 不给 `--repeat` 就用任务自带的预算（当前 6 个都是 1），`--repeat N` 覆盖一切；
-- 现成的 6 个 id：`api-rename`、`big-file-paging`、`config-hunt`、`csv-sum`、`gate-repair-loop`、`noisy-test-triage`；
-- 加 `--show` 先确认要跑哪几对，再摘掉它真跑。
\ No newline at end of file

From f9324b6b715e86addd2555608bb735a2ae17655f Mon Sep 17 00:00:00 2001
From: Richeir <richeir@outlook.com>
Date: Sat, 24 Oct 2026 16:35:59 +0800
Subject: [PATCH 07/10] feat(bench): report title (beta), ops labels, and a
 12-stage gate-repair-loop
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The generated report's heading is now "# DSH-OPS Benchmark Report (beta)";
the file name keeps its old shape ("DSH-OPS Benchmark Report <UTC>.md"),
which the report subcommand, the runner help and the bench README all say.

Every rendered "cand" label becomes "ops" — the first table, the (ops only)
marker, the tool table, the three diagnostic headers and the Evidence line —
matching the bench-ops arm label. JSON keys, CLI flags and warning codes are
unchanged: they are the machine contract.

gate-repair-loop's pipeline is 12 stages instead of 24; every stage is still
broken, so the repair loop halves with it. Seed, probes and linesPerGate are
untouched, and the fixture regenerates with all invariants intact.

test/bench-cli drops the README ↔ run.schema.json cross-check — the bench
docs are now one short README — and keeps the schema self-checks.
---
 bench/README.md                        | 18 +++++-------------
 bench/compare.mjs                      | 18 +++++++++---------
 bench/run.mjs                          |  2 +-
 bench/tasks/gate-repair-loop.task.json |  4 ++--
 test/bench-cli.test.mjs                |  9 +--------
 test/bench-compare.test.mjs            | 12 ++++++------
 6 files changed, 24 insertions(+), 39 deletions(-)

diff --git a/bench/README.md b/bench/README.md
index a0517394..15066ed7 100644
--- a/bench/README.md
+++ b/bench/README.md
@@ -34,22 +34,14 @@ cp bench/llm.patch.example.yml bench/llm.patch.yml           # bash
 ## 怎么跑全量
 
 ```console
-node bench/cli.mjs ab --folder full-sweep-34
-node bench/cli.mjs ab --show        # 只看计划：打印每对的顺序，不 spawn、不花钱
+node bench/cli.mjs ab
 ```
 
-- 全量 = `bench/tasks/` 下 6 个任务 × 每个 1 次 × 2 臂 = 6 对 12 个会话，一个进程串行跑完，奇数轮 base→cand、偶数轮 cand→base；
-- 不给 `--folder` 会自动取下一个空闲的 `benchmark-YYYY-MM-DD-NN`（按当天日期编号，从 `-00` 起）；Ctrl-C 中断时已跑完的会话照样写成摘要，不丢；
-- 跑完自动在组目录写 `DSH-OPS Benchmark Report <UTC>.md`（`--no-report` 关闭，被打断的 sweep 不写）；
-- 默认不写 `run.json`：每臂留 `results/` + `summary.json`；要那份封存文档才加 `--seal`（它会先 dump 两侧 profile 做指纹，约 0.4s，取不到就在 spawn 之前拒绝）。
+- 会自动取下一个空闲的 `benchmark-YYYY-MM-DD-NN`（按当天日期编号，从 `-00` 起）
+- 跑完自动在组目录写 `DSH-OPS Benchmark Report <UTC>.md`（报告标题带 (beta)）
 
 ## 怎么跑单个 task
 
 ```console
-node bench/cli.mjs ab --task csv-sum --repeat 1 --folder probe-csv-sum
-```
-
-- `--task` 可重复传多个，只跑点名的那些；id 写错会在跑之前退 2，并把已知 id 列出来；
-- 不给 `--repeat` 就用任务自带的预算（当前 6 个都是 1），`--repeat N` 覆盖一切；
-- 现成的 6 个 id：`api-rename`、`big-file-paging`、`config-hunt`、`csv-sum`、`gate-repair-loop`、`noisy-test-triage`；
-- 加 `--show` 先确认要跑哪几对，再摘掉它真跑。
\ No newline at end of file
+node bench/cli.mjs ab --task csv-sum
+```
\ No newline at end of file
diff --git a/bench/compare.mjs b/bench/compare.mjs
index 43c021f5..1119b4e4 100644
--- a/bench/compare.mjs
+++ b/bench/compare.mjs
@@ -52,8 +52,8 @@ const SEALED_RUN = 'run.json'
 const LEGACY_SUMMARY = 'summary.json'
 /** The summary document's format tag. */
 const SUMMARY_FORMAT = 'dsh-ops-bench-summary-v1'
-/** The report's fixed title; the two sides are named in Evidence, not in the heading. */
-const REPORT_TITLE = '# DSH-OPS Benchmark Report'
+/** The report's fixed title, marked (beta); the two sides are named in Evidence, not in the heading. */
+const REPORT_TITLE = '# DSH-OPS Benchmark Report (beta)'
 /** The file name stem: the title's words, so the artifact is recognizable in a folder listing. */
 const REPORT_STEM = 'DSH-OPS Benchmark Report'
 /** The panel's palette: the report and `panel.html` must agree on what green and red mean. */
@@ -458,12 +458,12 @@ function taskSection(comparison) {
   const lines = [
     '## Per-task pairs',
     '',
-    '| task | base | cand (Δ%) | steps base→cand (Δ%) | tool calls base→cand (Δ%) | time base→cand (Δ%) | tool errors | pass |',
+    '| task | base | ops (Δ%) | steps base→ops (Δ%) | tool calls base→ops (Δ%) | time base→ops (Δ%) | tool errors | pass |',
     '| --- | --- | --- | --- | --- | --- | --- | --- |',
   ]
   for (const task of comparison.tasks) {
     const pair = task.paired
-    const name = task.inBase && task.inCand ? task.id : `${task.id}${task.inBase ? '(base only)' : '(cand only)'}`
+    const name = task.inBase && task.inCand ? task.id : `${task.id}${task.inBase ? '(base only)' : '(ops only)'}`
     lines.push(`| ${name} | ${number(pair.baseValue)} | ${candCell(pair.candValue, pair.pct)} | ${deltaCell(task.base[keys.steps], task.cand[keys.steps], task.delta.stepsPct)} | ${deltaCell(task.base[keys.toolCalls], task.cand[keys.toolCalls], task.delta.toolCallsPct)} | ${timeCell(task.base[keys.duration], task.cand[keys.duration], task.delta.durationPct)} | ${countCell(task.base[keys.toolErrors], task.cand[keys.toolErrors])} | ${passCell(task)} |`)
   }
   lines.push(`| **TOTAL** | ${number(totals.baseGrandTotal)} | ${candCell(totals.candGrandTotal, totals.grandTotalPct)} | ${deltaCell(totals.baseSteps, totals.candSteps, percentChange(totals.baseSteps, totals.candSteps))} | ${deltaCell(totals.baseToolCalls, totals.candToolCalls, percentChange(totals.baseToolCalls, totals.candToolCalls))} | ${timeCell(totals.baseDurationMs, totals.candDurationMs, percentChange(totals.baseDurationMs, totals.candDurationMs))} | ${countCell(totals.baseToolErrors, totals.candToolErrors)} | ${totals.basePasses}/${totals.baseRuns}→${totals.candPasses}/${totals.candRuns} |`)
@@ -482,7 +482,7 @@ function bucketSection(comparison) {
   const lines = [
     `## Per-task bucket detail (${comparison.aggregate})`,
     '',
-    '| task | input base→cand (Δ%) | output base→cand (Δ%) | cache read base→cand (Δ%) |',
+    '| task | input base→ops (Δ%) | output base→ops (Δ%) | cache read base→ops (Δ%) |',
     '| --- | --- | --- | --- |',
   ]
   for (const task of comparison.tasks) {
@@ -510,7 +510,7 @@ function usageSplitSection(comparison) {
   }
   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 | base | cand | Δ (Δ%) | share of Δ |',
+    '| bucket | base | ops | Δ (Δ%) | share of Δ |',
     '| --- | --- | --- | --- | --- |',
     row('uncached input', buckets.input),
     row('output', buckets.output),
@@ -535,7 +535,7 @@ function stepsSection(comparison) {
   const lines = [
     `## steps and tool calls (${comparison.aggregate})`,
     '',
-    '| task | steps base→cand (Δ%) | tool calls base→cand (Δ%) |',
+    '| task | steps base→ops (Δ%) | tool calls base→ops (Δ%) |',
     '| --- | --- | --- |',
   ]
   for (const task of comparison.tasks) {
@@ -592,7 +592,7 @@ function toolSection(comparison) {
   const cell = (name, counts) => (counts ? `${number(counts.base)} → ${cand(name, counts)}` : '—')
   const rows = [...totals.entries()].sort((left, right) => (Number(own(right[0])) - Number(own(left[0]))) || (right[1].cand - left[1].cand) || left[0].localeCompare(right[0]))
   lines.push(
-    `| tool | base | cand | ${comparison.tasks.map((task) => task.id).join(' | ')} |`,
+    `| tool | base | ops | ${comparison.tasks.map((task) => task.id).join(' | ')} |`,
     `| --- | --- | --- | ${comparison.tasks.map(() => '---').join(' | ')} |`,
   )
   for (const [name, counts] of rows) {
@@ -642,7 +642,7 @@ export function renderReport(comparison, sources = {}) {
     '## Evidence',
     '',
     `- base:${sources.base?.file ?? '?'}(spec \`${sources.base?.spec ?? '?'}\`,${sources.base?.kind ?? '?'})`,
-    `- cand:${sources.cand?.file ?? '?'}(spec \`${sources.cand?.spec ?? '?'}\`,${sources.cand?.kind ?? '?'})`,
+    `- ops:${sources.cand?.file ?? '?'}(spec \`${sources.cand?.spec ?? '?'}\`,${sources.cand?.kind ?? '?'})`,
     `- document: format \`${comparison.format}\` · aggregate \`${comparison.aggregate}\` · tolerance ${rawPercent(comparison.tolerancePct)}`,
     '',
     `Time is reported like any other metric: the time column shows each task's wall-clock (${comparison.aggregate}), and the cost basis of the verdict remains paired tokens (${COMPARE_FORMAT}).`,
diff --git a/bench/run.mjs b/bench/run.mjs
index 31a71a17..e89572ef 100644
--- a/bench/run.mjs
+++ b/bench/run.mjs
@@ -497,7 +497,7 @@ export async function main(argv, io = {}) {
   }
 
   const interrupt = io.interrupt ?? createInterrupt()
-  const uninstall = (io.installSignals ?? true) === false ? () => {} : installSignals(interrupt, err, io)
+  const uninstall = (io.installSignals ?? true) === false ? () => { } : installSignals(interrupt, err, io)
   const log = (level, line) => (level === 'warn' ? err : out)(line)
   // The recorded command line names the overlay when the operator did not: a summary that
   // cannot say which route ran is not evidence of anything.
diff --git a/bench/tasks/gate-repair-loop.task.json b/bench/tasks/gate-repair-loop.task.json
index a687af96..f2ac64d3 100644
--- a/bench/tasks/gate-repair-loop.task.json
+++ b/bench/tasks/gate-repair-loop.task.json
@@ -1,10 +1,10 @@
 {
   "id": "gate-repair-loop",
-  "title": "Repair a 24-stage release gate that stops at the first broken stage",
+  "title": "Repair a 12-stage release gate that stops at the first broken stage",
   "prompt": "check.js is a generated release gate. It loads the stage modules in gates/ (gates/gate_00.js, gates/gate_01.js, and so on) in order, validates each stage against fixed golden values, and stops at the first stage that disagrees; exit code 0 means every stage passed. Run it, find the failing stage, and repair the stage modules in gates/ until the gate passes. Each stage module documents its own contract; make the code agree with it. Do not change check.js or package.json, and do not add or remove files. When the gate exits 0 it prints the pipeline's final value; write that integer, and nothing else, into answer.txt.",
   "fixture": {
     "generator": "gatePipeline",
-    "params": { "seed": 53, "gates": 24, "probes": 40, "linesPerGate": 70 }
+    "params": { "seed": 53, "gates": 12, "probes": 40, "linesPerGate": 70 }
   },
   "verify": [
     { "type": "command", "command": "node", "args": ["check.js"], "exitCode": 0 },
diff --git a/test/bench-cli.test.mjs b/test/bench-cli.test.mjs
index e92c44fc..c28f5ef7 100644
--- a/test/bench-cli.test.mjs
+++ b/test/bench-cli.test.mjs
@@ -186,7 +186,7 @@ await test('the spawn plan never uses a shim and keeps argv verbatim', () => {
   assert.equal(exe.command, '/usr/bin/dsh')
   assert.deepEqual(exe.args, ['--version'])
 })
-await test('run.schema.json parses, describes every property with a unit, and matches the README', () => {
+await test('run.schema.json parses and describes every property with a unit', () => {
   const schema = JSON.parse(fs.readFileSync(path.join(PACKAGE_ROOT, 'bench', 'run.schema.json'), 'utf8'))
   assert.equal(schema.$schema, 'https://json-schema.org/draft/2020-12/schema')
   assert.deepEqual([...schema.required].sort(), Object.keys(schema.properties).sort())
@@ -211,13 +211,6 @@ await test('run.schema.json parses, describes every property with a unit, and ma
   walk(schema, 'run.json')
   assert.deepEqual(missing, [], 'every property documents itself')
   assert.deepEqual(units, [], 'every numeric field names its unit')
-
-  const readme = fs.readFileSync(path.join(PACKAGE_ROOT, 'bench', 'README.md'), 'utf8')
-  const section = readme.split(/^## /m).find((part) => part.startsWith('run.json 契约'))
-  assert.ok(section, 'README documents the run.json contract')
-  const documented = [...section.matchAll(/^\|\s*`([A-Za-z][A-Za-z0-9]*)`\s*\|/gm)].map((match) => match[1])
-  assert.ok(documented.length > 0, 'the contract table has rows')
-  assert.deepEqual([...documented].sort(), Object.keys(schema.properties).sort())
 })
 
 report('bench-cli')
diff --git a/test/bench-compare.test.mjs b/test/bench-compare.test.mjs
index 7d9d03f1..da0706a3 100644
--- a/test/bench-compare.test.mjs
+++ b/test/bench-compare.test.mjs
@@ -173,14 +173,14 @@ await test('the same comparison renders byte-identical text twice, and the closi
   const text = renderReport(beyond, SOURCES)
   assert.equal(renderReport(beyond, SOURCES), text, 'rendering is a pure function of its inputs')
   assertEnglish(text)
-  assert.match(text, /^# DSH-OPS Benchmark Report\n\n## Per-task pairs$/m, 'the title leads straight into the data — no summary bar')
-  assert.match(text, /^\| task \| base \| cand \(Δ%\) \| steps base→cand \(Δ%\) \| tool calls base→cand \(Δ%\) \| time base→cand \(Δ%\) \| tool errors \| pass \|$/m, 'the first table carries cost, behaviour, wall-clock evidence and pass: no pairs, exclusion or direction column')
+  assert.match(text, /^# DSH-OPS Benchmark Report \(beta\)\n\n## Per-task pairs$/m, 'the title leads straight into the data — no summary bar')
+  assert.match(text, /^\| task \| base \| ops \(Δ%\) \| steps base→ops \(Δ%\) \| tool calls base→ops \(Δ%\) \| time base→ops \(Δ%\) \| tool errors \| pass \|$/m, 'the first table carries cost, behaviour, wall-clock evidence and pass: no pairs, exclusion or direction column')
   assert.ok(text.includes(`| csv-sum | 1,000 | 926 (${green('\u22127.4%')}) | 4 → 4 (${green('0.0%')}) | 6 → 6 (${green('0.0%')}) | 60.0s → 55.0s (${green('\u22128.3%')}) | 0 → 0 | 2/2→2/2 |`), 'each cell keeps its own Δ% in parentheses, painted like every other percent — time included')
   assert.doesNotMatch(text, /geomean/, 'the table ends at TOTAL: the geomean row is gone')
   assert.doesNotMatch(text, /## Excluded pairs|## A\/A noise band|## Token attribution/, 'the report keeps to cost, calls and the verdict: the three diagnostic sections are gone')
   assert.doesNotMatch(text, /^## (Per-task pairs|Tool calls \(per-side overlap counts\)|Per-task bucket detail \(median\)|usage split \(TOTAL, median\)|steps and tool calls \(median\))\n\n(?!\|)/m, 'a table heading leads straight into its table: no explanatory line')
   assert.match(text, /^- base:\/runs\/aa\/base\/run\.json\(spec `bench-base`,run\)$/m, 'the compared sides stay named in Evidence')
-  assert.match(text, /^- cand:\/runs\/aa\/cand\/run\.json\(spec `bench-ops`,run\)$/m)
+  assert.match(text, /^- ops:\/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')
@@ -250,7 +250,7 @@ await test('the tool table keeps the per-side totals, splits them by task, and c
   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.match(text, /^\| tool \| base \| ops \| csv-sum \|$/m, 'the base/ops totals stay, and each task adds a column')
   assert.ok(text.includes(`| ops_read | 2 | ${green('3')} | 2 → ${green('3')} |`), 'an ops tool rising is green: the plugin replaced a built-in')
   assert.ok(text.includes(`| bash | 1 | ${red('2')} | 1 → ${red('2')} |`), 'a built-in rising is red: the candidate reached past the plugin')
   assert.ok(text.includes('| write | 4 | 4 | 4 → 4 |'), 'equal counts are not painted')
@@ -275,7 +275,7 @@ await test('the tool table keeps the per-side totals, splits them by task, and c
     { noiseFloorPct: 3.1, failOn: 'both' },
   )
   const twoText = renderReport(twoTasks, SOURCES)
-  assert.match(twoText, /^\| tool \| base \| cand \| csv-sum \| api-rename \|$/m)
+  assert.match(twoText, /^\| tool \| base \| ops \| csv-sum \| api-rename \|$/m)
   assert.ok(twoText.includes(`| ops_read | 3 | ${green('7')} | 1 → ${green('3')} | 2 → ${green('4')} |`), 'the count belongs to the task that made the call')
 })
 
@@ -412,7 +412,7 @@ await test('label, directory and file forms resolve to the same comparison', asy
     for (const cli of [byLabel, byDir, byFile]) assert.equal(await cli.run(), EXIT.ok)
     // The comparison renders identically; the evidence section is the one place
     // that echoes how each side was named (`spec`), which the caller chose.
-    const body = (text) => text.split('\n').filter((line) => !/^- (base|cand):/.test(line)).join('\n')
+    const body = (text) => text.split('\n').filter((line) => !/^- (base|ops):/.test(line)).join('\n')
     assert.equal(body(byLabel.text()), body(byDir.text()))
     assert.equal(body(byFile.text()), body(byDir.text()), 'all three forms reach the same comparison')
     assert.match(byLabel.text(), /- base:.*run\.json\(spec `bench-base`,run\)/)

From 646e1bce530907d9abb8bf5f8ee4b278e6876a4d Mon Sep 17 00:00:00 2001
From: Richeir <richeir@outlook.com>
Date: Sat, 24 Oct 2026 17:50:26 +0800
Subject: [PATCH 08/10] feat(bench): add the per-request overhead table and
 slim the report
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The report gains "Per-request overhead (what every request costs before any
work)": one first-request cell per task (base → ops with the absolute delta
and a painted Δ%). Real sweeps never recorded the data it needs, so the
session fold now derives metrics.prompt exactly as the aggregator defines
it — per-step prompt = input + cacheRead + cacheWrite, the first request set
only by step 1, per-turn firsts, reported all-or-nothing — and new sweeps
light the table up while archives without the data render the section's
Skipped note instead of inventing numbers.

Everything else got smaller: Warnings, Conclusion, Evidence, the steps and
tool calls table, the usage split table and the closing footer are gone, so
the report is four data tables and nothing else. The gate's verdict still
travels through the exit code and the comparison document, unchanged.
Section headings lose their parenthetical qualifiers (Tool calls, Per-task
bucket detail), per-column headers read "steps: base→ops (Δ%)" to separate
the metric from the direction, and renderReport drops its sources parameter,
which only the removed Evidence ever used.
---
 bench/compare.mjs               | 193 ++++++--------------------------
 bench/run.mjs                   |   6 +-
 bench/run/session.mjs           |  78 ++++++++++++-
 test/bench-compare.test.mjs     | 137 ++++++++++-------------
 test/bench-run-session.test.mjs |  31 +++++
 5 files changed, 200 insertions(+), 245 deletions(-)

diff --git a/bench/compare.mjs b/bench/compare.mjs
index 1119b4e4..dd5ccf01 100644
--- a/bench/compare.mjs
+++ b/bench/compare.mjs
@@ -15,15 +15,11 @@
  * the two sides, calls it, and renders what it returned. With no noise floor the
  * report says so and abstains from every cost direction (`noise-floor-unknown`).
  *
- * The report opens with its fixed title and then the evidence a reviewer works
- * through — the per-task paired table, the pairs a failed side forced out of the cost
- * statistics, the A/A band, and the diagnostic sections #183 carried (per-task bucket
- * detail, the usage-bucket split and the token attribution), which say *why* the
- * number moved (a bigger per-request prompt is a tool-schema cost, extra steps are a
- * model-behaviour cost, fatter tool results are a context cost; the fixes are
- * opposite, so the report has to say which one it was) — and closes with the conclusion:
- * pass rate, paired token Δ, the noise band, whether a direction is readable and the
- * gate. None of the diagnostics can change the gate.
+ * The report opens with its fixed title and then the data a reviewer works
+ * through — the per-task paired table, the tool table and the diagnostic sections
+ * (per-task bucket detail, per-request overhead) which say
+ * *why* the number moved. It prints no verdict prose and no side paths: the gate's
+ * verdict travels through the exit code and the comparison document, not the markdown.
  *
  * Durations are displayed like any other metric (the per-task table's time column);
  * the verdict's cost basis remains paired tokens.
@@ -37,7 +33,6 @@ import { fileURLToPath } from 'node:url'
 
 import {
   AGGREGATES,
-  COMPARE_FORMAT,
   FAIL_ON,
   REGRESSION_SCOPES,
   compareSummaries,
@@ -343,17 +338,6 @@ function signed(value) {
   return `${rounded > 0 ? '+' : rounded < 0 ? MINUS : ''}${Math.abs(rounded).toLocaleString('en-US')}`
 }
 
-/**
- * Paint every percent inside a string the core produced. Gate reasons and warnings are
- * quoted verbatim — the digits stay the core's, only the colour is added — so they read
- * in the same two colours as the percents this module formats itself.
- * @param {string} text - the core's string.
- * @returns {string} the same text, percents wrapped.
- */
-function paintPercents(text) {
-  return text.replace(/[+-]?\d+(?:\.\d+)?%/g, (whole) => color(whole, Number.parseFloat(whole)))
-}
-
 /**
  * Paint one rendered value: a drop (or no change) is green, a rise is red — the same
  * two colours `panel.html` uses, inline because a markdown file cannot carry a
@@ -373,69 +357,6 @@ function percent(value) {
   return color(`${value > 0 ? '+' : value < 0 ? MINUS : ''}${Math.abs(value).toFixed(1)}%`, value)
 }
 
-/**
- * A percent the core stated as a bare number — a band half-width, a tolerance, a share
- * of the delta. Printed verbatim (no sign is invented) and painted like every other
- * percent in the report.
- * @param {number|null} value - the number, with `%` appended as-is.
- * @returns {string} the painted text.
- */
-function rawPercent(value) {
-  if (value === null || value === undefined || !Number.isFinite(value)) return 'n/a'
-  return color(`${value}%`, value)
-}
-
-/**
- * The direction sentence — the one place the three noise outcomes are worded.
- * The core's conclusion names travel verbatim so the report and the JSON cannot drift.
- * @param {object} cost - `verdict.cost` from the comparison.
- * @returns {string} the sentence.
- */
-function directionSentence(cost) {
-  if (cost.conclusion === 'incomparable') {
-    return 'Direction: no pair passed on both sides with complete usage ⇒ cost is incomparable; no direction is read'
-  }
-  if (cost.conclusion === 'noise-floor-unknown') {
-    return `Direction: Δ ${percent(cost.pct)}, but the noise floor is unknown ⇒ abstaining, no direction is read (noise-floor-unknown); supply one with --noise-floor-pct N or --noise <base> <cand>`
-  }
-  if (cost.conclusion === 'within-noise') {
-    return `Direction: Δ ${percent(cost.pct)} sits inside the noise band ±${rawPercent(cost.noiseFloorPct)} ⇒ interval only, no direction is read (within-noise)`
-  }
-  if (cost.conclusion === 'cheaper' || cost.conclusion === 'costlier') {
-    return `Direction: Δ ${percent(cost.pct)}, beyond the noise floor ±${rawPercent(cost.noiseFloorPct)} ⇒ readable direction: ${cost.conclusion}`
-  }
-  return `Direction: Δ ${percent(cost.pct)}, no readable direction (${cost.conclusion ?? 'no-change'})`
-}
-
-/**
- * The conclusion that closes the report: pass rate, paired token Δ, noise floor, direction
- * and gate, in that order, plus the reasons the gate gave. It ends the document, so a
- * reviewer meets the verdict after the evidence instead of before it.
- * @param {object} comparison - the comparison structure.
- * @returns {string[]} the section lines.
- */
-function verdictSection(comparison) {
-  const { gate, totals, verdict, noiseFloor } = comparison
-  const passes = `${totals.basePasses}/${totals.baseRuns} → ${totals.candPasses}/${totals.candRuns}`
-  const pairs = `${gate.usablePairs}/${gate.usablePairs + gate.excludedPairs}`
-  const tokenLine = gate.tokensComparable && gate.costComparable
-    ? `💰 tokens (paired ${pairs}): ${number(totals.baseGrandTotal)} → ${number(totals.candGrandTotal)}, Δ ${percent(totals.grandTotalPct)}`
-    : `💰 tokens: incomparable (${gate.tokensComparable ? `no pair passed on both sides, ${gate.excludedPairs} pair(s) excluded` : 'usage incomplete on at least one side'})`
-  const gateLine = gate.fail ? `🚦 failed (${gate.primary})` : '🚦 passed'
-  const lines = [
-    '## Conclusion',
-    '',
-    `- pass rate: ${passes}${gate.passDropFailed ? ' (drop; decided before cost)' : totals.candPassRate > totals.basePassRate ? ' (up)' : ' (flat)'}`,
-    `- ${tokenLine.replace('💰 ', '')}`,
-    `- noise floor (A/A): ${noiseFloor.comparable ? `±${rawPercent(noiseFloor.pct)}, method \`${noiseFloor.method}\`` : 'unknown (noise-floor-unknown)'}`,
-    `- ${directionSentence(verdict.cost)}`,
-    `- gate: ${gateLine} · \`--fail-on ${gate.failOn}\` · regression scope \`${gate.regressionScope}\` · tolerance ${rawPercent(gate.tolerancePct)} · cost basis \`${gate.costBasis}\``,
-    `- basis: ${comparison.aggregate} · profile ${comparison.base.profile ?? '?'} → ${comparison.cand.profile ?? '?'} · model ${comparison.base.model ?? '?'} → ${comparison.cand.model ?? '?'}`,
-  ]
-  for (const reason of gate.reasons) lines.push(`- reason: ${paintPercents(reason)}`)
-  return lines
-}
-
 /**
  * The per-task paired table: cost, the behaviour behind it (steps, tool calls, tool
  * errors) and the pass migration, all on the row a reviewer reads first.
@@ -458,7 +379,7 @@ function taskSection(comparison) {
   const lines = [
     '## Per-task pairs',
     '',
-    '| task | base | ops (Δ%) | steps base→ops (Δ%) | tool calls base→ops (Δ%) | time base→ops (Δ%) | tool errors | pass |',
+    '| task | base | ops (Δ%) | steps: base→ops (Δ%) | tool calls: base→ops (Δ%) | time: base→ops (Δ%) | tool errors | pass |',
     '| --- | --- | --- | --- | --- | --- | --- | --- |',
   ]
   for (const task of comparison.tasks) {
@@ -480,9 +401,9 @@ function bucketSection(comparison) {
   const keys = { input: useMin ? 'inputMin' : 'inputMedian', output: useMin ? 'outputMin' : 'outputMedian', cacheRead: useMin ? 'cacheReadMin' : 'cacheReadMedian' }
   const cell = (baseValue, candValue) => `${number(baseValue)} → ${number(candValue)} (${percent(percentChange(baseValue, candValue))})`
   const lines = [
-    `## Per-task bucket detail (${comparison.aggregate})`,
+    '## Per-task bucket detail',
     '',
-    '| task | input base→ops (Δ%) | output base→ops (Δ%) | cache read base→ops (Δ%) |',
+    '| task | input: base→ops (Δ%) | output: base→ops (Δ%) | cache read: base→ops (Δ%) |',
     '| --- | --- | --- | --- |',
   ]
   for (const task of comparison.tasks) {
@@ -496,53 +417,33 @@ function bucketSection(comparison) {
 }
 
 /**
- * The usage split: how the TOTAL delta divides between uncached input, output and
- * cache reads, with each bucket's share of the delta. The gate judges the total.
+ * The per-request overhead table: the first request of a run carries no history, so its
+ * delta is the fixed cost a tool surface or prompt policy adds, paid on every request.
+ * Archives without `metrics.prompt` cannot separate that request, so the section says
+ * so instead of inventing numbers.
  * @param {object} comparison - the comparison structure.
  * @returns {string[]} the section lines.
  */
-function usageSplitSection(comparison) {
-  const buckets = comparison.totals.buckets
-  const lines = [`## usage split (TOTAL, ${comparison.aggregate})`, '']
-  if (!buckets.comparable) {
-    lines.push('Skipped: at least one side lost `step_end.usage`, so per-bucket Δs would present a lower bound as a measurement.')
+function overheadSection(comparison) {
+  const lines = ['## Per-request overhead (what every request costs before any work)', '']
+  const prompted = comparison.tasks.some((task) => Number.isFinite(task.base.firstRequestPromptMedian) || Number.isFinite(task.cand.firstRequestPromptMedian))
+  if (!prompted) {
+    lines.push('Skipped: neither side recorded `metrics.prompt`, so the first request cannot be separated from the run.')
     return lines
   }
-  const row = (label, bucket) => `| ${label} | ${number(bucket.base)} | ${number(bucket.cand)} | ${signed(bucket.delta)} (${percent(percentChange(bucket.base, bucket.cand))}) | ${rawPercent(bucket.sharePct)} |`
+  const firstCell = (task) => {
+    const base = task.base.firstRequestPromptMedian
+    const cand = task.cand.firstRequestPromptMedian
+    if (!Number.isFinite(base) || !Number.isFinite(cand)) return 'n/a'
+    return `${number(base)} → ${number(cand)} (${signed(task.delta.firstRequestPromptAbs)}, ${percent(task.delta.firstRequestPromptPct)})`
+  }
   lines.push(
-    '| bucket | base | ops | Δ (Δ%) | share of Δ |',
-    '| --- | --- | --- | --- | --- |',
-    row('uncached input', buckets.input),
-    row('output', buckets.output),
-    row('cache read', buckets.cacheRead),
-    row('**TOTAL**', buckets.grandTotal),
+    '| task | first request: base→ops |',
+    '| --- | --- |',
   )
-  return lines
-}
-
-/**
- * The behaviour behind the token delta: steps and tool calls, per task and summed.
- * The extra-steps term in token attribution is this table's Δ steps at the baseline's prompt
- * size, so a cost move can be read against the behaviour that produced it. Neither
- * count can change the gate.
- * @param {object} comparison - the comparison structure.
- * @returns {string[]} the section lines.
- */
-function stepsSection(comparison) {
-  const useMin = comparison.aggregate === 'min'
-  const keys = { steps: useMin ? 'stepsMin' : 'stepsMedian', toolCalls: useMin ? 'toolCallsMin' : 'toolCallsMedian' }
-  const cell = (baseValue, candValue, pct) => `${count(baseValue)} → ${count(candValue)} (${percent(pct)})`
-  const lines = [
-    `## steps and tool calls (${comparison.aggregate})`,
-    '',
-    '| task | steps base→ops (Δ%) | tool calls base→ops (Δ%) |',
-    '| --- | --- | --- |',
-  ]
   for (const task of comparison.tasks) {
-    lines.push(`| ${task.id} | ${cell(task.base[keys.steps], task.cand[keys.steps], task.delta.stepsPct)} | ${cell(task.base[keys.toolCalls], task.cand[keys.toolCalls], task.delta.toolCallsPct)} |`)
+    lines.push(`| ${task.id} | ${firstCell(task)} |`)
   }
-  const totals = comparison.totals
-  lines.push(`| **TOTAL** | ${cell(totals.baseSteps, totals.candSteps, percentChange(totals.baseSteps, totals.candSteps))} | ${cell(totals.baseToolCalls, totals.candToolCalls, percentChange(totals.baseToolCalls, totals.candToolCalls))} |`)
   return lines
 }
 
@@ -578,7 +479,7 @@ function toolSection(comparison) {
     }
     return { id: task.id, counts }
   })
-  const lines = ['## Tool calls (per-side overlap counts)', '']
+  const lines = ['## Tool calls', '']
   if (totals.size === 0) {
     lines.push('Skipped: neither side recorded `toolCallsByName`.')
     return lines
@@ -602,28 +503,16 @@ function toolSection(comparison) {
   return lines
 }
 
-/**
- * Every warning the core recorded (model mismatch, incomplete usage, one-sided
- * tasks, pairing leftovers) — nothing measured is allowed to disappear quietly.
- * @param {object} comparison - the comparison structure.
- * @returns {string[]} the section lines.
- */
-function warningSection(comparison) {
-  if (comparison.warnings.length === 0) return ['## Warnings', '', 'No warnings.']
-  return ['## Warnings', '', ...comparison.warnings.map((warning) => `- ${paintPercents(warning)}`)]
-}
-
 /**
  * Render the comparison as the report document — the text `reportFileName` names and
  * `main` writes.
  *
- * Pure: same comparison and sources in, byte-identical text out. No timestamps are
- * written, so the report is reproducible and diffable.
+ * Pure: same comparison in, byte-identical text out. No timestamps are written, so the
+ * report is reproducible and diffable.
  * @param {object} comparison - the structure from `compareSummaries`.
- * @param {{base?: object, cand?: object}} [sources] - the two resolved sides.
  * @returns {string} the report text (no trailing newline).
  */
-export function renderReport(comparison, sources = {}) {
+export function renderReport(comparison) {
   const lines = [
     REPORT_TITLE,
     '',
@@ -633,21 +522,7 @@ export function renderReport(comparison, sources = {}) {
     '',
     ...bucketSection(comparison),
     '',
-    ...usageSplitSection(comparison),
-    '',
-    ...stepsSection(comparison),
-    '',
-    ...warningSection(comparison),
-    '',
-    '## Evidence',
-    '',
-    `- base:${sources.base?.file ?? '?'}(spec \`${sources.base?.spec ?? '?'}\`,${sources.base?.kind ?? '?'})`,
-    `- ops:${sources.cand?.file ?? '?'}(spec \`${sources.cand?.spec ?? '?'}\`,${sources.cand?.kind ?? '?'})`,
-    `- document: format \`${comparison.format}\` · aggregate \`${comparison.aggregate}\` · tolerance ${rawPercent(comparison.tolerancePct)}`,
-    '',
-    `Time is reported like any other metric: the time column shows each task's wall-clock (${comparison.aggregate}), and the cost basis of the verdict remains paired tokens (${COMPARE_FORMAT}).`,
-    '',
-    ...verdictSection(comparison),
+    ...overheadSection(comparison),
   ]
   return lines.join('\n')
 }
@@ -758,13 +633,9 @@ export async function main(argv, io = {}) {
     noiseFloorPct: options.noiseFloorPct ?? undefined,
     noise: noise ?? undefined,
   })
-  const sources = {
-    base: { spec: options.base, file: base.file, kind: base.kind },
-    cand: { spec: options.cand, file: cand.file, kind: cand.kind },
-  }
   const payload = options.json
     ? `${JSON.stringify(comparison, null, 2)}\n`
-    : `${renderReport(comparison, sources)}\n`
+    : `${renderReport(comparison)}\n`
   out(payload)
 
   const target = reportPath(options, cand, now())
diff --git a/bench/run.mjs b/bench/run.mjs
index e89572ef..84640ec9 100644
--- a/bench/run.mjs
+++ b/bench/run.mjs
@@ -378,13 +378,9 @@ export function sweepReport(result, context = {}) {
   const now = context.now ?? Date.now
   const write = context.writeFile ?? fs.writeFileSync
   const mkdir = context.mkdir ?? fs.mkdirSync
-  const sources = {
-    base: { spec: result.arms[0].label, file: result.summaryFiles.base, kind: 'summary' },
-    cand: { spec: result.arms[1].label, file: result.summaryFiles.cand, kind: 'summary' },
-  }
   const target = path.join(path.dirname(result.dirs.base), reportFileName(now()))
   mkdir(path.dirname(target), { recursive: true })
-  write(target, `${renderReport(result.compare, sources)}\n`, 'utf8')
+  write(target, `${renderReport(result.compare)}\n`, 'utf8')
   return { target, skipped: null }
 }
 
diff --git a/bench/run/session.mjs b/bench/run/session.mjs
index b31f9c02..e1f01a3d 100644
--- a/bench/run/session.mjs
+++ b/bench/run/session.mjs
@@ -30,6 +30,8 @@ import { DEFAULT_TIMEOUT_MS } from '../lib/tasks.mjs'
 
 /** The five token buckets `run.schema.json $defs/usage` requires, in its order. */
 const USAGE_BUCKETS = ['inputTokens', 'outputTokens', 'cacheReadTokens', 'cacheWriteTokens', 'reasoningTokens']
+/** The buckets a step re-sends to the model: its prompt size. */
+const PROMPT_BUCKETS = ['inputTokens', 'cacheReadTokens', 'cacheWriteTokens']
 
 /** Cap on the stdout-close barrier; it matters only for a spawn that left a stream open. */
 const DEFAULT_STREAM_FLUSH_GRACE_MS = 1_000
@@ -136,9 +138,10 @@ export function toVerifyChecks(outcome) {
 /**
  * A streaming fold of the event stream into the schema's `metrics` fields, deliberately
  * narrow: steps, tool calls, tool errors, the five usage buckets, the all-or-nothing
- * `usageReported` and the last turn's end reason. Prompt-shape analysis belongs to the
- * aggregate slice; this keeps its invariant — one step without usage makes the totals a
- * lower bound.
+ * `usageReported`, the prompt shape the report's per-request overhead table reads, and
+ * the last turn's end reason. This keeps the aggregate invariant — one step without
+ * usage makes the totals a lower bound, and one step without a prompt size makes the
+ * prompt summary incomplete.
  * @returns {{push(line: string): void, finish(): object}} the fold.
  */
 function createFold() {
@@ -149,6 +152,14 @@ function createFold() {
     toolErrors: 0,
     toolCallsByName: Object.create(null),
     usage: emptyUsage(),
+    // `promptSizes` is every step that reported a size, in order; `firstPrompt` is set
+    // only by the run's **first** step, so a run whose step 1 lost its usage reports an
+    // unknown first request instead of silently promoting step 2's smaller, already-warm
+    // prompt to "the request with no history".
+    promptSizes: [],
+    firstPrompt: null,
+    firstStepSeen: false,
+    turnFirsts: [],
     turnEndReason: null,
   }
   return {
@@ -164,7 +175,20 @@ function createFold() {
       if (event.type === 'status') {
         if (event.phase === 'step_end') {
           state.steps += 1
-          if (addUsage(state, event.usage)) state.stepsWithUsage += 1
+          const firstStep = !state.firstStepSeen
+          state.firstStepSeen = true
+          if (addUsage(state, event.usage)) {
+            state.stepsWithUsage += 1
+            const size = promptTokens(event.usage)
+            if (size !== null) {
+              state.promptSizes.push(size)
+              if (firstStep) state.firstPrompt = size
+              const turn = stepIndex(event.turn)
+              if (turn !== null && !state.turnFirsts.some((entry) => entry.turn === turn)) {
+                state.turnFirsts.push({ turn, tokens: size })
+              }
+            }
+          }
           return
         }
         if (event.phase === 'turn_end') {
@@ -190,6 +214,14 @@ function createFold() {
         toolCallsByName: { ...state.toolCallsByName },
         usage: { ...state.usage },
         usageReported: state.steps > 0 && state.stepsWithUsage === state.steps,
+        prompt: {
+          reported: state.steps > 0 && state.stepsWithUsage === state.steps && state.promptSizes.length === state.steps,
+          firstStep: state.firstPrompt,
+          median: state.promptSizes.length > 0 ? medianSize(state.promptSizes) : null,
+          max: state.promptSizes.length > 0 ? Math.max(...state.promptSizes) : null,
+          total: state.promptSizes.length > 0 ? state.promptSizes.reduce((sum, value) => sum + value, 0) : null,
+          perTurn: state.turnFirsts,
+        },
         turnEndReason: state.turnEndReason,
       }
     },
@@ -212,6 +244,43 @@ function addUsage(state, usage) {
   return true
 }
 
+/**
+ * One step's prompt size: the buckets re-sent to the model (input + cacheRead +
+ * cacheWrite), falling back to `totalTokens - outputTokens` when a provider reports
+ * only a total, and `null` when nothing usable is there.
+ * @param {object} usage - the `step_end` event's usage object.
+ * @returns {number|null} the prompt token count, or null.
+ */
+function promptTokens(usage) {
+  let sum = 0
+  let seen = false
+  for (const bucket of PROMPT_BUCKETS) {
+    const value = usage[bucket]
+    if (typeof value !== 'number' || !Number.isFinite(value)) continue
+    sum += Math.max(0, Math.round(value))
+    seen = true
+  }
+  if (seen) return sum
+  const total = usage.totalTokens
+  const output = usage.outputTokens
+  if (typeof total === 'number' && Number.isFinite(total)) {
+    return Math.max(0, Math.round(total) - (typeof output === 'number' && Number.isFinite(output) ? Math.round(output) : 0))
+  }
+  return null
+}
+
+/** A numeric event field as a number, or null. */
+function stepIndex(value) {
+  return typeof value === 'number' && Number.isFinite(value) ? value : null
+}
+
+/** The median of the step prompt sizes (the midpoint of an even count halves). */
+function medianSize(sizes) {
+  const sorted = [...sizes].sort((left, right) => left - right)
+  const mid = Math.floor(sorted.length / 2)
+  return sorted.length % 2 === 1 ? sorted[mid] : (sorted[mid - 1] + sorted[mid]) / 2
+}
+
 /**
  * Run one task × repeat: fixture → one headless session → archive → verdict.
  *
@@ -490,6 +559,7 @@ export async function runSession(spec, options = {}) {
       toolErrors: counted.toolErrors,
       usage: counted.usage,
       usageReported: counted.usageReported,
+      prompt: counted.prompt,
       toolCallsByName: counted.toolCallsByName,
       turnEndReason: counted.turnEndReason,
       // Identity and archive pointers the seal step lifts into `results[]` / `archive[]`.
diff --git a/test/bench-compare.test.mjs b/test/bench-compare.test.mjs
index da0706a3..b23779ff 100644
--- a/test/bench-compare.test.mjs
+++ b/test/bench-compare.test.mjs
@@ -153,12 +153,6 @@ function literal(text) {
   return text.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
 }
 
-/** The two resolved sides a render needs, with stable paths. */
-const SOURCES = {
-  base: { file: '/runs/aa/base/run.json', spec: 'bench-base', kind: 'run' },
-  cand: { file: '/runs/aa/cand/run.json', spec: 'bench-ops', kind: 'run' },
-}
-
 /** The two spans the report paints every percent with: green for a drop, red for a rise. */
 const green = (text) => `<span style="color:#3fb950">${text}</span>`
 const red = (text) => `<span style="color:#f85149">${text}</span>`
@@ -166,90 +160,88 @@ const red = (text) => `<span style="color:#f85149">${text}</span>`
 /** The report is English-only: no CJK character may reach a generated artifact. */
 const assertEnglish = (text) => assert.doesNotMatch(text, /[\u3400-\u4dbf\u4e00-\u9fff\uf900-\ufaff]/, 'the report must not contain CJK characters')
 
-await test('the same comparison renders byte-identical text twice, and the closing conclusion words each noise outcome', () => {
+await test('the same comparison renders byte-identical text twice: tables first, Evidence last, no verdict prose', () => {
   const base = summary('bench-base', [metrics('csv-sum', 1000, true), metrics('csv-sum', 1000, true)])
   const cheaper = summary('bench-ops', [metrics('csv-sum', 926, true, { durationMs: 55_000 }), metrics('csv-sum', 926, true, { durationMs: 55_000 })])
   const beyond = compareSummaries(base, cheaper, { noiseFloorPct: 3.1, failOn: 'both' })
-  const text = renderReport(beyond, SOURCES)
-  assert.equal(renderReport(beyond, SOURCES), text, 'rendering is a pure function of its inputs')
+  const text = renderReport(beyond)
+  assert.equal(renderReport(beyond), text, 'rendering is a pure function of its inputs')
   assertEnglish(text)
   assert.match(text, /^# DSH-OPS Benchmark Report \(beta\)\n\n## Per-task pairs$/m, 'the title leads straight into the data — no summary bar')
-  assert.match(text, /^\| task \| base \| ops \(Δ%\) \| steps base→ops \(Δ%\) \| tool calls base→ops \(Δ%\) \| time base→ops \(Δ%\) \| tool errors \| pass \|$/m, 'the first table carries cost, behaviour, wall-clock evidence and pass: no pairs, exclusion or direction column')
+  assert.match(text, /^\| task \| base \| ops \(Δ%\) \| steps: base→ops \(Δ%\) \| tool calls: base→ops \(Δ%\) \| time: base→ops \(Δ%\) \| tool errors \| pass \|$/m, 'the first table carries cost, behaviour, wall-clock evidence and pass: no pairs, exclusion or direction column')
   assert.ok(text.includes(`| csv-sum | 1,000 | 926 (${green('\u22127.4%')}) | 4 → 4 (${green('0.0%')}) | 6 → 6 (${green('0.0%')}) | 60.0s → 55.0s (${green('\u22128.3%')}) | 0 → 0 | 2/2→2/2 |`), 'each cell keeps its own Δ% in parentheses, painted like every other percent — time included')
   assert.doesNotMatch(text, /geomean/, 'the table ends at TOTAL: the geomean row is gone')
   assert.doesNotMatch(text, /## Excluded pairs|## A\/A noise band|## Token attribution/, 'the report keeps to cost, calls and the verdict: the three diagnostic sections are gone')
-  assert.doesNotMatch(text, /^## (Per-task pairs|Tool calls \(per-side overlap counts\)|Per-task bucket detail \(median\)|usage split \(TOTAL, median\)|steps and tool calls \(median\))\n\n(?!\|)/m, 'a table heading leads straight into its table: no explanatory line')
-  assert.match(text, /^- base:\/runs\/aa\/base\/run\.json\(spec `bench-base`,run\)$/m, 'the compared sides stay named in Evidence')
-  assert.match(text, /^- ops:\/runs\/aa\/cand\/run\.json\(spec `bench-ops`,run\)$/m)
+  assert.doesNotMatch(text, /^## (Per-task pairs|Tool calls|Per-task bucket detail|Per-request overhead)\n\n(?!\|)/m, 'a table heading leads straight into its table: no explanatory line')
   const headings = text.split('\n').filter((line) => line.startsWith('## '))
-  assert.equal(headings[headings.length - 1], '## Conclusion', 'the conclusion closes the report')
-  assert.ok(text.includes(`- Direction: Δ ${green('\u22127.4%')}, beyond the noise floor ±${red('3.1%')} ⇒ readable direction: cheaper`), 'a drop beyond the band reads green')
-  assert.ok(text.includes(`- noise floor (A/A): ±${red('3.1%')}, method \`provided\``))
-  assert.match(text, /Time is reported like any other metric/)
-
-  // Inside the band: the interval is reported, the direction is not.
-  const inside = compareSummaries(base, summary('bench-ops', [metrics('csv-sum', 975, true), metrics('csv-sum', 975, true)]), { noiseFloorPct: 3.1, failOn: 'both' })
-  const insideText = renderReport(inside, SOURCES)
-  assert.ok(insideText.includes(`- Direction: Δ ${green('\u22122.5%')} sits inside the noise band ±${red('3.1%')} ⇒ interval only, no direction is read (within-noise)`))
-  assert.doesNotMatch(insideText, /readable direction/)
-  assert.match(insideText, /- gate: 🚦 passed ·/)
-
-  // No floor at all: the report says so and withholds every direction.
-  const unknown = compareSummaries(base, summary('bench-ops', [metrics('csv-sum', 1500, true), metrics('csv-sum', 1500, true)]), { failOn: 'both' })
-  const unknownText = renderReport(unknown, SOURCES)
-  assert.match(unknownText, /- noise floor \(A\/A\): unknown \(noise-floor-unknown\)/)
-  assert.ok(unknownText.includes(`- Direction: Δ ${red('+50.0%')}, but the noise floor is unknown ⇒ abstaining, no direction is read (noise-floor-unknown)`))
-  assert.match(unknownText, /--noise-floor-pct N or --noise <base> <cand>/)
-  assert.doesNotMatch(unknownText, /readable direction/)
-  assert.match(unknownText, /- gate: 🚦 passed ·/, 'an abstaining gate is not a failed gate')
-
-  // A costlier delta beyond the band is the one case that names a regression.
+  assert.equal(headings[headings.length - 1], '## Per-request overhead (what every request costs before any work)', 'the overhead table closes the report')
+  assert.doesNotMatch(text, /## Conclusion|## Warnings|## Evidence|## Usage split|## steps and tool calls|Direction:|noise floor \(A\/A\)|- gate:/, 'no verdict, warning or evidence prose: the verdict lives in the exit code and the comparison document')
+  assert.doesNotMatch(text, /Time is reported/, 'the report is tables and nothing else')
+
+  // The gate still judges even though the report no longer prints a conclusion: a
+  // costlier delta fails the comparison document, and the CLI maps it to exit 1.
   const worse = compareSummaries(base, summary('bench-ops', [metrics('csv-sum', 1050, true), metrics('csv-sum', 1050, true)]), { noiseFloorPct: 3.1, failOn: 'both' })
-  const worseText = renderReport(worse, SOURCES)
-  assert.ok(worseText.includes(`- Direction: Δ ${red('+5.0%')}, beyond the noise floor ±${red('3.1%')} ⇒ readable direction: costlier`), 'a rise beyond the band reads red')
-  assert.match(worseText, /- gate: 🚦 failed \(regression\) ·/)
+  const worseText = renderReport(worse)
   assert.ok(worseText.includes(`| csv-sum | 1,000 | 1,050 (${red('+5.0%')}) | 4 → 4 (${green('0.0%')}) | 6 → 6 (${green('0.0%')}) | 60.0s → 60.0s (${green('0.0%')}) | 0 → 0 | 2/2→2/2 |`))
-  assert.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)
+  assert.equal(worse.gate.fail, true, 'the gate verdict stays in the comparison document')
+  assert.equal(worse.gate.primary, 'regression')
+  assertEnglish(worseText)
 })
 
-await test('the steps and tool calls table pairs each task, sums the totals, and reads the aggregate its title names', () => {
+await test('the first table reads the aggregate its flag names: medians, min, halved medians and raw error counts', () => {
   const base = summary('bench-base', [metrics('csv-sum', 1000, true, { steps: 5 }), metrics('csv-sum', 1000, true, { steps: 3 })])
   const cand = summary('bench-ops', [metrics('csv-sum', 900, true, { steps: 3 }), metrics('csv-sum', 900, true, { steps: 3 })])
-
-  const text = renderReport(compareSummaries(base, cand, { noiseFloorPct: 3.1, failOn: 'both' }), SOURCES)
+  const text = renderReport(compareSummaries(base, cand, { noiseFloorPct: 3.1, failOn: 'both' }))
   assertEnglish(text)
-  assert.match(text, /^## steps and tool calls \(median\)$/m)
-  assert.ok(text.includes(`| csv-sum | 4 → 3 (${green('\u221225.0%')}) | 6 → 6 (${green('0.0%')}) |`))
-  assert.ok(text.includes(`| **TOTAL** | 4 → 3 (${green('\u221225.0%')}) | 6 → 6 (${green('0.0%')}) |`), 'no change is green too')
+  assert.ok(text.includes(`| csv-sum | 1,000 | 900 (${green('\u221210.0%')}) | 4 → 3 (${green('\u221225.0%')}) | 6 → 6 (${green('0.0%')}) | 60.0s → 60.0s (${green('0.0%')}) | 0 → 0 | 2/2→2/2 |`), 'the steps and tool-call cells carry the medians with their Δ%')
 
-  // `min` must move the cells, not only the title: the same fixture reads 3 → 3.
-  const minText = renderReport(compareSummaries(base, cand, { noiseFloorPct: 3.1, failOn: 'both', aggregate: 'min' }), SOURCES)
-  assert.match(minText, /^## steps and tool calls \(min\)$/m)
-  assert.ok(minText.includes(`| csv-sum | 3 → 3 (${green('0.0%')}) | 6 → 6 (${green('0.0%')}) |`))
-  assert.ok(minText.includes(`| **TOTAL** | 3 → 3 (${green('0.0%')}) | 6 → 6 (${green('0.0%')}) |`))
+  const minText = renderReport(compareSummaries(base, cand, { noiseFloorPct: 3.1, failOn: 'both', aggregate: 'min' }))
+  assert.ok(minText.includes(`| 3 → 3 (${green('0.0%')}) | 6 → 6 (${green('0.0%')}) |`), '`min` moves the cells, not only the title')
 
   // An even repeat count halves the median: the cell has to show 12.5, not round it
   // into "13 → 13 (+4.0%)", which contradicts its own Δ%.
   const halfBase = summary('bench-base', [metrics('csv-sum', 1000, true, { toolCalls: 13 }), metrics('csv-sum', 1000, true, { toolCalls: 12 })])
   const halfCand = summary('bench-ops', [metrics('csv-sum', 900, true, { toolCalls: 13 }), metrics('csv-sum', 900, true, { toolCalls: 13 })])
-  const halfText = renderReport(compareSummaries(halfBase, halfCand, { noiseFloorPct: 3.1, failOn: 'both' }), SOURCES)
-  assert.ok(halfText.includes(`| csv-sum | 4 → 4 (${green('0.0%')}) | 12.5 → 13 (${red('+4.0%')}) |`))
+  const halfText = renderReport(compareSummaries(halfBase, halfCand, { noiseFloorPct: 3.1, failOn: 'both' }))
+  assert.ok(halfText.includes(`| 12.5 → 13 (${red('+4.0%')}) |`), 'a halved median shows 12.5, not a rounded 13')
 
   // Tool errors are raw counts in the first table, not a median ratio: 2 → 0.
   const errBase = summary('bench-base', [metrics('csv-sum', 1000, true, { toolErrors: 2 })])
   const errCand = summary('bench-ops', [metrics('csv-sum', 900, true, { toolErrors: 0 })])
-  const errText = renderReport(compareSummaries(errBase, errCand, { noiseFloorPct: 3.1, failOn: 'both' }), SOURCES)
+  const errText = renderReport(compareSummaries(errBase, errCand, { noiseFloorPct: 3.1, failOn: 'both' }))
   assert.ok(errText.includes(`| 60.0s → 60.0s (${green('0.0%')}) | 2 → 0 | 1/1→1/1 |`), 'tool errors are counted, not percentaged')
 })
 
+await test('the per-request overhead table prices the first request and degrades without prompt data', () => {
+  const base = summary('bench-base', [
+    metrics('csv-sum', 1000, true, { steps: 6, firstStep: 6249, total: 15186 }),
+    metrics('csv-sum', 1000, true, { steps: 6, firstStep: 6249, total: 15186 }),
+  ])
+  const cand = summary('bench-ops', [
+    metrics('csv-sum', 1000, true, { steps: 6, firstStep: 8032, total: 23628 }),
+    metrics('csv-sum', 1000, true, { steps: 6, firstStep: 8032, total: 23628 }),
+  ])
+  const text = renderReport(compareSummaries(base, cand, { noiseFloorPct: 3.1, failOn: 'both' }))
+  assertEnglish(text)
+  assert.match(text, /^## Per-request overhead \(what every request costs before any work\)$/m)
+  assert.ok(text.includes(`| csv-sum | 6,249 → 8,032 (+1,783, ${red('+28.5%')}) |`), 'the row carries only the first-request delta, abs and painted pct')
+  assert.doesNotMatch(text, /prompt \/ step|Fixed per-request cost|The first request of a run carries no history/)
+
+  const noPrompt = renderReport(compareSummaries(
+    summary('bench-base', [metrics('csv-sum', 1000, true, { prompt: false })]),
+    summary('bench-ops', [metrics('csv-sum', 1000, true, { prompt: false })]),
+  ))
+  assert.match(noPrompt, /Skipped: neither side recorded `metrics\.prompt`/, 'no prompt data ⇒ the section says so instead of inventing numbers')
+  assert.doesNotMatch(noPrompt, /first request: base→ops/)
+})
+
 await test('the tool table keeps the per-side totals, splits them by task, and colours adoption', () => {
   const base = summary('bench-base', [metrics('csv-sum', 1000, true, { toolCallsByName: { ops_read: 2, bash: 1, write: 4 } })])
   const cand = summary('bench-ops', [metrics('csv-sum', 900, true, { toolCallsByName: { ops_read: 3, bash: 2, write: 4 } })])
-  const text = renderReport(compareSummaries(base, cand, { noiseFloorPct: 3.1, failOn: 'both' }), SOURCES)
-  assert.match(text, /^## Tool calls \(per-side overlap counts\)$/m)
+  const text = renderReport(compareSummaries(base, cand, { noiseFloorPct: 3.1, failOn: 'both' }))
+  assert.match(text, /^## Tool calls$/m)
   const headings = text.split('\n').filter((line) => line.startsWith('## '))
-  assert.equal(headings[1], '## Tool calls (per-side overlap counts)', 'the tool table sits directly under the per-task pair table: it is the first explanation of where the token Δ went')
+  assert.equal(headings[1], '## Tool calls', 'the tool table sits directly under the per-task pair table: it is the first explanation of where the token Δ went')
   assert.match(text, /^\| tool \| base \| ops \| csv-sum \|$/m, 'the base/ops totals stay, and each task adds a column')
   assert.ok(text.includes(`| ops_read | 2 | ${green('3')} | 2 → ${green('3')} |`), 'an ops tool rising is green: the plugin replaced a built-in')
   assert.ok(text.includes(`| bash | 1 | ${red('2')} | 1 → ${red('2')} |`), 'a built-in rising is red: the candidate reached past the plugin')
@@ -257,7 +249,7 @@ await test('the tool table keeps the per-side totals, splits them by task, and c
 
   // Falling is green for a built-in and red for an ops tool: adoption, not the sign.
   const closed = summary('bench-ops', [metrics('csv-sum', 900, true, { toolCallsByName: { ops_read: 3 } })])
-  const closedText = renderReport(compareSummaries(base, closed, { noiseFloorPct: 3.1, failOn: 'both' }), SOURCES)
+  const closedText = renderReport(compareSummaries(base, closed, { noiseFloorPct: 3.1, failOn: 'both' }))
   assert.ok(closedText.includes(`| bash | 1 | ${green('0')} | 1 → ${green('0')} |`), 'a built-in the candidate stopped calling is green')
   assert.ok(closedText.includes(`| write | 4 | ${green('0')} | 4 → ${green('0')} |`))
 
@@ -266,7 +258,7 @@ await test('the tool table keeps the per-side totals, splits them by task, and c
     summary('bench-ops', [metrics('csv-sum', 900, true, { toolCallsByName: { ops_read: 2 } })]),
     { noiseFloorPct: 3.1, failOn: 'both' },
   )
-  assert.ok(renderReport(declined, SOURCES).includes(`| ops_read | 5 | ${red('2')} | 5 → ${red('2')} |`), 'an ops tool falling is red: adoption moved backwards')
+  assert.ok(renderReport(declined).includes(`| ops_read | 5 | ${red('2')} | 5 → ${red('2')} |`), 'an ops tool falling is red: adoption moved backwards')
 
   // Each task keeps its own column; a tool nobody used in a task reads as a dash.
   const twoTasks = compareSummaries(
@@ -274,7 +266,7 @@ await test('the tool table keeps the per-side totals, splits them by task, and c
     summary('bench-ops', [metrics('csv-sum', 900, true, { toolCallsByName: { ops_read: 3 } }), metrics('api-rename', 900, true, { toolCallsByName: { ops_read: 4 } })]),
     { noiseFloorPct: 3.1, failOn: 'both' },
   )
-  const twoText = renderReport(twoTasks, SOURCES)
+  const twoText = renderReport(twoTasks)
   assert.match(twoText, /^\| tool \| base \| ops \| csv-sum \| api-rename \|$/m)
   assert.ok(twoText.includes(`| ops_read | 3 | ${green('7')} | 1 → ${green('3')} | 2 → ${green('4')} |`), 'the count belongs to the task that made the call')
 })
@@ -283,18 +275,17 @@ await test('excluded pairs leave the report body but stay in the warnings, and t
   const base = summary('bench-base', [metrics('csv-sum', 1000, true), metrics('csv-sum', 1000, true), metrics('csv-sum', 1000, true)])
   const cand = summary('bench-ops', [metrics('csv-sum', 500, true), metrics('csv-sum', 100, false), metrics('csv-sum', 200, false)])
   const comparison = compareSummaries(base, cand, { noiseFloorPct: 3.1, failOn: 'pass-drop' })
-  const text = renderReport(comparison, SOURCES)
+  const text = renderReport(comparison)
   assertEnglish(text)
   assert.doesNotMatch(text, /## Excluded pairs/, 'the section is gone; the counts must not vanish with it')
   assert.ok(text.includes(`| csv-sum | 1,000 | 500 (${green('\u221250.0%')}) |`), 'the pair table still prices the one usable pair')
   assert.ok(text.includes('| 3/3→1/3 |'), 'the pass column counts every repeat, not only the usable pairs')
   assert.doesNotMatch(text, /pairs usable\/counted/, 'the usable/considered split no longer has a column')
-  assert.match(text, /- cost-pairs-excluded: 2 \(base 0, cand 2, both 0\)/, 'the warnings still carry how many pairs the cost statistics lost')
+  assert.ok(comparison.warnings.includes('cost-pairs-excluded: 2 (base 0, cand 2, both 0)'), 'the comparison document still carries how many pairs the cost statistics lost')
 
   const clean = compareSummaries(base, summary('bench-ops', base.results.map((entry) => ({ ...entry, usage: { ...entry.usage } }))), { noiseFloorPct: 3.1, failOn: 'none' })
-  const cleanText = renderReport(clean, SOURCES)
-  assert.match(cleanText, /No warnings\./, 'nothing excluded means nothing to warn about')
-  assertEnglish(cleanText)
+  assert.deepEqual(clean.warnings, [], 'nothing excluded means nothing to warn about')
+  assertEnglish(text)
 })
 
 await test('--fail-on gates individually, and a gate that cannot run abstains at exit 0', async () => {
@@ -322,7 +313,7 @@ await test('--fail-on gates individually, and a gate that cannot run abstains at
     const abstain = invoke([baseline, costlier, '--out', '-', '--fail-on', 'both'])
     assert.equal(await abstain.run(), EXIT.ok)
     assert.match(abstain.err(), /noise floor unknown ⇒ cost direction withheld/)
-    assert.match(abstain.text(), /noise-floor-unknown/)
+    assert.match(abstain.err(), /noise-floor-unknown/, 'the abstaining gate says so on stderr — the report prints no verdict prose')
   })
 })
 
@@ -410,13 +401,10 @@ await test('label, directory and file forms resolve to the same comparison', asy
     const byDir = invoke([baseDir, candDir, ...common])
     const byFile = invoke([path.join(baseDir, 'run.json'), path.join(candDir, 'run.json'), ...common])
     for (const cli of [byLabel, byDir, byFile]) assert.equal(await cli.run(), EXIT.ok)
-    // The comparison renders identically; the evidence section is the one place
-    // that echoes how each side was named (`spec`), which the caller chose.
-    const body = (text) => text.split('\n').filter((line) => !/^- (base|ops):/.test(line)).join('\n')
-    assert.equal(body(byLabel.text()), body(byDir.text()))
-    assert.equal(body(byFile.text()), body(byDir.text()), 'all three forms reach the same comparison')
-    assert.match(byLabel.text(), /- base:.*run\.json\(spec `bench-base`,run\)/)
-    assert.match(byDir.text(), /- base:.*run\.json\(spec `.*bench-base`,run\)/)
+    // The report carries no side paths, so the three resolution forms render
+    // byte-identically: nothing anywhere echoes how each side was named.
+    assert.equal(byLabel.text(), byDir.text())
+    assert.equal(byFile.text(), byDir.text(), 'all three forms reach the same comparison')
     assert.ok(byDir.text().includes(`api-rename | 500 | 620 (${red('+24.0%')}) | 2 → 2 (${green('0.0%')}) | 1 → 1 (${green('0.0%')}) | 0.0s → 0.0s (${green('0.0%')}) | 0 → 0 | 1/1→1/1 |`))
 
     // A group is searched with --folder; the flat root is searched without it.
@@ -485,13 +473,12 @@ await test('--noise measures the floor in the call, and a missing prompt degrade
     assert.equal(doc.noiseFloor.method, 'aa-max-abs-task-pct')
     assert.equal(doc.noiseFloor.pct, 4, '+50% clears the measured 4% floor')
     assert.equal(doc.gate.regressionFailed, true)
-    assert.match(renderReport(doc, SOURCES), /method `aa-max-abs-task-pct`/)
 
     // A row with no prompt capture cannot support attribution: the core records that,
     // and the report has no attribution section left to hedge in.
     const bare = compareSummaries(summary('bench-base', [metrics('csv-sum', 1000, true, { prompt: false })]), summary('bench-ops', [metrics('csv-sum', 900, true, { prompt: false })]), { noiseFloorPct: 3.1 })
     assert.equal(bare.overhead.comparable, false, 'the core marks the split incomparable')
-    const text = renderReport(bare, SOURCES)
+    const text = renderReport(bare)
     assert.doesNotMatch(text, /Token attribution|fixed overhead per request/)
     assertEnglish(text)
   })
diff --git a/test/bench-run-session.test.mjs b/test/bench-run-session.test.mjs
index 5ddb2111..f997b0d5 100644
--- a/test/bench-run-session.test.mjs
+++ b/test/bench-run-session.test.mjs
@@ -203,6 +203,14 @@ await test('archive + metrics + trace: NDJSON appended verbatim, usage folded, t
     assert.deepEqual(row.toolCallsByName, { read: 1 })
     assert.deepEqual(row.usage, { inputTokens: 10, outputTokens: 5, cacheReadTokens: 2, cacheWriteTokens: 1, reasoningTokens: 0 })
     assert.equal(row.usageReported, false, 'one step without usage degrades the whole row instead of understating it')
+    assert.deepEqual(row.prompt, {
+      reported: false,
+      firstStep: 13,
+      median: 13,
+      max: 13,
+      total: 13,
+      perTurn: [{ turn: 1, tokens: 13 }],
+    }, 'the first request is 10+2+1 prompt tokens; the step without usage keeps the summary incomplete')
     assert.equal(row.turnEndReason, 'completed')
     assert.equal(row.verifyPassed, false, 'the fake child wrote no answer, so the check fails')
 
@@ -224,6 +232,29 @@ await test('archive + metrics + trace: NDJSON appended verbatim, usage folded, t
   })
 })
 
+await test('the fold records the prompt shape: first request, per-step sizes, per-turn firsts', async () => {
+  await withTempDir('bench-session-prompt', async (root) => {
+    const events = [
+      { type: 'status', phase: 'step_end', step: 1, turn: 1, usage: { inputTokens: 10, outputTokens: 5, cacheReadTokens: 2, cacheWriteTokens: 1 } },
+      { type: 'status', phase: 'step_end', step: 2, turn: 1, usage: { inputTokens: 40, outputTokens: 5, cacheReadTokens: 0, cacheWriteTokens: 0 } },
+      { type: 'status', phase: 'step_end', step: 3, turn: 2, usage: { inputTokens: 100, outputTokens: 5, cacheReadTokens: 0, cacheWriteTokens: 0 } },
+    ]
+    const rig = spawnRig((child) => child.emitFrom({ events, stderr: '', exit: 0 }))
+    const row = await runSession(
+      { task: { ...TASK, verify: [{ type: 'fileExists', path: 'answer.txt' }] }, repeatIndex: 1 },
+      optionsFor(root, { spawn: rig.spawn }),
+    )
+    assert.deepEqual(row.prompt, {
+      reported: true,
+      firstStep: 13,
+      median: 40,
+      max: 100,
+      total: 153,
+      perTurn: [{ turn: 1, tokens: 13 }, { turn: 2, tokens: 100 }],
+    }, 'prompt size is input + cacheRead + cacheWrite per step; each turn contributes its first request')
+  })
+})
+
 await test('timeout: timedOut true, exit null, and the kill is recorded in the archive', async () => {
   await withTempDir('bench-session-timeout', async (root) => {
     const killed = []

From 7f17d056b2e30ebc0015d990f6164347611cf3a9 Mon Sep 17 00:00:00 2001
From: Richeir <richeir@outlook.com>
Date: Sat, 24 Oct 2026 17:56:51 +0800
Subject: [PATCH 09/10] docs(bench): describe every task in the README
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

bench/README.md gains a task table: fixture size, what each task measures
(symbol rename vs decoys, paged reads against stale-comment bait, layered
config priorities, shell-side aggregation, the run-fix-rerun repair loop,
exact log extraction) and which ops_* tool each step maps to. The numbers
match the current fixtures — api-rename 12 modules and gate-repair-loop 12
stages included — and the expectations are the generators', recomputed per
run.
---
 bench/README.md | 15 ++++++++++++++-
 1 file changed, 14 insertions(+), 1 deletion(-)

diff --git a/bench/README.md b/bench/README.md
index 15066ed7..e51df905 100644
--- a/bench/README.md
+++ b/bench/README.md
@@ -44,4 +44,17 @@ node bench/cli.mjs ab
 
 ```console
 node bench/cli.mjs ab --task csv-sum
-```
\ No newline at end of file
+```
+
+## 任务一览
+
+六个任务各自压一种能力，`ops_*` 工具名来自 `publicToolName()`。每个任务的期望值都由夹具生成器现算（`derive*`），判卷在 `bench/lib/verify.mjs`。
+
+| 任务 | 工作量 | 主要测什么 | 相关工具 |
+| --- | --- | --- | --- |
+| `api-rename` | 12 个模块 + `core.js`（另生成 `check.mjs`），把 `parsePayload` 改名为 `decodePayload` | 符号级改名而非文本替换：定义、import、调用点一个不能漏；诱饵 `parsePayloadLegacy` / `parsePayloadAsync` 和完全不碰该符号的文件必须原样保留；判卷是 `src/` 全部文件的字节级 SHA-256 全等 + `node check.mjs` 退 0 | `ops_grep`（+`ops_glob`）搜调用点；`ops_read_files` 读文件；`ops_edit_file` / `ops_replace` 改名 |
+| `big-file-paging` | 4200 行单文件 `src/pipeline.js` | 分页读取：定位 `auditLimit('staging')` 所在行段，只读需要的两段而不是整读文件；文件里埋了过期注释和被取代的 `LEGACY_LIMIT_TABLE`，grep 一次仍要判断；`answer.txt` 等于该常量的整数 | `ops_grep` 定位；`ops_inspect_local_file`（或 `ops_read_files`）带 `offset`/`limit` 只读两段；`ops_write_file` 写答案 |
+| `config-hunt` | 3 层配置目录 + 12 个 `packages/*/config.json` 诱饵 | 层级查找与优先级判断：先 glob 出配置层，再 grep key，最后按 README 的优先级取 `MAX_UPLOAD_MB` 的有效值；只 grep key 就停下有 1/4 概率拿错答案 | `ops_glob` 找层；`ops_grep` 找 key；`ops_read_files` 读优先级文档与三层配置；`ops_write_file` 写答案 |
+| `csv-sum` | 8000 行 CSV，汇总 EU 区 `amount` 列 | 上下文控制：把聚合交给 shell 而不是把 8000 行读进上下文，`answer.txt` 只写整数和 | `ops_bash` 聚合；`ops_read_files` 只看表头确认列；`ops_write_file` 写答案 |
+| `gate-repair-loop` | 12 个 stage 模块（每个约 70 行）+ `check.js` | 迭代修复循环：门禁停在第一个坏 stage，每个 stage 只错一处绑定常量、契约写在模块自己的注释里，跑→修→再跑直到退 0；`check.js` 字节不变是 invariant | `ops_bash` 跑门禁；`ops_read_files` 读 stage；`ops_edit_file` 按契约修常量；`ops_write_file` 写 `answer.txt` |
+| `noisy-test-triage` | 2400 个测试、恰好一行 `not ok` | 精确提取：跑测试重定向到文件，在日志里只捞那一行失败测试名写入 `failure.txt`（必须精确匹配），且 runner 仍退 1 是 invariant | `ops_bash` 跑并重定向；`ops_grep` 只捞那一行（如 `^not ok`，可配 `outputMode: summary/content`）；必要时 `ops_read_files`；`ops_write_file` 写结果 |

From f1dafcc31d3e8cc46db68d5b9bf1f0af24c6e0d5 Mon Sep 17 00:00:00 2001
From: Richeir <richeir@outlook.com>
Date: Sat, 24 Oct 2026 18:06:42 +0800
Subject: [PATCH 10/10] docs(bench): retitle the manual and add a where-to-look
 section
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The bench README becomes the Benchmark Manual: setup says what it prepares
(the two headless profiles and the locally built plugin), the LLM overlay
section is reworded, and the group-folder naming plus the auto-written
report move into their own "结果在哪看" section.
---
 bench/README.md | 17 ++++++++++-------
 1 file changed, 10 insertions(+), 7 deletions(-)

diff --git a/bench/README.md b/bench/README.md
index e51df905..a196fd86 100644
--- a/bench/README.md
+++ b/bench/README.md
@@ -1,4 +1,4 @@
-# Benchmark
+# Benchmark Manual
 
 ## 测试前的准备
 
@@ -11,12 +11,12 @@ npm run build && npm run build:ptc     # lib/ + 原生 worker
 
 ```console
 npm i -g @deepseek-ai/dsh
-node bench/cli.mjs setup              # 先加 --dry-run 看计划；检查失败会在碰 profile 之前拒绝
+node bench/cli.mjs setup              # 会自动添加 2 个 headless profile（base、dsh），然后在 dsh 上面安装本地代码 build 出来的插件
 ```
 
-### 配 LLM 路由 overlay
+### 配 LLM 链接
 
-跑 `node bench/cli.mjs setup` 会在副本不存在时自动复制一份（存在就一字不改）；想自己重来一份就手动复制，会覆盖已有的：
+跑 `node bench/cli.mjs setup` 会在自动创建；也可以手动创建（会覆盖已有的）：
 
 ```console
 cp bench/llm.patch.example.yml bench/llm.patch.yml           # bash
@@ -37,15 +37,18 @@ cp bench/llm.patch.example.yml bench/llm.patch.yml           # bash
 node bench/cli.mjs ab
 ```
 
-- 会自动取下一个空闲的 `benchmark-YYYY-MM-DD-NN`（按当天日期编号，从 `-00` 起）
-- 跑完自动在组目录写 `DSH-OPS Benchmark Report <UTC>.md`（报告标题带 (beta)）
-
 ## 怎么跑单个 task
 
 ```console
 node bench/cli.mjs ab --task csv-sum
 ```
 
+## 结果在哪看
+
+- 在 bench/runs 文件夹里面可以看到
+- 文件夹名称格式为 `benchmark-YYYY-MM-DD-NN`（按当天日期编号，从 `-00` 起）
+- 跑完自动在组目录写 `DSH-OPS Benchmark Report <UTC>.md`
+
 ## 任务一览
 
 六个任务各自压一种能力，`ops_*` 工具名来自 `publicToolName()`。每个任务的期望值都由夹具生成器现算（`derive*`），判卷在 `bench/lib/verify.mjs`。