@qvac/harness 1.0.0-rc.2 → 1.0.0-rc.3

package/bench/cpu.ts

@@ -0,0 +1,457 @@
+// CPU and run-log benchmark for Node, Bun, and Bare.
+import { CompletionEngine } from '../lib/capabilities/completion-engine/index.ts'
+import type { CompletionSdk, Message, ToolDefinition } from '../lib/contract/index.ts'
+import b4a from 'b4a'
+import process from 'process'
+import { RunLog, type EngineBoot, type EngineStep } from '../lib/run-log/index.ts'
+import { driveCompletion } from '../lib/capabilities/completion-engine/driver.ts'
+import { HookPipeline } from '../lib/hooks/index.ts'
+import { defaultAgentPorts } from '../lib/capabilities/agent-ports.ts'
+import { outboundGuard } from '../lib/tools/outbound-guard.ts'
+import { installAbortControllerPolyfill } from '../lib/helpers/abort-polyfill.ts'
+
+installAbortControllerPolyfill()
+
+type RedactionMode = 'nohost' | 'plain' | 'bench' | 'production'
+type Spacing = 'immediate' | 'timeout'
+type Workload = 'tools' | 'stream'
+interface CliOptions {
+  runs: number
+  mode: string
+  spacing: string
+  workload: string
+  json: boolean
+}
+interface WorkloadInput {
+  sdk: CompletionSdk
+  args: Parameters<typeof CompletionEngine.run>[1]
+  host: ReturnType<typeof countingHost>
+}
+interface CountOptions {
+  count?: boolean
+}
+interface ModeResultsOptions {
+  mode: RedactionMode
+  runs: number
+  spacings: Spacing[]
+  workloads: Workload[]
+}
+type BenchResult =
+  | {
+      workload: 'tools'
+      mode: RedactionMode
+      runs: number
+      cpuMs: number
+      cpuSamplesMs: number[]
+      logBytes: number
+      records: number
+    }
+  | {
+      workload: 'stream'
+      mode: RedactionMode
+      spacing: Spacing
+      runs: number
+      cpuMs: number
+      cpuSamplesMs: number[]
+      usPerToken: number
+      contentEvents: number
+      logBytes: number
+      records: number
+    }
+const TOKENS = 2000
+// Keep every token observable by starting outside round.ts's burst window.
+const FIRST_TOKEN_MS = 110
+const USAGE = [
+  'Usage: cpu.ts [runs] [--mode=nohost|plain|bench|production|all]',
+  '  [--spacing=immediate|timeout|all] [--workload=tools|stream|all] [--json]',
+  'Node: node --experimental-strip-types bench/cpu.ts',
+  'Bun: bun --tsconfig-override=bench/bun-tsconfig.json bench/cpu.ts',
+  'Bare: bare bench/cpu.ts'
+].join('\n')
+
+function parseOptions(args: string[]): CliOptions {
+  let runs = 3
+  let mode = 'all'
+  let spacing = 'all'
+  let workload = 'all'
+  let json = false
+  let positionalRuns = false
+
+  for (const arg of args) {
+    if (arg === '--json') {
+      json = true
+    } else if (arg === '--help' || arg === '-h') {
+      console.log(USAGE)
+      process.exit(0)
+    } else if (arg.startsWith('--mode=')) {
+      mode = arg.slice('--mode='.length)
+    } else if (arg.startsWith('--spacing=')) {
+      spacing = arg.slice('--spacing='.length)
+    } else if (arg.startsWith('--workload=')) {
+      workload = arg.slice('--workload='.length)
+    } else if (!arg.startsWith('-') && !positionalRuns) {
+      runs = Number(arg)
+      positionalRuns = true
+    } else {
+      throw new Error(`Unknown option: ${arg}`)
+    }
+  }
+
+  if (!Number.isInteger(runs) || runs < 1) {
+    throw new Error('runs must be a positive integer')
+  }
+
+  return { runs, mode, spacing, workload, json }
+}
+
+function selectValues<Value extends string>(
+  value: string,
+  allowed: readonly Value[],
+  label: string
+): Value[] {
+  if (value === 'all') {
+    return [...allowed]
+  }
+
+  const selected = allowed.find((option) => option === value)
+  if (selected === undefined) {
+    throw new Error(`Unknown ${label}: ${value}`)
+  }
+
+  return [selected]
+}
+
+function options() {
+  const parsed = parseOptions(process.argv.slice(2))
+  return {
+    runs: parsed.runs,
+    modes: selectValues(parsed.mode, ['nohost', 'plain', 'bench', 'production'], 'mode'),
+    spacings: selectValues(parsed.spacing, ['immediate', 'timeout'], 'spacing'),
+    workloads: selectValues(parsed.workload, ['tools', 'stream'], 'workload'),
+    json: parsed.json
+  }
+}
+
+async function collect<Event extends { type?: string }>(
+  run: AsyncIterable<Event>
+): Promise<Event[]> {
+  const events: Event[] = []
+  for await (const event of run) {
+    events.push(event)
+  }
+
+  return events
+}
+
+function cpuMs(start: NodeJS.CpuUsage): number {
+  const d = process.cpuUsage(start)
+  return (d.user + d.system) / 1000
+}
+
+function median(values: number[]): number {
+  const sorted = [...values].sort((a, b) => a - b)
+  const value = sorted[Math.floor(sorted.length / 2)]
+  if (value === undefined) {
+    throw new Error('Cannot find the median of an empty sample')
+  }
+
+  return value
+}
+
+// 101 messages, ~200 KB: a review-sized conversation.
+function history(): Message[] {
+  return Array.from({ length: 101 }, (_, i) => ({
+    role: i % 2 ? 'assistant' : 'user',
+    content: `${i} ${'x'.repeat(2000)}`
+  }))
+}
+
+function readTool(name: string): ToolDefinition {
+  return {
+    name,
+    description: 'read something',
+    toolset: null,
+    parameters: { type: 'object', properties: { path: { type: 'string' } } },
+    effect: () => 'read',
+    autoApprove: true,
+    execute: () => Promise.resolve({ content: `${name} ${'r'.repeat(2048)}` })
+  }
+}
+
+// 3 tool rounds x 2 read calls/round, then a plain answer round.
+function toolWorkloadSdk(tools: ToolDefinition[]): CompletionSdk {
+  let round = 0
+  return {
+    completion: () => {
+      const r = round++
+      if (r < 3) {
+        return {
+          tokenStream: (async function* () {})(),
+          final: Promise.resolve({
+            contentText: '',
+            toolCalls: tools.map((t, i) => ({
+              id: `call-${r}-${i}`,
+              name: t.name,
+              arguments: { path: `f${r}${i}` }
+            })),
+            raw: { fullText: '' }
+          })
+        }
+      }
+
+      return {
+        tokenStream: (async function* () {
+          yield 'done'
+        })(),
+        final: Promise.resolve({ contentText: 'done', toolCalls: [], raw: { fullText: 'done' } })
+      }
+    }
+  }
+}
+
+function countingHost(count: boolean, mode: RedactionMode) {
+  const core = memoryCore()
+  const records: unknown[] = []
+  const stats = { bytes: 0, records: 0 }
+  let boot: EngineBoot = RunLog.createEngineBoot()
+  return {
+    core,
+    stats,
+    get boot() {
+      return boot
+    },
+    async onStep(step: EngineStep) {
+      const next = RunLog.applyEngineStep(boot, step)
+      if (mode === 'production') {
+        for (const record of step.records) {
+          await core.append(record)
+        }
+      } else if (mode === 'bench') {
+        for (const record of step.records) {
+          records.push(JSON.parse(JSON.stringify(record)))
+        }
+      }
+
+      if (count) {
+        for (const record of step.records) {
+          stats.bytes += b4a.byteLength(JSON.stringify(record))
+          stats.records++
+        }
+      }
+
+      boot = next
+    },
+    digestKey: new Uint8Array(32).fill(7)
+  }
+}
+
+function memoryCore() {
+  const records: unknown[] = []
+  return {
+    get length() {
+      return records.length
+    },
+    ready: () => Promise.resolve(),
+    get(index: number) {
+      const value = records[index]
+      return Promise.resolve(value === undefined ? null : JSON.parse(JSON.stringify(value)))
+    },
+    append(value: unknown) {
+      records.push(JSON.parse(JSON.stringify(value)))
+      return Promise.resolve()
+    }
+  }
+}
+
+function runWithMode(mode: RedactionMode, { sdk, args, host }: WorkloadInput) {
+  // No onStep: the run log journal still runs, so only the host append is left out.
+  if (mode === 'nohost') {
+    return collect(CompletionEngine.run(sdk, args))
+  }
+
+  const completionOptions = {
+    boot: host.boot,
+    onStep: host.onStep,
+    requestDigestKey: host.digestKey
+  }
+  if (mode === 'production') {
+    return collect(CompletionEngine.run(sdk, args, completionOptions))
+  }
+
+  const redactor = mode === 'bench' ? RunLog.createRedactor(args.tools ?? []) : undefined
+  const driverOptions: Parameters<typeof driveCompletion>[2] = {
+    ...completionOptions,
+    pipeline: new HookPipeline(HookPipeline.defaults()),
+    outbound: outboundGuard,
+    agentPorts: defaultAgentPorts
+  }
+  if (redactor) {
+    Object.assign(driverOptions, {
+      redact: redactor,
+      redactShared: redactor.redactShared,
+      redactOperationResult: redactor.redactOperationResult,
+      redactStep: redactor.redactStep
+    })
+  }
+
+  return collect(driveCompletion(args, () => Promise.resolve({ sdk }), driverOptions))
+}
+
+async function runToolWorkload(mode: RedactionMode, options: CountOptions = {}) {
+  const { count = false } = options
+  const tools = [readTool('read_a'), readTool('read_b')]
+  const host = countingHost(count, mode)
+  const { stats } = host
+  const args = { runId: 'bench-tools', modelId: 'm', messages: history(), tools }
+  const start = process.cpuUsage()
+  await runWithMode(mode, { sdk: toolWorkloadSdk(tools), args, host })
+  return { ms: cpuMs(start), ...stats }
+}
+
+function streamingSdk(spacing: Spacing): CompletionSdk {
+  return {
+    completion: () => ({
+      tokenStream: (async function* () {
+        await new Promise((resolve) => setTimeout(resolve, FIRST_TOKEN_MS))
+        for (let i = 0; i < TOKENS; i++) {
+          await new Promise((resolve) =>
+            spacing === 'immediate' ? setImmediate(resolve) : setTimeout(resolve, 0)
+          )
+          yield 't'
+        }
+      })(),
+      final: Promise.resolve({
+        contentText: 't'.repeat(TOKENS),
+        toolCalls: [],
+        raw: { fullText: '' }
+      })
+    })
+  }
+}
+
+async function runStreaming(mode: RedactionMode, spacing: Spacing, options: CountOptions = {}) {
+  const { count = false } = options
+  const host = countingHost(count, mode)
+  const { stats } = host
+  const args = { runId: `bench-stream-${Math.random()}`, modelId: 'm', messages: history() }
+  const start = process.cpuUsage()
+  const events = await runWithMode(mode, { sdk: streamingSdk(spacing), args, host })
+  const ms = cpuMs(start)
+  return {
+    ms,
+    contentEvents: events.filter((event) => event.type === 'content').length,
+    ...stats
+  }
+}
+
+async function measureTools(mode: RedactionMode, runs: number): Promise<BenchResult> {
+  const log = await runToolWorkload(mode, { count: true })
+  const samples = []
+  for (let i = 0; i < runs; i++) {
+    samples.push(await runToolWorkload(mode))
+  }
+
+  return {
+    workload: 'tools',
+    mode,
+    runs,
+    cpuMs: median(samples.map((sample) => sample.ms)),
+    cpuSamplesMs: samples.map((sample) => sample.ms),
+    logBytes: log.bytes,
+    records: log.records
+  }
+}
+
+async function measureStream(
+  mode: RedactionMode,
+  spacing: Spacing,
+  runs: number
+): Promise<BenchResult> {
+  const log = await runStreaming(mode, spacing, { count: true })
+  const samples = []
+  for (let i = 0; i < runs; i++) {
+    samples.push(await runStreaming(mode, spacing))
+  }
+
+  const cpu = median(samples.map((sample) => sample.ms))
+
+  return {
+    workload: 'stream',
+    mode,
+    spacing,
+    runs,
+    cpuMs: cpu,
+    cpuSamplesMs: samples.map((sample) => sample.ms),
+    usPerToken: (cpu * 1000) / TOKENS,
+    contentEvents: log.contentEvents,
+    logBytes: log.bytes,
+    records: log.records
+  }
+}
+
+async function resultsForMode({
+  mode,
+  runs,
+  spacings,
+  workloads
+}: ModeResultsOptions): Promise<BenchResult[]> {
+  const results: BenchResult[] = []
+  if (workloads.includes('tools')) {
+    results.push(await measureTools(mode, runs))
+  }
+
+  if (workloads.includes('stream')) {
+    for (const spacing of spacings) {
+      results.push(await measureStream(mode, spacing, runs))
+    }
+  }
+
+  return results
+}
+
+function runtimeInfo() {
+  const bun = Reflect.get(globalThis, 'Bun')
+  if (bun && typeof bun === 'object' && 'version' in bun && typeof bun.version === 'string') {
+    return { runtime: 'bun', version: bun.version }
+  }
+
+  return {
+    runtime: process.release?.name ?? (process.version.startsWith('v1.') ? 'bare' : 'unknown'),
+    version: process.version
+  }
+}
+
+async function main() {
+  const { runs, modes, spacings, workloads, json } = options()
+  const results: BenchResult[] = []
+  for (const mode of modes) {
+    results.push(...(await resultsForMode({ mode, runs, spacings, workloads })))
+  }
+
+  const report = { ...runtimeInfo(), runs, results }
+  if (json) {
+    console.log(JSON.stringify(report))
+    return
+  }
+
+  console.log(`${report.runtime} ${report.version}; median of ${runs} runs`)
+  for (const result of results) {
+    const logMiB = (result.logBytes / (1024 * 1024)).toFixed(3)
+    if (result.workload === 'tools') {
+      console.log(
+        `tools mode=${result.mode} cpu=${result.cpuMs.toFixed(2)}ms log=${logMiB}MiB records=${result.records}`
+      )
+    } else {
+      const usPerToken =
+        'usPerToken' in result && typeof result.usPerToken === 'number' ? result.usPerToken : 0
+      console.log(
+        `stream mode=${result.mode} spacing=${result.spacing} cpu=${result.cpuMs.toFixed(2)}ms usPerToken=${usPerToken.toFixed(2)} contentEvents=${result.contentEvents} log=${logMiB}MiB records=${result.records}`
+      )
+    }
+  }
+}
+
+main().catch((error) => {
+  console.error(error)
+  process.exitCode = 1
+})

