@hecer/yoke 1.18.0 → 1.20.0

package/bench/RESULTS.md

@@ -1,11 +1,41 @@
 # Benchmark results
 
+The [1.20.0 parallel acceptance smoke](results/parallel-validation-2026-09-30.json)
+accepted all three independent stories and passed all 15 immutable replay tests after
+the runtime claim exclusion fix. Its single corrected run took 112,949 ms. This is
+validation of the corrected fixture, not a new A/B efficiency comparison; the dated
+1.19.0 comparisons below remain historical. See the
+[release validation report](../docs/RELEASE-VALIDATION-1.20.0.md) for limits.
+
 Result schema v1 records fixture version, sample label, permission profile, telemetry/model
 availability, verdict/blocker, conflicts, wall time, iterations, and final fixture-test status.
 
 Fixture `string-kit` (3 stories, 16 pre-written assertions). Methodology and caveats:
 [README.md](README.md). One row per run — raw JSON in [`results/`](results/).
 
+## Direct Codex comparison and integration audit (2026-09-29)
+
+Authenticated comparison of Yoke 1.19.0 against direct Codex, requesting the same
+`gpt-6.1-sol / low` model and effort with routing and native delegation disabled.
+Two alternating queue pairs passed the same ten original tests: median elapsed time
+was **118.3 seconds for direct Codex** and **274.9 seconds for Yoke serial**.
+Yoke used **91.9% more fresh input tokens** in this small sample.
+
+One corrected independent-task run per arm passed all fifteen original tests for
+direct Codex (71.3 seconds) and Yoke serial (442.2 seconds). Yoke parallel used three
+workers but accepted **0/3 stories**: integration gates lost the worker's
+`YOKE_STORY` context. Its 117.1-second failure is **not** a speedup.
+The deterministic control probe reproduced this integration defect separately
+from provider calls. Initial fixture setup/path failures are retained as diagnostics.
+
+These measurements do not establish general superiority, USD cost, CPU/RAM savings,
+or routing benefits. Host skills/plugins were not fully audited and background load
+was uncontrolled. See [the complete comparison](../docs/CODEX-COMPARISON-2026-09-29.md),
+[Goals/resource findings](../docs/GOALS-RESOURCE-AUDIT-2026-09-29.md), and the separately
+formatted [comparison summary](results/codex-comparison-2026-09-29.json) and
+[integration diagnostics](results/goal-integration-probes-2026-09-29.json).
+These two aggregate audit artifacts are not individual result-schema-v1 run records.
+
 ## Synthetic dispatcher matrix (2026-09-27)
 
 One local run of `node bench/run-parallel-matrix.mjs` after the shared integration pipeline was

package/bench/analyze-codex-comparison.mjs

@@ -0,0 +1,22 @@
+// node bench/analyze-codex-comparison.mjs <results.json> ... > summary.json
+import { readFileSync } from 'node:fs'
+const sources = process.argv.slice(2).map(path => JSON.parse(readFileSync(path, 'utf8')))
+if (!sources.length) throw new Error('Supply comparison results.json files')
+const rows = sources.flatMap(s => s.results).map(({ dir, ...row }) => ({
+  ...row,
+  freshInputTokens: Number.isFinite(row.usage?.inputTokens) && Number.isFinite(row.usage?.cachedInputTokens)
+    ? row.usage.inputTokens - row.usage.cachedInputTokens : null,
+}))
+if (!rows.length) throw new Error('No completed runs')
+for (const row of rows) if (!Number.isFinite(row.wallMs) || row.wallMs <= 0 || (row.freshInputTokens !== null && row.freshInputTokens < 0)) throw new Error('Invalid measurement')
+const median = values => { const sorted = [...values].sort((a,b) => a-b); const n = sorted.length; return n ? (sorted[Math.floor((n-1)/2)] + sorted[Math.floor(n/2)]) / 2 : null }
+const groups = [...new Set(rows.map(r => `${r.fixture}:${r.arm}`))].map(key => {
+  const runs = rows.filter(r => `${r.fixture}:${r.arm}` === key)
+  if (new Set(runs.map(r => `${r.model}:${r.effort}:${r.routing}`)).size !== 1) throw new Error('Incompatible execution policies in one comparison group')
+  return { fixture: runs[0].fixture, arm: runs[0].arm, runs: runs.length, accepted: runs.filter(r => r.accepted).length,
+    medianWallMs: median(runs.map(r => r.wallMs)),
+    medianFreshInputTokens: runs.every(r => r.freshInputTokens !== null) ? median(runs.map(r => r.freshInputTokens)) : null,
+    medianOutputTokens: runs.every(r => Number.isFinite(r.usage?.outputTokens)) ? median(runs.map(r => r.usage.outputTokens)) : null,
+    medianAllInputTokens: runs.every(r => Number.isFinite(r.usage?.inputTokens)) ? median(runs.map(r => r.usage.inputTokens)) : null }
+})
+console.log(JSON.stringify({ auditedVersion: '1.19.0', auditedCommit: '05fac3db1a51412563005e07f80e6e5a9aab8e06', models: [...new Set(rows.map(r => r.model))], effort: 'low', groups, runs: rows, limitations: [...new Set(sources.flatMap(s => s.limits))], pricesMeasured: false, cpuMeasured: false, memoryMeasured: false }, null, 2))

