@hecer/yoke 1.21.1 → 1.23.0

package/bench/result-schema.mjs

@@ -10,3 +10,135 @@ export function validateResult(result) {
   if (!['completed', 'blocked', 'unavailable', 'auth-failed'].includes(result.verdict)) throw new Error(`invalid verdict: ${result.verdict}`)
   return result
 }
+
+// Comparison manifests are separate from the historical individual-run schema above.
+// A "verified" manifest describes comparable recorded conditions, not a causal or
+// statistically conclusive performance result.
+const record = value => value !== null && typeof value === 'object' && !Array.isArray(value)
+const nonempty = value => typeof value === 'string' && value.trim().length > 0
+const boolean = value => typeof value === 'boolean'
+const sha256 = value => typeof value === 'string' && /^[a-f0-9]{64}$/.test(value)
+const positiveInteger = value => Number.isSafeInteger(value) && value > 0
+
+export const comparisonContextFields = {
+  'source.version': nonempty,
+  'source.commit': value => typeof value === 'string' && /^(?:[a-f0-9]{40}|[a-f0-9]{64})$/.test(value),
+  'source.dirty': boolean,
+  'source.buildDigest': sha256,
+  'source.stable': value => value === true,
+  'fixture.id': nonempty,
+  'fixture.seedDigest': sha256,
+  'fixture.acceptanceDigest': sha256,
+  'fixture.requirementsDigest': sha256,
+  'execution.provider': nonempty,
+  'execution.requestedModel': nonempty,
+  'execution.actualModels': value => Array.isArray(value) && value.length > 0 && value.every(nonempty) && new Set(value).size === value.length,
+  'execution.effort': nonempty,
+  'execution.routing': boolean,
+  'execution.nativeMultiAgent': boolean,
+  'execution.nativeGoal': boolean,
+  'execution.parallel': positiveInteger,
+  'execution.workflow': nonempty,
+  'execution.promptDigest': sha256,
+  'execution.promptScope': value => ['provider-prompt', 'workflow-input-bundle'].includes(value),
+  'startup.permissionProfile': value => ['safe', 'read-only', 'unsafe'].includes(value),
+  'startup.bare': boolean,
+  'startup.ignoreRules': boolean,
+  'startup.commitPolicy': nonempty,
+  'startup.isolation': nonempty,
+  'startup.timeoutPolicy': nonempty,
+  'startup.userStatePolicy': nonempty,
+  'environment.platform': nonempty,
+  'environment.arch': nonempty,
+  'environment.nodeVersion': nonempty,
+  'environment.providerVersion': nonempty,
+  'environment.hostDigest': sha256,
+  'environment.hostLoad': value => ['uncontrolled', 'isolated'].includes(value),
+  'environment.skillsPlugins': value => ['not-audited', 'audited'].includes(value),
+}
+
+export const allowedComparisonVariables = Object.keys(comparisonContextFields)
+  .filter(field => !field.startsWith('fixture.') && field !== 'source.stable')
+
+export function comparisonValue(context, field) {
+  return field.split('.').reduce((value, key) => record(value) ? value[key] : undefined, context)
+}
+
+export function stableComparisonJson(value) {
+  if (Array.isArray(value)) return '[' + value.map(stableComparisonJson).join(',') + ']'
+  if (record(value)) return '{' + Object.keys(value).sort().map(key => JSON.stringify(key) + ':' + stableComparisonJson(value[key])).join(',') + '}'
+  return JSON.stringify(value)
+}
+
+export function comparisonManifestIssues(manifest) {
+  if (!record(manifest)) return ['Missing versioned comparison manifest']
+  const issues = []
+  if (manifest.schemaVersion !== 1) issues.push('Unsupported comparison manifest version')
+  if (!nonempty(manifest.id)) issues.push('Missing comparison identity')
+  if (!['workflow', 'controlled'].includes(manifest.kind)) issues.push('Unknown comparison kind')
+  if (!Array.isArray(manifest.arms) || manifest.arms.length < 2 || !manifest.arms.every(nonempty) || new Set(manifest.arms).size !== manifest.arms.length) issues.push('Declare at least two distinct comparison arms')
+  if (!positiveInteger(manifest.repeats)) issues.push('Declare the planned number of paired repeats')
+  if (!Array.isArray(manifest.allowedDifferences)) issues.push('Declare allowed differences explicitly, including an empty list when appropriate')
+  else {
+    const fields = new Set()
+    for (const difference of manifest.allowedDifferences) {
+      if (!record(difference) || !allowedComparisonVariables.includes(difference.field) || !nonempty(difference.reason)) {
+        issues.push('Invalid comparison variable or missing rationale')
+        continue
+      }
+      if (fields.has(difference.field)) issues.push('Duplicate comparison variable: ' + difference.field)
+      fields.add(difference.field)
+    }
+  }
+  return issues
+}
+
+export function comparisonContextIssues(context) {
+  if (!record(context)) return ['Missing per-run comparison context']
+  const issues = []
+  for (const [field, validate] of Object.entries(comparisonContextFields)) {
+    if (!validate(comparisonValue(context, field))) issues.push('Missing, unknown or invalid condition: ' + field)
+  }
+  // Refuse silently ignored startup/source conditions introduced by a future writer.
+  for (const [section, fields] of Object.entries(context)) {
+    if (!record(fields)) { issues.push('Invalid context section: ' + section); continue }
+    for (const field of Object.keys(fields)) {
+      if (!(section + '.' + field in comparisonContextFields)) issues.push('Unknown comparison condition: ' + section + '.' + field)
+    }
+  }
+  return issues
+}
+
+export function assessComparison(manifests, runs) {
+  const manifest = manifests[0]
+  let reasons = manifests.flatMap(comparisonManifestIssues)
+  if (reasons.length) return { status: 'unverified', reasons: [...new Set(reasons)] }
+  if (manifests.some(value => stableComparisonJson(value) !== stableComparisonJson(manifest))) return { status: 'incompatible', reasons: ['Comparison manifests differ for the same identity'] }
+  reasons = runs.flatMap(run => comparisonContextIssues(run.context).map(issue => run.arm + ': ' + issue))
+  for (const run of runs) {
+    if (!manifest.arms.includes(run.arm) || !positiveInteger(run.repeat) || run.repeat > manifest.repeats) reasons.push('Unexpected arm or repeat')
+    if (run.fixture !== run.context?.fixture?.id) reasons.push('Fixture label disagrees with measured context')
+    if (typeof run.accepted !== 'boolean') reasons.push('Missing acceptance outcome')
+  }
+  if (reasons.length) return { status: 'unverified', reasons: [...new Set(reasons)] }
+  const keys = runs.map(run => run.arm + ':' + run.repeat)
+  if (new Set(keys).size !== keys.length) return { status: 'incompatible', reasons: ['Duplicate arm/repeat measurements'] }
+  const permitted = new Set(manifest.allowedDifferences.map(value => value.field))
+  for (const field of Object.keys(comparisonContextFields)) {
+    const valueOf = run => {
+      const value = comparisonValue(run.context, field)
+      return stableComparisonJson(field === 'execution.actualModels' ? [...value].sort() : value)
+    }
+    for (const arm of manifest.arms) {
+      if (new Set(runs.filter(run => run.arm === arm).map(valueOf)).size > 1) reasons.push('Conditions changed within arm ' + arm + ': ' + field)
+    }
+    if (!permitted.has(field) && new Set(runs.map(valueOf)).size > 1) reasons.push('Undeclared difference between arms: ' + field)
+  }
+  if (reasons.length) return { status: 'incompatible', reasons: [...new Set(reasons)] }
+  if (runs.length !== manifest.arms.length * manifest.repeats) return { status: 'incomplete', reasons: ['Not all declared paired runs are present'] }
+  if (runs.some(run => !run.accepted)) return { status: 'acceptance-failed', reasons: ['At least one arm failed immutable acceptance; failed elapsed time is not a speedup'] }
+  if (runs.some(run => run.usage?.measurementComplete === false || ['inputTokens', 'cachedInputTokens', 'outputTokens'].some(field => !Number.isFinite(run.usage?.[field]) || run.usage[field] < 0))) {
+    return { status: 'unverified', reasons: ['Incomplete token telemetry; retain diagnostic timings without an efficiency comparison'] }
+  }
+  return { status: 'verified', reasons: [] }
+}

