@hecer/yoke 1.20.0 → 1.22.0

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');
 }

package/dist/observability/invocation.js

@@ -0,0 +1,42 @@
+import { randomUUID } from 'node:crypto';
+import { parseProviderTelemetry } from '../agents/telemetry.js';
+import { appendEvent } from './events.js';
+import { providerTelemetryUsage } from './usage.js';
+/** A single invocation boundary, including failures and injected runner seams. */
+export function measureInvocation(options) {
+    const started = Date.now(), callId = randomUUID(), runId = options.runId ?? randomUUID();
+    let result;
+    let failure;
+    const base = { runId, storyId: options.storyId, attemptId: callId, agent: options.agent, role: options.role };
+    appendEvent(options.root, { ...base, timestamp: new Date(started).toISOString(), type: 'status', data: { callId, parentCallId: options.parentCallId, state: 'started' } });
+    try {
+        result = options.execute(options.invocation);
+        return result;
+    }
+    catch (error) {
+        failure = error;
+        throw error;
+    }
+    finally {
+        let salvaged;
+        try {
+            const stdout = failure && typeof failure === 'object' && 'stdout' in failure ? failure.stdout : undefined;
+            salvaged = stdout == null ? undefined : providerTelemetryUsage(parseProviderTelemetry(options.agent, String(stdout).split(/\r?\n/u)));
+        }
+        catch { /* Failed measurement must not replace the original provider error. */ }
+        const usage = result?.tokens ?? salvaged;
+        const complete = usage !== undefined && usage.measurementComplete !== false;
+        const durationMs = Date.now() - started;
+        appendEvent(options.root, {
+            ...base, timestamp: new Date().toISOString(), type: 'tokens', durationMs, outcome: result?.success ? 'succeeded' : 'failed',
+            data: {
+                ...usage, callId, parentCallId: options.parentCallId,
+                provider: options.agent, role: options.role,
+                requestedProvider: options.selection?.provider, requestedModel: options.selection?.model,
+                requestedReasoningEffort: options.selection?.reasoningEffort, requestedVariant: options.selection?.variant,
+                actualModel: usage?.model, measurementComplete: complete, usageAvailable: complete,
+                costMeasurementComplete: usage?.costMeasurementComplete ?? (typeof usage?.totalCostUsd === 'number'),
+            },
+        });
+    }
+}

package/dist/observability/usage.js

@@ -0,0 +1,17 @@
+/** Preserve known lower bounds; missing telemetry must never become a free call. */
+export function providerTelemetryUsage(telemetry) {
+    if (!telemetry.tokens && !telemetry.partialUsage)
+        return undefined;
+    const known = { ...telemetry.partialUsage, ...telemetry.tokens };
+    if (!Object.values(known).some(value => typeof value === 'number'))
+        return undefined;
+    const model = known.model ?? (telemetry.reportedModels?.length === 1 ? telemetry.reportedModels[0] : undefined);
+    return {
+        ...known,
+        ...(model ? { model } : {}),
+        inputTokens: known.inputTokens ?? 0,
+        outputTokens: known.outputTokens ?? 0,
+        measurementComplete: telemetry.usageAvailable,
+        costMeasurementComplete: typeof telemetry.tokens?.totalCostUsd === 'number',
+    };
+}

package/dist/prd/command.js

@@ -7,9 +7,11 @@ import { bindAssessments, preparedProblems } from './assess.js';
 import { resolvePlanner } from '../routing/planning.js';
 import { readPlanningFile } from '../routing/contracts.js';
 import { acquireLock, releaseLock } from '../loop/lock.js';
-import { agentInvocation, buildWatchdogInvocation, runAgent, isAgentAvailable, } from '../loop/runner.js';
+import { agentInvocation, buildWatchdogInvocation, runCapturedAgent, isAgentAvailable, } from '../loop/runner.js';
 import { resolveIdleMs } from '../loop/run-command.js';
 import { detectHostAgent, resolveRunnerAgent } from '../agents/host.js';
