@hecer/yoke 1.7.0 → 1.9.0

package/dist/goals/command.js

@@ -1,3 +1,5 @@
+import { loadConfig } from "../retrofit/config.js";
+import { makeAsyncAdaptiveRunner } from "../routing/router.js";
 import { randomUUID } from 'node:crypto';
 import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync, unlinkSync, readdirSync } from 'node:fs';
 import { join } from 'node:path';
@@ -97,7 +99,7 @@ export function goalHandoff(root) {
 async function executeAgent(input) {
     const handle = startProviderProcess(input.provider, buildProviderInvocation(input.provider, input.prompt, input.root, 'safe', input.selection), { signal: input.signal, idleTimeoutMs: 20 * 60_000 });
     const result = await handle.completion;
-    return { success: result.kind === 'succeeded', summary: result.kind === 'succeeded' ? 'Agent finished; independently checked below' : `${result.kind}: ${result.stderr.slice(-3000)}`, ...result.telemetry.tokens };
+    return { success: result.kind === 'succeeded', summary: result.kind === 'succeeded' ? 'Agent finished; independently checked below' : `${result.kind}: ${result.stderr.slice(-3000)}`, ...result.telemetry.tokens, tokens: result.telemetry.tokens };
 }
 export async function runProjectGoal(root, options = {}) {
     const lock = acquireLock(root);
@@ -130,7 +132,24 @@ export async function runProjectGoal(root, options = {}) {
                 throw error;
         }
         const provider = options.provider ?? 'codex';
-        const execute = options.execute ?? executeAgent;
+        const rawExecute = options.execute ?? executeAgent;
+        const config = loadConfig(root);
+        const execute = async (input) => {
+            if (!config?.routing?.enabled || config.routing.strategy !== "capability")
+                return rawExecute(input);
+            const routed = makeAsyncAdaptiveRunner({ parent: provider, parentSelection: input.selection, projectRoot: root, workers: config.routing.workers, strategy: "capability", maxCandidates: config.routing.maxCandidates, maxAttempts: Math.min(goal.maxAttempts, config.routing.maxAttempts ?? 5),
+                captureRoute: async (agent, context, prompt, selection) => {
+                    const run = await startProviderProcess(agent, buildProviderInvocation(agent, prompt, root, "read-only", selection), { signal: input.signal, idleTimeoutMs: 20 * 60_000 }).completion;
+                    return { success: run.kind === "succeeded", summary: run.kind, output: run.stdout, tokens: run.telemetry.tokens };
+                },
+                makeWorker: (agent, selection) => async (context) => {
+                    const result = await rawExecute({ ...input, provider: agent, selection, prompt: input.prompt + "\nPlanner approach:\n" + (context.story.assessment?.approach ?? "") });
+                    return { ...result, infrastructureFailure: !result.success, tokens: result.tokens ?? (result.inputTokens !== undefined && result.outputTokens !== undefined ? { inputTokens: result.inputTokens, outputTokens: result.outputTokens, model: result.model } : undefined) };
+                }, });
+            const result = await routed({ targetDir: root, story: { id: goal.id, title: goal.objective, priority: 1, passes: false, agent: provider, acceptance: manifest.criteria.map(c => c.text) } });
+            const last = result.tokens?.calls?.at(-1);
+            return { ...result, provider: last?.provider ?? provider, model: last?.actualModel, inputTokens: result.tokens?.measurementComplete ? result.tokens.inputTokens : undefined, outputTokens: result.tokens?.measurementComplete ? result.tokens.outputTokens : undefined };
+        };
         let report = checkProject(root);
         while (report.status !== 'passed') {
             const protectionProblem = acceptanceProtectionProblem(root);
@@ -167,10 +186,18 @@ export async function runProjectGoal(root, options = {}) {
             const agentDurationMs = Date.now() - started;
             const checkStarted = Date.now();
             report = checkProject(root);
+            if (!result.routing?.blocked)
+                result.routing?.recordOutcome(report.status === 'passed');
             appendEvent(root, { runId: goal.id, timestamp: new Date().toISOString(), type: 'phase-ended', phase: 'verify', durationMs: Date.now() - checkStarted, outcome: report.status });
-            goal.attempts.push({ provider, model: result.model ?? options.selection?.model, startedAt: new Date(started).toISOString(), durationMs: agentDurationMs, success: result.success, summary: result.summary.slice(0, 8000), checkId: report.id, inputTokens: result.inputTokens, outputTokens: result.outputTokens });
-            appendEvent(root, { runId: goal.id, timestamp: new Date().toISOString(), type: 'attempt-ended', attemptId: `${goal.id}:${goal.attempts.length}`, durationMs: Date.now() - started, outcome: report.status, data: { provider, model: result.model, inputTokens: result.inputTokens, outputTokens: result.outputTokens } });
+            goal.attempts.push({ provider: result.provider ?? provider, model: result.model ?? options.selection?.model, startedAt: new Date(started).toISOString(), durationMs: agentDurationMs, success: result.success, summary: result.summary.slice(0, 8000), checkId: report.id, inputTokens: result.inputTokens, outputTokens: result.outputTokens });
+            const usageAvailable = result.inputTokens !== undefined && result.outputTokens !== undefined;
+            appendEvent(root, { runId: goal.id, timestamp: new Date().toISOString(), type: 'tokens', attemptId: `${goal.id}:${goal.attempts.length}`, durationMs: agentDurationMs, data: { ...result.tokens, provider: result.provider ?? provider, role: 'parent', model: result.model, inputTokens: result.inputTokens, outputTokens: result.outputTokens, usageAvailable } });
+            appendEvent(root, { runId: goal.id, timestamp: new Date().toISOString(), type: 'attempt-ended', attemptId: `${goal.id}:${goal.attempts.length}`, durationMs: Date.now() - started, outcome: report.status, data: { provider, model: result.model, usageAvailable } });
+            if (report.status === 'passed')
+                appendEvent(root, { runId: goal.id, timestamp: new Date().toISOString(), type: 'accepted', attemptId: `${goal.id}:${goal.attempts.length}` });
             goal = save(root, { ...goal, lastCheck: report.id, pendingAttempt: undefined });
+            if (result.routing?.blocked)
+                return save(root, { ...goal, status: "blocked", reason: result.summary });
             if (controller.signal.aborted)
                 return save(root, { ...goal, status: 'blocked', reason: 'Time budget exceeded; work retained' });
         }

package/dist/loop/dispatcher.js

@@ -163,11 +163,13 @@ export function createDispatcher(options) {
                 case 'integrated':
                     input.story.passes = true;
                     integrated.push(input.story.id);
+                    options.onAccepted?.(input.story);
                     result.routing.recordOutcome?.(true);
                     return;
                 case 'integrated-but-blocked':
                     input.story.passes = true;
                     integrated.push(input.story.id);
+                    options.onAccepted?.(input.story);
                     integrationBlocks.push(merge.reason);
                     result.routing.recordOutcome?.(true);
                     return;
@@ -301,7 +303,8 @@ export function createDispatcher(options) {
                 paused = true;
             if (!paused && !cancellationReason && integrationBlocks.length === 0 && iterations < options.maxIterations) {
                 const busy = new Set([...active.keys(), ...queued.keys(), ...failed]);
-                const slots = Math.max(0, options.maxConcurrency - active.size);
+                // Integration/review retains its execution slot until the candidate lands.
+                const slots = Math.max(0, options.maxConcurrency - active.size - queued.size);
                 const ready = readyStories(options.stories, { activeAreas: areas, activeWrites: [...reservedWrites.values()] }).filter(story => !busy.has(story.id));
                 let launched = 0;
                 for (const story of ready) {
@@ -316,7 +319,7 @@ export function createDispatcher(options) {
                 }
             }
             if (active.size > 0) {
-                await Promise.race([...active.values()].map(worker => worker.task));
+                await Promise.race([...active.values()].map(worker => worker.task).concat([...queued.values()]));
                 continue;
             }
             if (queued.size > 0) {

package/dist/loop/git.js

@@ -1,6 +1,6 @@
 import { execFileSync } from 'node:child_process';
 import { sanitizeCommitMessage } from './identity.js';
-export const RUNTIME_PATHS = ['.yoke/artifacts', '.yoke/events', '.yoke/checks', '.yoke/goal.json', '.yoke/goal.pause'];
+export const RUNTIME_PATHS = ['.yoke/artifacts', '.yoke/events', '.yoke/history', '.yoke/routing', '.yoke/checks', '.yoke/goal.json', '.yoke/goal.pause'];
 export const RUNTIME_EXCLUDES = RUNTIME_PATHS.map(path => `:(exclude)${path}${path.endsWith('.json') || path.endsWith('.pause') ? '' : '/**'}`);
 export const realGitOps = {
     isClean(dir) {

package/dist/loop/loop.js

@@ -1,3 +1,4 @@
+import { knownInfrastructureFailure } from "../routing/capability.js";
 import { existsSync, unlinkSync, readFileSync } from 'node:fs';
 import { acceptanceProtectionProblem } from '../check/command.js';
 import { join, relative } from 'node:path';
@@ -302,10 +303,14 @@ export function runLoop(opts) {
             let landed = null;
             try {
                 opts.git.addWorktree(opts.targetDir, wt);
-                const result = opts.runner({ targetDir: wt, story });
+                const result = runImplementation(opts, wt, story, reporter);
                 iterations++;
                 if (result.tokens)
                     reporter.addTokens(result.tokens);
+                if (result.routing?.blocked) {
+                    reporter.blocked(result.summary);
+                    return { status: "blocked", iterations, reason: result.summary, finalProgress: progress(stories) };
+                }
                 let decision;
                 try {
                     decision = consumeDecisionRequest(wt, opts.targetDir, story.id);
@@ -398,7 +403,6 @@ export function runLoop(opts) {
                     reporter.blocked(protection);
                     return { status: 'blocked', iterations, reason: protection, 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.
@@ -412,6 +416,7 @@ export function runLoop(opts) {
                 savePrd(wtPrd, updated);
                 opts.git.commitAll(wt, `yoke: complete ${story.id} ${story.title}`, opts.commitIdentity);
                 opts.git.integrate(opts.targetDir, wt);
+                result.routing?.recordOutcome(true);
                 landed = progress(updated);
             }
             catch (e) {
@@ -433,10 +438,14 @@ export function runLoop(opts) {
                 reporter.storyDone({ id: story.id, title: story.title }, landed);
             continue;
         }
-        const result = opts.runner({ targetDir: opts.targetDir, story });
+        const result = runImplementation(opts, opts.targetDir, story, reporter);
         iterations++;
         if (result.tokens)
             reporter.addTokens(result.tokens);
+        if (result.routing?.blocked) {
+            reporter.blocked(result.summary);
+            return { status: "blocked", iterations, reason: result.summary, finalProgress: progress(stories) };
+        }
         let decision;
         try {
             decision = consumeDecisionRequest(opts.targetDir, opts.targetDir, story.id);
@@ -570,3 +579,35 @@ export function runLoop(opts) {
         reporter.storyDone({ id: story.id, title: story.title }, progress(updated));
     }
 }
+function runImplementation(opts, dir, story, reporter) {
+    let feedback;
+    for (let attempt = 0;; attempt++) {
+        const result = opts.runner({ targetDir: dir, story, feedback });
+        if (!result.routing?.canRetry || result.routing.blocked || attempt >= 7)
+            return result;
+        if (["decision-request.yaml", "ambiguity.md", "loop.pause"].some(name => existsSync(join(dir, ".yoke", name))) || existsSync(pauseFilePath(opts.targetDir)))
+            return result;
+        const protection = acceptanceProtectionProblem(dir, opts.targetDir);
+        if (protection)
+            return result;
+        const criteria = runCriterionGates(opts, dir, story);
+        const gates = [opts.verify, opts.design, opts.perf, opts.audit].filter((gate) => Boolean(gate));
+        let verdict = criteria;
+        if (verdict.passed)
+            for (const gate of gates) {
+                verdict = runGate(gate, dir, story.id);
+                if (!verdict.passed)
+                    break;
+            }
+        if (verdict.passed)
+            return result;
+        if (knownInfrastructureFailure(verdict.summary)) {
+            result.routing.recordOutcome(false, "infrastructure");
+            return result;
+        }
+        result.routing.recordOutcome(false);
+        if (result.tokens)
+            reporter.addTokens(result.tokens);
+        feedback = verdict.summary;
+    }
+}

package/dist/loop/parallel-command.js

@@ -1,5 +1,8 @@
 import { existsSync, rmSync } from 'node:fs';
 import { acceptanceProtectionProblem } from '../check/command.js';
+import { makeAsyncAdaptiveRunner } from '../routing/router.js';
+import { startProviderProcess } from '../agents/process.js';
+import { runnerInvocation, isAgentAvailable } from './runner.js';
 import { createDispatcher } from './dispatcher.js';
 import { consumeDecisionRequest } from './decision.js';
 import { pauseFilePath } from './loop.js';
@@ -45,6 +48,7 @@ export async function runParallelLoopCommand(input) {
         } : {}),
         pause,
         onProgress: status => input.reporter.parallel?.(status),
+        onAccepted: story => input.reporter.accepted?.(story),
         gates: {
             verify: input.verify,
             design: input.design,
@@ -202,7 +206,7 @@ function workerReporter(reporter, worker, candidate) {
             else
                 reporter.quality(quality);
         },
-        addTokens: usage => reporter.addTokens(usage),
+        addTokens: usage => reporter.addTokens({ ...usage, storyId: worker.story.id }),
     };
 }
 function candidateReporter(reporter, worker, candidate, state, reason) {
@@ -247,29 +251,66 @@ function reportIntegrator(reporter, worker, phase) {
         reporter.phase(phase);
 }
 function asyncRunner(input, provider, signal, workerId) {
-    const { model: _globalModel, reasoningEffort: _globalReasoningEffort, ...selection } = input.selection;
+    if (input.routing) {
+        const routed = makeAsyncAdaptiveRunner({
+            parent: input.routing.strategy === 'capability' ? input.runnerAgent : provider.provider,
+            parentSelection: input.routing.strategy === 'capability' ? input.selection : { ...input.selection, model: provider.model, reasoningEffort: provider.reasoningEffort, nativeMultiAgent: false },
+            projectRoot: input.targetDir,
+            workers: input.routing.workers,
+            rules: input.routing.rules,
+            strategy: input.routing.strategy,
+            maxCandidates: input.routing.maxCandidates,
+            maxAttempts: input.routing.maxAttempts,
+            onDecision: (id, decision) => input.reporter.routingDecision?.(id, decision),
+            orchestratorSelection: input.routing.orchestrator,
+            isAvailable: input.isAvailable ?? isAgentAvailable,
+            captureRoute: async (agent, context, prompt, selection) => {
+                const result = await startProviderProcess(agent, runnerInvocation(agent, prompt, context.targetDir, true, 'read-only', selection), { idleTimeoutMs: input.idleMs, signal, workerId }).completion;
+                return { ...providerProcessResultToAgentResult(agent, context.story.id, result), output: result.stdout };
+            },
+            makeWorker: (agent, selection) => async (context) => {
+                if (signal?.aborted)
+                    return { success: false, summary: 'Routing cancelled before worker start' };
+                input.reporter.parallelWorker?.({ story: context.story.id, storyTitle: context.story.title, provider: agent, selectedProvider: agent, selectedModel: selection.model, phase: 'implementing' });
+                const run = makeAsyncRunner(agent, { onAmbiguity: input.onAmbiguity, permissions: input.permissions, selection,
+                    process: { idleTimeoutMs: input.idleMs, signal, workerId } });
+                return providerProcessResultToAgentResult(agent, context.story.id, await run(context).completion);
+            },
+        });
+        return context => context.story.agent && input.routing?.strategy !== 'capability'
+            ? asyncRunner({ ...input, routing: undefined }, provider, signal, workerId)(context)
+            : routed(context);
+    }
+    const { model: _globalModel, reasoningEffort: _globalReasoningEffort, nativeMultiAgent: _globalNative, bare: globalBare, ...selection } = input.selection;
     const runner = makeAsyncRunner(provider.provider, {
         onAmbiguity: input.onAmbiguity,
         permissions: input.permissions,
         selection: {
             ...selection,
-            ...(provider.provider === 'codex' ? { nativeMultiAgent: false } : {}),
+            ...(provider.provider !== 'gemini' && globalBare !== undefined ? { bare: globalBare } : {}),
+            nativeMultiAgent: false,
             ...(provider.model ? { model: provider.model } : {}),
             ...(provider.reasoningEffort ? { reasoningEffort: provider.reasoningEffort } : {}),
         },
         process: { idleTimeoutMs: input.idleMs, signal, workerId },
     });
-    return async (context) => providerProcessResultToAgentResult(provider.provider, context.story.id, await runner(context).completion);
+    return async (context) => {
+        const started = Date.now();
+        const result = providerProcessResultToAgentResult(provider.provider, context.story.id, await runner(context).completion);
+        if (result.tokens)
+            result.tokens = { ...result.tokens, provider: provider.provider, role: 'worker', storyId: context.story.id, durationMs: Date.now() - started };
+        return result;
+    };
 }
 export function providerProcessResultToAgentResult(agent, storyId, result) {
     const tokens = result.telemetry.tokens;
     const telemetry = tokens ? { tokens } : {};
     switch (result.kind) {
         case 'succeeded': return { success: true, summary: `${agent} implemented ${storyId}`, ...telemetry };
-        case 'cancelled': return { success: false, summary: result.reason, ...telemetry };
-        case 'timed-out': return { success: false, summary: result.reason, ...telemetry };
-        case 'spawn-failed': return { success: false, summary: result.error, ...telemetry };
-        case 'failed': return { success: false, summary: `${agent} exited ${result.exitCode ?? 'without a code'}`, ...telemetry };
+        case 'cancelled': return { success: false, infrastructureFailure: true, summary: result.reason, ...telemetry };
+        case 'timed-out': return { success: false, infrastructureFailure: true, summary: result.reason, ...telemetry };
+        case 'spawn-failed': return { success: false, infrastructureFailure: true, summary: result.error, ...telemetry };
+        case 'failed': return { success: false, infrastructureFailure: true, summary: `${agent} exited ${result.exitCode ?? 'without a code'}`, ...telemetry };
         default: return assertNever(result);
     }
 }

package/dist/loop/prd.js

@@ -4,6 +4,7 @@ import { parse, stringify } from 'yaml';
 import { z } from 'zod';
 import { StoryQualityDeclarationSchema } from '../quality/types.js';
 import { validWriteScope } from './scheduler.js';
+import { AssessmentSchema } from '../routing/assessment.js';
 export const AcceptanceCriterionSchema = z.object({
     id: z.string().regex(/^[A-Za-z0-9][A-Za-z0-9._-]*$/),
     text: z.string().min(1),
@@ -45,6 +46,7 @@ export const StorySchema = z.object({
     /** Inbox request that created this story. Used for idempotent append-only intake. */
     sourceChange: z.string().min(1).optional(),
     quality: StoryQualityDeclarationSchema.optional(),
+    assessment: AssessmentSchema.optional(),
 }).superRefine((story, ctx) => {
     const structured = story.acceptance.filter(isAcceptanceCriterion);
     const ids = structured.map(criterion => criterion.id);

package/dist/loop/reporter.js

@@ -93,6 +93,7 @@ export function makeReporter(dir, opts = {}, now = () => new Date()) {
     let tokens;
     const runId = randomUUID();
     let measuredCalls = 0;
+    let unknownCalls = 0;
     let measuredCosts = 0;
     let unmeasuredAttempts = 0;
     const attempts = new Map();
@@ -143,8 +144,10 @@ export function makeReporter(dir, opts = {}, now = () => new Date()) {
     };
     const persist = (status, logLabel, consoleLine) => {
         const time = Date.parse(status.updatedAt);
-        if (logLabel === 'story-done')
+        if (logLabel === 'story-done') {
             finishAttempt('serial', 'completed', time);
+            appendEvent(dir, { runId, timestamp: status.updatedAt, type: 'accepted', storyId: status.story });
+        }
         else if (status.state !== 'running')
             for (const key of [...attempts.keys()])
                 finishAttempt(key, status.state, time);
@@ -163,7 +166,7 @@ export function makeReporter(dir, opts = {}, now = () => new Date()) {
             if (key.startsWith('parallel:') && !workerKeys.has(key))
                 finishAttempt(key, 'worker-ended', time);
         const withPercent = { ...status, percent: percentOf(status.progress) };
-        const measurement = { measuredCalls, unmeasuredAttempts, usageAvailable: measuredCalls > 0, costAvailable: measuredCosts === 0 ? 'unknown' : measuredCosts === measuredCalls && unmeasuredAttempts === 0 && tokens?.measurementComplete !== false && tokens?.costMeasurementComplete !== false ? 'measured' : 'partial' };
+        const measurement = { measuredCalls, unknownCalls, unmeasuredAttempts, usageAvailable: measuredCalls > 0, costAvailable: measuredCosts === 0 ? 'unknown' : measuredCosts === measuredCalls && unknownCalls === 0 && unmeasuredAttempts === 0 && tokens?.measurementComplete !== false && tokens?.costMeasurementComplete !== false ? 'measured' : 'partial' };
         const next = { ...withPercent, ...(tokens ? { tokens: { ...tokens } } : {}), measurement };
         current = next;
         appendEvent(dir, { runId, timestamp: status.updatedAt, type: 'status', ...(status.story ? { storyId: status.story } : {}), data: { ...next } });
@@ -179,6 +182,17 @@ export function makeReporter(dir, opts = {}, now = () => new Date()) {
             emitConsole(consoleLine);
     };
     return {
+        routingDecision(storyId, decision) {
+            if (current)
+                persist({ ...current, routingDecisions: { ...current.routingDecisions, [storyId]: decision }, updatedAt: now().toISOString() }, "routing", `  · route ${storyId}: ${decision.profile} (${decision.reason})`);
+        },
+        execution(provider, requestedModel) {
+            if (current)
+                persist({ ...current, execution: { provider, requestedModel, startedAt: now().toISOString() }, updatedAt: now().toISOString() }, 'execution', `  · ${provider}/${requestedModel ?? 'provider-default'}`);
+        },
+        accepted(story) {
+            appendEvent(dir, { runId, timestamp: now().toISOString(), type: 'accepted', storyId: story.id });
+        },
         storyStart(story, iteration, progress) {
             const ts = now().toISOString();
             finishAttempt('serial', 'superseded', Date.parse(ts));
@@ -237,10 +251,15 @@ export function makeReporter(dir, opts = {}, now = () => new Date()) {
                 return previous
                     ? {
                         ...worker,
+                        startedAt: previous.startedAt,
+                        selectedProvider: previous.selectedProvider,
+                        selectedModel: previous.selectedModel,
+                        ...(previous.model ? { model: previous.model } : {}),
+                        provider: previous.provider,
                         ...(previous.phase ? { phase: previous.phase } : {}),
                         ...(previous.quality ? { quality: previous.quality } : {}),
                     }
-                    : worker;
+                    : { ...worker, startedAt: now().toISOString() };
             });
             const reportedCandidates = previousWorkers.filter(worker => worker.candidateId && !(workers ?? []).some(candidate => sameWorker(candidate, worker)));
             const parallel = {
@@ -299,13 +318,14 @@ export function makeReporter(dir, opts = {}, now = () => new Date()) {
                 if (value !== undefined && (!Number.isFinite(value) || value < 0))
                     delete usage[key];
             }
-            measuredCalls++;
-            if (usage.totalCostUsd !== undefined && Number.isFinite(usage.totalCostUsd) && usage.totalCostUsd >= 0)
-                measuredCosts++;
-            const attempt = attempts.get('serial');
+            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;
+            measuredCosts += calls.filter(call => call.totalCostUsd !== undefined && Number.isFinite(call.totalCostUsd) && call.totalCostUsd >= 0).length;
+            const attempt = usage.storyId ? [...attempts.values()].find(attempt => attempt.storyId === usage.storyId) : attempts.get('serial');
             if (attempt)
-                attempt.usageAvailable = true;
-            appendEvent(dir, { runId, timestamp: now().toISOString(), type: 'tokens', ...(attempt ? { storyId: attempt.storyId, attemptId: attempt.id } : {}), data: { usageAvailable: true, ...usage } });
+                attempt.usageAvailable = usage.measurementComplete !== false;
+            appendEvent(dir, { runId, timestamp: now().toISOString(), type: 'tokens', ...(usage.storyId ? { storyId: usage.storyId } : {}), ...(usage.durationMs !== undefined ? { durationMs: usage.durationMs } : {}), ...(attempt ? { storyId: attempt.storyId, attemptId: attempt.id } : {}), data: { usageAvailable: usage.measurementComplete !== false, ...usage } });
             const model = usage.model ?? tokens?.model;
             const cachedInputTokens = (tokens?.cachedInputTokens ?? 0) + (usage.cachedInputTokens ?? 0);
             const cacheWriteInputTokens = (tokens?.cacheWriteInputTokens ?? 0) + (usage.cacheWriteInputTokens ?? 0);

package/dist/loop/run-command.js

@@ -1,3 +1,4 @@
+import { roleSelection } from "../routing/capability.js";
 import { join } from 'node:path';
 import { existsSync } from 'node:fs';
 import { loadConfig, saveConfig, defaultConfig, resolveOutputPolicy, resolveVerifyCommand } from '../retrofit/config.js';
@@ -97,9 +98,9 @@ export function resolveIdleMs(flagMinutes, configMinutes) {
     return minutes > 0 ? minutes * 60_000 : 0;
 }
 export function runLoopCommand(targetDir, opts) {
-    const parallel = opts.parallel ?? 1;
+    let parallel = opts.parallel ?? 1;
     const candidates = opts.candidates ?? 1;
-    if (opts.resumeWorktree && (!opts.isolate || parallel !== 1 || candidates !== 1)) {
+    if (opts.resumeWorktree && (opts.isolate === false || parallel !== 1 || candidates !== 1)) {
         console.error('--resume-worktree requires --isolate --parallel=1 --candidates=1');
         return 2;
     }
@@ -145,6 +146,18 @@ export function runLoopCommand(targetDir, opts) {
         console.error(`No PRD found at ${path}. Create one (see canon loop/prd.schema.md).`);
         return 2;
     }
+    const parallelSetting = opts.parallelAuto ? 'auto' : opts.parallel ?? config.loop.parallel ?? 'auto';
+    if (parallelSetting === 'auto') {
+        const pending = loadPrd(path).filter(story => !story.passes);
+        parallel = !opts.resumeWorktree && !config.actions?.length && pending.length > 1 && pending.every(story => story.writes?.length) ? 3 : 1;
+    }
+    else
+        parallel = parallelSetting;
+    const isolate = opts.isolate ?? config.loop.isolate ?? true;
+    if (opts.resumeWorktree && (!isolate || parallel !== 1)) {
+        console.error('--resume-worktree requires isolation and one worker');
+        return 2;
+    }
     if (candidates > 1) {
         const missingQuality = loadPrd(path).find(story => !story.passes && !story.quality);
         if (missingQuality) {
@@ -229,11 +242,13 @@ export function runLoopCommand(targetDir, opts) {
         console.error('Quality candidate selection requires quality.critic.model (or legacy quality.criticModel) before any runner or worktree is started.');
         return 2;
     }
+    let executionReporter;
     const quality = createQualityCommandHooks({
         targetDir,
-        config,
+        config: opts.routing === false ? { ...config, routing: undefined } : config,
         runnerAgent,
         idleMs,
+        onUsage: usage => executionReporter?.addTokens(usage),
         policy: qualityOverrides,
         ...(opts.qualityRuntime ? { runtime: opts.qualityRuntime } : {}),
     });
@@ -246,23 +261,20 @@ export function runLoopCommand(targetDir, opts) {
         announce(`Quality: ${resolved.policy} · critic: ${criticAgent}${configuredCriticModel ? `/${configuredCriticModel}` : '/provider-default'} · repair: ${repairAgent}${config.quality?.repair?.model ?? config.quality?.repairModel ? `/${config.quality?.repair?.model ?? config.quality?.repairModel}` : '/provider-default'} · permissions: read-only critic/safe repair · budget: ${limit}`);
     }
     const permissions = opts.permissions ?? config.runner?.permissions ?? 'safe';
-    const routingEnabled = opts.routing ?? config.routing?.enabled ?? false;
+    const routingRequested = opts.routing ?? config.routing?.enabled ?? true;
+    const routingEnabled = routingRequested && Boolean(config.routing?.workers.length);
     const runnerSelection = {
         model: config.runner?.model,
         reasoningEffort: config.runner?.reasoningEffort,
         bare: config.runner?.bare,
-        ...((runnerAgent === 'codex' && (routingEnabled || opts.routing === false)) ? { nativeMultiAgent: false } : {}),
+        nativeMultiAgent: false,
     };
-    if ((parallel > 1 || candidates > 1) && routingEnabled) {
-        console.error('Adaptive routing is not available with parallel workers or quality candidates. Run with --parallel=1 --candidates=1 or disable routing.');
-        return 2;
-    }
     const parallelProviders = [{
             provider: runnerAgent,
             ...(runnerSelection.model ? { model: runnerSelection.model } : {}),
             ...(runnerSelection.reasoningEffort ? { reasoningEffort: runnerSelection.reasoningEffort } : {}),
         }];
-    const parallelAffinityProviders = (config.routing?.workers ?? []).map(worker => ({
+    const parallelAffinityProviders = config.routing?.strategy === 'capability' ? config.agents.map(agent => ({ provider: agent, ...(agent === runnerAgent ? runnerSelection : {}) })) : (config.routing?.workers ?? []).map(worker => ({
         provider: worker.agent,
         ...(worker.model ? { model: worker.model } : {}),
         ...(worker.reasoningEffort ? { reasoningEffort: worker.reasoningEffort } : {}),
@@ -291,7 +303,7 @@ export function runLoopCommand(targetDir, opts) {
         }
     }
     const ambiguityPolicy = opts.decisionPolicy ?? opts.onAmbiguity ?? config.loop.decisionPolicy ?? config.loop.onAmbiguity ?? 'auto';
-    if (routingEnabled && (!config.routing || config.routing.workers.length === 0)) {
+    if (opts.routing === true && (!config.routing || config.routing.workers.length === 0)) {
         console.error('Adaptive routing was requested, but no worker profiles are configured. Run yoke setup . --routing or add routing.workers to .yoke/config.yaml.');
         return 2;
     }
@@ -321,6 +333,7 @@ export function runLoopCommand(targetDir, opts) {
         // Token reporting is part of the machine interface: in --json mode a claude
         // runner switches to stream-json so cumulative usage rides on every status.
         const runnerOpts = {
+            onStart: (agent, selection) => executionReporter?.execution?.(agent, selection.model),
             tokenReport: opts.json === true,
             onAmbiguity: ambiguityPolicy,
             perfCommand: config.perf?.command,
@@ -330,12 +343,15 @@ export function runLoopCommand(targetDir, opts) {
         runner = routingEnabled && config.routing
             ? makeAdaptiveRunner({
                 parent: runnerAgent,
+                projectRoot: targetDir,
                 parentSelection: runnerOpts.selection,
                 orchestratorSelection: config.routing.orchestrator ?? runnerOpts.selection,
                 workers: config.routing.workers,
                 rules: config.routing.rules,
                 strategy: config.routing.strategy,
                 maxCandidates: config.routing.maxCandidates,
+                maxAttempts: config.routing.maxAttempts,
+                onDecision: (id, decision) => executionReporter?.routingDecision?.(id, decision),
                 idleTimeoutMs: idleMs,
                 permissions,
                 runnerOpts,
@@ -343,7 +359,7 @@ export function runLoopCommand(targetDir, opts) {
             })
             : makeRunner(runnerAgent, idleMs, runnerOpts);
         const announce = opts.json ? console.error : console.log;
-        announce(`Runner: ${runnerAgent} · permissions: ${permissions} · routing: ${routingEnabled ? 'on' : 'off'} · cwd: ${targetDir}`);
+        announce(`Runner: ${runnerAgent} · permissions: ${permissions} · routing: ${routingEnabled ? 'on' : routingRequested ? 'auto (parent; no worker profiles)' : 'off'} · workers: ${parallel} · isolation: ${isolate || parallel > 1 ? 'on' : 'off'} · cwd: ${targetDir}`);
     }
     if (config.actions?.length) {
         if (parallel > 1 || candidates > 1) {
@@ -353,6 +369,7 @@ 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 ?? ['codex', 'gemini', 'claude'].find(agent => agent !== runnerAgent && available(agent));
         if (!reviewerAgent) {
@@ -362,6 +379,7 @@ export function runLoopCommand(targetDir, opts) {
             }
         }
         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;
@@ -370,7 +388,29 @@ export function runLoopCommand(targetDir, opts) {
             console.error(`Reviewer agent CLI "${resolvedReviewer}" was not found on PATH. Install it, or pick another with --reviewer=<claude|codex|gemini>.`);
             return 2;
         }
-        review = makeReviewRunner(resolvedReviewer, idleMs);
+        review = context => {
+            const implementer = readStatus(targetDir)?.routingDecisions?.[context.story.id]?.provider ?? runnerAgent;
+            const selectedReviewer = !opts.reviewer && resolvedReviewer === implementer
+                ? ["codex", "claude", "gemini"].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 });
+            }
+        };
     }
     let lock;
     try {
@@ -388,12 +428,13 @@ export function runLoopCommand(targetDir, opts) {
         console.warn(`Took over a stale loop lock (pid ${lock.stalePid} is gone).`);
     }
     const reporter = opts.reporter ?? makeReporter(targetDir, { json: opts.json });
+    executionReporter = reporter;
     const buildResume = (storyId, requestId) => buildTrustedDecisionResumeState({
         storyId,
         requestId,
         ...(opts.maxIterations !== undefined ? { maxIterations: opts.maxIterations } : {}),
         agent: runnerAgent,
-        isolate: parallel > 1 || candidates > 1 || (opts.isolate ?? false),
+        isolate: parallel > 1 || candidates > 1 || isolate,
         reviewer: opts.reviewer,
         review: opts.review === true || opts.reviewRunner !== undefined,
         allowSelfReview: opts.allowSelfReview ?? false,
@@ -440,6 +481,8 @@ export function runLoopCommand(targetDir, opts) {
             selection: runnerSelection,
             providers: parallelProviders,
             affinityProviders: parallelAffinityProviders,
+            routing: routingEnabled ? config.routing : undefined,
+            isAvailable: available,
             onAmbiguity: ambiguityPolicy,
             git: opts.git,
             identity: commitIdentity,
@@ -473,7 +516,7 @@ export function runLoopCommand(targetDir, opts) {
             perf,
             audit,
             maxIterations,
-            isolate: (opts.parallel ?? 1) > 1 ? true : (opts.isolate ?? false),
+            isolate,
             review,
             reporter,
             ...(quality ?? {}),