@hecer/yoke 1.1.0 → 1.2.0

package/bench/run-large.mjs

@@ -0,0 +1,188 @@
+#!/usr/bin/env node
+// Controlled routing A/B against a full repository snapshot kept outside this repo.
+import { spawn, spawnSync } from 'node:child_process'
+import { cpSync, existsSync, mkdirSync, readFileSync, readdirSync, rmSync, symlinkSync, writeFileSync } from 'node:fs'
+import { basename, dirname, join, resolve } from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { parse } from 'yaml'
+import { validateResult } from './result-schema.mjs'
+
+const benchDir = dirname(fileURLToPath(import.meta.url))
+const repoRoot = dirname(benchDir)
+const cli = join(repoRoot, 'dist', 'cli.js')
+const args = Object.fromEntries(process.argv.slice(2).filter(arg => arg.startsWith('--')).map(arg => {
+  const [key, ...value] = arg.slice(2).split('=')
+  return [key, value.length ? value.join('=') : true]
+}))
+
+const seed = args.seed ? resolve(String(args.seed)) : null
+const routing = String(args.routing ?? '')
+const runRoot = resolve(String(args['run-root'] ?? join(benchDir, '.runs')))
+if (!seed || !existsSync(seed) || !['on', 'off'].includes(routing)) {
+  console.error('usage: node bench/run-large.mjs --seed=<dir> --routing=<on|off> [--run-root=<dir>] [--max=4] [--timeout=15] [--label=note]')
+  process.exit(2)
+}
+
+let acceptanceManifest = null
+try { acceptanceManifest = JSON.parse(readFileSync(join(seed, 'bench-acceptance.json'), 'utf8')) } catch { /* legacy large seed */ }
+const stamp = new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19)
+const fixture = String(acceptanceManifest?.fixture ?? 'yoke-large')
+const fixtureVersion = String(acceptanceManifest?.fixtureVersion ?? 'yoke-large@1')
+const runDir = join(runRoot, `${fixture}-codex-routing-${routing}-${stamp}`)
+mkdirSync(runDir, { recursive: true })
+const excluded = new Set(['.git', 'node_modules', 'dist', '.worktrees'])
+cpSync(seed, runDir, {
+  recursive: true,
+  filter: source => source === seed || !excluded.has(basename(source)),
+})
+symlinkSync(join(repoRoot, 'node_modules'), join(runDir, 'node_modules'), 'junction')
+
+const git = (...gitArgs) => {
+  const result = spawnSync('git', ['-C', runDir, ...gitArgs], { encoding: 'utf8' })
+  if (result.status !== 0) throw new Error(`git ${gitArgs.join(' ')} failed: ${result.stderr}`)
+}
+git('init', '-q')
+git('-c', 'user.name=bench', '-c', 'user.email=bench@yoke', 'add', '-A')
+git('-c', 'user.name=bench', '-c', 'user.email=bench@yoke', 'commit', '-q', '-m', 'bench: full Yoke baseline')
+
+const env = {
+  ...process.env,
+  YOKE_NO_UPDATE_CHECK: '1',
+  YOKE_REGISTRY_DIR: join(runRoot, '.routing-registries', basename(runDir)),
+}
+for (const key of Object.keys(env)) if (key.startsWith('CLAUDE_CODE') || key === 'CLAUDECODE') delete env[key]
+
+const events = []
+const started = Date.now()
+console.error(`[bench-large] routing=${routing} -> ${runDir}`)
+const child = spawn(process.execPath, [
+  cli, 'loop', 'run', runDir, '--json', '--runner=codex',
+  `--max=${Number(args.max ?? 4)}`, `--timeout=${Number(args.timeout ?? 15)}`,
+  routing === 'on' ? '--routing' : '--no-routing', '--unsafe',
+], { env, stdio: ['ignore', 'pipe', 'inherit'] })
+let buffer = ''
+child.stdout.on('data', chunk => {
+  buffer += chunk
+  let newline
+  while ((newline = buffer.indexOf('\n')) >= 0) {
+    const line = buffer.slice(0, newline).trim()
+    buffer = buffer.slice(newline + 1)
+    if (!line) continue
+    try { events.push({ at: Date.now(), ...JSON.parse(line) }) } catch { /* provider noise is not evidence */ }
+  }
+})
+const exitCode = await new Promise(resolveExit => child.on('close', resolveExit))
+const wallClockMs = Date.now() - started
+
+const build = spawnSync(process.execPath, [join(repoRoot, 'node_modules', 'typescript', 'bin', 'tsc')], { cwd: runDir, env, encoding: 'utf8', timeout: 10 * 60_000 })
+const tests = spawnSync(process.execPath, [join(repoRoot, 'node_modules', 'vitest', 'vitest.mjs'), 'run'], { cwd: runDir, env, encoding: 'utf8', timeout: 10 * 60_000 })
+const hiddenTargets = acceptanceManifest?.acceptanceTests?.map(test => [String(test.source), String(test.hidden)]) ?? [
+  ['tests/routing/large-registry-status.test.ts', 'tests/routing/benchmark-original-status.test.ts'],
+  ['tests/routing/large-fallback.test.ts', 'tests/routing/benchmark-original-fallback.test.ts'],
+]
+for (const [source, target] of hiddenTargets) {
+  mkdirSync(dirname(join(runDir, target)), { recursive: true })
+  cpSync(join(seed, source), join(runDir, target))
+}
+const hiddenTests = spawnSync(process.execPath, [
+  join(repoRoot, 'node_modules', 'vitest', 'vitest.mjs'), 'run',
+  ...hiddenTargets.map(([, target]) => target), '--maxWorkers=1',
+], { cwd: runDir, env, encoding: 'utf8', timeout: 10 * 60_000 })
+for (const [, target] of hiddenTargets) rmSync(join(runDir, target), { force: true })
+const finalTestsPass = build.status === 0 && tests.status === 0 && hiddenTests.status === 0
+if (!finalTestsPass) {
+  console.error('[bench-large] independent final verification failed')
+  console.error(build.error ?? build.stderr ?? build.stdout)
+  console.error(tests.error ?? tests.stderr ?? tests.stdout)
+  console.error(hiddenTests.error ?? hiddenTests.stderr ?? hiddenTests.stdout)
+}
+
+const prd = parse(readFileSync(join(runDir, '.yoke', 'prd.yaml'), 'utf8'))
+const storyIds = Array.isArray(prd) ? prd.map(story => String(story.id)) : []
+const firstSeen = {}
+for (const event of events) if (event.story && !(event.story in firstSeen)) firstSeen[event.story] = event.at
+const stories = storyIds.map((id, index) => {
+  const start = firstSeen[id]
+  const next = storyIds.slice(index + 1).map(candidate => firstSeen[candidate]).find(value => value !== undefined)
+  return {
+    id,
+    durationMs: start === undefined ? null : (next ?? started + wallClockMs) - start,
+    iterations: new Set(events.filter(event => event.story === id).map(event => event.iteration)).size,
+    finalTestsPass,
+  }
+})
+const last = events.at(-1) ?? {}
+let status = {}
+try { status = JSON.parse(readFileSync(join(runDir, '.yoke', 'loop-status.json'), 'utf8')) } catch { /* early refusal */ }
+
+const sourceStats = root => {
+  let files = 0
+  let lines = 0
+  const walk = dir => {
+    for (const entry of readdirSync(dir, { withFileTypes: true })) {
+      const path = join(dir, entry.name)
+      if (entry.isDirectory()) walk(path)
+      else if (/\.(ts|js|mjs)$/.test(entry.name)) {
+        files++
+        lines += readFileSync(path, 'utf8').split(/\r?\n/).filter(line => line.trim()).length
+      }
+    }
+  }
+  walk(root)
+  return { files, lines }
+}
+const stats = sourceStats(join(runDir, 'src'))
+const config = parse(readFileSync(join(runDir, '.yoke', 'config.yaml'), 'utf8'))
+const inputTokens = Number(status.tokens?.inputTokens ?? 0)
+const cachedInputTokens = Number(status.tokens?.cachedInputTokens ?? 0)
+const testCount = Number((tests.stdout.match(/Tests\s+(\d+)\s+passed/) ?? [])[1] ?? 0) || null
+const result = {
+  schemaVersion: 1,
+  fixtureVersion,
+  runner: 'codex',
+  sampleLabel: String(args.label ?? `large-routing-${routing}`),
+  permissionProfile: 'unsafe',
+  yokeVersion: JSON.parse(readFileSync(join(repoRoot, 'package.json'), 'utf8')).version,
+  fixture,
+  routing,
+  startedAt: new Date(started).toISOString(),
+  wallClockMs,
+  exitCode,
+  finalState: last.state ?? null,
+  verdict: exitCode === 0 && finalTestsPass ? 'completed' : 'blocked',
+  blocker: exitCode === 0 && finalTestsPass ? null : (status.reason ?? 'loop or independent final verification failed'),
+  conflicts: events.filter(event => /conflict/i.test(String(event.reason ?? event.summary ?? ''))).length,
+  iterations: stories.reduce((sum, story) => sum + story.iterations, 0),
+  finalTestsPass,
+  progress: last.progress ?? null,
+  usageAvailable: Number(status.tokens?.inputTokens ?? 0) + Number(status.tokens?.outputTokens ?? 0) > 0,
+  modelAvailable: Boolean(status.tokens?.model || config?.runner?.model),
+  requestedParentModel: config?.runner?.model ?? null,
+  tokens: status.tokens ?? null,
+  modelCalls: status.tokens?.calls ?? [],
+  tokenBreakdown: status.tokens ? {
+    inputTokens,
+    cachedInputTokens,
+    freshInputTokens: Math.max(0, inputTokens - cachedInputTokens),
+    cacheWriteInputTokens: Number(status.tokens.cacheWriteInputTokens ?? 0),
+    outputTokens: Number(status.tokens.outputTokens ?? 0),
+    reasoningOutputTokens: Number(status.tokens.reasoningOutputTokens ?? 0),
+    ...(typeof status.tokens.totalCostUsd === 'number' ? { reportedCostUsd: status.tokens.totalCostUsd } : {}),
+  } : null,
+  stories,
+  srcLoc: stats.lines,
+  sourceFiles: stats.files,
+  finalVerification: {
+    buildExitCode: build.status,
+    testExitCode: tests.status,
+    finalTestCount: testCount,
+    originalAcceptanceTestsExitCode: hiddenTests.status,
+    originalAcceptanceTestCount: Number(acceptanceManifest?.acceptanceTestCount ?? 4),
+  },
+}
+validateResult(result)
+mkdirSync(join(benchDir, 'results'), { recursive: true })
+const output = join(benchDir, 'results', `${fixture}-codex-routing-${routing}-${stamp}.json`)
+writeFileSync(output, `${JSON.stringify(result, null, 2)}\n`)
+console.error(`[bench-large] done: ${output}`)
+console.log(JSON.stringify(result, null, 2))