+import { measureInvocation } from '../observability/invocation.js';
+import { statePath } from '../workspace/state.js';
 export const PRD_TEMPLATE = `# Yoke PRD — the loop picks the lowest-priority open story each iteration.
 # Story format (see canon/loop/prd.schema.md):
 # - id: STORY-1
@@ -92,14 +94,25 @@ export function runPrdDraft(targetDir, opts) {
     }
     try {
         const before = readPlanningFile(targetDir, '.yoke/prd.yaml');
-        const rollback = () => { if (before === undefined)
-            rmSync(path, { force: true });
-        else
-            writeFileSync(path, before); };
+        const rollback = () => {
+            const destination = join(statePath(targetDir), 'prd.yaml');
+            // Unlink a provider-created file link instead of writing through it.
+            rmSync(destination, { force: true });
+            if (before !== undefined)
+                writeFileSync(destination, before, { flag: 'wx' });
+        };
         const inv = agentInvocation(agent, buildPrdDraftPrompt(idea, planningBrief), targetDir, 'safe', planner.selection);
         console.log(`Drafting PRD with ${agent}...`);
-        const run = opts.run ?? ((i) => runAgent(buildWatchdogInvocation(i, idleMs)));
-        const result = run(inv);
+        const run = opts.run ?? ((i) => runCapturedAgent(agent, buildWatchdogInvocation(i, idleMs)));
+        let result;
+        try {
+            result = measureInvocation({ root: targetDir, agent, role: 'prd-draft', selection: planner.selection, invocation: inv, execute: run });
+        }
+        catch (error) {
+            rollback();
+            console.error(`PRD draft failed: ${error.message}`);
+            return 1;
+        }
         if (!result.success) {
             rollback();
             console.error(`PRD draft failed: ${result.summary}`);

package/dist/prd/decompose.js

@@ -11,7 +11,8 @@ import { writeScopesOverlap, validWriteScope } from '../loop/scheduler.js';
 import { withSharedWorkerSync } from '../loop/resource-pool.js';
 import { loadConfig } from '../retrofit/config.js';
 import { detectHostAgent, resolveRunnerAgent } from '../agents/host.js';
-import { agentInvocation, buildWatchdogInvocation, isAgentAvailable, runAgent } from '../loop/runner.js';
+import { agentInvocation, buildWatchdogInvocation, isAgentAvailable, runCapturedAgent } from '../loop/runner.js';
+import { measureInvocation } from '../observability/invocation.js';
 const ProposalSchema = z.array(z.object({
     id: z.string().regex(/^[A-Za-z0-9][A-Za-z0-9._-]{0,99}$/u),
     title: z.string().min(1).max(300),
@@ -181,7 +182,9 @@ export function runPrdDecompose(root, options) {
         if (prompt.length > 60_000)
             throw Error('Planning input exceeds 60000 characters; condense .yoke/plan.md first');
         const invocation = agentInvocation(planner.agent, prompt, root, 'safe', planner.selection);
-        const result = withSharedWorkerSync({ targetDir: root, storyId: `prd-decompose:${parent.id}`, provider: planner.agent, role: 'implementation' }, () => (options.run ?? (item => runAgent(buildWatchdogInvocation(item, options.timeoutMinutes === undefined ? 20 * 60_000 : options.timeoutMinutes > 0 ? options.timeoutMinutes * 60_000 : 0))))(invocation));
+        const result = withSharedWorkerSync({ targetDir: root, storyId: `prd-decompose:${parent.id}`, provider: planner.agent, role: 'implementation' }, () => measureInvocation({ root, agent: planner.agent, role: 'prd-decompose', storyId: parent.id, selection: planner.selection, invocation,
+            execute: options.run ?? (item => runCapturedAgent(planner.agent, buildWatchdogInvocation(item, options.timeoutMinutes === undefined ? 20 * 60_000 : options.timeoutMinutes > 0 ? options.timeoutMinutes * 60_000 : 0))),
+        }));
         if (!result.success)
             throw Error(`planning request failed: ${result.summary}`);
         if (!existsSync(proposalPath))

package/dist/retrofit/command.js

@@ -8,9 +8,16 @@ import { ensureGitignore } from './gitignore.js';
 import { loadConfig, saveConfig, defaultConfig } from './config.js';
 import { loadManifest } from '../canon/manifest.js';
 import { detectHostAgent } from '../agents/host.js';
+import { pruneWorktrees } from '../loop/cleanup.js';
 export function runRetrofit(targetDir, opts) {
     const canonDir = resolveCanonDir();
     const canonVersion = loadManifest(join(canonDir, 'manifest.yaml')).version;
+    if (opts.cleanWorktrees) {
+        const pruneRes = pruneWorktrees(targetDir);
+        if (pruneRes.removed.length > 0) {
+            console.log(`Pruned ${pruneRes.removed.length} orphaned worktree(s).`);
+        }
+    }
     const detection = detectProject(targetDir);
     const agents = opts.agents && opts.agents.length > 0
         ? opts.agents
@@ -26,6 +33,19 @@ export function runRetrofit(targetDir, opts) {
     ensureGitignore(targetDir);
     const priorAgents = existing?.agents ?? [];
     const mergedAgents = [...new Set([...priorAgents, ...agents])];
+    const runnerConfig = { ...(existing?.runner ?? {}) };
+    if (opts.runnerModel !== undefined)
+        runnerConfig.model = opts.runnerModel;
+    if (opts.runnerReasoning !== undefined)
+        runnerConfig.reasoningEffort = opts.runnerReasoning;
+    let updatedWorkers = existing?.routing?.workers;
+    if (updatedWorkers && (opts.agentModels || opts.agentReasoning)) {
+        updatedWorkers = updatedWorkers.map(w => {
+            const model = opts.agentModels?.[w.agent] ?? w.model;
+            const reasoningEffort = opts.agentReasoning?.[w.agent] ?? w.reasoningEffort;
+            return { ...w, ...(model ? { model } : {}), ...(reasoningEffort ? { reasoningEffort } : {}) };
+        });
+    }
     const config = {
         ...(existing ?? defaultConfig(canonVersion)),
         canonVersion,
@@ -33,6 +53,8 @@ export function runRetrofit(targetDir, opts) {
         loop: { ...existing?.loop, enabled: opts.loop },
         codeGraph,
         codeIntelligence: { ...(existing?.codeIntelligence ?? {}), mode: codeIntelligence },
+        ...(Object.keys(runnerConfig).length > 0 ? { runner: runnerConfig } : {}),
+        ...(existing?.routing && updatedWorkers ? { routing: { ...existing.routing, workers: updatedWorkers } } : {}),
         ...(existing?.design
             ? { design: existing.design }
             : detection.ui.detected ? { design: { mode: 'auto', max: 4 } } : {}),

package/dist/retrofit/config.js

@@ -16,7 +16,21 @@ const CodeIntelligenceSchema = z.object({
     policy: z.object({ allowNetwork: z.boolean().default(false), excludePatterns: z.array(z.string().min(1)).max(100).default([]), maxFileBytes: z.number().int().positive().max(20_000_000).optional() }).optional(),
     limits: z.object({ tokenBudget: z.number().int().min(128).max(16000).default(2400), timeoutMs: z.number().int().min(100).max(600000).default(10000), maxBytes: z.number().int().positive().max(10_000_000).default(2_000_000), maxBackends: z.number().int().min(1).max(3).default(3) }).optional(),
 });
-const SmokeFlowSchema = z.object({ name: z.string().min(1), path: z.string().min(1), landmark: z.string().optional() });
+const SmokeStepTimeout = z.number().int().min(1).max(30000).optional();
+const SmokeSelector = z.string().min(1).max(4096);
+const SmokeStepSchema = z.discriminatedUnion('action', [
+    z.object({ action: z.literal('click'), selector: SmokeSelector, timeoutMs: SmokeStepTimeout }).strict(),
+    z.object({ action: z.literal('fill'), selector: SmokeSelector, value: z.string().max(8192).optional(), valueEnv: z.string().regex(/^[A-Za-z_][A-Za-z0-9_]*$/u).optional(), timeoutMs: SmokeStepTimeout }).strict(),
+    z.object({ action: z.literal('press'), selector: SmokeSelector, key: z.string().min(1).max(128), timeoutMs: SmokeStepTimeout }).strict(),
+    z.object({ action: z.literal('expect-visible'), selector: SmokeSelector, timeoutMs: SmokeStepTimeout }).strict(),
+    z.object({ action: z.literal('expect-text'), selector: SmokeSelector, text: z.string().max(8192), exact: z.boolean().optional(), timeoutMs: SmokeStepTimeout }).strict(),
+    z.object({ action: z.literal('expect-url'), url: z.string().min(1).max(4096), timeoutMs: SmokeStepTimeout }).strict(),
+    z.object({ action: z.literal('reload'), timeoutMs: SmokeStepTimeout }).strict(),
+]).superRefine((step, context) => {
+    if (step.action === 'fill' && (step.value === undefined) === (step.valueEnv === undefined))
+        context.addIssue({ code: 'custom', message: 'A fill step needs exactly one of value or valueEnv' });
+});
+const SmokeFlowSchema = z.object({ name: z.string().min(1), path: z.string().min(1), landmark: z.string().optional(), timeoutMs: z.number().int().min(1).max(120000).optional(), steps: z.array(SmokeStepSchema).min(1).max(50).optional() });
 const SmokeSchema = z.object({ baseUrl: z.string().min(1), flows: z.array(SmokeFlowSchema).min(1) });
 const OutputPolicySchema = z.object({
     previewBytes: z.number().int().positive().optional(),
@@ -56,6 +70,12 @@ const RoutingWorkerSchema = z.object({
     capabilities: z.array(z.string().min(1)).default([]),
     tier: z.enum(['light', 'standard', 'strong', 'frontier']).optional(),
     roles: z.array(z.enum(['implementation', 'reviewer', 'critic', 'repair'])).optional(),
+    profileMetadata: z.object({
+        version: z.literal(1),
+        catalog: z.string().min(1).max(120),
+        source: z.enum(['yoke-default', 'operator']),
+        basis: z.literal('configured-prior'),
+    }).strict().optional(),
 });
 const RoutingRuleSchema = z.object({
     area: z.string().min(1).optional(),
@@ -104,6 +124,11 @@ export const YokeConfigSchema = z.object({
         assessmentPolicy: z.enum(['on-demand', 'prepared']).optional(),
         fallback: z.enum(['parent', 'block']).optional(),
         maxTier: z.enum(['light', 'standard', 'strong', 'frontier']).optional(),
+        optimization: z.object({
+            version: z.literal(1),
+            objective: z.enum(['cost', 'speed', 'balanced']),
+            minSamples: z.number().int().min(10).max(10000).optional(),
+        }).strict().optional(),
         maxCandidates: z.number().int().min(1).max(5).default(3),
         orchestrator: z.object({
             provider: z.string().regex(/^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/).optional(),

package/dist/retrofit/gitignore.js

@@ -3,6 +3,7 @@ import { join } from 'node:path';
 export const YOKE_IGNORE_LINES = [
     '.yoke/worktrees/',
     '.yoke/integration-recovery/',
+    '.yoke/failure-progress/',
     '.yoke/run-state.json',
     '.yoke/run-state.*.tmp',
     '.yoke/backup/',
@@ -31,6 +32,7 @@ export const YOKE_IGNORE_LINES = [
     '.yoke/checks/',
     '.yoke/events/',
     '.yoke/history/', '.yoke/routing/',
+    '.yoke/routing-attempts/',
     '.yoke/goal.json',
     '.yoke/goal.json.*.tmp',
     '.yoke/goal.pause',

package/dist/retrofit/planners/claude.js

@@ -2,7 +2,7 @@ import { readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { loadManifest } from '../../canon/manifest.js';
 import { mcpServers, rtkInstruction } from '../tools.js';
-import { hasWsl } from '../wsl.js';
+import { hasWsl, hasRtk } from '../wsl.js';
 import { detectGstack } from '../gstack.js';
 import { PRESERVE_SCAFFOLD } from '../preserve.js';
 import { skillPackageActions } from '../skill-actions.js';
@@ -22,7 +22,7 @@ This project uses the Yoke harness. Baseline instructions:
 ${rtkNote ? `\n${rtkNote}\n` : ''}${composeNote ? `\n${composeNote}\n` : ''}
 ${PRESERVE_SCAFFOLD}
 `;
