@hecer/yoke 1.19.0 → 1.21.1

package/dist/loop/run-command.js

@@ -2,13 +2,15 @@ import { roleSelection } from "../routing/capability.js";
 import { join } from 'node:path';
 import { existsSync, unlinkSync } from 'node:fs';
 import { loadConfig, saveConfig, defaultConfig, resolveOutputPolicy, resolveVerifyCommand } from '../retrofit/config.js';
-import { allPass, loadPrd, progress, selectNextStory } from './prd.js';
+import { allPass, loadPrd, progress, selectNextStory, storyPathSegment } from './prd.js';
 import { pauseFilePath, requestLoopPause, runLoop } from './loop.js';
 import { commitPaths, realGitOps } from './git.js';
 import { makeRunner, makeReviewRunner, isAgentAvailable } from './runner.js';
 import { commandVerifier, commandsVerifier, retryingVerifier } from './verify.js';
 import { readStatus, makeReporter, fmtDuration } from './reporter.js';
-import { acquireLock, releaseLock } from './lock.js';
+import { acquireLock, releaseLock, readLock } from './lock.js';
+import { statePath } from '../workspace/state.js';
+import { accountRunIterations, createLoopRun, readRunState, writeRunState } from './run-state.js';
 import { maybeAutoUpgrade } from '../update/upgrade.js';
 import { resolveCommitIdentity } from './identity.js';
 import { runAudit } from '../audit/command.js';
@@ -51,7 +53,7 @@ export function setLoopEnabled(targetDir, enabled) {
     config.loop = { ...config.loop, enabled };
     saveConfig(targetDir, config);
 }
