@hecer/yoke 1.6.2 → 1.8.0

package/dist/loop/parallel-command.js

@@ -1,4 +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';
@@ -7,6 +11,11 @@ import { loadPrd, progress } from './prd.js';
 import { makeAsyncRunner } from './runner.js';
 import { runStoryWorker } from './worker.js';
 export async function runParallelLoopCommand(input) {
+    const originalVerify = input.verify;
+    input = { ...input, verify: path => {
+            const problem = acceptanceProtectionProblem(path, input.targetDir);
+            return problem ? { passed: false, summary: problem } : originalVerify(path);
+        } };
     const adapters = makeParallelAdapters(input.targetDir, input.identity, input.git);
     if (!adapters.git.isClean(input.targetDir)) {
         input.reporter.blocked('target working tree is not clean');
@@ -39,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,
@@ -196,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) {
@@ -241,18 +251,54 @@ 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: provider.provider,
+            parentSelection: { ...input.selection, model: provider.model, reasoningEffort: provider.reasoningEffort, ...(provider.provider === 'codex' ? { nativeMultiAgent: false } : {}) },
+            projectRoot: input.targetDir,
+            workers: input.routing.workers,
+            rules: input.routing.rules,
+            strategy: input.routing.strategy,
+            maxCandidates: input.routing.maxCandidates,
+            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
+            ? 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 !== '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;
@@ -286,5 +332,7 @@ function integrationGate(input, path, story, reporter) {
         return { passed: false, summary: quality.summary };
     if (input.review)
         reporter.phase('reviewing');
-    return reviewGate(input.review, path, story);
+    const verdict = reviewGate(input.review, path, story);
+    const protection = acceptanceProtectionProblem(path, input.targetDir);
+    return protection ? { passed: false, summary: protection } : verdict;
 }

package/dist/loop/prd.js

@@ -3,6 +3,7 @@ import { readFileSync, writeFileSync } from 'node:fs';
 import { parse, stringify } from 'yaml';
 import { z } from 'zod';
 import { StoryQualityDeclarationSchema } from '../quality/types.js';
+import { validWriteScope } from './scheduler.js';
 export const AcceptanceCriterionSchema = z.object({
     id: z.string().regex(/^[A-Za-z0-9][A-Za-z0-9._-]*$/),
     text: z.string().min(1),
@@ -38,6 +39,8 @@ export const StorySchema = z.object({
     passes: z.boolean(),
     needs: z.array(z.string().min(1)).optional(),
     area: z.string().min(1).optional(),
+    /** Advisory relative file/directory scopes; not a filesystem permission boundary. */
+    writes: z.array(z.string().min(1).max(500).refine(validWriteScope, 'Write scopes must be relative non-glob paths without traversal')).max(100).optional(),
     agent: z.enum(['claude', 'codex', 'gemini']).optional(),
     /** Inbox request that created this story. Used for idempotent append-only intake. */
     sourceChange: z.string().min(1).optional(),

package/dist/loop/recovery.js

@@ -0,0 +1,51 @@
+import { execFileSync } from 'node:child_process';
+import { createHash } from 'node:crypto';
+import { existsSync, mkdirSync, readFileSync, realpathSync as filesystemRealpathSync, writeFileSync } from 'node:fs';
+import { dirname, join, relative, resolve, isAbsolute } from 'node:path';
+import { z } from 'zod';
+const Recovery = z.object({ version: z.literal(1), root: z.string(), worktree: z.string(), base: z.string(), prdHash: z.string() }).strict();
+const digest = (file) => createHash('sha256').update(readFileSync(file)).digest('hex');
+const pathIdentity = (path) => process.platform === 'win32' ? path.toLowerCase() : path;
+// Native handle-based resolution expands Windows 8.3 names. The JS realpath
+// implementation can retain RUNNER~1 while Git reports runneradmin.
+const realpathSync = filesystemRealpathSync.native;
+/** Explicit recovery is valid only for the unchanged original target and PRD. */
+export function prepareIsolatedWorktree(directory, worktree, resume) {
+    const root = realpathSync(directory);
+    // Resolve caller aliases (including Windows 8.3 temp paths) against the same
+    // canonical root before comparing them with Git's registered path spellings.
+    const wt = resolve(root, relative(resolve(directory), resolve(worktree)));
+    const expectedParent = join(root, '.yoke', 'worktrees');
+    if (pathIdentity(dirname(wt)) !== pathIdentity(expectedParent))
+        throw new Error('Recovery worktree path must be a direct project worktree');
+    const git = (args, cwd = root) => execFileSync('git', args, { cwd, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] }).trim();
+    const common = realpathSync(resolve(root, git(['rev-parse', '--git-common-dir'])));
+    const name = createHash('sha256').update(wt).digest('hex');
+    const record = join(common, 'yoke-recovery', `${name}.json`);
+    const base = git(['rev-parse', 'HEAD']);
+    const prdHash = digest(join(root, '.yoke', 'prd.yaml'));
+    if (existsSync(wt)) {
+        if (!resume)
+            throw new Error(`Retained worktree: ${wt}. Use --resume-worktree to continue or explicit loop cleanup to discard.`);
+        if (!existsSync(record))
+            throw new Error('No trusted worktree recovery record exists');
+        const saved = Recovery.parse(JSON.parse(readFileSync(record, 'utf8')));
+        if (pathIdentity(saved.root) !== pathIdentity(root) || pathIdentity(saved.worktree) !== pathIdentity(wt) || saved.base !== base || saved.prdHash !== prdHash)
+            throw new Error('Target or PRD changed; recovery is stale');
+        const actual = realpathSync(wt);
+        const rel = relative(realpathSync(expectedParent), actual);
+        if (isAbsolute(rel) || rel.startsWith('..') || rel.includes('/') || rel.includes('\\'))
+            throw new Error('Recovery worktree path escaped');
+        const registered = git(['worktree', 'list', '--porcelain']).split(/\r?\n/).filter(line => line.startsWith('worktree ')).map(line => realpathSync(resolve(line.slice(9))));
+        if (!registered.some(path => pathIdentity(path) === pathIdentity(actual)))
+            throw new Error(`Recovery directory is not a registered worktree: ${actual}; registered: ${registered.join(', ')}`);
+        if (pathIdentity(realpathSync(resolve(actual, git(['rev-parse', '--git-common-dir'], actual)))) !== pathIdentity(common))
+            throw new Error('Recovery belongs to a different repository');
+        git(['merge-base', '--is-ancestor', base, 'HEAD'], actual);
+        return;
+    }
+    mkdirSync(dirname(record), { recursive: true });
+    git(['worktree', 'add', '--detach', wt, base]);
+    // Record is outside the worker checkout and binds reuse to its source state.
+    writeFileSync(record, JSON.stringify({ version: 1, root, worktree: wt, base, prdHash }), { mode: 0o600 });
+}

package/dist/loop/reporter.js

@@ -1,5 +1,8 @@
 import { existsSync, readFileSync, writeFileSync, mkdirSync, renameSync, appendFileSync, statSync, rmSync } from 'node:fs';
 import { join } from 'node:path';
+import { randomUUID } from 'node:crypto';
+import { appendEvent } from '../observability/events.js';
+import { estimateDurations, validDuration } from '../estimation/durations.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
@@ -39,10 +42,12 @@ function durationsPath(dir) {
 }
 export function readDurations(dir) {
     try {
+        if (statSync(durationsPath(dir)).size > 64 * 1024)
+            return [];
         const arr = JSON.parse(readFileSync(durationsPath(dir), 'utf8'));
         if (!Array.isArray(arr))
             return [];
-        return arr.filter((d) => typeof d?.ms === 'number' && d.ms > 0);
+        return arr.filter((d) => typeof d?.storyId === 'string' && validDuration(d?.ms)).slice(-DURATION_HISTORY_CAP);
     }
     catch {
         return [];
@@ -86,6 +91,43 @@ export function makeReporter(dir, opts = {}, now = () => new Date()) {
         sink(line); };
     let current = null;
     let tokens;
+    const runId = randomUUID();
+    let measuredCalls = 0;
+    let unknownCalls = 0;
+    let measuredCosts = 0;
+    let unmeasuredAttempts = 0;
+    const attempts = new Map();
+    const finishPhase = (attempt, time) => {
+        if (attempt.phase)
+            appendEvent(dir, { runId, timestamp: new Date(time).toISOString(), type: 'phase-ended', storyId: attempt.storyId, attemptId: attempt.id, phase: attempt.phase, durationMs: Math.max(0, time - attempt.phaseStarted) });
+    };
+    const finishAttempt = (key, outcome, time) => {
+        const attempt = attempts.get(key);
+        if (!attempt)
+            return;
+        if (!attempt.usageAvailable)
+            unmeasuredAttempts++;
+        finishPhase(attempt, time);
+        const durationMs = Math.max(0, time - attempt.started);
+        appendEvent(dir, { runId, timestamp: new Date(time).toISOString(), type: 'attempt-ended', storyId: attempt.storyId, attemptId: attempt.id, durationMs, outcome, data: { usageAvailable: attempt.usageAvailable,
+                ...(attempt.prediction ? { prediction: attempt.prediction, ...(outcome === 'completed' ? { errorMs: durationMs - attempt.prediction.expectedMs, withinObservedRange: durationMs >= attempt.prediction.lowerMs && durationMs <= attempt.prediction.upperMs } : {}) } : {}),
+            } });
+        attempts.delete(key);
+    };
+    const track = (key, storyId, phase, time) => {
+        const attempt = attempts.get(key);
+        if (!attempt) {
+            const estimate = estimateDurations(history, runDurations);
+            attempts.set(key, { id: randomUUID(), storyId, started: time, phase, phaseStarted: time, usageAvailable: false,
+                ...(estimate ? { prediction: { expectedMs: estimate.typicalMs, lowerMs: estimate.lowerMs, upperMs: estimate.upperMs, sampleCount: estimate.sampleCount } } : {}),
+            });
+        }
+        else if (attempt.phase !== phase) {
+            finishPhase(attempt, time);
+            attempt.phase = phase;
+            attempt.phaseStarted = time;
+        }
+    };
     // ETA source: durations of stories completed in THIS run beat the persisted
     // history of earlier runs (current velocity over old experience).
     const history = readDurations(dir).map(h => h.ms);
@@ -93,17 +135,41 @@ export function makeReporter(dir, opts = {}, now = () => new Date()) {
     let storyStartedAt = null;
     const percentOf = (p) => (p.total > 0 ? Math.round((p.passed / p.total) * 100) : 0);
     const etaFor = (p) => {
-        const pool = runDurations.length > 0 ? runDurations : history;
-        if (pool.length === 0)
+        const estimate = estimateDurations(history, runDurations);
+        if (!estimate)
             return undefined;
-        const avg = pool.reduce((a, b) => a + b, 0) / pool.length;
+        const avg = estimate.typicalMs;
         const remainingStories = Math.max(0, p.total - p.passed);
-        return { avgStoryMs: Math.round(avg), remainingStories, etaMs: Math.round(avg * remainingStories) };
+        return { avgStoryMs: Math.round(avg), remainingStories, etaMs: Math.round(avg * remainingStories), lowerMs: Math.round(estimate.lowerMs * remainingStories), upperMs: Math.round(estimate.upperMs * remainingStories), sampleCount: estimate.sampleCount, confidence: estimate.confidence };
     };
     const persist = (status, logLabel, consoleLine) => {
+        const time = Date.parse(status.updatedAt);
+        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);
+        else if (status.story && status.phase)
+            track('serial', status.story, status.phase, time);
+        const workerKeys = new Set();
+        for (const worker of [...(status.parallel?.workers ?? []), ...(status.parallel?.integrator ? [status.parallel.integrator] : [])]) {
+            const key = `parallel:${worker.story}:${worker.candidateId ?? ''}:${worker.worktree ?? ''}`;
+            workerKeys.add(key);
+            if (worker.lifecycle === 'removed')
+                finishAttempt(key, 'removed', time);
+            else
+                track(key, worker.story, worker.phase ?? worker.lifecycle, time);
+        }
+        for (const key of [...attempts.keys()])
+            if (key.startsWith('parallel:') && !workerKeys.has(key))
+                finishAttempt(key, 'worker-ended', time);
         const withPercent = { ...status, percent: percentOf(status.progress) };
-        const next = tokens ? { ...withPercent, tokens: { ...tokens } } : withPercent;
+        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 } });
         try {
             writeStatus(dir, next);
             appendLog(dir, `${next.updatedAt}  ${logLabel}  ${next.story ?? '-'}  ${next.reason ?? ''}`.trimEnd());
@@ -116,8 +182,16 @@ export function makeReporter(dir, opts = {}, now = () => new Date()) {
             emitConsole(consoleLine);
     };
     return {
+        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));
             storyStartedAt = now().getTime();
             const eta = etaFor(progress);
             const hint = eta ? ` · ~${fmtDuration(eta.etaMs)} left (Ø ${fmtDuration(eta.avgStoryMs)}/story)` : '';
@@ -128,7 +202,7 @@ export function makeReporter(dir, opts = {}, now = () => new Date()) {
             const t = now().getTime();
             const ms = storyStartedAt !== null ? Math.max(0, t - storyStartedAt) : undefined;
             storyStartedAt = null;
-            if (ms !== undefined) {
+            if (validDuration(ms)) {
                 runDurations.push(ms);
                 appendDuration(dir, { storyId: story.id, ms });
             }
@@ -173,10 +247,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 = {
@@ -227,12 +306,30 @@ export function makeReporter(dir, opts = {}, now = () => new Date()) {
             persist({ ...base, parallel: withoutIntegrator, updatedAt: now().toISOString() }, 'parallel-integrator', '  · integration complete');
         },
         addTokens(usage) {
+            if (![usage.inputTokens, usage.outputTokens].every(value => Number.isFinite(value) && value >= 0))
+                return;
+            usage = { ...usage };
+            for (const key of ['cachedInputTokens', 'cacheWriteInputTokens', 'reasoningOutputTokens', 'totalCostUsd']) {
+                const value = usage[key];
+                if (value !== undefined && (!Number.isFinite(value) || value < 0))
+                    delete usage[key];
+            }
+            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 = 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);
             const reasoningOutputTokens = (tokens?.reasoningOutputTokens ?? 0) + (usage.reasoningOutputTokens ?? 0);
             const totalCostUsd = (tokens?.totalCostUsd ?? 0) + (usage.totalCostUsd ?? 0);
             tokens = {
+                ...((tokens?.measurementComplete !== undefined || usage.measurementComplete !== undefined) ? { measurementComplete: tokens?.measurementComplete !== false && usage.measurementComplete !== false } : {}),
+                ...((tokens?.costMeasurementComplete !== undefined || usage.costMeasurementComplete !== undefined) ? { costMeasurementComplete: tokens?.costMeasurementComplete !== false && usage.costMeasurementComplete !== false } : {}),
                 inputTokens: (tokens?.inputTokens ?? 0) + usage.inputTokens,
                 ...((tokens?.cachedInputTokens !== undefined || usage.cachedInputTokens !== undefined) ? { cachedInputTokens } : {}),
                 ...((tokens?.cacheWriteInputTokens !== undefined || usage.cacheWriteInputTokens !== undefined) ? { cacheWriteInputTokens } : {}),

package/dist/loop/run-command.js

@@ -14,12 +14,14 @@ import { runAudit } from '../audit/command.js';
 import { detectHostAgent, resolveRunnerAgent } from '../agents/host.js';
 import { buildTrustedDecisionResumeState, clearDecisionResume, decisionProcessingExists, decisionRequestId, formatPendingDecision, readPendingDecision, writeDecisionResume, } from './decision.js';
 import { makeAdaptiveRunner } from '../routing/router.js';
+import { makeActionRunner } from '../execution/actions.js';
 import { runChangeApply } from '../change/inbox.js';
 import { createQualityCommandHooks } from '../quality/command.js';
 import { resolveQualityPolicy } from '../quality/types.js';
 import { runParallelLoopCommand } from './parallel-command.js';
 import { detectUiProject } from '../retrofit/ui-detect.js';
 import { designVerifier } from '../scan/gate.js';
+import { prepareIsolatedWorktree } from './recovery.js';
 export const DEFAULT_IDLE_MINUTES = 20;
 const STALE_MINUTES = 20; // a running status older than this likely means the loop died
 export function relativeTime(fromIso, now) {
@@ -95,8 +97,12 @@ 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 === false || parallel !== 1 || candidates !== 1)) {
+        console.error('--resume-worktree requires --isolate --parallel=1 --candidates=1');
+        return 2;
+    }
     if (!Number.isInteger(parallel) || parallel < 1) {
         console.error('--parallel must be a positive integer');
         return 2;
@@ -139,6 +145,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) {
@@ -177,7 +195,10 @@ export function runLoopCommand(targetDir, opts) {
     maybeAutoUpgrade(config.update?.auto);
     const available = opts.isAvailable ?? isAgentAvailable;
     const runnerAgent = resolveRunnerAgent(config, opts.agent, detectHostAgent());
-    const git = opts.git ?? realGitOps;
+    const git = opts.git ?? {
+        ...realGitOps,
+        addWorktree: (repo, worktree) => prepareIsolatedWorktree(repo, worktree, opts.resumeWorktree === true),
+    };
     let commitIdentity = opts.commitIdentity;
     if (!commitIdentity && !opts.git) {
         try {
@@ -220,11 +241,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,
         runnerAgent,
         idleMs,
+        onUsage: usage => executionReporter?.addTokens(usage),
         policy: qualityOverrides,
         ...(opts.qualityRuntime ? { runtime: opts.qualityRuntime } : {}),
     });
@@ -237,17 +260,14 @@ 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,
-        ...((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 } : {}),
@@ -282,7 +302,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;
     }
@@ -303,7 +323,7 @@ export function runLoopCommand(targetDir, opts) {
     if (!runner) {
         const requiredProviders = parallel > 1 || candidates > 1
             ? [...new Set(loadPrd(path).filter(story => !story.passes).map(story => story.agent ?? runnerAgent))]
-            : [runnerAgent];
+            : loadPrd(path).filter(story => !story.passes).every(story => config.actions?.some(action => action.storyId === story.id)) ? [] : [runnerAgent];
         const unavailableProvider = requiredProviders.find(agent => !available(agent));
         if (unavailableProvider) {
             console.error(`Agent CLI "${unavailableProvider}" was not found on PATH. Install it, or pick another with --runner=<claude|codex|gemini>.`);
@@ -312,6 +332,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,
@@ -321,9 +342,11 @@ 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,
                 idleTimeoutMs: idleMs,
@@ -333,9 +356,17 @@ 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) {
+            console.error('Configured tool actions currently require --parallel=1 --candidates=1');
+            return 2;
+        }
+        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) {
@@ -345,6 +376,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;
@@ -355,6 +387,20 @@ export function runLoopCommand(targetDir, opts) {
         }
         review = makeReviewRunner(resolvedReviewer, idleMs);
     }
+    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 {
         lock = acquireLock(targetDir);
@@ -371,12 +417,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,
@@ -423,6 +470,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,
@@ -456,7 +505,7 @@ export function runLoopCommand(targetDir, opts) {
             perf,
             audit,
             maxIterations,
-            isolate: (opts.parallel ?? 1) > 1 ? true : (opts.isolate ?? false),
+            isolate,
             review,
             reporter,
             ...(quality ?? {}),