parallel-codex-tui 0.3.0 → 0.3.2

package/dist/orchestrator/collaboration-channel.js

@@ -70,7 +70,7 @@ export async function createFeatureChannel(input) {
     await writeText(channel.actorRepliesPath, "");
     await writeText(channel.criticFindingsPath, "");
     if (input.actorEngine && input.criticEngine) {
-        await writeFeatureAssignment(channel, input.actorEngine, input.criticEngine);
+        await writeFeatureAssignment(channel, input.actorEngine, input.criticEngine, input.actorModel, input.criticModel);
     }
     await updateFeatureStatus(channel, "created");
     await appendFeatureDialogue(channel, "feature.created", "actor", "Feature mailbox created for the current turn.");
@@ -89,7 +89,7 @@ async function ensureFeatureChannelFiles(input, channel, refreshDefinition) {
         }
     }
     if (!(await pathExists(channel.assignmentPath)) && input.actorEngine && input.criticEngine) {
-        await writeFeatureAssignment(channel, input.actorEngine, input.criticEngine);
+        await writeFeatureAssignment(channel, input.actorEngine, input.criticEngine, input.actorModel, input.criticModel);
     }
 }
 export async function readFeatureAssignment(channel, fallback) {
@@ -101,15 +101,23 @@ export async function readFeatureAssignment(channel, fallback) {
             version: 1,
             actor_engine: fallback.actor,
             critic_engine: fallback.critic,
+            actor_model: "",
+            critic_model: "",
+            actor_override: false,
+            critic_override: false,
             updated_at: new Date(0).toISOString()
         });
     }
 }
-export async function writeFeatureAssignment(channel, actorEngine, criticEngine) {
+export async function writeFeatureAssignment(channel, actorEngine, criticEngine, actorModel = "", criticModel = "", options = {}) {
     const assignment = FeatureAssignmentSchema.parse({
         version: 1,
         actor_engine: actorEngine,
         critic_engine: criticEngine,
+        actor_model: actorModel,
+        critic_model: criticModel,
+        actor_override: options.actorOverride ?? false,
+        critic_override: options.criticOverride ?? false,
         updated_at: new Date().toISOString()
     });
     await writeJson(channel.assignmentPath, assignment);

package/dist/orchestrator/orchestrator.js

@@ -1,5 +1,7 @@
+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";
@@ -184,17 +186,25 @@ 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 };
         });
     }
@@ -205,6 +215,18 @@ export class Orchestrator {
         }
         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);
@@ -273,7 +295,15 @@ export class Orchestrator {
             if (!status || status.task_id !== task.id || status.state === "approved") {
                 continue;
             }
-            await writeFeatureAssignment({ assignmentPath: join(featureDir, "assignment.json") }, executionRoles.actor.engine, executionRoles.critic.engine);
+            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) {
@@ -536,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);
@@ -547,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];
@@ -582,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);
@@ -593,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];
@@ -761,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
                 })));
@@ -845,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);
@@ -864,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 };
@@ -883,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);
@@ -898,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 };
@@ -959,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");
@@ -970,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 {
@@ -1101,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}`);
@@ -1111,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);
@@ -1122,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");
@@ -1135,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");
@@ -1156,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);
@@ -1187,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`);
@@ -1679,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,
@@ -1726,7 +1782,7 @@ export class Orchestrator {
             outputLogPath: actor.outputLogPath,
             statusPath: actor.statusPath,
             prompt: await readTextIfExists(actor.promptPath),
-            modelConfig: await this.roleConfiguration.modelForTurn(turn.dir, "actor", engine),
+            modelConfig: execution.modelConfig,
             signal: input.signal
         }, task, feature, featureScoped
             ? undefined
@@ -1740,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,
@@ -1787,7 +1844,7 @@ export class Orchestrator {
             outputLogPath: critic.outputLogPath,
             statusPath: critic.statusPath,
             prompt: await readTextIfExists(critic.promptPath),
-            modelConfig: await this.roleConfiguration.modelForTurn(turn.dir, "critic", engine),
+            modelConfig: execution.modelConfig,
             signal: input.signal
         }, task, feature, featureScoped
             ? undefined
@@ -2058,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;
         }
@@ -2096,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,
@@ -2479,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)}`;
@@ -2503,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;
 }