package/canon/manifest.yaml

@@ -1,5 +1,5 @@
 name: yoke-canon
-version: 1.19.0
+version: 1.23.0
 agents: [claude, codex, gemini, qwen, opencode, kilo, pi, hermes]
 skills:
   - { id: tdd, path: skills/tdd, kind: methodology, invocation: auto }

package/canon/skills/visual-verification/SKILL.md

@@ -24,6 +24,9 @@ Configure the key user flows once in `.yoke/config.yaml`:
 ```yaml
 smoke:
   baseUrl: http://localhost:3000
+  sourceIdentity:
+    path: /assets/app-specific-static-source.js
+    sha256: "<replace with SHA-256 of the served bytes>"
   flows:
     - name: home
       path: /
@@ -33,7 +36,26 @@ smoke:
       landmark: "form"
 ```
 
-With that in place, the `yoke flow-smoke .` step from the section-1 pipeline is live.
+The example contains a required hash placeholder. Before running production smoke, replace
+the resource path with a stable, app-specific source resource and the hash with its actual
+64-character lowercase SHA-256. The schema allows the field to be absent for existing
+configuration readers; production `flow-smoke` requires it.
+
+Start the intended server and confirm its checkout/build and port. Fetch the resource from
+the effective `baseUrl` origin, using the exact body bytes returned by the server. Hash those
+bytes, not a local source file that a dev server may transform. The resource must return a
+successful HTTP response without redirects, finish within five seconds and contain at most
+1 MiB. Keep it stable for the whole smoke run. When `--url` changes the origin, verify that
+origin serves the intended build before deriving the pin.
+
+Refresh the expected hash explicitly after an intentional source/build change and after
+confirming the server serves that change. A mismatch must fail the gate; do not automatically
+overwrite the expected hash with whatever a port happens to serve. A shared health response
+or unchanged marker cannot identify changed app code. This static pin proves only that the
+selected resource matches before and after the run; retain the checkout fingerprint and
+acceptance evidence for broader source binding.
+
+With a real pin in place, the `yoke flow-smoke .` step from the section-1 pipeline is live.
 `yoke flow-smoke` loads each route against the running dev server, waits for the landmark,
 fails on any console error, and **always** saves a screenshot to `.yoke/proof/<story>/`
 (the loop labels the folder with the current story id via `YOKE_STORY`; standalone runs use
@@ -50,5 +72,6 @@ already handles the failure case.
 
 ## Rule
 
-Green pipeline = types + units + no design-slop over budget + every flow renders without
+Green pipeline = types + units + no design-slop over budget + served-source identity matches
+before and after the run + every flow renders without
 console errors, with a screenshot to prove it. Only then is the story actually done.

package/canon/tools/codex-rtk-hook.mjs

@@ -2,24 +2,14 @@ import { spawnSync } from 'node:child_process'
 import { resolve } from 'node:path'
 import { pathToFileURL } from 'node:url'
 
-function rtkCheck(command) {
-  const result = spawnSync('rtk', ['hook', 'check', command], { encoding: 'utf8', timeout: 3000 })
-  return result.status === 0 ? result.stdout.trim() : ''
+function nativeHook(input) {
+  const result = spawnSync('rtk', ['hook', 'codex'], { input: JSON.stringify(input), encoding: 'utf8', timeout: 3000 })
+  return result.status === 0 && result.stdout.trim() ? JSON.parse(result.stdout) : null
 }
 
-export function rewriteHookInput(input, check = rtkCheck) {
-  if (input?.tool_name !== 'Bash' && input?.toolName !== 'Bash') return null
-  const toolInput = input.tool_input ?? input.toolInput
-  const command = toolInput?.command
-  if (typeof command !== 'string' || command.trim() === '') return null
-  const rewritten = check(command)
-  if (!rewritten || rewritten === command) return null
-  return {
-    hookSpecificOutput: {
-      hookEventName: 'PreToolUse',
-      updatedInput: { ...toolInput, command: rewritten },
-    },
-  }
+export function rewriteHookInput(input, processHook = nativeHook) {
+  // Native RTK owns Codex schema, permission-mode handling and fail-open rules.
+  try { return processHook(input) ?? null } catch { return null }
 }
 
 async function main() {

package/dist/agents/pi-telemetry.js

@@ -39,10 +39,11 @@ export function createPiTelemetry() {
             if (complete) {
                 // Optional totals must also cover every turn; omitted is not measured zero.
                 const measured = Object.fromEntries(Object.entries(totals).filter(([key]) => counts[key] === turns));
+                const partial = Object.fromEntries(Object.entries(totals).filter(([key]) => counts[key] !== turns));
                 return { usageAvailable: true, tokens: {
                         ...measured, inputTokens: totals.inputTokens, outputTokens: totals.outputTokens,
                         ...(reportedModels.length === 1 ? { model: reportedModels[0] } : {}),
-                    }, ...(reportedModels.length > 1 ? { reportedModels } : {}) };
+                    }, ...(Object.keys(partial).length ? { partialUsage: partial } : {}), ...(reportedModels.length > 1 ? { reportedModels } : {}) };
             }
             return { usageAvailable: false,
                 ...(Object.keys(totals).length ? { partialUsage: { ...totals } } : {}),

package/dist/agents/process-streams.js

@@ -1,4 +1,4 @@
-import { parseProviderTelemetry } from './telemetry.js';
+import { createStepTelemetry, parseProviderTelemetry } from './telemetry.js';
 import { createPiTelemetry } from './pi-telemetry.js';
 export function createBoundedOutput(limitBytes) {
     let text = '';
@@ -22,11 +22,17 @@ export function createTelemetryAccumulator(agent) {
     let trailing = '';
     let telemetry = { usageAvailable: false };
     let reportedModels = [];
-    const stepTotals = agent === 'opencode' || agent === 'kilo'
-        ? { input: 0, output: 0, cached: 0, cacheWrite: 0, reasoning: 0, cost: 0, hasInput: false, hasOutput: false, hasCached: false, hasCacheWrite: false, hasReasoning: false, hasCost: false }
-        : undefined;
+    const steps = agent === 'opencode' || agent === 'kilo' ? createStepTelemetry() : undefined;
     const update = (lines) => {
         for (const line of lines) {
+            if (steps) {
+                try {
+                    const event = JSON.parse(line);
+                    if (event && typeof event === 'object' && !Array.isArray(event))
+                        steps.consume(event);
+                }
+                catch { /* non-JSON diagnostics carry no usage */ }
+            }
             if (pi) {
                 try {
                     const event = JSON.parse(line);
@@ -45,35 +51,6 @@ export function createTelemetryAccumulator(agent) {
             // never add it to earlier results or to assistant-message snapshots.
             if (next.tokens || next.partialUsage)
                 telemetry = next;
-            if (stepTotals && isStepFinish(line)) {
-                const usage = next.tokens ?? next.partialUsage;
-                if (usage) {
-                    if (usage.inputTokens !== undefined) {
-                        stepTotals.input += usage.inputTokens;
-                        stepTotals.hasInput = true;
-                    }
-                    if (usage.outputTokens !== undefined) {
-                        stepTotals.output += usage.outputTokens;
-                        stepTotals.hasOutput = true;
-                    }
-                    if (usage.cachedInputTokens !== undefined) {
-                        stepTotals.cached += usage.cachedInputTokens;
-                        stepTotals.hasCached = true;
-                    }
-                    if (usage.cacheWriteInputTokens !== undefined) {
-                        stepTotals.cacheWrite += usage.cacheWriteInputTokens;
-                        stepTotals.hasCacheWrite = true;
-                    }
-                    if (usage.reasoningOutputTokens !== undefined) {
-                        stepTotals.reasoning += usage.reasoningOutputTokens;
-                        stepTotals.hasReasoning = true;
-                    }
-                    if (usage.totalCostUsd !== undefined) {
-                        stepTotals.cost += usage.totalCostUsd;
-                        stepTotals.hasCost = true;
-                    }
-                }
-            }
         }
     };
     return {
@@ -88,42 +65,13 @@ export function createTelemetryAccumulator(agent) {
             trailing = '';
             if (pi)
                 return pi.finish();
-            if (stepTotals && (stepTotals.hasInput || stepTotals.hasOutput)) {
-                const latest = telemetry.tokens;
-                const inputTokens = stepTotals.hasInput ? stepTotals.input : latest?.inputTokens;
-                const outputTokens = stepTotals.hasOutput ? stepTotals.output : latest?.outputTokens;
-                const partialUsage = {
-                    ...(inputTokens !== undefined ? { inputTokens } : {}),
-                    ...(outputTokens !== undefined ? { outputTokens } : {}),
-                    ...(stepTotals.hasCached ? { cachedInputTokens: stepTotals.cached } : latest?.cachedInputTokens !== undefined ? { cachedInputTokens: latest.cachedInputTokens } : {}),
-                    ...(stepTotals.hasCacheWrite ? { cacheWriteInputTokens: stepTotals.cacheWrite } : latest?.cacheWriteInputTokens !== undefined ? { cacheWriteInputTokens: latest.cacheWriteInputTokens } : {}),
-                    ...(stepTotals.hasReasoning ? { reasoningOutputTokens: stepTotals.reasoning } : latest?.reasoningOutputTokens !== undefined ? { reasoningOutputTokens: latest.reasoningOutputTokens } : {}),
-                    ...(stepTotals.hasCost ? { totalCostUsd: stepTotals.cost } : latest?.totalCostUsd !== undefined ? { totalCostUsd: latest.totalCostUsd } : {}),
-                    ...(latest?.model ? { model: latest.model } : {}),
-                };
-                if (inputTokens !== undefined && outputTokens !== undefined) {
-                    telemetry = { usageAvailable: true, tokens: { ...partialUsage, inputTokens, outputTokens } };
-                }
-                else {
-                    telemetry = { usageAvailable: false, partialUsage };
-                }
-            }
+            telemetry = steps?.finish() ?? telemetry;
             if (telemetry.tokens) {
                 const { model: _model, ...tokens } = telemetry.tokens;
-                return { usageAvailable: telemetry.usageAvailable, tokens: { ...tokens, ...(reportedModels.length === 1 ? { model: reportedModels[0] } : {}) },
+                return { ...telemetry, tokens: { ...tokens, ...(reportedModels.length === 1 ? { model: reportedModels[0] } : {}) },
                     ...(reportedModels.length > 1 ? { reportedModels } : {}) };
             }
             return { ...telemetry, ...(reportedModels.length ? { reportedModels } : {}) };
         },
     };
 }
-function isStepFinish(line) {
-    try {
-        const value = JSON.parse(line);
-        const part = value.part && typeof value.part === 'object' ? value.part : undefined;
-        return value.type === 'step_finish' || part?.type === 'step-finish';
-    }
-    catch {
-        return false;
-    }
-}

package/dist/agents/provider-selection.js

@@ -0,0 +1,12 @@
+/** Runner defaults belong to the runner that selected them. Undefined overrides
+ * are absent; explicit false values (for example bare: false) still override. */
+export function resolveProviderSelection(agent, defaults, overrides = {}) {
+    const inherited = defaults && (defaults.agent ?? 'codex') === agent ? defaults : {};
+    const result = {};
+    for (const key of ['provider', 'model', 'reasoningEffort', 'variant', 'bare', 'nativeMultiAgent']) {
+        const value = overrides[key] ?? inherited[key];
+        if (value !== undefined)
+            Object.assign(result, { [key]: value });
+    }
+    return result;
+}

package/dist/agents/telemetry.js

@@ -13,6 +13,50 @@ function parseJson(value) {
 function isRecord(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
+/** OpenCode-family usage belongs to individual completed steps. Each field needs
+ * coverage of every step before it can be called a total. Shared by batch and
+ * streaming readers so an omitted measurement cannot turn into a measured zero. */
+export function createStepTelemetry() {
+    let steps = 0;
+    const totals = {};
+    const counts = {};
+    return {
+        consume(event) {
+            const part = isRecord(event.part) ? event.part : undefined;
+            if (event.type !== 'step_finish' && part?.type !== 'step-finish')
+                return;
+            steps++;
+            const tokens = isRecord(part?.tokens) ? part.tokens : {};
+            const cache = isRecord(tokens.cache) ? tokens.cache : undefined;
+            const fields = {
+                inputTokens: tokens.input,
+                outputTokens: tokens.output,
+                cachedInputTokens: tokens.cached ?? tokens.cacheRead ?? cache?.read,
+                cacheWriteInputTokens: tokens.cacheWrite ?? cache?.write,
+                reasoningOutputTokens: tokens.reasoning,
+                totalCostUsd: part?.cost ?? event.cost,
+            };
+            for (const [field, raw] of Object.entries(fields)) {
+                const value = finite(raw);
+                if (value === undefined)
+                    continue;
+                totals[field] = (totals[field] ?? 0) + value;
+                counts[field] = (counts[field] ?? 0) + 1;
+            }
+        },
+        finish() {
+            if (!steps)
+                return undefined;
+            const complete = counts.inputTokens === steps && counts.outputTokens === steps;
+            if (!complete)
+                return { usageAvailable: false, ...(Object.keys(totals).length ? { partialUsage: { ...totals } } : {}) };
+            const measured = Object.fromEntries(Object.entries(totals).filter(([field]) => counts[field] === steps));
+            const partialUsage = Object.fromEntries(Object.entries(totals).filter(([field]) => counts[field] !== steps));
+            return { usageAvailable: true, tokens: { ...measured, inputTokens: totals.inputTokens, outputTokens: totals.outputTokens },
+                ...(Object.keys(partialUsage).length ? { partialUsage } : {}) };
+        },
+    };
+}
 function textContent(value) {
     if (typeof value === 'string')
         return value;
@@ -154,9 +198,7 @@ export function parseProviderTelemetry(agent, lines) {
     let totalCostUsd;
     let model;
     let reportedModels = [];
-    const harnessTotals = agent === 'opencode' || agent === 'kilo'
-        ? { input: 0, output: 0, cached: 0, cacheWrite: 0, reasoning: 0, cost: 0, hasInput: false, hasOutput: false, hasCached: false, hasCacheWrite: false, hasReasoning: false, hasCost: false }
-        : undefined;
+    const steps = agent === 'opencode' || agent === 'kilo' ? createStepTelemetry() : undefined;
     for (const line of lines) {
         let parsed;
         try {
@@ -168,45 +210,11 @@ export function parseProviderTelemetry(agent, lines) {
         if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed))
             continue;
         const event = parsed;
+        steps?.consume(event);
         if ((agent === 'qwen' || agent === 'claude') && event.parent_tool_use_id != null)
             continue;
         const message = event.message && typeof event.message === 'object' ? event.message : undefined;
         const stats = event.stats && typeof event.stats === 'object' ? event.stats : undefined;
-        const part = event.part && typeof event.part === 'object' ? event.part : undefined;
-        const partTokens = part?.tokens && typeof part.tokens === 'object' ? part.tokens : undefined;
-        if (harnessTotals && (event.type === 'step_finish' || part?.type === 'step-finish') && partTokens) {
-            const cache = partTokens.cache && typeof partTokens.cache === 'object' ? partTokens.cache : undefined;
-            const stepInput = finite(partTokens.input);
-            const stepOutput = finite(partTokens.output);
-            const stepCached = finite(partTokens.cached ?? partTokens.cacheRead ?? cache?.read);
-            const stepCacheWrite = finite(partTokens.cacheWrite ?? cache?.write);
-            const stepReasoning = finite(partTokens.reasoning);
-            const stepCost = finite(part?.cost ?? event.cost);
-            if (stepInput !== undefined) {
-                harnessTotals.input += stepInput;
-                harnessTotals.hasInput = true;
-            }
-            if (stepOutput !== undefined) {
-                harnessTotals.output += stepOutput;
-                harnessTotals.hasOutput = true;
-            }
-            if (stepCached !== undefined) {
-                harnessTotals.cached += stepCached;
-                harnessTotals.hasCached = true;
-            }
-            if (stepCacheWrite !== undefined) {
-                harnessTotals.cacheWrite += stepCacheWrite;
-                harnessTotals.hasCacheWrite = true;
-            }
-            if (stepReasoning !== undefined) {
-                harnessTotals.reasoning += stepReasoning;
-                harnessTotals.hasReasoning = true;
-            }
-            if (stepCost !== undefined) {
-                harnessTotals.cost += stepCost;
-                harnessTotals.hasCost = true;
-            }
-        }
         const usage = (event.usage && typeof event.usage === 'object'
             ? event.usage
             : message?.usage && typeof message.usage === 'object'
@@ -277,20 +285,12 @@ export function parseProviderTelemetry(agent, lines) {
         if (typeof eventModel === 'string' && eventModel && reportedModels.length <= 1)
             model = eventModel;
     }
-    if (harnessTotals) {
-        if (harnessTotals.hasInput)
-            inputTokens = harnessTotals.input;
-        if (harnessTotals.hasOutput)
-            outputTokens = harnessTotals.output;
-        if (harnessTotals.hasCached)
-            cachedInputTokens = harnessTotals.cached;
-        if (harnessTotals.hasCacheWrite)
-            cacheWriteInputTokens = harnessTotals.cacheWrite;
-        if (harnessTotals.hasReasoning)
-            reasoningOutputTokens = harnessTotals.reasoning;
-        if (harnessTotals.hasCost)
-            totalCostUsd = harnessTotals.cost;
-    }
+    const stepUsage = steps?.finish();
+    if (stepUsage)
+        return { ...stepUsage,
+            ...(stepUsage.tokens && model ? { tokens: { ...stepUsage.tokens, model } } : {}),
+            ...(!stepUsage.tokens && model ? { reportedModels: [model] } : {}),
+        };
     if (inputTokens === undefined || outputTokens === undefined) {
         const partialUsage = {
             ...(inputTokens !== undefined ? { inputTokens } : {}),

package/dist/change/inbox.js

@@ -9,8 +9,9 @@ import { existsSync, mkdirSync, readFileSync, readdirSync, renameSync, rmSync, w
 import { basename, dirname, isAbsolute, join, resolve } from 'node:path';
 import { z } from 'zod';
 import { criterionCommandProblem, isAcceptanceCriterion, loadPrd, parsePrd, savePrd, validateDependencies } from '../loop/prd.js';
-import { agentInvocation, buildWatchdogInvocation, isAgentAvailable, runAgent, } from '../loop/runner.js';
+import { agentInvocation, buildWatchdogInvocation, isAgentAvailable, runCapturedAgent, } from '../loop/runner.js';
 import { commitPaths } from '../loop/git.js';
+import { measureInvocation } from '../observability/invocation.js';
 const ChangeRequestSchema = z.object({
     version: z.literal(1),
     id: z.string().regex(/^[A-Za-z0-9][A-Za-z0-9._-]*$/),
@@ -184,7 +185,9 @@ export function runChangeApply(targetDir, opts) {
     rmSync(proposal, { force: true });
     const base = agentInvocation(opts.runner, buildChangePrompt(request, proposal, existing, brief), plannerDir, opts.permissions ?? 'safe', opts.selection);
     const invocation = buildWatchdogInvocation(base, opts.timeoutMs ?? 0);
-    const result = (opts.run ?? runAgent)(invocation);
+    const result = measureInvocation({ root: targetDir, agent: opts.runner, role: 'change-planner', storyId: request.id, runId: `change:${request.id}`, selection: opts.selection, invocation,
+        execute: opts.run ?? (item => runCapturedAgent(opts.runner, item)),
+    });
     if (!result.success)
         return { ok: false, added: 0, summary: `planner failed: ${result.summary}`, changeId: request.id };
     if (readFileSync(prdPath, 'utf8') !== existingText || (readPlanningFile(targetDir, '.yoke/plan.md', 80_000) ?? '') !== brief) {
@@ -246,7 +249,9 @@ export function runChangeApply(targetDir, opts) {
     rmSync(reviewPath, { force: true });
     const reviewBase = agentInvocation(reviewer, buildChangeReviewPrompt(request, reviewPath, appended), plannerDir, opts.permissions ?? 'safe', reviewer === opts.runner ? opts.selection : undefined);
     const reviewInvocation = buildWatchdogInvocation(reviewBase, opts.timeoutMs ?? 0);
-    const reviewResult = (opts.review ?? runAgent)(reviewInvocation);
+    const reviewResult = measureInvocation({ root: targetDir, agent: reviewer, role: 'coverage-review', storyId: request.id, runId: `change:${request.id}`, selection: reviewer === opts.runner ? opts.selection : undefined, invocation: reviewInvocation,
+        execute: opts.review ?? (item => runCapturedAgent(reviewer, item)),
+    });
     if (!reviewResult.success) {
         return { ok: false, added: 0, summary: `coverage review failed: ${reviewResult.summary}`, changeId: request.id };
     }