package/bench/compare-codex.mjs

@@ -0,0 +1,71 @@
+// Controlled live comparison. Run after npm run build.
+// node bench/compare-codex.mjs --repeats=2 --fixture=routing-queue
+import { cpSync, mkdirSync, readFileSync, writeFileSync, readdirSync } from 'node:fs'
+import { createHash } from 'node:crypto'
+import { spawn, spawnSync } from 'node:child_process'
+import { dirname, join, resolve } from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { parse, stringify } from 'yaml'
+import { buildProviderInvocation, startProviderProcess } from '../dist/agents/providers.js'
+const repo = dirname(dirname(fileURLToPath(import.meta.url)))
+const version = JSON.parse(readFileSync(join(repo, 'package.json'), 'utf8')).version
+const opts = Object.fromEntries(process.argv.slice(2).map(x => x.replace(/^--/, '').split('=')))
+const fixture = opts.fixture ?? 'routing-queue'
+if (!['routing-queue', 'string-kit', 'independent-utils'].includes(fixture)) throw new Error('Unsupported fixture')
+const repeats = Number(opts.repeats ?? 2)
+if (!Number.isInteger(repeats) || repeats < 1 || repeats > 10) throw new Error('repeats must be 1..10')
+const model = opts.model ?? 'gpt-6.1-sol'
+const root = resolve(opts.root ?? `G:/NN-Developed/Yoke-Testground/b${Date.now().toString(36)}`)
+mkdirSync(root, { recursive: true })
+const seed = join(repo, 'bench', 'fixtures', fixture)
+const stories = parse(readFileSync(join(seed, '.yoke/prd.yaml'), 'utf8'))
+const originalTests = readdirSync(join(seed, 'tests')).filter(f => f.endsWith('.test.mjs')).sort()
+const protectedFiles = new Map(['bench-verify.mjs', ...originalTests.map(f => join('tests', f))].map(file => [file, readFileSync(join(seed, file))]))
+const acceptanceDigest = createHash('sha256').update(Buffer.concat([...protectedFiles].flatMap(([file, bytes]) => [Buffer.from(file + '\0'), bytes]))).digest('hex')
+const prompt = 'Implement all requirements below. Run node bench-verify.mjs. Preserve tests and the verification script. Do not commit.\n' + stories.map(s => `${s.id}: ${s.title}\n${s.acceptance.join('\n')}`).join('\n\n')
+const results = []
+const requestedArms = opts.arms?.split(',')
+if (requestedArms && (!requestedArms.length || requestedArms.some(arm => !['codex', 'yoke-serial', 'yoke-parallel'].includes(arm)))) throw new Error('arms must name codex,yoke-serial,yoke-parallel')
+for (let repeat = 0; repeat < repeats; repeat++) {
+  const baseArms = fixture === 'independent-utils' ? ['codex', 'yoke-serial', 'yoke-parallel'] : ['codex', 'yoke-serial']
+  const selectedArms = requestedArms ? baseArms.filter(arm => requestedArms.includes(arm)) : baseArms
+  if (!selectedArms.length) throw new Error('No requested arms apply to this fixture')
+  const arms = repeat % 2 ? [...selectedArms].reverse() : selectedArms
+  for (const arm of arms) {
+    const dir = join(root, `${repeat + 1}-${arm}`)
+    mkdirSync(dir); cpSync(seed, dir, { recursive: true })
+    const parallel = arm === 'yoke-parallel' ? 3 : 1
+    writeFileSync(join(dir, '.yoke/config.yaml'), stringify({ canonVersion: '1.2.0', agents: ['codex'], loop: { enabled: true, parallel, isolate: true }, runner: { agent: 'codex', model, reasoningEffort: 'low', bare: true }, routing: { enabled: false }, verify: { command: 'node bench-verify.mjs' } }))
+    for (const args of [['init', '-q'], ['add', '-A'], ['-c', 'user.name=benchmark', '-c', 'user.email=benchmark@yoke.local', 'commit', '-qm', 'Immutable fixture seed']]) {
+      const r = spawnSync('git', args, { cwd: dir, encoding: 'utf8' }); if (r.status !== 0) throw new Error(r.stderr)
+    }
+    console.log(JSON.stringify({ type: 'start', fixture, repeat: repeat + 1, arm, model, dir }))
+    const start = Date.now(); let outcome; let events = []; let usage
+    if (arm === 'codex') {
+      const inv = buildProviderInvocation('codex', prompt, dir, 'unsafe', { model, reasoningEffort: 'low', bare: true, nativeMultiAgent: false })
+      inv.args.push('--ignore-rules')
+      const controller = new AbortController(); const timer = setTimeout(() => controller.abort(), 600_000)
+      try {
+        const r = await startProviderProcess('codex', inv, { signal: controller.signal, idleTimeoutMs: 180_000 }).completion
+        outcome = r.kind; usage = r.telemetry.tokens
+        writeFileSync(join(root, `${fixture}-${repeat + 1}-${arm}.log`), JSON.stringify(r, null, 2))
+      } finally { clearTimeout(timer) }
+    } else {
+      const child = spawn(process.execPath, [join(repo, 'dist/cli.js'), 'loop', 'run', dir, '--json', '--runner=codex', '--no-routing', `--parallel=${parallel}`, '--max=3', '--timeout=10', '--unsafe'], { cwd: dir, env: { ...process.env, LOCALAPPDATA: join(root, 'state') }, stdio: ['ignore', 'pipe', 'pipe'] })
+      let output = '', errors = ''; child.stdout.on('data', d => { output += d }); child.stderr.on('data', d => { errors += d })
+      outcome = await new Promise((res, rej) => { child.on('error', rej); child.on('close', res) })
+      events = output.split('\n').flatMap(line => { try { return [JSON.parse(line)] } catch { return [] } })
+      writeFileSync(join(root, `${fixture}-${repeat + 1}-${arm}.log`), output + '\nSTDERR\n' + errors)
+      usage = events.filter(e => e.type === 'status' && e.tokens).at(-1)?.tokens
+    }
+    const wallMs = Date.now() - start
+    // Replay immutable originals after the agent exits. Agent-written tests never determine quality.
+    mkdirSync(join(dir, 'tests'), { recursive: true })
+    for (const [file, bytes] of protectedFiles) writeFileSync(join(dir, file), bytes)
+    const testFiles = originalTests.map(f => join('tests', f))
+    const checkStart = Date.now(); const check = spawnSync(process.execPath, ['--test', ...testFiles], { cwd: dir, encoding: 'utf8', timeout: 60_000 })
+    writeFileSync(join(root, `${fixture}-${repeat + 1}-${arm}.acceptance.log`), check.stdout + check.stderr)
+    const result = { fixture, repeat: repeat + 1, arm, model, effort: 'low', routing: false, nativeMultiAgent: false, parallel, acceptanceDigest, wallMs, acceptanceMs: Date.now() - checkStart, accepted: check.status === 0, outcome, usage: usage ?? null, events: events.length, dir }
+    results.push(result); writeFileSync(join(root, 'results.json'), JSON.stringify({ version, root, results, limits: ['Small fixture sample; not representative of production projects', 'CPU and RAM not measured', 'Routing disabled; fixed model and effort', 'Immutable tests replayed after execution; not hidden from agents', 'User config disabled; not an audit of every installed plugin'] }, null, 2)); console.log(JSON.stringify({ type: 'result', ...result }))
+  }
+}