package/bench/evidence/2026-09-28-review15.md

@@ -0,0 +1,225 @@
+# Review 15 performance re-measure — 2026-09-28
+
+No tuning. Both runtimes exceed the 1.5× streaming and 2× tool-workload targets in this measurement.
+
+## Revisions and method
+
+- Branch: `refactor/add-state-machine`, HEAD `a029f2ec07de03c9bdce306c0d22494917399d4e` plus the uncommitted Lot 1 ownership fix in `lib/run-log-redact.ts`. Lots 2–3 change documentation and tests.
+- Main comparison: merge-base `7d4a1ec282ed29b2480b551e6a4670d448441e63`, obtained with `git merge-base HEAD origin/main`.
+- Machine: Darwin arm64. Runtimes: Node v24.11.0 and Bun 1.3.14.
+- Method: [issue #129](https://github.com/tetherto/qvac-harness/issues/129), “Measurement method.” Fake SDK, 101 messages (roughly 200 KB), 2,000 token events, 110 ms initial delay followed by `setImmediate` spacing; 3 rounds × 2 auto-approved read tools followed by an answer.
+- Three fresh processes per runtime/revision, three timed runs per workload per process. Each workload first runs once to count log bytes and warm the process. CPU time is `process.cpuUsage()`, not elapsed time. Results below are medians of the three process medians; all nine CPU samples are retained below.
+- Process pairs ran sequentially: branch/main, main/branch, branch/main; Node pair then Bun pair in each pass. No benchmark processes overlapped. The shared machine was not reserved, so other agent activity and Bun’s wide stream samples remain sources of variance.
+- Branch used the existing `bench/cpu.ts` in production mode with host boot folding and JSON-copy storage. Every stream measurement reported 2,000 content events.
+- Baseline deviation: the merge-base predates both `bench/cpu.ts` and the run-log API. Its temporary copy used identical workloads, warm-up, timing, and reporting, with only the entry-point/storage adapter changed to `completion(sdk, args)`. Main accepts two arguments and emits no journal records; its log bytes/records are zero. The exact adapter diff is below.
+- Benchmark SHA-256: `305ff7270f08b058e706efd6de75a57a109817a7f03106b608bc9ec1b2c15ba1`.
+- Measured redactor SHA-256: `007bf7c3146e7e2132062c50f62f709e6495e13ae03ebe3017f49621a0f298b0`.
+
+## Results
+
+| Runtime | Workload |           Branch |             Main | Branch/main | Limit | Meets limit |
+| ------- | -------- | ---------------: | ---------------: | ----------: | ----: | ----------- |
+| Node    | stream   | 14.3875 µs/token |  7.6265 µs/token |      1.887× |  1.5× | no          |
+| Node    | tools    |       27.7580 ms |        1.3510 ms |     20.546× |    2× | no          |
+| Bun     | stream   | 24.7500 µs/token | 15.8645 µs/token |      1.560× |  1.5× | no          |
+| Bun     | tools    |       36.8500 ms |        2.0140 ms |     18.297× |    2× | no          |
+
+| Runtime | Revision | Tool log bytes / records         | Stream log bytes / records (processes 1, 2, 3) |
+| ------- | -------- | -------------------------------- | ---------------------------------------------- |
+| Node    | branch   | 324611, 324611, 324611 / 57 each | 248235, 248245, 248235 / 9 each                |
+| Node    | main     | 0, 0, 0 / 0 each                 | 0, 0, 0 / 0 each                               |
+| Bun     | branch   | 324611, 324611, 324611 / 57 each | 248235, 248235, 248240 / 9 each                |
+| Bun     | main     | 0, 0, 0 / 0 each                 | 0, 0, 0 / 0 each                               |
+
+Stream log sizes vary slightly because the benchmark generates a random run ID. Tool log sizes were identical across these processes. These measurements do not verify the golden-bytes fixture; it was not regenerated.
+
+## Exact benchmark commands
+
+Run each command three times per revision, in the interleaved order above:
+
+```sh
+QVAC_NO_SKILL_BIN_PROBE=1 /tmp/node-v24.11.0-darwin-arm64/bin/node --experimental-strip-types bench/cpu.ts 3 --mode=production --spacing=immediate --workload=all --json
+QVAC_NO_SKILL_BIN_PROBE=1 /Users/matheus/.bun/bin/bun --tsconfig-override=bench/bun-tsconfig.json bench/cpu.ts 3 --mode=production --spacing=immediate --workload=all --json
+```
+
+The baseline was created with `git worktree add --detach /tmp/qvac-review15-giokq5_1/main 7d4a1ec282ed29b2480b551e6a4670d448441e63`. Its `node_modules` symlink reused the branch’s installed dependency resolutions, and `bun-tsconfig.json` was copied unchanged. The temporary worktree was removed after measurement.
+
+## Raw CPU samples
+
+| Runtime | Revision | Process | Tool ms (3 runs)       | Stream CPU ms (3 runs; divide by 2 for µs/token) |
+| ------- | -------- | ------: | ---------------------- | ------------------------------------------------ |
+| node    | branch   |       1 | 30.668, 27.576, 29.124 | 25.374, 32.936, 32.531                           |
+| node    | main     |       1 | 1.743, 1.351, 1.123    | 10.491, 15.769, 15.307                           |
+| bun     | branch   |       1 | 58.115, 35.710, 36.574 | 29.654, 49.500, 107.315                          |
+| bun     | main     |       1 | 3.041, 2.292, 1.223    | 36.103, 13.894, 31.729                           |
+| node    | main     |       2 | 1.584, 1.494, 1.095    | 15.253, 12.610, 17.444                           |
+| node    | branch   |       2 | 32.229, 24.765, 27.758 | 28.775, 25.674, 31.390                           |
+| bun     | main     |       2 | 3.081, 2.014, 1.081    | 35.047, 16.004, 20.184                           |
+| bun     | branch   |       2 | 54.465, 34.368, 38.625 | 43.572, 48.618, 69.273                           |
+| node    | branch   |       3 | 29.307, 24.338, 27.701 | 26.108, 26.253, 27.608                           |
+| node    | main     |       3 | 1.519, 1.345, 1.032    | 11.542, 16.398, 13.744                           |
+| bun     | branch   |       3 | 54.344, 34.818, 36.850 | 39.626, 73.367, 72.450                           |
+| bun     | main     |       3 | 2.887, 1.857, 1.112    | 39.319, 41.242, 71.949                           |
+
+## Baseline adapter diff
+
+Apply to a temporary copy of the branch benchmark; it does not alter the workload bodies or measurement loops.
+
+```diff
+--- branch/bench/cpu.ts
++++ main/bench/cpu.ts
+@@ -6,17 +6,6 @@
+   type ToolDefinition
+ } from '../../lib/capabilities/completion.ts'
+ import process from 'process'
+-import {
+-  applyEngineStep,
+-  createEngineBoot,
+-  type EngineBoot,
+-  type EngineStep
+-} from '../../lib/run-log-protocol.ts'
+-import { driveCompletion } from '../../lib/capabilities/completion-engine/driver.ts'
+-import { createRunLogRedactor } from '../../lib/run-log-redact.ts'
+-import { installAbortControllerPolyfill } from '../../lib/capabilities/completion-engine/abort-polyfill.ts'
+-
+-installAbortControllerPolyfill()
+
+ type RedactionMode = 'plain' | 'bench' | 'production'
+ type Spacing = 'immediate' | 'timeout'
+@@ -216,40 +205,8 @@
+   }
+ }
+
+-function countingHost(count: boolean, mode: RedactionMode) {
+-  const core = memoryCore()
+-  const records: unknown[] = []
+-  const stats = { bytes: 0, records: 0 }
+-  let boot: EngineBoot = createEngineBoot()
+-  return {
+-    core,
+-    stats,
+-    get boot() {
+-      return boot
+-    },
+-    async onStep(step: EngineStep) {
+-      const next = applyEngineStep(boot, step)
+-      if (mode === 'production') {
+-        for (const record of step.records) {
+-          await core.append(record)
+-        }
+-      } else if (mode === 'bench') {
+-        for (const record of step.records) {
+-          records.push(JSON.parse(JSON.stringify(record)))
+-        }
+-      }
+-
+-      if (count) {
+-        for (const record of step.records) {
+-          stats.bytes += textEncoder.encode(JSON.stringify(record)).byteLength
+-          stats.records++
+-        }
+-      }
+-
+-      boot = next
+-    },
+-    digestKey: new Uint8Array(32).fill(7)
+-  }
++function countingHost(_count: boolean, _mode: RedactionMode) {
++  return { core: memoryCore(), stats: { bytes: 0, records: 0 } }
+ }
+
+ function memoryCore() {
+@@ -270,28 +227,8 @@
+   }
+ }
+
+-function runWithMode(mode: RedactionMode, { sdk, args, host }: WorkloadInput) {
+-  const completionOptions = {
+-    boot: host.boot,
+-    onStep: host.onStep,
+-    requestDigestKey: host.digestKey
+-  }
+-  if (mode === 'production') {
+-    return collect(completion(sdk, args, completionOptions))
+-  }
+-
+-  const redactor = mode === 'bench' ? createRunLogRedactor(args.tools ?? []) : undefined
+-  const driverOptions: Parameters<typeof driveCompletion>[2] = { ...completionOptions }
+-  if (redactor) {
+-    Object.assign(driverOptions, {
+-      redact: redactor,
+-      redactShared: redactor.redactShared,
+-      redactOperationResult: redactor.redactOperationResult,
+-      redactStep: redactor.redactStep
+-    })
+-  }
+-
+-  return collect(driveCompletion(args, () => Promise.resolve({ sdk }), driverOptions))
++function runWithMode(_mode: RedactionMode, { sdk, args }: WorkloadInput) {
++  return collect(completion(sdk, args))
+ }
+
+ async function runToolWorkload(mode: RedactionMode, options: CountOptions = {}) {
+```
+
+## Tool-workload profile and re-measure — 2026-09-28, same day
+
+Same revisions as above (HEAD `a029f2e`, merge-base `7d4a1ec`), after the changes listed under “What changed”. Machine load average was 6–7 throughout; differences under ~15% are noise.
+
+### Profile (Node, `--cpu-prof --cpu-prof-interval=100`, 30 timed tool runs)
+
+Top self-time frames before any change, module loading excluded (664 ms of workload over 31 runs):
+
+| Self ms | Share | Frame                                                          |
+| ------: | ----: | -------------------------------------------------------------- |
+|   108.2 | 16.3% | `brandCapturedRecord` lib/run-log/protocol.ts:305              |
+|    45.0 |  6.8% | garbage collector                                              |
+|    26.1 |  3.9% | `append` bench/cpu.ts:266 (host JSON copy)                     |
+|    26.0 |  3.9% | `compactHistory` map callback lib/run-log/history-codec.ts:417 |
+|    25.0 |  3.8% | `define` lib/run-log-redact.ts:167                             |
+
+Self time by file, per run: protocol.ts 4.9 ms, run-log-redact.ts 3.0 ms, history-codec.ts 2.5 ms, xstate 1.8 ms, GC 1.5 ms, bench host 0.9 ms, stable-stringify.ts 0.8 ms; nothing else above 0.6 ms.
+
+Deterministic section timing (hrtime around each call, 10 timed runs) per run: compactSnapshot 2.25 ms, redactShared 2.19 ms, event encode 1.40 ms, append redactRecord+capture 1.33 ms, host append 1.12 ms, applyEngineStep 0.77 ms, snapshot diff 0.45 ms, getPersistedSnapshot 0.33 ms. These sum to about 10 ms of a 26–29 ms run; the rest is spread across the XState actor loop, the driver, operation records and GC.
+
+Branding counters, per run: about 5,000 freshly branded nodes at 700 ns each (3.5 ms), from redactRecord 2,494, redactShared 1,227, event encode 580, delta patch 515, compactSnapshot 183. The uncommitted always-clone in walkRunRecord/redactRecord accounted for the redactRecord share: it re-cloned already-branded patches and snapshots and branded them again.
+
+### What changed
+
+- `lib/run-log-redact.ts`: captured values reaching `walkRunRecord`, `redactRecord` and `copyPatch` are reused by reference again (zero-copy). `cloneStructure` still copies captured input, and `walkHistoryEntry` still clones captured messages, so nothing reachable from live `context.history` is branded (N84). Fresh brand visits per run drop from about 5,000 to 3,460.
+- `test/run-log-redact.ts`: the assertions that required copying captured input now assert the pass-through, and the identity tests (live nodes never shared, 40-round restored history) are unchanged.
+- Append-path copy count over the tool workload (`captureRunRecord` misses, 11 runs × 57 records): **0**.
+- A brand-walk micro-optimisation (array index loop) was tried and reverted: unmeasurable at this noise level.
+- Log bytes unchanged: tools 324611 / 57 records; `test/run-log-golden-bytes.ts` and `test/completion-recovery-matrix.ts` pass.
+
+### Results (same commands and interleaving as above)
+
+| Runtime | Workload |           Branch |             Main | Branch/main | Limit | Meets limit |
+| ------- | -------- | ---------------: | ---------------: | ----------: | ----: | ----------- |
+| Node    | stream   | 13.4825 µs/token |  7.7775 µs/token |      1.734× |  1.5× | no          |
+| Node    | tools    |       29.1920 ms |        1.4280 ms |     20.443× |    2× | no          |
+| Bun     | stream   | 18.1330 µs/token | 16.0295 µs/token |      1.131× |  1.5× | yes         |
+| Bun     | tools    |       38.6190 ms |        2.1580 ms |     17.896× |    2× | no          |
+
+The tool workload did not move: the cut removed about 1.5 ms of branding, which is inside run-to-run noise on this machine. Redactor SHA-256: `d64b6103f081969ef9d56a6bbe5f2d6f3f9fe35a7dcad22734593cbe46d79183`. Benchmark SHA-256: `305ff7270f08b058e706efd6de75a57a109817a7f03106b608bc9ec1b2c15ba1` (unchanged).
+
+### Raw CPU samples
+
+| Runtime | Revision | Process | Tool ms (3 runs)       | Stream CPU ms (3 runs; divide by 2 for µs/token) |
+| ------- | -------- | ------: | ---------------------- | ------------------------------------------------ |
+| node    | branch   |       1 | 33.290, 28.572, 29.864 | 41.942, 28.681, 30.363                           |
+| node    | main     |       1 | 1.507, 1.556, 1.072    | 11.554, 14.193, 14.610                           |
+| bun     | branch   |       1 | 58.033, 34.929, 38.619 | 26.353, 36.266, 96.164                           |
+| bun     | main     |       1 | 3.180, 2.158, 1.034    | 25.701, 33.694, 38.158                           |
+| node    | main     |       2 | 2.230, 1.427, 1.153    | 12.278, 22.986, 15.555                           |
+| node    | branch   |       2 | 32.094, 27.156, 29.012 | 26.243, 27.721, 26.965                           |
+| bun     | main     |       2 | 3.378, 2.315, 1.252    | 25.693, 12.538, 17.701                           |
+| bun     | branch   |       2 | 53.866, 32.177, 37.547 | 38.825, 79.629, 102.442                          |
+| node    | branch   |       3 | 29.694, 29.192, 25.870 | 26.662, 26.331, 27.544                           |
+| node    | main     |       3 | 1.479, 1.428, 1.076    | 12.326, 23.221, 15.700                           |
+| bun     | branch   |       3 | 54.822, 32.487, 39.635 | 28.558, 32.516, 60.522                           |
+| bun     | main     |       3 | 3.243, 2.143, 1.210    | 32.059, 31.021, 49.043                           |
+
+### Where the 20× comes from
+
+No frame is above 16% of the workload. Each run writes 57 records (1 metadata of 219 KB, 1 checkpoint, 31 deltas, 24 operations) and each of the 31 deltas pays a persisted snapshot, a redaction walk, history compaction, a structural diff, a record redaction, a capture and the host's JSON copy: roughly 0.3–0.5 ms per delta on Node. Main writes nothing. Reaching 2× (about 2.9 ms) needs fewer journal writes per round or a much cheaper per-write path, not another frame-level cut; both change the record stream that `test/run-log-golden-bytes.ts` pins.