@hecer/yoke 1.21.1 → 1.22.0

package/dist/loop/reporter.js

@@ -4,6 +4,7 @@ import { join } from 'node:path';
 import { randomUUID } from 'node:crypto';
 import { appendEvent } from '../observability/events.js';
 import { estimateDurations, validDuration } from '../estimation/durations.js';
+import { recordActiveRoutingUsage, markActiveRoutingUsageIncomplete } from '../routing/attempts.js';
 export const LOG_CAP_BYTES = 256 * 1024;
 // Append a line to .yoke/loop.log, keeping the file bounded: once it exceeds
 // capBytes, truncate to the recent tail (starting at a line boundary) so the log
@@ -225,15 +226,15 @@ export function makeReporter(dir, opts = {}, now = () => new Date()) {
             const base = phase === 'exploring' || phase === 'waiting-exploration' || phase === 'waiting-recovery'
                 ? (({ story: _story, storyTitle: _storyTitle, ...withoutStory }) => withoutStory)(status)
                 : status;
-            persist({ ...base, state: 'running', phase, ...(progress ? { progress } : {}), ...(reason ? { reason } : { reason: undefined }), updatedAt: now().toISOString() }, phase, `  · ${phase}…`);
+            persist({ ...base, state: 'running', phase, failure: undefined, ...(progress ? { progress } : {}), ...(reason ? { reason } : { reason: undefined }), updatedAt: now().toISOString() }, phase, `  · ${phase}…`);
         },