package/bench/run.mjs

@@ -1,18 +1,19 @@
 #!/usr/bin/env node
 // Yoke benchmark harness.
 //
-//   node bench/run.mjs --runner=claude [--max=6] [--timeout=10] [--label=note]
+//   node bench/run.mjs --runner=claude [--fixture=string-kit] [--routing=on|off|config]
 //
 // Copies the fixture into bench/.runs/<runner>-<stamp>, git-inits it, then drives
 // `yoke loop run --json` and measures from the OUTSIDE (the loop itself records no
-// durations): per-story wall-clock from NDJSON event timestamps, tokens/model from
-// the loop's token hook (claude runner only), and quality as the fixture's own
+// durations): per-story wall-clock from NDJSON event timestamps, tokens/model from
+// provider telemetry when available, and quality as the fixture's own
 // pre-written tests — run per story AFTER the loop finishes, on the final tree.
 import { spawn, spawnSync } from 'node:child_process'
-import { cpSync, mkdirSync, readFileSync, writeFileSync, readdirSync, statSync } from 'node:fs'
+import { cpSync, existsSync, mkdirSync, readFileSync, writeFileSync, readdirSync, statSync } from 'node:fs'
 import { join, dirname } from 'node:path'
 import { fileURLToPath } from 'node:url'