package/bench/fixtures/independent-utils/.yoke/prd.yaml

@@ -0,0 +1,30 @@
+- id: STORY-1
+  title: Stable unique values
+  priority: 1
+  writes: [src/unique.mjs]
+  needs: []
+  acceptance:
+    - Export unique(values) from src/unique.mjs, returning first occurrences in input order using SameValueZero equality.
+    - Never mutate the input. Non-array input throws TypeError. Preserve object identity.
+    - node bench-verify.mjs exits 0
+  passes: false
+- id: STORY-2
+  title: Array chunking
+  priority: 2
+  writes: [src/chunk.mjs]
+  needs: []
+  acceptance:
+    - Export chunk(values,size) from src/chunk.mjs. Split arrays into consecutive new arrays of at most size elements.
+    - An empty input returns an empty array. Never mutate the input. Non-array input throws TypeError; size must be a positive integer or throw RangeError.
+    - node bench-verify.mjs exits 0
+  passes: false
+- id: STORY-3
+  title: Numeric range
+  priority: 3
+  writes: [src/range.mjs]
+  needs: []
+  acceptance:
+    - Export range(start,end,step=1) from src/range.mjs. Generate start-inclusive, end-exclusive numbers with a positive or negative step.
+    - A step pointing away from end returns an empty array. Zero step or any non-finite argument throws RangeError. Equal endpoints return an empty array.
+    - node bench-verify.mjs exits 0
+  passes: false

package/bench/fixtures/independent-utils/bench-verify.mjs

@@ -0,0 +1,4 @@
+import { spawnSync } from 'node:child_process'
+const ids = process.env.YOKE_STORY ? [process.env.YOKE_STORY] : ['STORY-1', 'STORY-2', 'STORY-3']
+const r = spawnSync(process.execPath, ['--test', ...ids.map(id => `tests/${id}.test.mjs`)], { stdio: 'inherit' })
+process.exit(r.status ?? 1)