-export function planClaude(canonDir, targetDir, wslAvailable = hasWsl(), codeGraph = 'graphify', gstackDetected = detectGstack(targetDir), codeIntelligence = 'off') {
+export function planClaude(canonDir, targetDir, wslAvailable = (hasWsl() || hasRtk()), codeGraph = 'graphify', gstackDetected = detectGstack(targetDir), codeIntelligence = 'off', rtkAvailable) {
     const manifest = loadManifest(join(canonDir, 'manifest.yaml'));
     const actions = [];
     for (const skill of manifest.skills) {
@@ -34,8 +34,8 @@ export function planClaude(canonDir, targetDir, wslAvailable = hasWsl(), codeGra
         content: readFileSync(join(canonDir, 'AGENTS.md'), 'utf8'),
         reason: 'baseline instructions',
     });
-    // rtk: PreToolUse hook needs WSL on Windows; otherwise fall back to instruction mode.
-    const rtkHookable = wslAvailable;
+    // rtk: PreToolUse hook works natively if rtk is available, or via WSL on Windows.
+    const rtkHookable = rtkAvailable !== undefined ? (wslAvailable || rtkAvailable) : wslAvailable;
     actions.push({
         kind: 'write',
         target: 'CLAUDE.md',

package/dist/retrofit/wsl.js

@@ -1,7 +1,6 @@
 import { execFileSync } from 'node:child_process';
-// True only on Windows where a WSL distribution responds. Used to decide whether
-// rtk can use its transparent PreToolUse hook (needs WSL) or must fall back to
-// instruction mode. Never throws.
+import { join } from 'node:path';
+// True only on Windows where a WSL distribution responds.
 export function hasWsl() {
     if (process.platform !== 'win32')
         return false;
@@ -13,3 +12,24 @@ export function hasWsl() {
         return false;
     }
 }
+// True if the rtk binary is available natively or on PATH. Never throws.
+export function hasRtk() {
+    try {
+        const cmd = process.platform === 'win32' ? 'rtk.exe' : 'rtk';
+        execFileSync(cmd, ['--version'], { stdio: 'pipe', timeout: 3000 });
+        return true;
+    }
+    catch {
+        if (process.platform === 'win32') {
+            const home = process.env.USERPROFILE ?? process.env.HOME;
+            if (home) {
+                try {
+                    execFileSync(join(home, '.local', 'bin', 'rtk.exe'), ['--version'], { stdio: 'pipe', timeout: 3000 });
+                    return true;
+                }
+                catch { /* ignore */ }
+            }
+        }
+        return false;
+    }
+}