-        blocked(reason) {
+        blocked(reason, failure) {
             const base = current ?? emptyStatus(now().toISOString());
-            persist({ ...withoutParallel(base), state: 'blocked', reason, updatedAt: now().toISOString() }, 'blocked', `■ blocked on ${base.story ?? '?'}: ${reason}`);
+            persist({ ...withoutParallel(base), state: 'blocked', reason, failure, updatedAt: now().toISOString() }, 'blocked', `■ blocked on ${base.story ?? '?'}: ${reason}`);
         },
         complete(progress) {
             persist({ ...withoutParallel(current ?? emptyStatus(now().toISOString())), state: 'complete', phase: undefined,
-                progress, reason: undefined, updatedAt: now().toISOString() }, 'complete', `✔ loop complete — ${progress.passed}/${progress.total}`);
+                progress, reason: undefined, failure: undefined, updatedAt: now().toISOString() }, 'complete', `✔ loop complete — ${progress.passed}/${progress.total}`);
         },
         capReached(progress) {
             persist({ ...withoutParallel(current ?? emptyStatus(now().toISOString())), state: 'cap-reached', phase: undefined,
@@ -345,6 +346,22 @@ export function makeReporter(dir, opts = {}, now = () => new Date()) {
                 if (value !== undefined && (!Number.isFinite(value) || value < 0))
                     delete usage[key];
             }
+            if (!usage.calls?.length && !usage.callId)
+                usage.callId = randomUUID();
+            const costRole = usage.role && ['reviewer', 'critic', 'repair', 'quality-critic', 'quality-repair', 'candidate-selection'].includes(usage.role);
+            if (usage.storyId && (usage.routingAttemptId || (costRole && !usage.calls?.length))) {
+                try {
+                    recordActiveRoutingUsage(dir, usage.storyId, usage);
+                }
+                catch {
+                    // Accounting failures must disqualify economic evidence without losing
+                    // the independent event below or interrupting a useful implementation.
+                    try {
+                        markActiveRoutingUsageIncomplete(dir, usage.storyId);
+                    }
+                    catch { /* Router finalization also fails closed on corrupt accounting. */ }
+                }
+            }
             const calls = usage.calls?.length ? usage.calls : [{ usageAvailable: usage.measurementComplete !== false, totalCostUsd: usage.totalCostUsd }];
             measuredCalls += calls.filter(call => call.usageAvailable !== false).length;
             unknownCalls += calls.filter(call => call.usageAvailable === false).length;

package/dist/loop/run-command.js

@@ -1,4 +1,5 @@
 import { roleSelection } from "../routing/capability.js";
+import { createHash } from 'node:crypto';
 import { join } from 'node:path';
 import { existsSync, unlinkSync } from 'node:fs';
 import { loadConfig, saveConfig, defaultConfig, resolveOutputPolicy, resolveVerifyCommand } from '../retrofit/config.js';
@@ -31,6 +32,15 @@ import { MAX_PROJECT_WORKERS, sharedPoolStatus, withSharedWorkerSync } from './r
 import { runPrdExplore } from '../prd/explore.js';
 export const DEFAULT_IDLE_MINUTES = 20;
 const STALE_MINUTES = 20; // a running status older than this likely means the loop died
+const nativeReporters = new WeakSet();
+function executionPolicyFingerprint(policy) {
+    const canonical = JSON.stringify(policy, (_key, value) => {
+        if (!value || typeof value !== 'object' || Array.isArray(value))
+            return value;
+        return Object.fromEntries(Object.keys(value).sort().map(key => [key, value[key]]));
+    });
+    return createHash('sha256').update(canonical).digest('hex');
+}
 export function relativeTime(fromIso, now) {
     const ms = Math.max(0, now.getTime() - Date.parse(fromIso));
     const s = Math.floor(ms / 1000);
@@ -241,6 +251,8 @@ async function runContinuousExploration(targetDir, options) {
     }
     const limitDeadline = options.savedRun?.exploreDeadline ?? (options.exploreLimitMs === undefined ? undefined : Date.now() + options.exploreLimitMs);
     const reporter = options.reporter ?? makeReporter(targetDir, { json: options.json, quiet: true });
+    if (!options.reporter)
+        nativeReporters.add(reporter);
     let config;
     try {
         config = loadConfig(targetDir);
@@ -261,6 +273,7 @@ async function runContinuousExploration(targetDir, options) {
     let reviewerAgent = options.reviewer ?? (reviewRequested ? SUPPORTED_AGENTS.find(agent => agent !== defaultImplementationAgent && available(agent)) : undefined);
     let explorationAgent = defaultExplorer;
     let retryWorktree = false;
+    let retryFeedback;
     const safeBatchSize = () => {
         if (retryWorktree)
             return 1;
@@ -365,6 +378,7 @@ async function runContinuousExploration(targetDir, options) {
             resultCode = await Promise.resolve(runLoopCommand(targetDir, {
                 ...innerOptions,
                 agent: implementationAgent,
+                recoveryFeedback: retryFeedback,
                 ...(reviewRequested && reviewerAgent ? { reviewer: reviewerAgent } : {}),
                 ...(batchLimit !== undefined ? { maxIterations: batchLimit } : {}),
                 ...(retryWorktree ? { resumeWorktree: true, parallel: 1, candidates: 1 } : {}),
@@ -455,7 +469,11 @@ async function runContinuousExploration(targetDir, options) {
             }
             continue;
         }
-        if (afterStatus?.reason?.startsWith('integrated completion gate failed') && allCurrentStoriesPass(targetDir)) {
+        if (afterStatus?.failure?.kind === 'no-progress') {
+            reporter.blocked(afterStatus.reason ?? 'Automatic continuation stopped after unchanged failures', afterStatus.failure);
+            return 1;
+        }
+        if (afterStatus?.failure?.kind === 'completion-failed' && allCurrentStoriesPass(targetDir)) {
             retryWorktree = false;
             reporter.phase('exploring', `all planned tasks pass, but ${afterStatus.reason}; looking for work that can resolve the completion gate`, currentProgress(targetDir));
             const scan = await scanForWork(`The integrated completion gate is still failing: ${afterStatus.reason}`);
@@ -478,6 +496,7 @@ async function runContinuousExploration(targetDir, options) {
             continue;
         }
         retryCount++;
+        retryFeedback = afterStatus?.reason;
         advanceRecoveryProviders();
         retryWorktree = (afterStatus?.parallel?.reopened ?? 0) === 0;
         const wait = retryDelay(retryCount);
@@ -579,9 +598,10 @@ export function runLoopCommand(targetDir, opts) {
         }
     }
     const outputPolicy = resolveOutputPolicy(config);
+    const configuredVerifyCommand = opts.verify ? undefined : resolveVerifyCommand(targetDir, config);
     let verify = opts.verify;
     if (!verify) {
-        const command = resolveVerifyCommand(targetDir, config);
+        const command = configuredVerifyCommand;
         if (!command) {
             console.error('No verify command configured. Set verify.command in .yoke/config.yaml (e.g. "npm test") so the loop can confirm tests pass before marking work done.');
             return 2;
@@ -752,6 +772,73 @@ export function runLoopCommand(targetDir, opts) {
         selection: runnerSelection,
         commit: (_path, request) => commitPaths(targetDir, ['.yoke/prd.yaml'], `yoke: plan change ${request.id}`, commitIdentity),
     }));
+    const reviewerProviders = !opts.reviewRunner && (opts.review || opts.reviewer) ? SUPPORTED_AGENTS.filter(available) : [];
+    let review = opts.reviewRunner;
+    let reviewProvider = 'unknown';
+    if (!review && (opts.review || opts.reviewer)) {
+        const reviewerAgent = opts.reviewer ?? reviewerProviders.find(agent => agent !== runnerAgent);
+        if (!reviewerAgent) {
+            if (!opts.allowSelfReview) {
+                console.error('No independent reviewer CLI is available. Install or select a second agent, or pass --allow-self-review explicitly.');
+                return 2;
+            }
+        }
+        const resolvedReviewer = reviewerAgent ?? runnerAgent;
+        reviewProvider = resolvedReviewer;
+        if (resolvedReviewer === runnerAgent && !opts.allowSelfReview) {
+            console.error(`Reviewer "${resolvedReviewer}" is also the implementer. Pick another agent or pass --allow-self-review explicitly.`);
+            return 2;
+        }
+        if (!available(resolvedReviewer)) {
+            console.error(`Reviewer agent CLI "${resolvedReviewer}" was not found on PATH. Install it, or pick another with --reviewer=<${AGENT_LIST}>.`);
+            return 2;
+        }
+        review = context => {
+            const implementer = readStatus(targetDir)?.routingDecisions?.[context.story.id]?.provider ?? runnerAgent;
+            const selectedReviewer = !opts.reviewer && resolvedReviewer === implementer
+                ? reviewerProviders.find(agent => agent !== implementer) ?? resolvedReviewer : resolvedReviewer;
+            if (selectedReviewer === implementer && !opts.allowSelfReview)
+                return { success: false, summary: "Independent review requires a provider distinct from the routed implementer", reviewOutcome: { kind: "infrastructure", summary: "Routed implementation and reviewer share a provider" } };
+            reviewProvider = selectedReviewer;
+            return makeReviewRunner(selectedReviewer, idleMs, undefined, routingEnabled ? roleSelection(targetDir, config, context.story, selectedReviewer, "reviewer") : undefined)(context);
+        };
+    }
+    if (review) {
+        const reviewRunner = review;
+        review = context => {
+            const started = Date.now();
+            let result;
+            try {
+                result = reviewRunner(context);
+                return result;
+            }
+            finally {
+                executionReporter?.addTokens({ inputTokens: 0, outputTokens: 0, measurementComplete: result?.tokens !== undefined, ...result?.tokens, provider: reviewProvider, role: 'reviewer', storyId: context.story.id, durationMs: Date.now() - started });
+            }
+        };
+    }
+    // Only native, attributable roles justify comparisons of complete attempts.
+    // Concurrent candidates have ambiguous story-wide role attribution and remain
+    // conservative until their costs can be joined to an individual alternative.
+    const completeAccounting = candidates === 1 && !opts.runner && !opts.verify && !opts.design && !opts.perf && !opts.audit
+        && !opts.reviewRunner && !opts.qualityRuntime && !opts.git && !opts.intake
+        && (!opts.reporter || nativeReporters.has(opts.reporter));
+    const accountingScope = completeAccounting ? 'execution-attempt' : undefined;
+    const executionPolicyKey = completeAccounting ? executionPolicyFingerprint({
+        version: 1,
+        mode: useParallelDispatcher ? candidates > 1 ? 'candidates' : 'parallel' : 'serial',
+        parallel, candidates, isolate: useParallelDispatcher || isolate,
+        verify: { command: configuredVerifyCommand, retries: config.verify?.retries ?? 1, requireCriteria: config.verify?.requireCriteria ?? false },
+        design: design ? { max: config.design?.max } : false,
+        perf: perf ? { command: config.perf?.command, retries: config.perf?.retries ?? 1 } : false,
+        audit: audit ? config.audit : false,
+        completion: completion ? { command: config.completion?.command, retries: config.completion?.retries ?? 1 } : false,
+        quality: quality ? { defaults: config.quality, overrides: qualityOverrides, limits: quality.repairLimits, runnerAgent, runner: config.runner, agents: config.agents } : false,
+        review: review ? { provider: reviewProvider, explicitProvider: opts.reviewer, eligibleProviders: reviewerProviders, allowSelfReview: opts.allowSelfReview ?? false } : false,
+        roleRouting: routingEnabled && (quality || review) ? config.routing : false,
+        permissions: { implementation: permissions, orchestrator: 'read-only', reviewer: 'read-only', critic: 'read-only', repair: 'safe' },
+        idleMs, ambiguityPolicy,
+    }) : undefined;
     let runner = opts.runner;
     if (!runner) {
         const requiredProviders = useParallelDispatcher
@@ -783,6 +870,9 @@ export function runLoopCommand(targetDir, opts) {
                 strategy: config.routing.strategy,
                 maxCandidates: config.routing.maxCandidates,
                 maxAttempts: config.routing.maxAttempts,
+                optimization: config.routing.optimization,
+                accountingScope,
+                executionPolicyKey,
                 planner: resolvePlanner(config, runnerAgent, runnerSelection),
                 assessmentPolicy: config.routing.assessmentPolicy,
                 fallback: config.routing.fallback,
@@ -805,50 +895,6 @@ export function runLoopCommand(targetDir, opts) {
         }
         runner = makeActionRunner(config.actions, runner);
     }
-    let review = opts.reviewRunner;
-    let reviewProvider = 'unknown';
-    if (!review && (opts.review || opts.reviewer)) {
-        const reviewerAgent = opts.reviewer ?? SUPPORTED_AGENTS.find(agent => agent !== runnerAgent && available(agent));
-        if (!reviewerAgent) {
-            if (!opts.allowSelfReview) {
-                console.error('No independent reviewer CLI is available. Install or select a second agent, or pass --allow-self-review explicitly.');
-                return 2;
-            }
-        }
-        const resolvedReviewer = reviewerAgent ?? runnerAgent;
-        reviewProvider = resolvedReviewer;
-        if (resolvedReviewer === runnerAgent && !opts.allowSelfReview) {
-            console.error(`Reviewer "${resolvedReviewer}" is also the implementer. Pick another agent or pass --allow-self-review explicitly.`);
-            return 2;
-        }
-        if (!available(resolvedReviewer)) {
-            console.error(`Reviewer agent CLI "${resolvedReviewer}" was not found on PATH. Install it, or pick another with --reviewer=<${AGENT_LIST}>.`);
-            return 2;
-        }
-        review = context => {
-            const implementer = readStatus(targetDir)?.routingDecisions?.[context.story.id]?.provider ?? runnerAgent;
-            const selectedReviewer = !opts.reviewer && resolvedReviewer === implementer
-                ? SUPPORTED_AGENTS.find(agent => agent !== implementer && available(agent)) ?? resolvedReviewer : resolvedReviewer;
-            if (selectedReviewer === implementer && !opts.allowSelfReview)
-                return { success: false, summary: "Independent review requires a provider distinct from the routed implementer", reviewOutcome: { kind: "infrastructure", summary: "Routed implementation and reviewer share a provider" } };
-            reviewProvider = selectedReviewer;
-            return makeReviewRunner(selectedReviewer, idleMs, undefined, routingEnabled ? roleSelection(targetDir, config, context.story, selectedReviewer, "reviewer") : undefined)(context);
-        };
-    }
-    if (review) {
-        const reviewRunner = review;
-        review = context => {
-            const started = Date.now();
-            let result;
-            try {
-                result = reviewRunner(context);
-                return result;
-            }
-            finally {
-                executionReporter?.addTokens({ inputTokens: 0, outputTokens: 0, measurementComplete: result?.tokens !== undefined, ...result?.tokens, provider: reviewProvider, role: 'reviewer', storyId: context.story.id, durationMs: Date.now() - started });
-            }
-        };
-    }
     if (!useParallelDispatcher) {
         if (runner) {
             const unpooled = runner;
@@ -951,6 +997,8 @@ export function runLoopCommand(targetDir, opts) {
             providers: parallelProviders,
             affinityProviders: parallelAffinityProviders,
             routing: routingEnabled ? config.routing : undefined,
+            accountingScope,
+            executionPolicyKey,
             planning: config.planning,
             isAvailable: available,
             onAmbiguity: ambiguityPolicy,
@@ -976,6 +1024,7 @@ export function runLoopCommand(targetDir, opts) {
             prdPath: path,
             targetDir,
             runner,
+            feedback: opts.recoveryFeedback,
             git,
             commitIdentity,
             verify,

package/dist/loop/runner.js

@@ -9,6 +9,7 @@ import { loadContext, formatForPrompt, contextDir } from '../context/context.js'
 import { contextPacket } from '../context/packet.js';
 import { buildProviderInvocation, startProviderProcess } from '../agents/providers.js';
 import { parseProviderResult, parseProviderTelemetry } from '../agents/telemetry.js';
+import { providerTelemetryUsage } from '../observability/usage.js';
 import { formatReviewContract, formatReviewStdoutContract, parseReviewVerdict } from '../review/verdict.js';
 import { prepareWindowsInvocation } from '../agents/windows-launch.js';
 import { readSupervision } from '../agents/supervision.js';
@@ -243,7 +244,7 @@ function processFailureSummary(error) {
 export function runCapturedAgent(agent, inv) {
     try {
         const output = runCliCapture(inv);
-        return { success: true, output, summary: 'exited 0', tokens: parseProviderTelemetry(agent, output.split(/\r?\n/)).tokens };
+        return { success: true, output, summary: 'exited 0', tokens: providerTelemetryUsage(parseProviderTelemetry(agent, output.split(/\r?\n/))) };
     }
     catch (error) {
         const partial = error.stdout;
@@ -252,7 +253,7 @@ export function runCapturedAgent(agent, inv) {
             success: false,
             output,
             summary: error.message,
-            tokens: output ? parseProviderTelemetry(agent, output.split(/\r?\n/)).tokens : undefined,
+            tokens: output ? providerTelemetryUsage(parseProviderTelemetry(agent, output.split(/\r?\n/))) : undefined,
         };
     }
 }
@@ -316,12 +317,12 @@ export function makeRunner(agent, idleTimeoutMs = 0, opts = {}) {
             try {
                 const out = capture(inv);
                 const telemetry = parseProviderTelemetry(agent, out.split(/\r?\n/));
-                return { success: true, summary: `${agent} implemented ${ctx.story.id}`, tokens: attributed(telemetry.tokens) };
+                return { success: true, summary: `${agent} implemented ${ctx.story.id}`, tokens: attributed(providerTelemetryUsage(telemetry)) };
             }
             catch (e) {
                 // Salvage usage from whatever the agent streamed before dying — those tokens were spent.
                 const partial = e.stdout;
-                const tokens = partial == null ? undefined : parseProviderTelemetry(agent, String(partial).split(/\r?\n/)).tokens;
+                const tokens = partial == null ? undefined : providerTelemetryUsage(parseProviderTelemetry(agent, String(partial).split(/\r?\n/)));
                 const reason = readSupervision(ctx.targetDir, new Date(started).toISOString())[0]?.reason;
                 return { success: false, infrastructureFailure: true, summary: `${agent} failed on ${ctx.story.id}: ${reason ?? e.message}`, tokens: attributed(tokens) };
             }

package/dist/loop/worker.js

@@ -3,6 +3,9 @@ import { existsSync } from "node:fs";
 import { join } from "node:path";
 import { acceptanceProtectionProblem } from "../check/command.js";
 import { isAcceptanceCriterion } from './prd.js';
+import { observeFailure } from './failure.js';
+import { consumeAmbiguity } from './loop.js';
+import { gateIdentity, snapshotGates, reuseGates } from './gate-snapshot.js';
 import { runQualityRepairLoop } from '../quality/loop.js';
 function emptyEvidence() { return { criteria: [] }; }
 function errorMessage(error) {
@@ -40,6 +43,7 @@ function reviewOutcome(result) {
     return { kind: 'malformed', summary: result.summary };
 }
 function runMechanicalGates(input, context, evidence) {
+    evidence.criteria = [];
     const criteria = context.story.acceptance.filter(isAcceptanceCriterion);
     if (criteria.length === 0) {
         if (input.requireCriterionEvidence)
@@ -170,8 +174,13 @@ export async function runStoryWorker(input) {
         return finalResult(input, { ...baseResult(input, evidence, preflight.summary), kind: 'mechanical-failure', stage: 'quality' });
     }
     let implementation;
+    let verified;
+    let failure;
     try {
-        implementation = await runWorkerImplementation(input, context, evidence);
+        const outcome = await runWorkerImplementation(input, context, evidence);
+        implementation = outcome.result;
+        verified = outcome.gates;
+        failure = outcome.failure;
     }
     catch (error) {
         return finalResult(input, {
@@ -185,110 +194,155 @@ export async function runStoryWorker(input) {
     if (implementation.infrastructureFailure)
         implementation.routing?.recordOutcome(false, 'infrastructure');
     if (implementation.infrastructureFailure || implementation.routing?.blocked)
-        return finalResult(input, { ...baseResult(input, evidence, implementation.summary), kind: "mechanical-failure", stage: "implementation" });
-    const afterImplementationCancellation = cancellationReason(input.cancellation);
-    if (afterImplementationCancellation) {
-        return finalResult(input, { ...baseResult(input, evidence, afterImplementationCancellation), kind: 'cancelled' });
-    }
-    const decision = input.beforeGates?.(context);
-    if (decision) {
-        return finalResult(input, { ...baseResult(input, evidence, decision), kind: 'paused', reason: 'decision' });
-    }
-    const gates = runMechanicalGates(input, context, evidence);
-    if (gates.kind === 'cancelled') {
-        return finalResult(input, { ...baseResult(input, evidence, gates.summary), kind: 'cancelled' });
-    }
-    if (gates.kind === 'failed') {
-        implementation.routing?.recordOutcome(false);
-        return finalResult(input, { ...baseResult(input, evidence, gates.summary), kind: 'mechanical-failure', stage: gates.stage });
-    }
-    const summary = implementation.success
-        ? implementation.summary
-        : `${implementation.summary} (runner exited non-zero but verify is green)`;
-    if (!qualityEnabled && !input.review) {
-        return finalResult(input, {
-            ...baseResult(input, evidence, summary),
-            kind: 'candidate',
-            routing: { outcome: 'pending-integration', ...(implementation.routing ? { recordOutcome: implementation.routing.recordOutcome } : {}) },
-            ...(implementation.tokens ? { tokens: implementation.tokens } : {}),
+        return finalResult(input, { ...baseResult(input, evidence, implementation.summary), kind: "mechanical-failure", stage: "implementation", ...(failure ? { failure } : {}) });
+    try {
+        const afterImplementationCancellation = cancellationReason(input.cancellation);
+        if (afterImplementationCancellation) {
+            implementation.routing?.recordOutcome(false, 'infrastructure');
+            return finalResult(input, { ...baseResult(input, evidence, afterImplementationCancellation), kind: 'cancelled' });
+        }
+        const ambiguity = consumeAmbiguity(context.targetDir);
+        if (ambiguity) {
+            implementation.routing?.recordOutcome(false, 'infrastructure');
+            return finalResult(input, {
+                ...baseResult(input, evidence, `story ${context.story.id} stopped: ambiguous acceptance criteria — ${ambiguity}`),
+                kind: 'paused', reason: 'ambiguity',
+            });
+        }
+        const decision = input.beforeGates?.(context);
+        if (decision) {
+            implementation.routing?.recordOutcome(false, 'infrastructure');
+            return finalResult(input, { ...baseResult(input, evidence, decision), kind: 'paused', reason: 'decision' });
+        }
+        if (input.pause?.()) {
+            implementation.routing?.recordOutcome(false, 'infrastructure');
+            return finalResult(input, { ...baseResult(input, evidence, 'worker paused before acceptance checks'), kind: 'paused' });
+        }
+        const gates = reuseGates(context.targetDir, context.story, verified) ?? runMechanicalGates(input, context, evidence);
+        if (gates.kind === 'cancelled') {
+            implementation.routing?.recordOutcome(false, 'infrastructure');
+            return finalResult(input, { ...baseResult(input, evidence, gates.summary), kind: 'cancelled' });
+        }
+        if (gates.kind === 'failed') {
+            implementation.routing?.recordOutcome(false);
+            const observed = input.failureRoot ? observeFailure({ root: input.failureRoot, scope: input.failureScope, directory: context.targetDir, story: context.story, stage: gates.stage, summary: gates.summary }) : undefined;
+            return finalResult(input, { ...baseResult(input, evidence, observed?.feedback ?? gates.summary), kind: 'mechanical-failure', stage: gates.stage, ...(observed ? { failure: observed.failure } : {}) });
+        }
+        const summary = implementation.success
+            ? implementation.summary
+            : `${implementation.summary} (runner exited non-zero but verify is green)`;
+        if (!qualityEnabled && !input.review) {
+            return finalResult(input, {
+                ...baseResult(input, evidence, summary),
+                kind: 'candidate',
+                routing: { outcome: 'pending-integration', ...(implementation.routing ? { recordOutcome: implementation.routing.recordOutcome } : {}) },
+                ...(implementation.tokens ? { tokens: implementation.tokens } : {}),
+            });
+        }
+        const beforeQualityCancellation = cancellationReason(input.cancellation);
+        if (beforeQualityCancellation) {
+            implementation.routing?.recordOutcome(false, 'infrastructure');
+            return finalResult(input, { ...baseResult(input, evidence, beforeQualityCancellation), kind: 'cancelled' });
+        }
+        const qualityStage = qualityEnabled ? input.qualityStage : undefined;
+        const review = input.review;
+        let qualityFailure;
+        const quality = runQualityRepairLoop({
+            ...(qualityStage
+                ? { quality: (round) => {
+                        input.reporter?.phase('comparing');
+                        return qualityStage(context, round);
+                    } }
+                : {}),
+            ...(review
+                ? { review: () => {
+                        input.reporter?.phase('reviewing');
+                        return reviewOutcome(review(context));
+                    } }
+                : {}),
+            repair: request => {
+                if (!input.repair)
+                    return { kind: 'blocked', summary: 'repair callback is not configured' };
+                input.reporter?.phase('repairing');
+                const observed = input.failureRoot ? observeFailure({ root: input.failureRoot, scope: input.failureScope, directory: context.targetDir, story: context.story, stage: 'quality', summary: JSON.stringify(request.finding) }) : undefined;
+                if (observed?.action === 'blocked') {
+                    qualityFailure = observed.failure;
+                    return { kind: 'blocked', summary: observed.feedback };
+                }
+                const targetedRequest = observed?.action === 'diagnose' ? { ...request, finding: { ...request.finding, message: observed.feedback } } : request;
+                const repair = input.repair(context, targetedRequest);
+                return repair.success ? { kind: 'repaired' } : { kind: 'blocked', summary: repair.summary };
+            },
+            rerunGates: () => {
+                const rerun = runMechanicalGates(input, context, evidence);
+                if (rerun.kind === 'passed')
+                    return { kind: 'passed' };
+                if (rerun.kind === 'cancelled')
+                    return rerun;
+                return { kind: 'failed', stage: rerun.stage, summary: rerun.summary };
+            },
+            ...(input.repairLimits ? { limits: input.repairLimits } : {}),
+            pause: input.pause,
+            onStatus: status => {
+                const metadata = input.qualityMetadata?.(context);
+                input.reporter?.quality({ ...status, ...(metadata ?? { policy: 'blocking' }) });
+            },
         });
+        evidence.quality = quality;
+        const afterQualityCancellation = cancellationReason(input.cancellation);
+        if (afterQualityCancellation) {
+            implementation.routing?.recordOutcome(false, 'infrastructure');
+            return finalResult(input, { ...baseResult(input, evidence, afterQualityCancellation), kind: 'cancelled' });
+        }
+        const result = { ...resultFromQuality(input, evidence, summary, quality), ...(qualityFailure ? { failure: qualityFailure } : {}) };
+        if (result.kind === 'paused' || result.kind === 'cancelled' || result.kind === 'review-failure' || result.kind === 'quality-failure')
+            implementation.routing?.recordOutcome(false, 'infrastructure');
+        else if (result.kind !== 'candidate')
+            implementation.routing?.recordOutcome(false);
+        if (result.kind === 'candidate') {
+            return finalResult(input, {
+                ...result,
+                routing: { outcome: 'pending-integration', ...(implementation.routing ? { recordOutcome: implementation.routing.recordOutcome } : {}) },
+                ...(implementation.tokens ? { tokens: implementation.tokens } : {}),
+            });
+        }
+        return finalResult(input, result);
     }
-    const beforeQualityCancellation = cancellationReason(input.cancellation);
-    if (beforeQualityCancellation) {
-        return finalResult(input, { ...baseResult(input, evidence, beforeQualityCancellation), kind: 'cancelled' });
-    }
-    const qualityStage = qualityEnabled ? input.qualityStage : undefined;
-    const review = input.review;
-    const quality = runQualityRepairLoop({
-        ...(qualityStage
-            ? { quality: (round) => {
-                    input.reporter?.phase('comparing');
-                    return qualityStage(context, round);
-                } }
-            : {}),
-        ...(review
-            ? { review: () => {
-                    input.reporter?.phase('reviewing');
-                    return reviewOutcome(review(context));
-                } }
-            : {}),
-        repair: request => {
-            if (!input.repair)
-                return { kind: 'blocked', summary: 'repair callback is not configured' };
-            input.reporter?.phase('repairing');
-            const repair = input.repair(context, request);
-            return repair.success ? { kind: 'repaired' } : { kind: 'blocked', summary: repair.summary };
-        },
-        rerunGates: () => {
-            const rerun = runMechanicalGates(input, context, evidence);
-            if (rerun.kind === 'passed')
-                return { kind: 'passed' };
-            if (rerun.kind === 'cancelled')
-                return rerun;
-            return { kind: 'failed', stage: rerun.stage, summary: rerun.summary };
-        },
-        ...(input.repairLimits ? { limits: input.repairLimits } : {}),
-        pause: input.pause,
-        onStatus: status => {
-            const metadata = input.qualityMetadata?.(context);
-            input.reporter?.quality({ ...status, ...(metadata ?? { policy: 'blocking' }) });
-        },
-    });
-    evidence.quality = quality;
-    const afterQualityCancellation = cancellationReason(input.cancellation);
-    if (afterQualityCancellation) {
-        return finalResult(input, { ...baseResult(input, evidence, afterQualityCancellation), kind: 'cancelled' });
-    }
-    const result = resultFromQuality(input, evidence, summary, quality);
-    if (result.kind !== 'candidate' && result.kind !== 'paused')
-        implementation.routing?.recordOutcome(false);
-    if (result.kind === 'candidate') {
-        return finalResult(input, {
-            ...result,
-            routing: { outcome: 'pending-integration', ...(implementation.routing ? { recordOutcome: implementation.routing.recordOutcome } : {}) },
-            ...(implementation.tokens ? { tokens: implementation.tokens } : {}),
-        });
+    catch (error) {
+        implementation.routing?.recordOutcome(false, 'infrastructure');
+        throw error;
     }
-    return finalResult(input, result);
 }
 async function runWorkerImplementation(input, context, evidence) {
-    let feedback;
+    let feedback = input.feedback;
     for (let attempt = 0;; attempt++) {
         const result = await input.runner({ ...context, feedback });
         if (!result.routing?.canRetry || result.routing.blocked || attempt >= 7 || cancellationReason(input.cancellation) || input.pause?.())
-            return result;
+            return { result };
         if (["decision-request.yaml", "ambiguity.md", "loop.pause"].some(name => existsSync(join(context.targetDir, ".yoke", name))) || acceptanceProtectionProblem(context.targetDir))
-            return result;
-        const gates = runMechanicalGates(input, context, evidence);
-        if (gates.kind !== "failed")
-            return result;
+            return { result };
+        const before = gateIdentity(context.targetDir, context.story);
+        let gates;
+        try {
+            gates = runMechanicalGates(input, context, evidence);
+        }
+        catch (error) {
+            result.routing.recordOutcome(false, 'infrastructure');
+            throw error;
+        }
+        if (gates.kind !== 'failed') {
+            return { result, ...(gates.kind === 'passed' ? { gates: snapshotGates(context.targetDir, context.story, before, gates) } : {}) };
+        }
         if (knownInfrastructureFailure(gates.summary)) {
             result.routing.recordOutcome(false, 'infrastructure');
-            return { ...result, success: false, infrastructureFailure: true, summary: gates.summary, routing: { ...result.routing, blocked: true, canRetry: false } };
+            return { result: { ...result, success: false, infrastructureFailure: true, summary: gates.summary, routing: { ...result.routing, blocked: true, canRetry: false } } };
         }
         result.routing.recordOutcome(false);
+        const observed = input.failureRoot ? observeFailure({ root: input.failureRoot, scope: input.failureScope, directory: context.targetDir, story: context.story, stage: gates.stage, summary: gates.summary }) : undefined;
+        if (observed?.action === 'blocked')
+            return { result: { ...result, success: false, summary: observed.feedback, routing: { ...result.routing, blocked: true, canRetry: false } }, failure: observed.failure };
         if (result.tokens)
             input.reporter?.addTokens(result.tokens);
-        feedback = gates.summary;
+        feedback = observed?.feedback ?? gates.summary;
     }
 }

package/dist/observability/history.js

@@ -30,7 +30,7 @@ export function archiveMeasurement(root, event) {
             throw error;
     }
     const data = event.data ?? {};
-    const allowed = ['inputTokens', 'outputTokens', 'cachedInputTokens', 'cacheWriteInputTokens', 'reasoningOutputTokens', 'totalCostUsd', 'agent', 'provider', 'model', 'actualModel', 'requestedModel', 'variant', 'role', 'calls', 'measurementComplete', 'costMeasurementComplete', 'usageAvailable', 'prediction', 'errorMs', 'withinObservedRange', 'escalated'];
+    const allowed = ['inputTokens', 'outputTokens', 'cachedInputTokens', 'cacheWriteInputTokens', 'reasoningOutputTokens', 'totalCostUsd', 'agent', 'provider', 'model', 'actualModel', 'requestedProvider', 'requestedModel', 'requestedReasoningEffort', 'requestedVariant', 'variant', 'role', 'callId', 'parentCallId', 'calls', 'measurementComplete', 'costMeasurementComplete', 'usageAvailable', 'prediction', 'errorMs', 'withinObservedRange', 'escalated'];
     const compact = { ...event, data: Object.fromEntries(allowed.filter(key => data[key] !== undefined).map(key => [key, data[key]])) };
     appendFileSync(file, JSON.stringify(compact) + '\n');
 }