package/bench/fixtures/independent-utils/package.json

@@ -0,0 +1 @@
+{"name":"yoke-independent-utils-benchmark","private":true,"type":"module","scripts":{"test":"node bench-verify.mjs"}}

package/bench/fixtures/independent-utils/src/chunk.mjs

@@ -0,0 +1 @@
+export function chunk() { throw new Error('Not implemented') }

package/bench/fixtures/independent-utils/src/range.mjs

@@ -0,0 +1 @@
+export function range() { throw new Error('Not implemented') }

package/bench/fixtures/independent-utils/src/unique.mjs

@@ -0,0 +1 @@
+export function unique() { throw new Error('Not implemented') }

package/bench/fixtures/independent-utils/tests/STORY-1.test.mjs

@@ -0,0 +1,8 @@
+import { test } from 'node:test'
+import assert from 'node:assert/strict'
+import { unique } from '../src/unique.mjs'
+test('deduplicates in order', () => assert.deepEqual(unique([2,1,2,3,1]), [2,1,3]))
+test('empty', () => assert.deepEqual(unique([]), []))
+test('SameValueZero', () => assert.deepEqual(unique([NaN,NaN,0,-0]), [NaN,0]))
+test('identity and immutable input', () => { const a = {}; const b = {}; const input = Object.freeze([a,b,a]); assert.deepEqual(unique(input), [a,b]) })
+test('invalid input', () => assert.throws(() => unique('abc'), TypeError))

package/bench/fixtures/independent-utils/tests/STORY-2.test.mjs

@@ -0,0 +1,8 @@
+import { test } from 'node:test'
+import assert from 'node:assert/strict'
+import { chunk } from '../src/chunk.mjs'
+test('consecutive chunks', () => assert.deepEqual(chunk([1,2,3,4,5],2), [[1,2],[3,4],[5]]))
+test('empty', () => assert.deepEqual(chunk([],2), []))
+test('large size', () => assert.deepEqual(chunk([1,2],9), [[1,2]]))
+test('immutable input and new arrays', () => { const input = Object.freeze([1,2]); assert.notEqual(chunk(input,2)[0], input) })
+test('invalid input and size', () => { assert.throws(() => chunk('abc',2), TypeError); for (const size of [0,-1,1.5,NaN,Infinity]) assert.throws(() => chunk([],size), RangeError) })

package/bench/fixtures/independent-utils/tests/STORY-3.test.mjs

@@ -0,0 +1,8 @@
+import { test } from 'node:test'
+import assert from 'node:assert/strict'
+import { range } from '../src/range.mjs'
+test('ascending', () => assert.deepEqual(range(1,5), [1,2,3,4]))
+test('descending', () => assert.deepEqual(range(5,0,-2), [5,3,1]))
+test('fractional', () => assert.deepEqual(range(0,1,0.25), [0,0.25,0.5,0.75]))
+test('empty', () => { assert.deepEqual(range(1,1), []); assert.deepEqual(range(1,5,-1), []); assert.deepEqual(range(5,1,1), []) })
+test('invalid numbers', () => { for (const args of [[0,1,0],[NaN,1],[0,Infinity],[0,1,Infinity]]) assert.throws(() => range(...args), RangeError) })

package/bench/probe-goal-integration.mjs