-import { validateResult } from './result-schema.mjs'
+import { validateResult } from './result-schema.mjs'
+import { parse } from 'yaml'
 
 const benchDir = dirname(fileURLToPath(import.meta.url))
 const repoRoot = dirname(benchDir)
@@ -26,16 +27,28 @@ const args = Object.fromEntries(
 )
 const runner = args.runner
 if (!['claude', 'codex', 'gemini'].includes(runner)) {
-  console.error('usage: node bench/run.mjs --runner=<claude|codex|gemini> [--max=6] [--timeout=10] [--label=note]')
+  console.error('usage: node bench/run.mjs --runner=<claude|codex|gemini> [--fixture=string-kit] [--routing=on|off|config] [--run-root=path] [--unsafe] [--max=6] [--timeout=10] [--label=note]')
   process.exit(2)
 }
-const max = Number(args.max ?? 6)
-const timeout = Number(args.timeout ?? 10)
-
-const stamp = new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19)
-const runDir = join(benchDir, '.runs', `${runner}-${stamp}`)
-mkdirSync(runDir, { recursive: true })
-cpSync(join(benchDir, 'fixtures', 'string-kit'), runDir, { recursive: true })
+const max = Number(args.max ?? 6)
+const timeout = Number(args.timeout ?? 10)
+const fixture = String(args.fixture ?? 'string-kit')
+const fixtureDir = join(benchDir, 'fixtures', fixture)
+const routing = String(args.routing ?? 'config')
+if (!existsSync(fixtureDir)) {
+  console.error(`unknown fixture: ${fixture}`)
+  process.exit(2)
+}
+if (!['on', 'off', 'config'].includes(routing)) {
+  console.error('routing must be on, off, or config')
+  process.exit(2)
+}
+
+const stamp = new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19)
+const runRoot = args['run-root'] ? String(args['run-root']) : join(benchDir, '.runs')
+const runDir = join(runRoot, `${fixture}-${runner}-routing-${routing}-${stamp}`)
+mkdirSync(runDir, { recursive: true })
+cpSync(fixtureDir, runDir, { recursive: true })
 
 const git = (...a) => {
   const r = spawnSync('git', ['-C', runDir, ...a], { encoding: 'utf8' })
@@ -49,10 +62,12 @@ git('-c', 'user.name=bench', '-c', 'user.email=bench@yoke', 'commit', '-q', '-m'
 const env = { ...process.env }
 for (const k of Object.keys(env)) if (k.startsWith('CLAUDE_CODE') || k === 'CLAUDECODE') delete env[k]
 
-console.error(`[bench] ${runner} → ${runDir}`)
+console.error(`[bench] ${runner} · fixture=${fixture} · routing=${routing} → ${runDir}`)
 const t0 = Date.now()
 const events = []
-const child = spawn(process.execPath, [cli, 'loop', 'run', runDir, '--json', `--runner=${runner}`, `--max=${max}`, `--timeout=${timeout}`], {
+const routingFlag = routing === 'on' ? ['--routing'] : routing === 'off' ? ['--no-routing'] : []
+const permissionFlag = args.unsafe ? ['--unsafe'] : []
+const child = spawn(process.execPath, [cli, 'loop', 'run', runDir, '--json', `--runner=${runner}`, `--max=${max}`, `--timeout=${timeout}`, ...routingFlag, ...permissionFlag], {
   env, stdio: ['ignore', 'pipe', 'inherit'],
 })
 let buf = ''
@@ -70,7 +85,10 @@ const exitCode = await new Promise(res => child.on('close', res))
 const wallClockMs = Date.now() - t0
 
 // Per-story duration: first event mentioning the story -> first event mentioning the next story (or end).
-const storyIds = ['STORY-1', 'STORY-2', 'STORY-3']
+const prd = parse(readFileSync(join(runDir, '.yoke', 'prd.yaml'), 'utf8'))
+const storyIds = Array.isArray(prd) ? prd.map(story => String(story.id)) : []
+const benchConfig = parse(readFileSync(join(runDir, '.yoke', 'config.yaml'), 'utf8'))
+const requestedParentModel = benchConfig?.runner?.model ?? null
 const firstSeen = {}
 for (const e of events) if (e.story && !(e.story in firstSeen)) firstSeen[e.story] = e.at
 const stories = storyIds.map((id, idx) => {
@@ -96,12 +114,13 @@ const loc = (dir) => readdirSync(dir).reduce((n, f) => {
 
 const result = {
   schemaVersion: 1,
-  fixtureVersion: 'string-kit@1',
+  fixtureVersion: `${fixture}@1`,
   runner,
   sampleLabel: String(args.label ?? `${runner}-${stamp}`),
   permissionProfile: args.unsafe ? 'unsafe' : 'safe',
   yokeVersion: JSON.parse(readFileSync(join(repoRoot, 'package.json'), 'utf8')).version,
-  fixture: 'string-kit',
+  fixture,
+  routing,
   startedAt: new Date(t0).toISOString(),
   wallClockMs,
   exitCode,
@@ -113,15 +132,17 @@ const result = {
   finalTestsPass: stories.every(story => story.finalTestsPass),
   progress: last.progress ?? null,
   usageAvailable: Number(status.tokens?.inputTokens ?? 0) + Number(status.tokens?.outputTokens ?? 0) > 0,
-  modelAvailable: typeof status.tokens?.model === 'string' && status.tokens.model !== '<synthetic>',
-  tokens: status.tokens ?? null,
+  modelAvailable: (typeof status.tokens?.model === 'string' && status.tokens.model !== '<synthetic>') || requestedParentModel !== null,
+  requestedParentModel,
+  tokens: status.tokens ?? null,
+  modelCalls: status.tokens?.calls ?? [],
   stories,
   srcLoc: loc(join(runDir, 'src')),
 }
 validateResult(result)
 
 mkdirSync(join(benchDir, 'results'), { recursive: true })
-const out = join(benchDir, 'results', `${runner}-${stamp}.json`)
+const out = join(benchDir, 'results', `${fixture}-${runner}-routing-${routing}-${stamp}.json`)
 writeFileSync(out, JSON.stringify(result, null, 2) + '\n')
 console.error(`[bench] done: ${out}`)
 console.log(JSON.stringify(result, null, 2))

package/dist/agents/providers.js

@@ -14,10 +14,27 @@ const argsFor = (agent, permissions) => {
         return ['exec', '--full-auto', '--json'];
     }
     if (permissions === 'unsafe')
-        return ['--yolo', '--output-format', 'stream-json'];
+        return ['--yolo'];
     const approval = permissions === 'read-only' ? 'plan' : 'auto_edit';
-    return ['--approval-mode', approval, '--sandbox', '--output-format', 'stream-json'];
+    return ['--approval-mode', approval, '--sandbox'];
 };
-export function buildProviderInvocation(agent, prompt, cwd, permissions = 'safe') {
-    return { command: agent, args: argsFor(agent, permissions), input: prompt, cwd };
+export function buildProviderInvocation(agent, prompt, cwd, permissions = 'safe', selection = {}) {
+    const args = argsFor(agent, permissions);
+    if (selection.model)
+        args.push('--model', selection.model);
+    if (selection.reasoningEffort) {
+        if (agent === 'claude')
+            args.push('--effort', selection.reasoningEffort);
+        else if (agent === 'codex')
+            args.push('--config', `model_reasoning_effort=${selection.reasoningEffort}`);
+    }
+    if (agent === 'codex' && selection.nativeMultiAgent === false)
+        args.push('--disable', 'multi_agent');
+    if (selection.bare) {
+        if (agent === 'codex')
+            args.push('--ignore-user-config');
+        else if (agent === 'claude')
+            args.push('--bare');
+    }
+    return { command: agent, args, input: prompt, cwd };
 }

package/dist/agents/telemetry.js

@@ -1,30 +1,69 @@
 const finite = (value) => typeof value === 'number' && Number.isFinite(value) ? value : undefined;
 export function parseProviderTelemetry(agent, lines) {
     let inputTokens;
+    let cachedInputTokens;
+    let cacheWriteInputTokens;
     let outputTokens;
+    let reasoningOutputTokens;
+    let totalCostUsd;
     let model;
     for (const line of lines) {
-        let event;
+        let parsed;
         try {
-            event = JSON.parse(line);
+            parsed = JSON.parse(line);
         }
         catch {
             continue;
         }
+        if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed))
+            continue;
+        const event = parsed;
         const message = event.message && typeof event.message === 'object' ? event.message : undefined;
-        const usage = (event.usage && typeof event.usage === 'object' ? event.usage : message?.usage);
-        const inValue = finite(usage?.input_tokens ?? usage?.inputTokens ?? usage?.prompt_tokens);
-        const outValue = finite(usage?.output_tokens ?? usage?.outputTokens ?? usage?.completion_tokens);
+        const stats = event.stats && typeof event.stats === 'object' ? event.stats : undefined;
+        const usage = (event.usage && typeof event.usage === 'object'
+            ? event.usage
+            : message?.usage && typeof message.usage === 'object'
+                ? message.usage
+                : stats?.usage && typeof stats.usage === 'object'
+                    ? stats.usage
+                    : stats);
+        const models = stats?.models && typeof stats.models === 'object' ? stats.models : undefined;
+        const firstModel = models ? Object.entries(models)[0] : undefined;
+        const modelUsage = firstModel?.[1] && typeof firstModel[1] === 'object' ? firstModel[1] : undefined;
+        const nestedModelTokens = modelUsage?.tokens && typeof modelUsage.tokens === 'object' ? modelUsage.tokens : undefined;
+        const source = nestedModelTokens ?? modelUsage ?? usage;
+        const inValue = finite(source?.input_tokens ?? source?.inputTokens ?? source?.prompt_tokens ?? source?.promptTokenCount ?? source?.input);
+        const cachedValue = finite(source?.cached_input_tokens ?? source?.cache_read_input_tokens ?? source?.cachedInputTokens ?? source?.cachedContentTokenCount ?? source?.cached);
+        const cacheWriteValue = finite(source?.cache_write_input_tokens ?? source?.cache_creation_input_tokens ?? source?.cacheWriteInputTokens ?? source?.cacheWrite);
+        const outValue = finite(source?.output_tokens ?? source?.outputTokens ?? source?.completion_tokens ?? source?.candidatesTokenCount ?? source?.output);
+        const reasoningValue = finite(source?.reasoning_output_tokens ?? source?.reasoningOutputTokens ?? source?.thoughtsTokenCount ?? source?.thoughts);
         if (inValue !== undefined)
             inputTokens = inValue;
+        if (cachedValue !== undefined)
+            cachedInputTokens = cachedValue;
+        if (cacheWriteValue !== undefined)
+            cacheWriteInputTokens = cacheWriteValue;
         if (outValue !== undefined)
             outputTokens = outValue;
-        const eventModel = event.model ?? message?.model;
+        if (reasoningValue !== undefined)
+            reasoningOutputTokens = reasoningValue;
+        const costValue = finite(event.total_cost_usd ?? event.totalCostUsd ?? stats?.total_cost_usd);
+        if (costValue !== undefined)
+            totalCostUsd = costValue;
+        const eventModel = event.model ?? message?.model ?? firstModel?.[0];
         if (typeof eventModel === 'string' && eventModel)
             model = eventModel;
     }
     if (inputTokens === undefined && outputTokens === undefined)
         return { usageAvailable: false };
-    const tokens = { inputTokens: inputTokens ?? 0, outputTokens: outputTokens ?? 0, ...(model ? { model } : {}) };
+    const tokens = {
+        inputTokens: inputTokens ?? 0,
+        ...(cachedInputTokens !== undefined ? { cachedInputTokens } : {}),
+        ...(cacheWriteInputTokens !== undefined ? { cacheWriteInputTokens } : {}),
+        outputTokens: outputTokens ?? 0,
+        ...(reasoningOutputTokens !== undefined ? { reasoningOutputTokens } : {}),
+        ...(totalCostUsd !== undefined ? { totalCostUsd } : {}),
+        ...(model ? { model } : {}),
+    };
     return { usageAvailable: true, tokens };
 }

package/dist/cli.js

@@ -86,10 +86,11 @@ export function main(argv) {
                 return 1;
             }
             const loop = rest.includes('--loop') ? true : rest.includes('--no-loop') ? false : undefined;
+            const routing = rest.includes('--routing') ? true : rest.includes('--no-routing') ? false : undefined;
             return runSetup(targetDir, {
                 host: hostArg, agents, runner: runnerArg,
                 codeGraph: graphArg,
-                loop, decisionPolicy: policyArg,
+                loop, routing, decisionPolicy: policyArg,
                 interactive: rest.includes('--yes') ? false : undefined,
             });
         }
@@ -254,8 +255,8 @@ export function main(argv) {
                     return 1;
                 }
                 const maxArg = rest.find(a => a.startsWith('--max='));
-                const rawMax = maxArg ? Number(maxArg.slice('--max='.length)) : 25;
-                if (!Number.isFinite(rawMax) || rawMax <= 0) {
+                const rawMax = maxArg ? Number(maxArg.slice('--max='.length)) : undefined;
+                if (rawMax !== undefined && (!Number.isInteger(rawMax) || rawMax <= 0)) {
                     console.error(`Invalid --max value: ${maxArg}`);
                     return 1;
                 }
@@ -286,6 +287,7 @@ export function main(argv) {
                     return 1;
                 }
                 const json = rest.includes('--json');
+                const routing = rest.includes('--routing') ? true : rest.includes('--no-routing') ? false : undefined;
                 const toArg = rest.find(a => a.startsWith('--timeout='));
                 let timeoutMinutes;
                 if (toArg) {
@@ -306,9 +308,9 @@ export function main(argv) {
                     console.error(`Invalid --decision-policy value: ${dpArg} (expected auto|critical)`);
                     return 1;
                 }
-                return runLoopCommand(targetDir, { maxIterations: rawMax, agent, isolate, parallel, reviewer, review, allowSelfReview, timeoutMinutes, json, onAmbiguity: oaArg, decisionPolicy: dpArg, permissions });
+                return runLoopCommand(targetDir, { maxIterations: rawMax, agent, isolate, parallel, reviewer, review, allowSelfReview, timeoutMinutes, json, routing, onAmbiguity: oaArg, decisionPolicy: dpArg, permissions });
             }
-            console.log('usage: yoke loop <on|off|status|decision|answer|resume [--discard]|cleanup [--remove-worktrees] [--discard-stale-recovery]|run [--max=N] [--parallel=N] [--runner=<claude|codex|gemini>] [--reviewer=<claude|codex|gemini>] [--review] [--allow-self-review] [--isolate] [--unsafe] [--timeout=<minutes>] [--decision-policy=<auto|critical>] [--json]> [targetDir]');
+            console.log('usage: yoke loop <on|off|status|decision|answer|resume [--discard]|cleanup [--remove-worktrees] [--discard-stale-recovery]|run [--max=N] [--parallel=N] [--runner=<claude|codex|gemini>] [--reviewer=<claude|codex|gemini>] [--review] [--allow-self-review] [--routing|--no-routing] [--isolate] [--unsafe] [--timeout=<minutes>] [--decision-policy=<auto|critical>] [--json]> [targetDir]');
             return 1;
         }
         case 'new': {

package/dist/loop/decision.js

@@ -58,7 +58,8 @@ export const DecisionResumeSchema = z.object({
     storyId: singleLine(128),
     requestId: z.string().regex(/^[a-f0-9]{16}$/u),
     answered: z.boolean().optional(),
-    maxIterations: z.number().int().positive(),
+    /** Absent preserves the default unlimited run across a critical-decision resume. */
+    maxIterations: z.number().int().positive().optional(),
     agent: z.enum(['claude', 'codex', 'gemini']).optional(),
     isolate: z.boolean().optional(),
     reviewer: z.enum(['claude', 'codex', 'gemini']).optional(),
@@ -70,6 +71,7 @@ export const DecisionResumeSchema = z.object({
     decisionPolicy: z.enum(['auto', 'critical']).optional(),
     permissions: z.enum(['safe', 'unsafe', 'read-only']).optional(),
     parallel: z.number().int().positive().optional(),
+    routing: z.boolean().optional(),
     projectId: z.string().regex(/^[a-f0-9]{16}$/u).optional(),
     baseCommit: z.string().regex(/^[a-f0-9]{40,64}$/u).optional(),
     prdHash: z.string().regex(/^[a-f0-9]{64}$/u).optional(),

package/dist/loop/loop.js

@@ -138,6 +138,7 @@ export function runLoop(opts) {
                 reporter.phase('verifying');
                 const verdict = runGate(opts.verify, wt, story.id);
                 if (!verdict.passed) {
+                    result.routing?.recordOutcome(false);
                     const base = result.success
                         ? `story ${story.id} did not verify: ${verdict.summary}`
                         : `story ${story.id} runner failed (${result.summary}) and verify is red: ${verdict.summary}`;
@@ -149,6 +150,7 @@ export function runLoop(opts) {
                     reporter.phase('perf');
                     const perfVerdict = runGate(opts.perf, wt, story.id);
                     if (!perfVerdict.passed) {
+                        result.routing?.recordOutcome(false);
                         const reason = blockReason(`story ${story.id} exceeded its performance budget: ${perfVerdict.summary}`, opts.targetDir, opts.git);
                         reporter.blocked(reason);
                         return { status: 'blocked', iterations, reason, finalProgress: progress(stories) };
@@ -158,6 +160,7 @@ export function runLoop(opts) {
                     reporter.phase('audit');
                     const auditVerdict = runGate(opts.audit, wt, story.id);
                     if (!auditVerdict.passed) {
+                        result.routing?.recordOutcome(false);
                         const reason = blockReason(`story ${story.id} failed security audit: ${auditVerdict.summary}`, opts.targetDir, opts.git);
                         reporter.blocked(reason);
                         return { status: 'blocked', iterations, reason, finalProgress: progress(stories) };
@@ -170,11 +173,13 @@ export function runLoop(opts) {
                     reporter.phase('reviewing');
                     const reviewResult = opts.review({ targetDir: wt, story });
                     if (!reviewResult.success) {
+                        result.routing?.recordOutcome(false);
                         const reason = blockReason(`story ${story.id} rejected in review: ${reviewResult.summary}`, opts.targetDir, opts.git);
                         reporter.blocked(reason);
                         return { status: 'blocked', iterations, reason, finalProgress: progress(stories) };
                     }
                 }
+                result.routing?.recordOutcome(true);
                 // The worktree is a checkout of committed HEAD, so the agent above reads
                 // context from HEAD's .yoke/context — commit context changes for --isolate
                 // to honour them. We write the decision here so `integrate` carries it back.
@@ -234,6 +239,7 @@ export function runLoop(opts) {
         reporter.phase('verifying');
         const verdict = runGate(opts.verify, opts.targetDir, story.id);
         if (!verdict.passed) {
+            result.routing?.recordOutcome(false);
             const base = result.success
                 ? `story ${story.id} did not verify: ${verdict.summary}`
                 : `story ${story.id} runner failed (${result.summary}) and verify is red: ${verdict.summary}`;
@@ -250,6 +256,7 @@ export function runLoop(opts) {
             reporter.phase('perf');
             const perfVerdict = runGate(opts.perf, opts.targetDir, story.id);
             if (!perfVerdict.passed) {
+                result.routing?.recordOutcome(false);
                 const reason = blockReason(`story ${story.id} exceeded its performance budget: ${perfVerdict.summary}`, opts.targetDir, opts.git);
                 reporter.blocked(reason);
                 return { status: 'blocked', iterations, reason, finalProgress: progress(stories) };
@@ -259,6 +266,7 @@ export function runLoop(opts) {
             reporter.phase('audit');
             const auditVerdict = runGate(opts.audit, opts.targetDir, story.id);
             if (!auditVerdict.passed) {
+                result.routing?.recordOutcome(false);
                 const reason = blockReason(`story ${story.id} failed security audit: ${auditVerdict.summary}`, opts.targetDir, opts.git);
                 reporter.blocked(reason);
                 return { status: 'blocked', iterations, reason, finalProgress: progress(stories) };
@@ -271,6 +279,7 @@ export function runLoop(opts) {
             reporter.phase('reviewing');
             const reviewResult = opts.review({ targetDir: opts.targetDir, story });
             if (!reviewResult.success) {
+                result.routing?.recordOutcome(false);
                 const reason = blockReason(`story ${story.id} rejected in review: ${reviewResult.summary}`, opts.targetDir, opts.git);
                 reporter.blocked(reason);
                 return {
@@ -281,6 +290,7 @@ export function runLoop(opts) {
                 };
             }
         }
+        result.routing?.recordOutcome(true);
         reporter.phase('committing');
         const dec = appendDecision(contextDir(opts.targetDir), {
             storyId: story.id,

package/dist/loop/reporter.js

@@ -159,10 +159,19 @@ export function makeReporter(dir, opts = {}, now = () => new Date()) {
         },
         addTokens(usage) {
             const model = usage.model ?? tokens?.model;
+            const cachedInputTokens = (tokens?.cachedInputTokens ?? 0) + (usage.cachedInputTokens ?? 0);
+            const cacheWriteInputTokens = (tokens?.cacheWriteInputTokens ?? 0) + (usage.cacheWriteInputTokens ?? 0);
+            const reasoningOutputTokens = (tokens?.reasoningOutputTokens ?? 0) + (usage.reasoningOutputTokens ?? 0);
+            const totalCostUsd = (tokens?.totalCostUsd ?? 0) + (usage.totalCostUsd ?? 0);
             tokens = {
                 inputTokens: (tokens?.inputTokens ?? 0) + usage.inputTokens,
+                ...((tokens?.cachedInputTokens !== undefined || usage.cachedInputTokens !== undefined) ? { cachedInputTokens } : {}),
+                ...((tokens?.cacheWriteInputTokens !== undefined || usage.cacheWriteInputTokens !== undefined) ? { cacheWriteInputTokens } : {}),
                 outputTokens: (tokens?.outputTokens ?? 0) + usage.outputTokens,
+                ...((tokens?.reasoningOutputTokens !== undefined || usage.reasoningOutputTokens !== undefined) ? { reasoningOutputTokens } : {}),
+                ...((tokens?.totalCostUsd !== undefined || usage.totalCostUsd !== undefined) ? { totalCostUsd } : {}),
                 ...(model ? { model } : {}),
+                ...((tokens?.calls || usage.calls) ? { calls: [...(tokens?.calls ?? []), ...(usage.calls ?? [])] } : {}),
             };
         },
     };