parallel-codex-tui 0.2.10 → 0.3.1

package/dist/orchestrator/orchestrator.js

@@ -1,10 +1,13 @@
+import { createHash } from "node:crypto";
 import { cp, readdir } from "node:fs/promises";
 import { join } from "node:path";
+import { runRuntimePreflight } from "../doctor.js";
 import { appendJsonLine, ensureDir, pathExists, readJson, readTextIfExists, removeIfExists, writeJson, writeText } from "../core/file-store.js";
 import { runWithLeaseFinalization } from "../core/lease-finalization.js";
 import { extractMainResponse } from "../core/main-response.js";
 import { claimTaskRunLease, TaskRunLeaseConflictError } from "../core/process-ownership.js";
 import { routerRuntimeDir } from "../core/paths.js";
+import { RoleConfigurationManager, roleSelectionWithEngines } from "../core/role-configuration.js";
 import { classifyRouterFailure, routerFallbackIsTransient } from "../core/router-audit.js";
 import { sanitizeRouterText } from "../core/router-redaction.js";
 import { routeRequestWithCodex, routerCommandLabel, routerProxyContext } from "../core/router.js";
@@ -59,6 +62,7 @@ export class Orchestrator {
     routerConfigLoader;
     dependencies;
     activeFeatureRuns = new Map();
+    roleConfiguration;
     constructor(config, sessions, workers, routeRunner, routerCwd = routerRuntimeDir(config.projectRoot, config.dataDir), routerConfigLoader, dependencies = {}) {
         this.config = config;
         this.sessions = sessions;
@@ -67,17 +71,21 @@ export class Orchestrator {
         this.routerCwd = routerCwd;
         this.routerConfigLoader = routerConfigLoader;
         this.dependencies = dependencies;
+        this.roleConfiguration = dependencies.roleConfiguration ?? RoleConfigurationManager.transient(config);
     }
     async handleRequest(input) {
         throwIfCancelled(input.signal);
-        const route = await this.routeRequest(input.request, input.cwd, input.signal, "initial", input.onRouteStart, input.onRouteFallback, input.onRouteProgress);
+        const routed = await this.routeRequest(input.request, input.cwd, input.signal, "initial", input.onRouteStart, input.onRouteFallback, input.onRouteProgress);
+        const roleSelection = input.roleSelection ?? await this.roleConfiguration.selectionForRequest();
+        const route = routeWithRoleSelection(routed, roleSelection);
         input.onRoute?.(route);
         throwIfCancelled(input.signal);
         const workers = [];
+        const executionInput = { ...input, roleSelection };
         if (route.mode === "simple") {
             try {
                 input.onStatus?.({ taskId: "main", main: "starting" });
-                const output = await this.runMain(input, workers);
+                const output = await this.runMain(executionInput, workers);
                 input.onStatus?.({ taskId: "main", main: "done" });
                 return {
                     mode: "simple",
@@ -104,18 +112,20 @@ export class Orchestrator {
             userPath: join(task.dir, "turns", "0001", "user.md"),
             routePath: join(task.dir, "turns", "0001", "route.json")
         };
-        return this.withTaskRunLease(task, () => this.runInitialTask(input, task, route, turn, workers));
+        await this.roleConfiguration.writeTurnSelection(turn.dir, roleSelectionWithEngines(route, roleSelection));
+        return this.withTaskRunLease(task, () => this.runInitialTask(executionInput, task, route, turn, workers));
     }
     async handleTaskTurn(input) {
         throwIfCancelled(input.signal);
         const task = this.sessions.taskFromId(input.taskId);
-        const route = input.route ?? await this.routeRequest(input.request, input.cwd, input.signal, "follow-up", input.onRouteStart, input.onRouteFallback, input.onRouteProgress);
+        const roleSelection = input.roleSelection ?? await this.roleConfiguration.selectionForRequest(task.dir);
+        const route = routeWithRoleSelection(input.route ?? await this.routeRequest(input.request, input.cwd, input.signal, "follow-up", input.onRouteStart, input.onRouteFallback, input.onRouteProgress), roleSelection);
         if (!input.route) {
             input.onRoute?.(route);
         }
         throwIfCancelled(input.signal);
         if (route.mode === "simple") {
-            return this.answerTaskQuestion({ ...input, route });
+            return this.answerTaskQuestion({ ...input, route, roleSelection });
         }
         return this.withTaskRunLease(task, async () => {
             throwIfCancelled(input.signal);
@@ -124,8 +134,9 @@ export class Orchestrator {
                 request: input.request,
                 route
             });
+            await this.roleConfiguration.writeTurnSelection(turn.dir, roleSelectionWithEngines(route, roleSelection));
             const workers = [];
-            return this.runPairTask(input, task, route, turn, workers);
+            return this.runPairTask({ ...input, roleSelection }, task, route, turn, workers);
         });
     }
     async retryTask(input) {
@@ -175,20 +186,126 @@ export class Orchestrator {
             };
             const assignmentPath = join(featureDir, "assignment.json");
             const current = await readFeatureAssignment({ assignmentPath }, fallback);
-            const assignment = await writeFeatureAssignment({ assignmentPath }, input.role === "actor" ? input.engine : current.actor_engine, input.role === "critic" ? input.engine : current.critic_engine);
+            const nextModel = input.model === undefined
+                ? input.role === "actor"
+                    ? current.actor_engine === input.engine ? current.actor_model : ""
+                    : current.critic_engine === input.engine ? current.critic_model : ""
+                : input.model;
+            const assignment = await writeFeatureAssignment({ assignmentPath }, input.role === "actor" ? input.engine : current.actor_engine, input.role === "critic" ? input.engine : current.critic_engine, input.role === "actor" ? nextModel : current.actor_model, input.role === "critic" ? nextModel : current.critic_model, {
+                actorOverride: input.role === "actor" ? true : current.actor_override,
+                criticOverride: input.role === "critic" ? true : current.critic_override
+            });
             await appendJsonLine(join(task.dir, "dialogue", "actor-critic.jsonl"), {
                 time: new Date().toISOString(),
                 feature_id: input.featureId,
                 turn_id: status.turn_id,
                 type: "feature.assignment_changed",
                 role: input.role,
-                message: `${capitalize(input.role)} reassigned to ${input.engine}.`,
+                message: `${capitalize(input.role)} reassigned to ${input.engine}/${nextModel.trim() || "default"}.`,
                 paths: { assignment: assignmentPath }
             });
-            await this.sessions.appendEvent(task, "feature.assignment_changed", `${input.featureId} ${input.role} reassigned to ${input.engine}`);
+            await this.sessions.appendEvent(task, "feature.assignment_changed", `${input.featureId} ${input.role} reassigned to ${input.engine}/${nextModel.trim() || "default"}`);
             return { featureId: input.featureId, assignment };
         });
     }
+    async roleConfigurationSnapshot(taskId) {
+        const task = taskId ? this.sessions.taskFromId(taskId) : null;
+        if (task && !(await pathExists(task.dir))) {
+            throw new Error(`Task session not found: ${taskId}`);
+        }
+        return this.roleConfiguration.snapshot(task?.dir);
+    }
+    async validateRoleConfiguration(roles) {
+        const parsed = this.roleConfiguration.validate(roles);
+        const candidate = structuredClone(this.config);
+        candidate.router.defaultMode = "auto";
+        candidate.pairing.main = parsed.main.engine;
+        candidate.pairing.judge = parsed.judge.engine;
+        candidate.pairing.actor = parsed.actor.engine;
+        candidate.pairing.critic = parsed.critic.engine;
+        const preflight = this.dependencies.roleConfigurationPreflight
+            ?? ((config, workspaceRoot) => runRuntimePreflight(config, workspaceRoot, process.env, { includeRouter: false }));
+        return preflight(candidate, this.roleConfiguration.workspaceRootPath());
+    }
+    async updateRoleConfiguration(input) {
+        if (input.scope !== "task") {
+            await this.roleConfiguration.apply(input.scope, input.roles);
+            return this.roleConfigurationSnapshot(input.taskId);
+        }
+        const taskId = input.taskId;
+        if (!taskId) {
+            throw new Error("No active Task is available for a current-task role configuration.");
+        }
+        const task = this.sessions.taskFromId(taskId);
+        if (!(await pathExists(task.dir))) {
+            throw new Error(`Task session not found: ${taskId}`);
+        }
+        return this.withTaskRunLease(task, async () => {
+            await this.roleConfiguration.apply("task", input.roles, task.dir);
+            await this.synchronizeRetryRoleConfiguration(task, input.roles);
+            await this.sessions.appendEvent(task, "task.role_configuration_changed", "Current Task role configuration updated");
+            return this.roleConfiguration.snapshot(task.dir);
+        });
+    }
+    async clearRoleConfiguration(scope, taskId) {
+        if (scope !== "task") {
+            await this.roleConfiguration.clear(scope);
+            return this.roleConfigurationSnapshot(taskId);
+        }
+        if (!taskId) {
+            throw new Error("No active Task is available for a current-task role configuration.");
+        }
+        const task = this.sessions.taskFromId(taskId);
+        if (!(await pathExists(task.dir))) {
+            throw new Error(`Task session not found: ${taskId}`);
+        }
+        return this.withTaskRunLease(task, async () => {
+            await this.roleConfiguration.clear("task", task.dir);
+            const roles = await this.roleConfiguration.selectionForTask(task.dir);
+            await this.synchronizeRetryRoleConfiguration(task, roles);
+            await this.sessions.appendEvent(task, "task.role_configuration_cleared", "Current Task role configuration reset");
+            return this.roleConfiguration.snapshot(task.dir);
+        });
+    }
+    async synchronizeRetryRoleConfiguration(task, roles) {
+        const meta = await readTaskMetaIfValid(task.metaPath);
+        if (!meta || !new Set(["failed", "cancelled", "paused"]).has(meta.status)) {
+            return;
+        }
+        const turn = await this.sessions.latestTurn(task);
+        if (!turn) {
+            return;
+        }
+        const route = routeWithRoleSelection(await readJson(turn.routePath, RouteDecisionSchema), roles);
+        const executionRoles = roleSelectionWithEngines(route, roles);
+        await writeJson(turn.routePath, route);
+        await this.sessions.recordLatestRoute(task, route);
+        await this.roleConfiguration.writeTurnSelection(turn.dir, executionRoles);
+        const featuresDir = join(task.dir, "features");
+        if (!(await pathExists(featuresDir))) {
+            return;
+        }
+        const entries = await readdir(featuresDir, { withFileTypes: true });
+        for (const entry of entries) {
+            if (!entry.isDirectory()) {
+                continue;
+            }
+            const featureDir = join(featuresDir, entry.name);
+            const status = await readFeatureStatusIfValid(join(featureDir, "status.json"));
+            if (!status || status.task_id !== task.id || status.state === "approved") {
+                continue;
+            }
+            const assignmentPath = join(featureDir, "assignment.json");
+            const current = await readFeatureAssignment({ assignmentPath }, {
+                actor: executionRoles.actor.engine,
+                critic: executionRoles.critic.engine
+            });
+            await writeFeatureAssignment({ assignmentPath }, current.actor_override ? current.actor_engine : executionRoles.actor.engine, current.critic_override ? current.critic_engine : executionRoles.critic.engine, current.actor_override ? current.actor_model : executionRoles.actor.model, current.critic_override ? current.critic_model : executionRoles.critic.model, {
+                actorOverride: current.actor_override,
+                criticOverride: current.critic_override
+            });
+        }
+    }
     async resumeTaskRun(input, pausedFeatureId) {
         throwIfCancelled(input.signal);
         const task = this.sessions.taskFromId(input.taskId);
@@ -226,11 +343,15 @@ export class Orchestrator {
                 throw new Error(`Task ${input.taskId} turn ${turn.turnId} has no request to retry.`);
             }
             const route = await readJson(turn.routePath, RouteDecisionSchema);
+            const roleSelection = await this.roleConfiguration.readTurnSelection(turn.dir)
+                ?? roleSelectionWithEngines(route, await this.roleConfiguration.selectionForTask(task.dir));
+            await this.roleConfiguration.writeTurnSelection(turn.dir, roleSelection);
             const executionInput = {
                 ...input,
                 request,
                 cwd: meta.cwd,
-                retry: true
+                retry: true,
+                roleSelection
             };
             const workers = [];
             input.onRoute?.(route);
@@ -311,14 +432,18 @@ export class Orchestrator {
     }
     async routeTaskFollowUp(input) {
         throwIfCancelled(input.signal);
-        const route = await this.routeRequest(input.request, input.cwd, input.signal, "follow-up", input.onRouteStart, input.onRouteFallback, input.onRouteProgress);
+        const routed = await this.routeRequest(input.request, input.cwd, input.signal, "follow-up", input.onRouteStart, input.onRouteFallback, input.onRouteProgress);
+        const task = this.sessions.taskFromId(input.taskId);
+        const roleSelection = input.roleSelection ?? await this.roleConfiguration.selectionForRequest(task.dir);
+        const route = routeWithRoleSelection(routed, roleSelection);
         input.onRoute?.(route);
         throwIfCancelled(input.signal);
         return {
             mode: route.mode,
             taskId: route.mode === "complex" ? input.taskId : null,
             reason: route.reason,
-            route
+            route,
+            roleSelection
         };
     }
     async answerTaskQuestion(input) {
@@ -327,7 +452,11 @@ export class Orchestrator {
         if (!(await pathExists(task.dir))) {
             throw new Error(`Task session not found: ${input.taskId}`);
         }
-        return this.withTaskRunLease(task, () => this.answerTaskQuestionWithLease(input, task));
+        const roleSelection = input.roleSelection ?? await this.roleConfiguration.selectionForRequest(task.dir);
+        return this.withTaskRunLease(task, () => this.answerTaskQuestionWithLease({
+            ...input,
+            roleSelection
+        }, task));
     }
     async answerTaskQuestionWithLease(input, task) {
         throwIfCancelled(input.signal);
@@ -437,6 +566,8 @@ export class Orchestrator {
                     feature,
                     actorEngine: route.actor_engine,
                     criticEngine: route.critic_engine,
+                    actorModel: selectedRoleModel(input.roleSelection, "actor", route.actor_engine),
+                    criticModel: selectedRoleModel(input.roleSelection, "critic", route.critic_engine),
                     resume: input.retry
                 })));
                 return await this.runFeaturePlanWithConflictReplan(input, task, route, turn, workers, judge, featurePlan, features);
@@ -448,6 +579,8 @@ export class Orchestrator {
                 judgeDir: judge.dir,
                 actorEngine: route.actor_engine,
                 criticEngine: route.critic_engine,
+                actorModel: selectedRoleModel(input.roleSelection, "actor", route.actor_engine),
+                criticModel: selectedRoleModel(input.roleSelection, "critic", route.critic_engine),
                 resume: input.retry
             });
             features = [feature];
@@ -483,6 +616,8 @@ export class Orchestrator {
                     feature,
                     actorEngine: route.actor_engine,
                     criticEngine: route.critic_engine,
+                    actorModel: selectedRoleModel(input.roleSelection, "actor", route.actor_engine),
+                    criticModel: selectedRoleModel(input.roleSelection, "critic", route.critic_engine),
                     resume: input.retry
                 })));
                 return await this.runFeaturePlanWithConflictReplan(input, task, route, turn, workers, judge, featurePlan, features);