@@ -0,0 +1,93 @@
+// Read-only protocol capability probe plus disposable local goal resource test.
+import { spawn } from 'node:child_process'
+import { join, resolve } from 'node:path'
+import { existsSync, mkdirSync, writeFileSync } from 'node:fs'
+import { createProjectGoal, runProjectGoal } from '../dist/goals/command.js'
+import { acquireSharedWorker, sharedPoolStatus } from '../dist/loop/resource-pool.js'
+const root = resolve(process.argv[2] ?? `G:/NN-Developed/Yoke-Testground/goal-probe-${Date.now()}`)
+mkdirSync(join(root, '.yoke'), { recursive: true })
+process.env.LOCALAPPDATA = join(root, 'isolated-state')
+process.env.YOKE_MAX_PARALLEL_WORKERS = '1'
+process.env.YOKE_STATE_DIR = join(root, 'yoke-state')
+writeFileSync(join(root, '.yoke/acceptance.yaml'), 'version: 1\nprotected: [test.mjs]\ncriteria:\n- id: outcome\n  text: Expected outcome\n  commands: [node test.mjs]\n')
+writeFileSync(join(root, 'test.mjs'), 'import {existsSync} from "node:fs"; process.exit(existsSync("implemented.txt") ? 0 : 1)')
+createProjectGoal(root, 'Disposable test goal', { acceptanceIds: ['outcome'] })
+const lease = await acquireSharedWorker({ targetDir: root, storyId: 'occupied', provider: 'codex', role: 'implementation' })
+let executedWhilePoolFull = false, occupiedPermitHeld = true
+let goal, queuedWhilePoolFull = false
+try {
+  const running = runProjectGoal(root, { execute: async () => {
+    const pool = sharedPoolStatus(); executedWhilePoolFull = occupiedPermitHeld && pool.activeUnits === pool.limit
+    writeFileSync(join(root, 'implemented.txt'), 'done')
+    return { success: true, summary: 'Fake executor for mechanical pool test', inputTokens: 1, outputTokens: 1 }
+  } })
+  // Admission is asynchronous. Release the occupied provider permit only after
+  // the goal has completed its independent check and queued for implementation.
+  const deadline = Date.now() + 15_000
+  while (Date.now() < deadline) {
+    if (sharedPoolStatus().waitingWorkers > 0) { queuedWhilePoolFull = true; break }
+    await new Promise(resolve => setTimeout(resolve, 100))
+  }
+  occupiedPermitHeld = false
+  await lease.release()
+  goal = await running
+} finally { await lease.release() }
+const findings = { poolProbe: { fakeExecutor: true, limit: 1, queuedWhilePoolFull, executedWhilePoolFull, goalStatus: goal.status }, protocol: [] }
+// A successful implementation that overshoots budget must remain blocked.
+const budgetRoot = join(root, 'budget-probe'); mkdirSync(join(budgetRoot, '.yoke'), { recursive: true })
+writeFileSync(join(budgetRoot, '.yoke/acceptance.yaml'), 'version: 1\nprotected: [test.mjs]\ncriteria:\n- id: outcome\n  text: Expected outcome\n  commands: [node test.mjs]\n')
+writeFileSync(join(budgetRoot, 'test.mjs'), 'import {existsSync} from "node:fs"; await new Promise(r=>setTimeout(r,120)); process.exit(existsSync("implemented.txt") ? 0 : 1)')
+createProjectGoal(budgetRoot, 'Disposable budget test', { acceptanceIds: ['outcome'], tokenBudget: 1, maxMinutes: 0.001 })
+const budgetStart = Date.now()
+const budgetGoal = await runProjectGoal(budgetRoot, { execute: async () => {
+  writeFileSync(join(budgetRoot, 'implemented.txt'), 'done')
+  return { success: true, summary: 'Fake executor reporting 100 tokens', inputTokens: 90, outputTokens: 10 }
+} })
+findings.budgetProbe = { fakeExecutor: true, tokenBudget: 1, measuredTokens: 100, timeBudgetMs: 60, totalWallMs: Date.now() - budgetStart, recordedAgentMs: budgetGoal.attempts[0]?.durationMs, status: budgetGoal.status }
+const objectiveRoot = join(root, 'objective-probe'); mkdirSync(join(objectiveRoot, '.yoke'), { recursive: true })
+writeFileSync(join(objectiveRoot, '.yoke/acceptance.yaml'), 'version: 1\nprotected: [test.mjs]\ncriteria:\n- id: old-feature\n  text: Existing feature still works\n  commands: [node test.mjs]\n')
+writeFileSync(join(objectiveRoot, 'test.mjs'), 'import {existsSync} from "node:fs"; process.exit(existsSync("old-feature.txt") ? 0 : 1)')
+writeFileSync(join(objectiveRoot, 'old-feature.txt'), 'already implemented')
+createProjectGoal(objectiveRoot, 'Implement the new feature by creating new-feature.txt')
+let objectiveExecutorCalled = false
+const objectiveGoal = await runProjectGoal(objectiveRoot, { execute: async () => { objectiveExecutorCalled = true; return { success: false, summary: 'Should need implementation' } } })
+findings.objectiveProbe = { requestedArtifact: 'new-feature.txt', requestedArtifactExists: existsSync(join(objectiveRoot, 'new-feature.txt')), acceptance: 'only checks old-feature.txt; intentionally unbound objective', executorCalled: objectiveExecutorCalled, attempts: objectiveGoal.attempts.length, status: objectiveGoal.status }
+const cli = join(process.env.APPDATA, 'npm/node_modules/@openai/codex/bin/codex.js')
+const child = spawn(process.execPath, [cli, 'app-server', '--stdio', '--enable', 'goals'], { cwd: root, stdio: ['pipe', 'pipe', 'pipe'] })
+let next = 1, buffer = '', errorText = ''; const pending = new Map()
+child.stderr.on('data', d => { errorText += d })
+child.stdout.on('data', data => {
+  buffer += data
+  while (buffer.includes('\n')) {
+    const i = buffer.indexOf('\n'), line = buffer.slice(0, i); buffer = buffer.slice(i + 1)
+    try { const message = JSON.parse(line); if (pending.has(message.id)) { const p = pending.get(message.id); pending.delete(message.id); message.error ? p.reject(new Error(JSON.stringify(message.error))) : p.resolve(message.result) } } catch {}
+  }
+})
+function rpc(method, params) {
+  return new Promise((resolve, reject) => {
+    const id = next++; const timer = setTimeout(() => { pending.delete(id); reject(new Error(`Timeout: ${method}`)) }, 30_000)
+    pending.set(id, { resolve: result => { clearTimeout(timer); resolve(result) }, reject: error => { clearTimeout(timer); reject(error) } })
+    child.stdin.write(JSON.stringify({ id, method, params }) + '\n')
+  })
+}
+try {
+  await rpc('initialize', { clientInfo: { name: 'yoke-goals-probe', version: '1.0.0' }, capabilities: { experimentalApi: true } })
+  child.stdin.write(JSON.stringify({ method: 'initialized' }) + '\n')
+  const start = await rpc('thread/start', { cwd: root, model: 'gpt-6.1-sol', approvalPolicy: 'never', sandbox: 'read-only' })
+  const threadId = start.thread.id
+  for (const [method, params] of [
+    ['thread/goal/set', { threadId, objective: 'Protocol-only goal: no development turn requested', tokenBudget: 1000 }],
+    ['thread/goal/get', { threadId }],
+    ['thread/goal/set', { threadId, status: 'paused' }],
+    ['thread/goal/get', { threadId }],
+    ['thread/goal/clear', { threadId }],
+    ['thread/goal/get', { threadId }],
+  ]) {
+    const result = await rpc(method, params); findings.protocol.push({ method, requestedStatus: params.status ?? null, result })
+  }
+  await rpc('thread/archive', { threadId })
+} catch (error) { findings.protocolError = error.message; findings.stderrTail = errorText.slice(-2000) }
+finally { child.stdin.end(); child.kill() }
+writeFileSync(join(root, 'findings.json'), JSON.stringify(findings, null, 2))
+console.log(JSON.stringify(findings, null, 2))
+if (findings.protocolError) process.exitCode = 1