-export function loopStatus(targetDir, now = () => new Date()) {
+export function loopStatus(targetDir, now = () => new Date(), opts) {
     const config = loadConfig(targetDir);
     const enabled = config?.loop.enabled ?? false;
     const path = prdPath(targetDir);
@@ -60,6 +62,12 @@ export function loopStatus(targetDir, now = () => new Date()) {
         const p = progress(loadPrd(path));
         prog = `${p.passed}/${p.total} stories pass`;
     }
+    const st = readStatus(targetDir);
+    if (opts?.compact) {
+        if (!st)
+            return `state=${enabled ? 'enabled' : 'disabled'} prd="${prog}"`;
+        return `state=${st.state} story=${st.story ?? 'none'} progress=${st.progress.passed}/${st.progress.total} phase=${st.phase} updated=${relativeTime(st.updatedAt, now())}`;
+    }
     const sharedPoolLine = () => {
         try {
             const pool = sharedPoolStatus();
@@ -69,7 +77,6 @@ export function loopStatus(targetDir, now = () => new Date()) {
             return `Shared pool unavailable: ${error.message}`;
         }
     };
-    const st = readStatus(targetDir);
     if (!st)
         return `Loop: ${enabled ? 'enabled' : 'disabled'}\nPRD: ${prog}\n${sharedPoolLine()}`;
     const head = `Loop: ${st.state.toUpperCase()}${st.story ? ` on ${st.story}${st.storyTitle ? ` "${st.storyTitle}"` : ''}` : ''}`;
@@ -232,7 +239,7 @@ async function runContinuousExploration(targetDir, options) {
         console.error('--explore-limit must be a positive, supported duration');
         return 2;
     }
-    const limitDeadline = options.exploreLimitMs === undefined ? undefined : Date.now() + options.exploreLimitMs;
+    const limitDeadline = options.savedRun?.exploreDeadline ?? (options.exploreLimitMs === undefined ? undefined : Date.now() + options.exploreLimitMs);
     const reporter = options.reporter ?? makeReporter(targetDir, { json: options.json, quiet: true });
     let config;
     try {
@@ -242,11 +249,11 @@ async function runContinuousExploration(targetDir, options) {
         config = null;
     }
     const defaultImplementationAgent = options.agent ?? resolveRunnerAgent(config, undefined, detectHostAgent());
-    const defaultExplorer = options.agent ?? config?.planning?.agent ?? defaultImplementationAgent;
+    const defaultExplorer = options.explorationPlanner?.agent ?? options.agent ?? config?.planning?.agent ?? defaultImplementationAgent;
     const available = options.isAvailable ?? isAgentAvailable;
     const reviewRequested = !options.reviewRunner && Boolean(options.review || options.reviewer);
     const innerOptions = { ...options, isolate: true, explore: true, explorationSupervisor: true, reporter, quiet: true };
-    let usedIterations = 0;
+    let usedIterations = options.savedRun?.consumedIterations ?? 0;
     let retryCount = 0;
     let explorationFailures = 0;
     let noActionScans = 0;
@@ -284,6 +291,8 @@ async function runContinuousExploration(targetDir, options) {
             return 'limit';
         const explorer = retryProviders(targetDir, explorationAgent, available);
         const result = runPrdExplore(targetDir, {
+            ownedLockToken: options.ownedLockToken,
+            ...(explorationAgent === options.explorationPlanner?.agent ? { selection: options.explorationPlanner.selection } : {}),
             runner: explorationAgent,
             timeoutMinutes: options.timeoutMinutes,
             isAvailable: options.isAvailable ?? isAgentAvailable,
@@ -370,7 +379,9 @@ async function runContinuousExploration(targetDir, options) {
         }
         const afterStatus = readStatus(targetDir);
         const changedStatus = afterStatus?.updatedAt !== beforeStatus?.updatedAt;
-        if (changedStatus && priorProgress.passed < priorProgress.total)
+        if (options.savedRun)
+            usedIterations = options.savedRun.consumedIterations ?? usedIterations;
+        else if (changedStatus && priorProgress.passed < priorProgress.total)
             usedIterations += Math.max(0, afterStatus?.iteration ?? 0);
         if (unexpectedFailure) {
             retryCount++;
@@ -468,7 +479,7 @@ async function runContinuousExploration(targetDir, options) {
         }
         retryCount++;
         advanceRecoveryProviders();
-        retryWorktree = true;
+        retryWorktree = (afterStatus?.parallel?.reopened ?? 0) === 0;
         const wait = retryDelay(retryCount);
         reporter.phase('waiting-recovery', `story ${afterStatus?.story ?? 'unknown'} remains incomplete: ${afterStatus?.reason ?? 'no passing completion status'}; retrying with ${implementationAgent ?? 'the configured runner'} in ${Math.ceil(wait / 1_000)} seconds`, currentProgress(targetDir));
         say(`The current task remains unfinished; its isolated work is retained. Next: retry with ${implementationAgent ?? 'the configured runner'} in ${Math.ceil(wait / 1_000)} seconds.`);
@@ -480,7 +491,7 @@ async function runContinuousExploration(targetDir, options) {
 }
 export function runLoopCommand(targetDir, opts) {
     if (opts.explore && !opts.explorationSupervisor)
-        return runContinuousExploration(targetDir, opts);
+        return startContinuousExploration(targetDir, opts);
     let parallel = opts.parallel ?? 1;
     const candidates = opts.candidates ?? 1;
     if (opts.resumeWorktree && (opts.isolate === false || parallel !== 1 || candidates !== 1)) {
@@ -554,7 +565,8 @@ export function runLoopCommand(targetDir, opts) {
         return 2;
     }
     const isolate = opts.isolate ?? config.loop.isolate ?? true;
-    const useParallelDispatcher = parallel > 1 || candidates > 1;
+    const retainedParallel = opts.explorationSupervisor && loadPrd(path).some(story => !story.passes && existsSync(statePath(targetDir, 'integration-recovery', `${storyPathSegment(story.id)}.json`)));
+    const useParallelDispatcher = parallel > 1 || candidates > 1 || retainedParallel === true;
     if (opts.resumeWorktree && (!isolate || parallel !== 1)) {
         console.error('--resume-worktree requires isolation and one worker');
         return 2;
@@ -668,11 +680,13 @@ export function runLoopCommand(targetDir, opts) {
     const routingRequested = opts.routing ?? config.routing?.enabled ?? true;
     const routingEnabled = routingRequested && Boolean(config.routing && (config.routing.workers.length || config.routing.fallback === 'block' || config.routing.maxTier || config.routing.assessmentPolicy === 'prepared'));
     const runnerSelection = {
-        provider: config.runner?.provider,
-        model: config.runner?.model,
-        reasoningEffort: config.runner?.reasoningEffort,
-        variant: config.runner?.variant,
-        bare: config.runner?.bare,
+        ...(opts.selection ?? {
+            provider: config.runner?.provider,
+            model: config.runner?.model,
+            reasoningEffort: config.runner?.reasoningEffort,
+            variant: config.runner?.variant,
+            bare: config.runner?.bare,
+        }),
         nativeMultiAgent: false,
     };
     const parallelProviders = [{
@@ -735,13 +749,7 @@ export function runLoopCommand(targetDir, opts) {
         timeoutMs: idleMs,
         isAvailable: available,
         permissions,
-        selection: {
-            provider: config.runner?.provider,
-            model: config.runner?.model,
-            reasoningEffort: config.runner?.reasoningEffort,
-            variant: config.runner?.variant,
-            bare: config.runner?.bare,
-        },
+        selection: runnerSelection,
         commit: (_path, request) => commitPaths(targetDir, ['.yoke/prd.yaml'], `yoke: plan change ${request.id}`, commitIdentity),
     }));
     let runner = opts.runner;
@@ -854,7 +862,14 @@ export function runLoopCommand(targetDir, opts) {
     }
     let lock;
     try {
-        lock = acquireLock(targetDir);
+        statePath(targetDir, 'loop.lock');
+        if (opts.ownedLockToken) {
+            if (readLock(targetDir)?.ownerToken !== opts.ownedLockToken)
+                throw new Error('Invalid borrowed loop lock');
+            lock = { acquired: true, ownerToken: opts.ownedLockToken };
+        }
+        else
+            lock = acquireLock(targetDir);
     }
     catch (error) {
         console.error(`Cannot acquire the Yoke loop lock: ${error.message}`);
@@ -867,8 +882,22 @@ export function runLoopCommand(targetDir, opts) {
     if (lock.stalePid !== undefined) {
         console.warn(`Took over a stale loop lock (pid ${lock.stalePid} is gone).`);
     }
-    const reporter = opts.reporter ?? makeReporter(targetDir, { json: opts.json, quiet: opts.quiet });
+    let reporter = opts.reporter ?? makeReporter(targetDir, { json: opts.json, quiet: opts.quiet });
     executionReporter = reporter;
+    try {
+        const saved = opts.savedRun ?? createLoopRun({ ...opts, agent: runnerAgent, selection: runnerSelection, parallel, isolate, routing: routingEnabled, timeoutMinutes: opts.timeoutMinutes ?? config.loop.timeoutMinutes });
+        if (opts.savedRun && readRunState(targetDir)?.runId !== opts.savedRun.runId)
+            throw new Error('Saved run changed before resume');
+        writeRunState(targetDir, saved, lock.ownerToken);
+        reporter = accountRunIterations(targetDir, saved, lock.ownerToken, reporter);
+        executionReporter = reporter;
+    }
+    catch (error) {
+        if (!opts.ownedLockToken)
+            releaseLock(targetDir, lock.ownerToken);
+        reporter.blocked(`could not persist loop run: ${error.message}`);
+        return 1;
+    }
     const buildResume = (storyId, requestId) => buildTrustedDecisionResumeState({
         storyId,
         requestId,
@@ -938,7 +967,8 @@ export function runLoopCommand(targetDir, opts) {
             completion,
             quality,
             onCriticalDecision: decision => writeDecisionResume(targetDir, buildResume(decision.storyId, decisionRequestId(decision))),
-        }).then(code => reconcileDecisionResume() ?? code).finally(() => releaseLock(targetDir, lock.ownerToken));
+        }).then(code => reconcileDecisionResume() ?? code).finally(() => { if (!opts.ownedLockToken)
+            releaseLock(targetDir, lock.ownerToken); });
     }
     try {
         const maxIterations = opts.maxIterations ?? Number.POSITIVE_INFINITY;
@@ -984,6 +1014,47 @@ export function runLoopCommand(targetDir, opts) {
         return 1;
     }
     finally {
-        releaseLock(targetDir, lock.ownerToken);
+        if (!opts.ownedLockToken)
+            releaseLock(targetDir, lock.ownerToken);
     }
 }
+async function startContinuousExploration(targetDir, options) {
+    let lock;
+    try {
+        if (options.isolate === false)
+            throw new Error('--explore requires isolated story worktrees');
+        if (options.exploreLimitMs !== undefined && (!Number.isSafeInteger(options.exploreLimitMs) || options.exploreLimitMs <= 0 || Date.now() + options.exploreLimitMs > 8_640_000_000_000_000))
+            throw new Error('--explore-limit must be a positive, supported duration');
+        statePath(targetDir, 'loop.lock');
+        lock = acquireLock(targetDir);
+        if (!lock.acquired) {
+            console.error('Another loop is already running here');
+            return 2;
+        }
+        const config = loadConfig(targetDir);
+        const implementationAgent = options.agent ?? resolveRunnerAgent(config, undefined, detectHostAgent());
+        const implementationSelection = options.selection ?? config?.runner ?? {};
+        const explorationPlanner = options.explorationPlanner ?? resolvePlanner(config, implementationAgent, implementationSelection, options.agent);
+        const run = options.savedRun ?? createLoopRun({ ...options, agent: implementationAgent, selection: implementationSelection, explorationPlanner, timeoutMinutes: options.timeoutMinutes ?? config?.loop.timeoutMinutes, ...(options.parallel === undefined && !options.parallelAuto ? typeof config?.loop.parallel === 'number' ? { parallel: config.loop.parallel } : { parallelAuto: true } : {}) });
+        if (options.savedRun && readRunState(targetDir)?.runId !== run.runId)
+            throw new Error('Saved run changed before resume');
+        writeRunState(targetDir, run, lock.ownerToken);
+        return await runContinuousExploration(targetDir, { ...options, selection: run.options.selection, explorationPlanner: run.options.explorationPlanner ?? explorationPlanner, savedRun: run, ownedLockToken: lock.ownerToken });
+    }
+    catch (error) {
+        console.error(`Cannot start exploration: ${error.message}`);
+        return 2;
+    }
+    finally {
+        if (lock?.acquired)
+            releaseLock(targetDir, lock.ownerToken);
+    }
+}
+/** Resume the saved execution identity without extending its exploration deadline. */
+export function resumeLoopCommand(targetDir) {
+    const run = readRunState(targetDir);
+    if (!run || run.mode === 'goal')
+        throw new Error('No saved loop run to resume');
+    const { native: _native, ...options } = run.options;
+    return runLoopCommand(targetDir, { ...options, ...(run.mode === 'loop' && options.maxIterations !== undefined ? { maxIterations: Math.max(0, options.maxIterations - (run.consumedIterations ?? 0)) } : {}), explore: run.mode === 'explore', savedRun: run, permissions: 'safe' });
+}

package/dist/loop/run-state.js

@@ -0,0 +1,116 @@
+import { randomUUID } from 'node:crypto';
+import { lstatSync, readFileSync, renameSync, rmSync, writeFileSync } from 'node:fs';
+import { z } from 'zod';
+import { statePath } from '../workspace/state.js';
+import { readLock } from './lock.js';
+import { AgentSchema, ModelSelectionSchema } from '../agents/contracts.js';
+const agent = AgentSchema;
+const bounded = z.number().int().min(1).max(1_000_000);
+const selection = ModelSelectionSchema.omit({ nativeMultiAgent: true }).strict();
+const Options = z.object({
+    agent: agent.optional(), reviewer: agent.optional(), maxIterations: bounded.optional(), isolate: z.boolean().optional(),
+    resumeWorktree: z.boolean().optional(), review: z.boolean().optional(), timeoutMinutes: z.number().finite().min(0).max(10080).optional(),
+    json: z.boolean().optional(), onAmbiguity: z.enum(['resolve', 'abort', 'auto', 'critical']).optional(), decisionPolicy: z.enum(['auto', 'critical']).optional(),
+    parallel: z.number().int().min(1).max(64).optional(), parallelAuto: z.boolean().optional(), routing: z.boolean().optional(),
+    quality: z.boolean().optional(), qualityRounds: bounded.optional(), qualityMinutes: z.number().finite().positive().max(10080).optional(),
+    qualityPolicy: z.enum(['blocking', 'advisory']).optional(), candidates: z.number().int().min(1).max(5).optional(),
+    exploreIntervalMinutes: z.number().int().min(1).max(1440).optional(), selection: selection.optional(), native: z.boolean().optional(),
+    explorationPlanner: z.object({ agent, selection }).strict().optional(),
+}).strict();
+const State = z.object({ version: z.literal(1), runId: z.string().uuid(), startedAt: z.string().datetime(), mode: z.enum(['loop', 'explore', 'goal']), goalId: z.string().uuid().optional(), consumedIterations: z.number().int().min(0).max(1_000_000_000).optional(), exploreDeadline: z.number().int().min(0).max(8_640_000_000_000_000).optional(), options: Options }).strict().superRefine((run, ctx) => {
+    if ((run.mode === 'goal') !== Boolean(run.goalId))
+        ctx.addIssue({ code: 'custom', message: 'Run goal identity does not match mode' });
+    if (run.mode !== 'explore' && run.exploreDeadline !== undefined)
+        ctx.addIssue({ code: 'custom', message: 'Exploration deadline does not match mode' });
+});
+function safeOptions(options) {
+    const selected = {};
+    for (const key of Object.keys(Options.shape)) {
+        const value = options[key];
+        if (value !== undefined) {
+            if (key === 'selection') {
+                const { nativeMultiAgent: _native, ...model } = ModelSelectionSchema.parse(value);
+                selected[key] = selection.parse(model);
+            }
+            else if (key === 'explorationPlanner') {
+                const planner = value;
+                const { nativeMultiAgent: _native, ...model } = ModelSelectionSchema.parse(planner.selection);
+                selected[key] = { agent: planner.agent, selection: selection.parse(model) };
+            }
+            else
+                selected[key] = value;
+        }
+    }
+    return Options.parse(selected);
+}
+export function createLoopRun(options, now = Date.now()) {
+    const deadline = options.exploreLimitMs === undefined ? undefined : now + options.exploreLimitMs;
+    return State.parse({ version: 1, runId: randomUUID(), startedAt: new Date(now).toISOString(), mode: options.explore ? 'explore' : 'loop', options: safeOptions(options), ...(deadline !== undefined ? { exploreDeadline: deadline } : {}) });
+}
+export function readRunState(root) {
+    const file = statePath(root, 'run-state.json');
+    try {
+        const stat = lstatSync(file);
+        if (!stat.isFile())
+            throw new Error('Saved run is not a file');
+        if (stat.size > 65536)
+            throw new Error('Saved run is too large');
+        return State.parse(JSON.parse(readFileSync(file, 'utf8')));
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return null;
+        throw error;
+    }
+}
+export function writeRunState(root, run, ownerToken) {
+    const validated = State.parse(run);
+    statePath(root, 'loop.lock');
+    if (!ownerToken || readLock(root)?.ownerToken !== ownerToken)
+        throw new Error('Saving run requires ownership of the loop lock');
+    const file = statePath(root, 'run-state.json');
+    const temp = statePath(root, `run-state.${randomUUID()}.tmp`);
+    try {
+        writeFileSync(temp, JSON.stringify(validated), { flag: 'wx', mode: 0o600 });
+        statePath(root, 'run-state.json');
+        renameSync(temp, file);
+    }
+    finally {
+        rmSync(temp, { force: true });
+    }
+}
+export function recordGoalRun(root, goalId, ownerToken, options = {}) {
+    const values = options;
+    let previous = null;
+    try {
+        previous = readRunState(root);
+    }
+    catch { /* an explicitly started goal may replace invalid old execution metadata */ }
+    const sameGoal = previous?.mode === 'goal' && previous.goalId === goalId ? previous : null;
+    writeRunState(root, State.parse({ version: 1, runId: sameGoal?.runId ?? randomUUID(), startedAt: sameGoal?.startedAt ?? new Date().toISOString(), mode: 'goal', goalId, options: safeOptions({ ...values, agent: values.agent ?? values.provider }) }), ownerToken);
+}
+/** Charge each dispatch before its reporter callback can begin provider work. */
+export function accountRunIterations(root, run, ownerToken, reporter) {
+    const previousIterations = run.consumedIterations ?? 0;
+    let charged = 0;
+    const account = (iteration) => {
+        if (iteration === undefined || !Number.isSafeInteger(iteration) || iteration <= charged)
+            return;
+        const current = readRunState(root);
+        if (current?.runId !== run.runId)
+            throw new Error('Execution identity changed before dispatch');
+        run.consumedIterations = previousIterations + iteration;
+        writeRunState(root, run, ownerToken);
+        charged = iteration;
+    };
+    return new Proxy(reporter, {
+        get(target, key) {
+            if (key === 'storyStart')
+                return (...args) => { account(args[1]); target.storyStart(...args); };
+            if (key === 'parallel')
+                return (status) => { account(status.iteration); target.parallel?.(status); };
+            const value = Reflect.get(target, key, target);
+            return typeof value === 'function' ? value.bind(target) : value;
+        },
+    });
+}

package/dist/prd/explore.js

@@ -10,7 +10,8 @@ import { readPlanningFile } from '../routing/contracts.js';
 import { loadConfig } from '../retrofit/config.js';
 import { commitPaths, realGitOps } from '../loop/git.js';
 import { resolveCommitIdentity } from '../loop/identity.js';
-import { acquireLock, releaseLock } from '../loop/lock.js';
+import { acquireLock, releaseLock, readLock } from '../loop/lock.js';
+import { statePath } from '../workspace/state.js';
 import { allPass, AcceptanceCriterionSchema, criterionCommandProblem, isAcceptanceCriterion, loadPrd, StorySchema, validateDependencies } from '../loop/prd.js';
 import { writeScopesOverlap, validWriteScope } from '../loop/scheduler.js';
 import { withSharedWorkerSync } from '../loop/resource-pool.js';
@@ -360,7 +361,14 @@ export function runPrdExplore(root, options = {}) {
         const prompt = promptFor(brief, context, recentCompleted, options.focus);
         if (prompt.length > MAX_PROMPT_CHARS)
             throw Error(`exploration input exceeds ${MAX_PROMPT_CHARS} characters; condense the project brief and context`);
-        lock = acquireLock(root);
+        statePath(root, 'loop.lock');
+        if (options.ownedLockToken) {
+            if (readLock(root)?.ownerToken !== options.ownedLockToken)
+                throw Error('Invalid borrowed exploration lock');
+            lock = { acquired: true, ownerToken: options.ownedLockToken };
+        }
+        else
+            lock = acquireLock(root);
         if (!lock.acquired)
             return { kind: 'retry', provider: planner.agent, summary: 'another Yoke operation owns the project lock' };
         if (options.pause?.())
@@ -370,7 +378,7 @@ export function runPrdExplore(root, options = {}) {
             || readPlanningFile(root, RECENT_EXPLORATION_FILE, RECENT_EXPLORATION_BYTES) !== recent.text
             || !realGitOps.isClean(root))
             throw Error('project changed while exploration was being prepared');
-        const invocation = buildWatchdogInvocation(runnerInvocation(planner.agent, prompt, root, true, 'read-only', planner.selection), options.timeoutMinutes === undefined ? 20 * 60_000 : options.timeoutMinutes > 0 ? options.timeoutMinutes * 60_000 : 0);
+        const invocation = buildWatchdogInvocation(runnerInvocation(planner.agent, prompt, root, true, 'read-only', options.selection ?? planner.selection), options.timeoutMinutes === undefined ? 20 * 60_000 : options.timeoutMinutes > 0 ? options.timeoutMinutes * 60_000 : 0);
         const started = Date.now();
         const result = withSharedWorkerSync({ targetDir: root, storyId: 'project-exploration', provider: planner.agent, role: 'implementation' }, () => (options.run ?? runCapturedAgent)(planner.agent, invocation));
         options.onUsage?.({
@@ -420,7 +428,7 @@ export function runPrdExplore(root, options = {}) {
         return { kind: 'retry', ...(plannerAgent ? { provider: plannerAgent } : {}), summary: error instanceof Error ? error.message : String(error) };
     }
     finally {
-        if (lock?.acquired)
+        if (lock?.acquired && !options.ownedLockToken)
             releaseLock(root, lock.ownerToken);
     }
 }

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

@@ -88,6 +88,7 @@ export const YokeConfigSchema = z.object({
         bare: z.boolean().optional(),
         permissions: PermissionProfileSchema.optional(),
     }).optional(),
+    goals: z.object({ nativeCodex: z.boolean().optional() }).optional(),
     planning: z.object({
         agent: AgentSchema.optional(),
         provider: z.string().regex(/^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/).optional(),

package/dist/retrofit/gitignore.js

@@ -2,6 +2,9 @@ import { existsSync, readFileSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
 export const YOKE_IGNORE_LINES = [
     '.yoke/worktrees/',
+    '.yoke/integration-recovery/',
+    '.yoke/run-state.json',
+    '.yoke/run-state.*.tmp',
     '.yoke/backup/',
     '.yoke/code-intelligence/',
     '.yoke/loop-status.json',

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;
+    }
+}

package/dist/setup/command.js

@@ -55,6 +55,8 @@ function parseAgents(value, fallback) {
     return parsed.length > 0 ? [...new Set(parsed)] : fallback;
 }
 function yes(value, fallback) {
+    if (!value)
+        return fallback;
     const normalized = value.trim().toLowerCase();
     if (['y', 'yes', 'j', 'ja', 'true', '1'].includes(normalized))
         return true;
@@ -99,6 +101,10 @@ export async function runSetup(targetDir, opts = {}) {
         let runner = defaultRunner;
         let decisionPolicy = defaultPolicy;
         let routing = defaultRouting;
+        let runnerModel = opts.runnerModel ?? existing?.runner?.model;
+        let runnerReasoning = opts.runnerReasoning ?? existing?.runner?.reasoningEffort;
+        const agentModels = { ...(opts.agentModels ?? {}) };
+        const agentReasoning = { ...(opts.agentReasoning ?? {}) };
         if (interactive && ask) {
             agents = parseAgents(await ask(`Agents [${defaultAgents.join(',')}] (${SUPPORTED_AGENTS.join(',')}|all): `), defaultAgents);
             const graphAnswer = (await ask(`Code graph [${defaultGraph}] (graphify|serena): `)).trim().toLowerCase();
@@ -112,12 +118,39 @@ export async function runSetup(targetDir, opts = {}) {
             if (policyAnswer === 'auto' || policyAnswer === 'critical')
                 decisionPolicy = policyAnswer;
             routing = yes(await ask(`Enable adaptive multi-model routing? [${defaultRouting ? 'yes' : 'no'}]: `), defaultRouting);
+            if (opts.configureModels) {
+                const configureModels = yes(await ask(`Configure model & reasoning effort per agent? [no]: `), false);
+                if (configureModels) {
+                    const rm = (await ask(`Runner model [${runnerModel ?? 'default'}]: `)).trim();
+                    if (rm)
+                        runnerModel = rm;
+                    const rr = (await ask(`Runner reasoning effort (none|low|medium|high|xhigh) [${runnerReasoning ?? 'default'}]: `)).trim();
+                    if (rr)
+                        runnerReasoning = rr;
+                    for (const a of agents) {
+                        const am = (await ask(`Model for agent "${a}" [${agentModels[a] ?? 'default'}]: `)).trim();
+                        if (am)
+                            agentModels[a] = am;
+                        const ar = (await ask(`Reasoning effort for agent "${a}" (none|low|medium|high|xhigh) [${agentReasoning[a] ?? 'default'}]: `)).trim();
+                        if (ar)
+                            agentReasoning[a] = ar;
+                    }
+                }
+            }
         }
         if (modelProviders.length && !agents.includes('qwen'))
             agents = [...agents, 'qwen'];
         if (!agents.includes(runner))
             agents = [...agents, runner];
-        const code = runRetrofit(targetDir, { loop, agents, codeGraph, codeIntelligence, host });
+        const priorRunner = existing?.runner?.agent ?? existing?.agents[0];
+        const runnerChanged = priorRunner !== undefined && priorRunner !== runner;
+        if (runnerChanged) {
+            if (opts.runnerModel === undefined)
+                runnerModel = undefined;
+            if (opts.runnerReasoning === undefined)
+                runnerReasoning = undefined;
+        }
+        const code = runRetrofit(targetDir, { loop, agents, codeGraph, codeIntelligence, host, cleanWorktrees: opts.cleanWorktrees, runnerModel, runnerReasoning, agentModels, agentReasoning });
         if (code !== 0)
             return code;
         applyActions(presetActions, targetDir, { backupDir: join(targetDir, '.yoke', 'backups', `model-presets-${Date.now()}`) });
@@ -125,14 +158,23 @@ export async function runSetup(targetDir, opts = {}) {
         if (!config)
             return 1;
         config.loop = { parallel: 'auto', isolate: true, ...config.loop, enabled: loop, decisionPolicy };
-        const priorRunner = existing?.runner?.agent ?? existing?.agents[0];
         const selectPresetModel = presetWorkers.length > 0 && runner === 'qwen' && (!existing || (priorRunner !== undefined && priorRunner !== runner));
         if (selectPresetModel && priorRunner !== 'qwen')
             config.runner = { permissions: config.runner?.permissions };
-        config.runner = { ...config.runner, agent: runner, ...(selectPresetModel && !config.runner?.model ? { model: presetWorkers[0].model } : {}) };
+        config.runner = {
+            ...config.runner,
+            agent: runner,
+            ...(runnerModel ? { model: runnerModel } : selectPresetModel && !config.runner?.model ? { model: presetWorkers[0].model } : {}),
+            ...(runnerReasoning ? { reasoningEffort: runnerReasoning } : {}),
+        };
         const existingWorkers = config.routing?.workers ?? [];
         const baseWorkers = existingWorkers.length > 0 && !opts.routingPreset ? existingWorkers : defaultRoutingWorkers(agents).filter(worker => !modelProviders.length || worker.agent !== 'qwen');
-        const workers = [...baseWorkers, ...presetWorkers.filter(worker => !baseWorkers.some(existing => existing.id === worker.id))];
+        const rawWorkers = [...baseWorkers, ...presetWorkers.filter(worker => !baseWorkers.some(existing => existing.id === worker.id))];
+        const workers = rawWorkers.map(w => {
+            const model = agentModels[w.agent] ?? w.model;
+            const reasoningEffort = agentReasoning[w.agent] ?? w.reasoningEffort;
+            return { ...w, ...(model ? { model } : {}), ...(reasoningEffort ? { reasoningEffort } : {}) };
+        });
         config.routing = {
             ...config.routing,
             enabled: routing,
@@ -145,7 +187,7 @@ export async function runSetup(targetDir, opts = {}) {
         };
         YokeConfigSchema.parse(config);
         saveConfig(targetDir, config);
-        console.log(`Yoke setup complete: agents=${agents.join(',')} · runner=${runner} · loop=${loop ? 'on' : 'off'} · routing=${routing ? 'on' : 'off'} · decisions=${decisionPolicy}`);
+        console.log(`Yoke setup complete: agents=${agents.join(',')} · runner=${runner}${runnerModel ? ` (${runnerModel})` : ''}${runnerReasoning ? ` [${runnerReasoning}]` : ''} · loop=${loop ? 'on' : 'off'} · routing=${routing ? 'on' : 'off'} · decisions=${decisionPolicy}`);
         return 0;
     }
     finally {