@@ -494,6 +629,8 @@ export class Orchestrator {
                 judgeDir: judge.dir,
                 actorEngine: route.actor_engine,
                 criticEngine: route.critic_engine,
+                actorModel: selectedRoleModel(input.roleSelection, "actor", route.actor_engine),
+                criticModel: selectedRoleModel(input.roleSelection, "critic", route.critic_engine),
                 resume: input.retry
             });
             features = [feature];
@@ -662,6 +799,8 @@ export class Orchestrator {
                     feature,
                     actorEngine: route.actor_engine,
                     criticEngine: route.critic_engine,
+                    actorModel: selectedRoleModel(currentInput.roleSelection, "actor", route.actor_engine),
+                    criticModel: selectedRoleModel(currentInput.roleSelection, "critic", route.critic_engine),
                     resume: true,
                     refreshDefinition: true
                 })));
@@ -746,7 +885,11 @@ export class Orchestrator {
             await this.sessions.updateTaskStatus(task, "actor_running");
             const actorRunById = new Map();
             if (restoredWave) {
-                const restoredActors = await Promise.all(wave.map((definition) => this.loadCompletedFeatureActor(task, requiredFeatureAssignment(assignments, requiredChannel(channels, definition)).actor_engine, definition, requiredChannel(channels, definition))));
+                const restoredActors = await Promise.all(wave.map((definition) => {
+                    const channel = requiredChannel(channels, definition);
+                    const assignment = requiredFeatureAssignment(assignments, channel);
+                    return this.loadCompletedFeatureActor(task, assignment.actor_engine, assignment.actor_model, definition, channel);
+                }));
                 for (const actorRun of restoredActors) {
                     if (actorRun) {
                         actorRunById.set(actorRun.definition.id, actorRun);
@@ -765,7 +908,8 @@ export class Orchestrator {
             }
             const freshActorRuns = await mapWithConcurrency(pendingActors, concurrency, async (definition) => {
                 const channel = requiredChannel(channels, definition);
-                const actor = await this.runActor(input, task, requiredFeatureAssignment(assignments, channel).actor_engine, judge.dir, workers, turn, channel, undefined, true, requiredFeatureWorkspace(workspaceWave.featureDirs, channel));
+                const assignment = requiredFeatureAssignment(assignments, channel);
+                const actor = await this.runActor(input, task, assignment.actor_engine, judge.dir, workers, turn, channel, assignment.actor_model, undefined, true, requiredFeatureWorkspace(workspaceWave.featureDirs, channel), true);
                 actorCompleted += 1;
                 reportProgress("actor", actorCompleted, wave.length, actorCompleted === wave.length ? "done" : "running", "waiting");
                 return { definition, channel, actor };
@@ -784,7 +928,10 @@ export class Orchestrator {
             await this.sessions.updateTaskStatus(task, "critic_running");
             const pairRunById = new Map();
             if (restoredWave) {
-                const restoredPairs = await Promise.all(actorRuns.map((actorRun) => this.loadCompletedFeaturePair(task, requiredFeatureAssignment(assignments, actorRun.channel).critic_engine, actorRun)));
+                const restoredPairs = await Promise.all(actorRuns.map((actorRun) => {
+                    const assignment = requiredFeatureAssignment(assignments, actorRun.channel);
+                    return this.loadCompletedFeaturePair(task, assignment.critic_engine, assignment.critic_model, actorRun);
+                }));
                 for (const pairRun of restoredPairs) {
                     if (pairRun) {
                         pairRunById.set(pairRun.definition.id, pairRun);
@@ -799,8 +946,9 @@ export class Orchestrator {
                 await this.sessions.appendEvent(task, "feature.wave_critic_checkpoints_reused", `Reused ${criticCompleted}/${actorRuns.length} completed Critic checkpoints in wave ${waveNumber}/${featureWaves.length}`);
             }
             const freshPairRuns = await mapWithConcurrency(pendingCritics, concurrency, async (actorRun) => {
+                const assignment = requiredFeatureAssignment(assignments, actorRun.channel);
                 const reviewWorkspace = await workspaceManager.prepareFeatureReviewWorkspace(workspaceWave, actorRun.channel.id);
-                const critic = await this.runCritic(input, task, requiredFeatureAssignment(assignments, actorRun.channel).critic_engine, judge.dir, actorRun.actor.dir, workers, turn, actorRun.channel, true, reviewWorkspace);
+                const critic = await this.runCritic(input, task, assignment.critic_engine, judge.dir, actorRun.actor.dir, workers, turn, actorRun.channel, assignment.critic_model, true, reviewWorkspace);
                 criticCompleted += 1;
                 reportProgress("critic", criticCompleted, actorRuns.length, "done", criticCompleted === actorRuns.length ? "done" : "running");
                 return { ...actorRun, critic };
@@ -860,7 +1008,8 @@ export class Orchestrator {
                 let revisionCompleted = 0;
                 reportProgress("revision", revisionCompleted, revisionRuns.length, "revision", "done");
                 const revisedActors = await mapWithConcurrency(revisionRuns, concurrency, async (pair) => {
-                    const actor = await this.runActor(input, task, requiredFeatureAssignment(assignments, pair.channel).actor_engine, judge.dir, workers, turn, pair.channel, buildRevisionRequest(pair.review, pair.channel, revisionRound, this.config.orchestration.maxRevisionRounds), true, requiredFeatureWorkspace(workspaceWave.featureDirs, pair.channel));
+                    const assignment = requiredFeatureAssignment(assignments, pair.channel);
+                    const actor = await this.runActor(input, task, assignment.actor_engine, judge.dir, workers, turn, pair.channel, assignment.actor_model, buildRevisionRequest(pair.review, pair.channel, revisionRound, this.config.orchestration.maxRevisionRounds), true, requiredFeatureWorkspace(workspaceWave.featureDirs, pair.channel));
                     await requireActorFindingReplies(pair.channel, [...(revisionFindingIds.get(pair.channel.id) ?? [])]);
                     revisionCompleted += 1;
                     reportProgress("revision", revisionCompleted, revisionRuns.length, "revision", "done");
@@ -871,8 +1020,9 @@ export class Orchestrator {
                 let recheckCompleted = 0;
                 reportProgress("critic", recheckCompleted, revisedActors.length, "done", "rerunning");
                 const revisedPairs = await mapWithConcurrency(revisedActors, concurrency, async (pair) => {
+                    const assignment = requiredFeatureAssignment(assignments, pair.channel);
                     const reviewWorkspace = await workspaceManager.prepareFeatureReviewWorkspace(workspaceWave, pair.channel.id);
-                    const critic = await this.runCritic(input, task, requiredFeatureAssignment(assignments, pair.channel).critic_engine, judge.dir, pair.actor.dir, workers, turn, pair.channel, true, reviewWorkspace);
+                    const critic = await this.runCritic(input, task, assignment.critic_engine, judge.dir, pair.actor.dir, workers, turn, pair.channel, assignment.critic_model, true, reviewWorkspace);
                     recheckCompleted += 1;
                     reportProgress("critic", recheckCompleted, revisedActors.length, "done", "rerunning");
                     return {
@@ -1002,6 +1152,10 @@ export class Orchestrator {
         };
         const workspaceRootDir = join(task.dir, "workspaces", `turn-${turn.turnId}`, "wave-0001");
         const integratedCheckpoint = input.retry && await waveIntegrationCheckpointMatches(workspaceRootDir, turn.turnId, 1, [feature.id]);
+        const [actorExecution, criticExecution] = await Promise.all([
+            this.featureWorkerExecution(turn, "actor", assignment.actor_engine, assignment.actor_model),
+            this.featureWorkerExecution(turn, "critic", assignment.critic_engine, assignment.critic_model)
+        ]);
         if (integratedCheckpoint) {
             const recovered = !(await featureIsApproved(feature));
             await this.sessions.appendEvent(task, recovered ? "feature.wave_checkpoint_recovered" : "feature.wave_checkpoint_reused", `${recovered ? "Recovered" : "Reused"} integrated checkpoint for single feature: ${feature.id}`);
@@ -1012,7 +1166,7 @@ export class Orchestrator {
                 critic: "done",
                 featureProgress: { wave: 1, waves: 1, phase: "integration", completed: 1, total: 1 }
             });
-            return this.completeTask(task, turn, judge, this.workerFiles(task, taskWorkerId("actor", assignment.actor_engine, turn.turnId)), this.workerFiles(task, taskWorkerId("critic", assignment.critic_engine, turn.turnId)), feature, input, workers, await integratedWaveChangedPaths(workspaceRootDir), workspaceManager, route.judge_engine);
+            return this.completeTask(task, turn, judge, this.workerFiles(task, taskWorkerId("actor", assignment.actor_engine, turn.turnId, undefined, actorExecution.modelKey)), this.workerFiles(task, taskWorkerId("critic", assignment.critic_engine, turn.turnId, undefined, criticExecution.modelKey)), feature, input, workers, await integratedWaveChangedPaths(workspaceRootDir), workspaceManager, route.judge_engine);
         }
         const restoredWave = input.retry ? await workspaceManager.restoreWave(workspaceInput) : null;
         const workspaceWave = restoredWave ?? await workspaceManager.prepareWave(workspaceInput);
@@ -1023,7 +1177,7 @@ export class Orchestrator {
         throwIfCancelled(input.signal);
         await this.sessions.updateTaskStatus(task, "actor_running");
         const restoredActor = restoredWave
-            ? await this.loadCompletedActor(task, assignment.actor_engine, feature, false)
+            ? await this.loadCompletedActor(task, assignment.actor_engine, assignment.actor_model, feature, false)
             : null;
         if (restoredActor) {
             await this.sessions.appendEvent(task, "feature.wave_actor_checkpoints_reused", "Reused 1/1 completed Actor checkpoint in wave 1/1");
@@ -1036,13 +1190,13 @@ export class Orchestrator {
         });
         let actor = restoredActor;
         if (!actor) {
-            actor = await this.runActor(input, task, assignment.actor_engine, judge.dir, workers, turn, feature, undefined, false, workspaceDir, true);
+            actor = await this.runActor(input, task, assignment.actor_engine, judge.dir, workers, turn, feature, assignment.actor_model, undefined, false, workspaceDir, true);
         }
         await updateFeatureStatus(feature, "actor_done");
         throwIfCancelled(input.signal);
         await this.sessions.updateTaskStatus(task, "critic_running");
         const restoredCritic = restoredActor
-            ? await this.loadCompletedCritic(task, assignment.critic_engine, feature, false)
+            ? await this.loadCompletedCritic(task, assignment.critic_engine, assignment.critic_model, feature, false)
             : null;
         if (restoredCritic) {
             await this.sessions.appendEvent(task, "feature.wave_critic_checkpoints_reused", "Reused 1/1 completed Critic checkpoint in wave 1/1");
@@ -1057,7 +1211,7 @@ export class Orchestrator {
         let critic = restoredCritic;
         if (!critic) {
             reviewWorkspace = await workspaceManager.prepareFeatureReviewWorkspace(workspaceWave, feature.id);
-            critic = await this.runCritic(input, task, assignment.critic_engine, judge.dir, actor.dir, workers, turn, feature, false, reviewWorkspace, true);
+            critic = await this.runCritic(input, task, assignment.critic_engine, judge.dir, actor.dir, workers, turn, feature, assignment.critic_model, false, reviewWorkspace, true);
         }
         await updateFeatureStatus(feature, "critic_done");
         throwIfCancelled(input.signal);
@@ -1088,14 +1242,14 @@ export class Orchestrator {
                 critic: "done"
             });
             await this.sessions.updateTaskStatus(task, "actor_running");
-            actor = await this.runActor(input, task, assignment.actor_engine, judge.dir, workers, turn, feature, buildRevisionRequest(review, feature, revisionRound, this.config.orchestration.maxRevisionRounds), false, workspaceDir, true);
+            actor = await this.runActor(input, task, assignment.actor_engine, judge.dir, workers, turn, feature, assignment.actor_model, buildRevisionRequest(review, feature, revisionRound, this.config.orchestration.maxRevisionRounds), false, workspaceDir, true);
             await requireActorFindingReplies(feature, [...revisionFindingIds]);
             await updateFeatureStatus(feature, "actor_done");
             throwIfCancelled(input.signal);
             reviewWorkspace = await workspaceManager.prepareFeatureReviewWorkspace(workspaceWave, feature.id);
             await this.sessions.updateTaskStatus(task, "critic_running");
             input.onStatus?.({ taskId: task.id, judge: "done", actor: "done", critic: "rerunning" });
-            critic = await this.runCritic(input, task, assignment.critic_engine, judge.dir, actor.dir, workers, turn, feature, false, reviewWorkspace, true);
+            critic = await this.runCritic(input, task, assignment.critic_engine, judge.dir, actor.dir, workers, turn, feature, assignment.critic_model, false, reviewWorkspace, true);
             await updateFeatureStatus(feature, "critic_done");
             throwIfCancelled(input.signal);
             review = await readTextIfExists(`${critic.dir}/review.md`);
@@ -1357,7 +1511,8 @@ export class Orchestrator {
     }
     async runMain(input, workers, context, taskId = null) {
         throwIfCancelled(input.signal);
-        const engine = this.config.pairing.main;
+        const target = input.roleSelection?.main ?? this.roleConfiguration.futureRoles().main;
+        const engine = target.engine;
         const dir = this.sessions.mainSessionDir();
         let lease;
         try {
@@ -1427,6 +1582,7 @@ export class Orchestrator {
             outputLogPath,
             statusPath,
             prompt,
+            modelConfig: this.roleConfiguration.modelForTarget(input.roleSelection?.main ?? this.roleConfiguration.futureRoles().main),
             signal: input.signal,
             onStatus: (runtimeStatus) => {
                 this.recordWorker(input, workers, { ...worker, runtimeStatus });
@@ -1473,6 +1629,7 @@ export class Orchestrator {
             outputLogPath: judge.outputLogPath,
             statusPath: judge.statusPath,
             prompt: await readTextIfExists(judge.promptPath),
+            modelConfig: await this.roleConfiguration.modelForTurn(turn.dir, "judge", engine),
             signal: input.signal
         }, "task", await this.previousTurnWorker(task, "judge", engine, turn.turnId));
         ensureWorkerSuccess(result);
@@ -1548,6 +1705,7 @@ export class Orchestrator {
             outputLogPath: finalJudge.outputLogPath,
             statusPath: finalJudge.statusPath,
             prompt: await readTextIfExists(finalJudge.promptPath),
+            modelConfig: await this.roleConfiguration.modelForTurn(turn.dir, "judge", engine),
             signal: input.signal
         }, "task", initialJudge);
         ensureWorkerSuccess(result);
@@ -1576,8 +1734,9 @@ export class Orchestrator {
         await this.sessions.appendEvent(task, "judge.final_approved", `Final Judge approved ${criterionIds.length} acceptance criteria`);
         input.onStatus?.({ taskId: task.id, judge: "done", actor: "done", critic: "done" });
     }
-    async runActor(input, task, engine, judgeDir, workers, turn, feature, revision, featureScoped = false, workspaceDir = input.cwd, isolatedWorkspace = featureScoped) {
-        const workerId = taskWorkerId("actor", engine, turn.turnId, featureScoped ? feature.id : undefined);
+    async runActor(input, task, engine, judgeDir, workers, turn, feature, modelName = "", revision, featureScoped = false, workspaceDir = input.cwd, isolatedWorkspace = featureScoped) {
+        const execution = await this.featureWorkerExecution(turn, "actor", engine, modelName);
+        const workerId = taskWorkerId("actor", engine, turn.turnId, featureScoped ? feature.id : undefined, execution.modelKey);
         const workerFiles = this.workerFiles(task, workerId);
         const actor = await this.sessions.initializeWorker(task, {
             workerId,
@@ -1623,6 +1782,7 @@ export class Orchestrator {
             outputLogPath: actor.outputLogPath,
             statusPath: actor.statusPath,
             prompt: await readTextIfExists(actor.promptPath),
+            modelConfig: execution.modelConfig,
             signal: input.signal
         }, task, feature, featureScoped
             ? undefined
@@ -1636,8 +1796,9 @@ export class Orchestrator {
         });
         return actor;
     }
-    async runCritic(input, task, engine, judgeDir, actorDir, workers, turn, feature, featureScoped = false, workspaceDir = input.cwd, isolatedWorkspace = featureScoped) {
-        const workerId = taskWorkerId("critic", engine, turn.turnId, featureScoped ? feature.id : undefined);
+    async runCritic(input, task, engine, judgeDir, actorDir, workers, turn, feature, modelName = "", featureScoped = false, workspaceDir = input.cwd, isolatedWorkspace = featureScoped) {
+        const execution = await this.featureWorkerExecution(turn, "critic", engine, modelName);
+        const workerId = taskWorkerId("critic", engine, turn.turnId, featureScoped ? feature.id : undefined, execution.modelKey);
         const workerFiles = this.workerFiles(task, workerId);
         const critic = await this.sessions.initializeWorker(task, {
             workerId,
@@ -1683,6 +1844,7 @@ export class Orchestrator {
             outputLogPath: critic.outputLogPath,
             statusPath: critic.statusPath,
             prompt: await readTextIfExists(critic.promptPath),
+            modelConfig: execution.modelConfig,
             signal: input.signal
         }, task, feature, featureScoped
             ? undefined
@@ -1741,6 +1903,7 @@ export class Orchestrator {
             outputLogPath: critic.outputLogPath,
             statusPath: critic.statusPath,
             prompt: await readTextIfExists(critic.promptPath),
+            modelConfig: await this.roleConfiguration.modelForTurn(turn.dir, "critic", engine),
             signal: input.signal
         });
         ensureWorkerSuccess(result);
@@ -1791,6 +1954,7 @@ export class Orchestrator {
             outputLogPath: actor.outputLogPath,
             statusPath: actor.statusPath,
             prompt: await readTextIfExists(actor.promptPath),
+            modelConfig: await this.roleConfiguration.modelForTurn(turn.dir, "actor", engine),
             signal: input.signal
         });
         ensureWorkerSuccess(result);
@@ -1896,6 +2060,7 @@ export class Orchestrator {
         }
         return adapter.run({
             ...spec,
+            modelConfig: spec.modelConfig ?? workerProvider(this.config, engine).config.model,
             nativeSession: existing,
             nativeSessionConfig: workerProvider(this.config, engine).config.nativeSession,
             onNativeSession: async (sessionId) => {
@@ -1950,35 +2115,39 @@ export class Orchestrator {
         }
         return undefined;
     }
-    async loadCompletedFeatureActor(task, engine, definition, channel) {
-        const actor = await this.loadCompletedActor(task, engine, channel, true);
+    async loadCompletedFeatureActor(task, engine, modelName, definition, channel) {
+        const actor = await this.loadCompletedActor(task, engine, modelName, channel, true);
         if (!actor) {
             return null;
         }
         return { definition, channel, actor };
     }
-    async loadCompletedFeaturePair(task, engine, actorRun) {
-        const critic = await this.loadCompletedCritic(task, engine, actorRun.channel, true);
+    async loadCompletedFeaturePair(task, engine, modelName, actorRun) {
+        const critic = await this.loadCompletedCritic(task, engine, modelName, actorRun.channel, true);
         return critic ? { ...actorRun, critic } : null;
     }
-    async loadCompletedActor(task, engine, channel, featureScoped) {
-        const actor = this.workerFiles(task, taskWorkerId("actor", engine, channel.turnId, featureScoped ? channel.id : undefined));
+    async loadCompletedActor(task, engine, modelName, channel, featureScoped) {
+        const execution = await this.featureWorkerExecution({ dir: join(task.dir, "turns", channel.turnId) }, "actor", engine, modelName);
+        const actor = this.workerFiles(task, taskWorkerId("actor", engine, channel.turnId, featureScoped ? channel.id : undefined, execution.modelKey));
         const status = await readWorkerStatusIfValid(actor.statusPath);
         if (status?.state !== "done"
             || status.role !== "actor"
             || status.engine !== engine
+            || (execution.modelKey && status.model_name !== execution.modelConfig.name)
             || (featureScoped ? status.feature_id !== channel.id : Boolean(status.feature_id))) {
             return null;
         }
         await mirrorWorkerFileToFeature(join(actor.dir, "worklog.md"), channel.actorWorklogPath);
         return actor;
     }
-    async loadCompletedCritic(task, engine, channel, featureScoped) {
-        const critic = this.workerFiles(task, taskWorkerId("critic", engine, channel.turnId, featureScoped ? channel.id : undefined));
+    async loadCompletedCritic(task, engine, modelName, channel, featureScoped) {
+        const execution = await this.featureWorkerExecution({ dir: join(task.dir, "turns", channel.turnId) }, "critic", engine, modelName);
+        const critic = this.workerFiles(task, taskWorkerId("critic", engine, channel.turnId, featureScoped ? channel.id : undefined, execution.modelKey));
         const status = await readWorkerStatusIfValid(critic.statusPath);
         if (status?.state !== "done"
             || status.role !== "critic"
             || status.engine !== engine
+            || (execution.modelKey && status.model_name !== execution.modelConfig.name)
             || (featureScoped ? status.feature_id !== channel.id : Boolean(status.feature_id))) {
             return null;
         }
@@ -1988,6 +2157,17 @@ export class Orchestrator {
         }
         return await featureCriticCheckpointIsReusable(channel, decision) ? critic : null;
     }
+    async featureWorkerExecution(turn, role, engine, assignedModel) {
+        const inherited = await this.roleConfiguration.modelForTurn(turn.dir, role, engine);
+        const requested = assignedModel.trim();
+        const modelConfig = requested
+            ? this.roleConfiguration.modelForTarget({ engine, model: requested })
+            : inherited;
+        return {
+            modelConfig,
+            modelKey: requested && requested !== inherited.name ? requested : ""
+        };
+    }
     async promptTurnContext(task, turn) {
         return {
             turnId: turn.turnId,
@@ -2260,6 +2440,14 @@ async function readWorkerStatusIfValid(statusPath) {
         return null;
     }
 }
+async function readFeatureStatusIfValid(statusPath) {
+    try {
+        return await readJson(statusPath, FeatureStatusSchema);
+    }
+    catch {
+        return null;
+    }
+}
 async function readTaskMetaIfValid(metaPath) {
     if (!(await pathExists(metaPath))) {
         return null;
@@ -2363,15 +2551,22 @@ function workerLabelForStatus(status) {
         return workerLabel(status.role, status.engine);
     }
     const base = `${status.role}-${status.engine}`;
-    const turnId = status.worker_id.match(new RegExp(`^${base}-(\\d{4,})$`))?.[1];
+    const turnId = status.worker_id.match(new RegExp(`^${base}-(\\d{4,})(?:-model-[a-f0-9]{8})?$`))?.[1];
     return taskWorkerLabel(status.role, status.engine, turnId ?? "0001");
 }
-function taskWorkerId(role, engine, turnId, featureId) {
+function taskWorkerId(role, engine, turnId, featureId, modelKey = "") {
     const base = `${role}-${engine}`;
-    if (featureId) {
-        return `${base}-${featureId}`;
-    }
-    return turnId === "0001" ? base : `${base}-${turnId}`;
+    const scoped = featureId
+        ? `${base}-${featureId}`
+        : turnId === "0001" ? base : `${base}-${turnId}`;
+    return modelKey ? `${scoped}-model-${workerModelKey(modelKey)}` : scoped;
+}
+function workerModelKey(model) {
+    return createHash("sha256").update(model).digest("hex").slice(0, 8);
+}
+function selectedRoleModel(selection, role, engine) {
+    const target = selection?.[role];
+    return target?.engine === engine ? target.model : "";
 }
 function capitalize(value) {
     return `${value.slice(0, 1).toUpperCase()}${value.slice(1)}`;
@@ -2387,7 +2582,7 @@ function workerStageOrder(worker) {
 function workerTurnOrder(worker) {
     const featureTurn = worker.featureId?.match(/^(\d{4,})(?:-|$)/)?.[1];
     const waveTurn = worker.id.match(/-wave-(\d{4,})-/)?.[1];
-    const taskTurn = worker.id.match(/-(\d{4,})$/)?.[1];
+    const taskTurn = worker.id.match(/-(\d{4,})(?:-model-[a-f0-9]{8})?$/)?.[1];
     const parsed = Number(featureTurn ?? waveTurn ?? taskTurn ?? "1");
     return Number.isInteger(parsed) && parsed > 0 ? parsed : 1;
 }
@@ -2698,3 +2893,11 @@ function judgeValidationError(turn, report) {
 function errorMessage(error) {
     return error instanceof Error ? error.message : String(error);
 }
+function routeWithRoleSelection(route, roles) {
+    return RouteDecisionSchema.parse({
+        ...route,
+        judge_engine: roles.judge.engine,
+        actor_engine: roles.actor.engine,
+        critic_engine: roles.critic.engine
+    });
+}