package/bench/probe-parallel-gate-context.mjs

@@ -0,0 +1,29 @@
+// Diagnostic using fake agents/Git adapters, exercising the real loop and dispatcher.
+import { cpSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs'
+import { join, resolve } from 'node:path'
+import { runLoopCommand } from '../dist/loop/run-command.js'
+import { saveConfig } from '../dist/retrofit/config.js'
+import { loadPrd, savePrd } from '../dist/loop/prd.js'
+const base = resolve(process.argv[2] ?? `G:/NN-Developed/Yoke-Testground/p${Date.now().toString(36)}`)
+process.env.LOCALAPPDATA = join(base, 'state')
+const findings = []
+for (const requiresStoryContext of [false, true]) {
+  const root = join(base, requiresStoryContext ? 'scoped' : 'control'); mkdirSync(join(root, '.yoke'), { recursive: true })
+  saveConfig(root, { canonVersion: 'test', agents: ['codex'], loop: { enabled: true }, verify: { command: 'node test.mjs' } })
+  savePrd(join(root, '.yoke/prd.yaml'), ['A','B','C'].map((id, index) => ({ id, title: id, priority: index + 1, acceptance: ['Expected result'], writes: [`src/${id}`], passes: false })))
+  const observedContexts = []
+  const code = await runLoopCommand(root, { parallel: 3, maxIterations: 3, quiet: true,
+    runner: () => ({ success: true, summary: 'Fake agent completed' }), isAvailable: () => true,
+    verify: () => { const context = process.env.YOKE_STORY ?? null; observedContexts.push(context); return { passed: !requiresStoryContext || ['A','B','C'].includes(context), summary: context ? 'Story-scoped verification passed' : 'Missing YOKE_STORY context' } },
+    git: { isClean: () => true, commitAll: () => undefined,
+      addWorktree: (_target, worktree) => { mkdirSync(join(worktree, '.yoke'), { recursive: true }); cpSync(join(root, '.yoke/prd.yaml'), join(worktree, '.yoke/prd.yaml')) },
+      // Retain disposable directories for inspection; no recursive deletion.
+      removeWorktree: () => undefined,
+      integrate: (_target, worktree) => savePrd(join(root, '.yoke/prd.yaml'), loadPrd(join(worktree, '.yoke/prd.yaml'))),
+    },
+  })
+  findings.push({ fakeAgentsAndGit: true, requiresStoryContext, exitCode: code, observedContexts, acceptedStories: loadPrd(join(root, '.yoke/prd.yaml')).filter(s => s.passes).length })
+}
+writeFileSync(join(base, 'findings.json'), JSON.stringify(findings, null, 2))
+console.log(JSON.stringify(findings, null, 2))
+if (findings.some(row => row.exitCode !== 0 || row.acceptedStories !== 3 || row.observedContexts.includes(null))) process.exitCode = 1

package/bench/results/codex-comparison-2026-09-29.json

@@ -0,0 +1,305 @@
+{
+  "auditedVersion": "1.19.0",
+  "auditedCommit": "05fac3db1a51412563005e07f80e6e5a9aab8e06",
+  "models": [
+    "gpt-6.1-sol"
+  ],
+  "effort": "low",
+  "groups": [
+    {
+      "fixture": "routing-queue",
+      "arm": "codex",
+      "runs": 2,
+      "accepted": 2,
+      "medianWallMs": 118278.5,
+      "medianFreshInputTokens": 25292,
+      "medianOutputTokens": 2162,
+      "medianAllInputTokens": 137548
+    },
+    {
+      "fixture": "routing-queue",
+      "arm": "yoke-serial",
+      "runs": 2,
+      "accepted": 2,
+      "medianWallMs": 274943.5,
+      "medianFreshInputTokens": 48524,
+      "medianOutputTokens": 4822,
+      "medianAllInputTokens": 396300
+    },
+    {
+      "fixture": "independent-utils",
+      "arm": "codex",
+      "runs": 1,
+      "accepted": 1,
+      "medianWallMs": 71283,
+      "medianFreshInputTokens": 10263,
+      "medianOutputTokens": 797,
+      "medianAllInputTokens": 84503
+    },
+    {
+      "fixture": "independent-utils",
+      "arm": "yoke-serial",
+      "runs": 1,
+      "accepted": 1,
+      "medianWallMs": 442189,
+      "medianFreshInputTokens": 92330,
+      "medianOutputTokens": 3905,
+      "medianAllInputTokens": 626986
+    },
+    {
+      "fixture": "independent-utils",
+      "arm": "yoke-parallel",
+      "runs": 1,
+      "accepted": 0,
+      "medianWallMs": 117101,
+      "medianFreshInputTokens": 81497,
+      "medianOutputTokens": 3487,
+      "medianAllInputTokens": 481753
+    }
+  ],
+  "runs": [
+    {
+      "fixture": "routing-queue",
+      "repeat": 1,
+      "arm": "codex",
+      "model": "gpt-6.1-sol",
+      "effort": "low",
+      "routing": false,
+      "nativeMultiAgent": false,
+      "wallMs": 112482,
+      "acceptanceMs": 175,
+      "accepted": true,
+      "outcome": "succeeded",
+      "usage": {
+        "inputTokens": 158620,
+        "cachedInputTokens": 121984,
+        "cacheWriteInputTokens": 0,
+        "outputTokens": 2190,
+        "reasoningOutputTokens": 18
+      },
+      "events": 0,
+      "freshInputTokens": 36636
+    },
+    {
+      "fixture": "routing-queue",
+      "repeat": 1,
+      "arm": "yoke-serial",
+      "model": "gpt-6.1-sol",
+      "effort": "low",
+      "routing": false,
+      "nativeMultiAgent": false,
+      "wallMs": 273000,
+      "acceptanceMs": 173,
+      "accepted": true,
+      "outcome": 0,
+      "usage": {
+        "inputTokens": 383543,
+        "cachedInputTokens": 334720,
+        "cacheWriteInputTokens": 0,
+        "outputTokens": 4924,
+        "reasoningOutputTokens": 104
+      },
+      "events": 11,
+      "freshInputTokens": 48823
+    },
+    {
+      "fixture": "routing-queue",
+      "repeat": 2,
+      "arm": "yoke-serial",
+      "model": "gpt-6.1-sol",
+      "effort": "low",
+      "routing": false,
+      "nativeMultiAgent": false,
+      "wallMs": 276887,
+      "acceptanceMs": 169,
+      "accepted": true,
+      "outcome": 0,
+      "usage": {
+        "inputTokens": 409057,
+        "cachedInputTokens": 360832,
+        "cacheWriteInputTokens": 0,
+        "outputTokens": 4720,
+        "reasoningOutputTokens": 81
+      },
+      "events": 11,
+      "freshInputTokens": 48225
+    },
+    {
+      "fixture": "routing-queue",
+      "repeat": 2,
+      "arm": "codex",
+      "model": "gpt-6.1-sol",
+      "effort": "low",
+      "routing": false,
+      "nativeMultiAgent": false,
+      "wallMs": 124075,
+      "acceptanceMs": 409,
+      "accepted": true,
+      "outcome": "succeeded",
+      "usage": {
+        "inputTokens": 116476,
+        "cachedInputTokens": 102528,
+        "cacheWriteInputTokens": 0,
+        "outputTokens": 2134,
+        "reasoningOutputTokens": 28
+      },
+      "events": 0,
+      "freshInputTokens": 13948
+    },
+    {
+      "fixture": "independent-utils",
+      "repeat": 1,
+      "arm": "codex",
+      "model": "gpt-6.1-sol",
+      "effort": "low",
+      "routing": false,
+      "nativeMultiAgent": false,
+      "parallel": 1,
+      "acceptanceDigest": "3e9734e6d286b7c9d19e6ce473eea17e1adf9e30a6ee8927c7240170602f14f7",
+      "wallMs": 71283,
+      "acceptanceMs": 354,
+      "accepted": true,
+      "outcome": "succeeded",
+      "usage": {
+        "inputTokens": 84503,
+        "cachedInputTokens": 74240,
+        "cacheWriteInputTokens": 0,
+        "outputTokens": 797,
+        "reasoningOutputTokens": 7
+      },
+      "events": 0,
+      "freshInputTokens": 10263
+    },
+    {
+      "fixture": "independent-utils",
+      "repeat": 1,
+      "arm": "yoke-serial",
+      "model": "gpt-6.1-sol",
+      "effort": "low",
+      "routing": false,
+      "nativeMultiAgent": false,
+      "parallel": 1,
+      "acceptanceDigest": "3e9734e6d286b7c9d19e6ce473eea17e1adf9e30a6ee8927c7240170602f14f7",
+      "wallMs": 442189,
+      "acceptanceMs": 454,
+      "accepted": true,
+      "outcome": 0,
+      "usage": {
+        "inputTokens": 626986,
+        "cachedInputTokens": 534656,
+        "cacheWriteInputTokens": 0,
+        "outputTokens": 3905,
+        "reasoningOutputTokens": 60
+      },
+      "events": 16,
+      "freshInputTokens": 92330
+    },
+    {
+      "fixture": "independent-utils",
+      "repeat": 1,
+      "arm": "yoke-parallel",
+      "model": "gpt-6.1-sol",
+      "effort": "low",
+      "routing": false,
+      "nativeMultiAgent": false,
+      "parallel": 3,
+      "acceptanceDigest": "3e9734e6d286b7c9d19e6ce473eea17e1adf9e30a6ee8927c7240170602f14f7",
+      "wallMs": 117101,
+      "acceptanceMs": 306,
+      "accepted": false,
+      "outcome": 1,
+      "usage": {
+        "inputTokens": 481753,
+        "cachedInputTokens": 400256,
+        "cacheWriteInputTokens": 0,
+        "outputTokens": 3487,
+        "reasoningOutputTokens": 72
+      },
+      "events": 22,
+      "freshInputTokens": 81497
+    }
+  ],
+  "limitations": [
+    "Small fixture sample; not representative of production projects",
+    "CPU and RAM not measured",
+    "Immutable tests replayed after execution; not hidden from agents",
+    "User config disabled; not an audit of every installed plugin",
+    "Routing disabled; fixed model and effort",
+    "Queue fixture: two alternating pairs; independent fixture: one sample per arm",
+    "Single Windows machine; uncontrolled background load",
+    "Failed parallel run is not an accepted speedup",
+    "No causal A/B test isolating context startup, worktree or verification overhead"
+  ],
+  "pricesMeasured": false,
+  "cpuMeasured": false,
+  "memoryMeasured": false,
+  "date": "2026-09-29",
+  "setupDiagnostics": [
+    {
+      "fixture": "independent-utils",
+      "repeat": 1,
+      "arm": "codex",
+      "model": "gpt-6.1-sol",
+      "effort": "low",
+      "routing": false,
+      "nativeMultiAgent": false,
+      "parallel": 1,
+      "wallMs": 75037,
+      "acceptanceMs": 352,
+      "accepted": true,
+      "outcome": "succeeded",
+      "usage": {
+        "inputTokens": 86851,
+        "cachedInputTokens": 75520,
+        "cacheWriteInputTokens": 0,
+        "outputTokens": 1013,
+        "reasoningOutputTokens": 37
+      },
+      "events": 0,
+      "diagnosticOnly": true,
+      "exclusionReason": "Initial fixture lacked runtime ignore rules; not grouped with corrected fixture"
+    },
+    {
+      "fixture": "independent-utils",
+      "repeat": 1,
+      "arm": "yoke-serial",
+      "model": "gpt-6.1-sol",
+      "effort": "low",
+      "routing": false,
+      "nativeMultiAgent": false,
+      "parallel": 1,
+      "wallMs": 116055,
+      "acceptanceMs": 627,
+      "accepted": false,
+      "outcome": 1,
+      "usage": {
+        "inputTokens": 176111,
+        "cachedInputTokens": 147072,
+        "cacheWriteInputTokens": 0,
+        "outputTokens": 1317,
+        "reasoningOutputTokens": 26
+      },
+      "events": 6,
+      "diagnosticOnly": true,
+      "exclusionReason": "Initial fixture lacked runtime ignore rules; not grouped with corrected fixture"
+    },
+    {
+      "fixture": "independent-utils",
+      "repeat": 1,
+      "arm": "yoke-parallel",
+      "model": "gpt-6.1-sol",
+      "effort": "low",
+      "routing": false,
+      "nativeMultiAgent": false,
+      "parallel": 3,
+      "wallMs": 3555,
+      "acceptanceMs": 678,
+      "accepted": false,
+      "outcome": 1,
+      "usage": null,
+      "events": 0,
+      "diagnosticOnly": true,
+      "exclusionReason": "Git worktree path exceeded Windows limit before provider startup"
+    }
+  ]
+}