parallel-codex-tui 0.3.0 → 0.3.1

package/README.md

@@ -6,7 +6,9 @@ Built with Codex-assisted development.
 
 ## Current Release
 
-`v0.3.0` is available from [npm](https://www.npmjs.com/package/parallel-codex-tui/v/0.3.0) and as a [GitHub Release](https://github.com/allendred/parallel-codex-tui/releases/tag/v0.3.0). `Ctrl+E` opens runtime role/model control for Main, Judge, Actor, and Critic. The complete matrix can apply once to the next request, persist for retries and follow-ups in the current Task, or become the default for future requests. Provider changes reset to that profile's configured model, `M` accepts a model override, every complex Turn records the exact consumed matrix, and historical Worker/native-session identity remains unchanged.
+`v0.3.1` is available from [npm](https://www.npmjs.com/package/parallel-codex-tui/v/0.3.1) and as a [GitHub Release](https://github.com/allendred/parallel-codex-tui/releases/tag/v0.3.1). `Ctrl+E` opens runtime role/model control for Main, Judge, Actor, and Critic. The complete matrix can apply once to the next request, persist for retries and follow-ups in the current Task, or become the default for future requests. Saving now validates every selected Provider before it writes configuration, and concurrent TUI instances atomically consume a one-shot matrix exactly once.
+
+Feature assignment now controls both Provider and model. From a retryable Feature, press `M`, use `A`/`C` to cycle the Actor/Critic Provider, and use `1`/`2` to edit the Actor/Critic model. A model change starts a distinct Worker identity, keeps all earlier logs and native sessions, and remains an explicit Feature override when Task defaults change. Status details show separate `actual`, `next`, and `future` role matrices alongside the selected historical Worker's persisted model.
 
 `Ctrl+T`, then `C`, opens every persisted Main conversation and provides the same durable management lifecycle as Task sessions: rename, archive, unarchive, scoped export, and confirmed deletion. Restoring one switches the exact `conversation_id`, reloads only that conversation's file-backed history, and restores its archived native Codex or Claude session ids when they are available. `Ctrl+N` creates an explicit, durable Main conversation boundary without deleting chat, Tasks, or Worker logs.
 
@@ -14,7 +16,7 @@ A real Claude acceptance retires the first native session, inserts 16 newer reco
 
 Complex task memory now retains the root Turn plus the latest 19 previous Turn summaries within a 12,000-character budget. When a longer task omits intermediate summaries inline, the prompt points the Worker to the complete immutable Turn history on disk. Main chat still extracts only the final Codex answer while retaining the complete CLI transcript in `output.log`; legacy transcript-shaped chat records are cleaned when displayed without rewriting their file-backed evidence. Workspace integration ignores known host metadata such as `.DS_Store` and AppleDouble files while continuing to reject real concurrent project edits.
 
-The default role map is Main/Judge/Actor on Codex and Critic on Claude. Status details show the complete active role map separately from each historical Worker's persisted Provider/model. Config monitoring labels Router-only edits as active on the next request and marks role, Worker, model, permission, or UI changes as requiring restart. Claude text/JSON print runs are recognized as buffered work, use the total deadline instead of a false first-output deadline, and run safe isolated tools through non-interactive `auto` permissions. The `v0.2.4` non-interactive Codex permission placement remains included. The release keeps terminal scrolling and copying available at the same time without requiring Shift and preserves the embedded native Agent scrollback across status-detail round trips and real PTY resizes.
+The default role map is Main/Judge/Actor on Codex and Critic on Claude. Status details show the actual, next, and future role maps separately from each historical Worker's persisted Provider/model. Config monitoring labels Router-only edits as active on the next request and marks role, Worker, model, permission, or UI changes as requiring restart. Claude text/JSON print runs are recognized as buffered work, use the total deadline instead of a false first-output deadline, and run safe isolated tools through non-interactive `auto` permissions. The `v0.2.4` non-interactive Codex permission placement remains included. The release keeps terminal scrolling and copying available at the same time without requiring Shift and preserves the embedded native Agent scrollback across status-detail round trips and real PTY resizes.
 
 Highlights:
 
@@ -27,7 +29,7 @@ Highlights:
 - Named Worker Providers support Codex-compatible, Claude-compatible, OpenAI-compatible, Anthropic-compatible, and custom generic commands with independent role, model, environment, permission, resume, and interactive settings.
 - Worker overview, Feature board, collaboration timeline, Task and Main conversation centers, status details, rendered Markdown/Diff/error logs, Unicode search, keyboard navigation, mouse scrolling, and configurable themes share one terminal UI system.
 
-Release acceptance includes a real three-Feature Tetris task with parallel Actor/Critic waves and final integration review. A clean `v0.2.5` task also ran Codex Judge and Actor, a buffered Claude Critic that independently executed `node --test` and `npm test`, atomic integration, and a resumed Codex Judge that independently passed all seven acceptance criteria. Real Codex and Claude probes both proved fresh and same-session resume calls; Codex fresh and resume runs executed workspace writes with root-level `-a never`, and Claude automated sessions executed safe Bash tools with `auto` permissions. The semantic Router completed a live classification, and one TUI completed Main calls in two workspaces before restoring the first workspace without leaking chat state. PTY coverage runs in Apple Terminal, tmux, and Zellij profiles at narrow and wide sizes, including status/log equivalence, preserving the native output tail across status-detail round trips, and proving both inline and on-demand file memory after native-session rollover. The deterministic repository suite contains 1,334 tests across 136 files: 1,333 pass by default, while one quota-consuming real-Agent test is skipped and passes through `npm run test:real-agents`.
+Release acceptance includes a real three-Feature Tetris task with parallel Actor/Critic waves and final integration review. A clean `v0.2.5` task also ran Codex Judge and Actor, a buffered Claude Critic that independently executed `node --test` and `npm test`, atomic integration, and a resumed Codex Judge that independently passed all seven acceptance criteria. Real Codex and Claude probes both proved fresh and same-session resume calls; Codex fresh and resume runs executed workspace writes with root-level `-a never`, and Claude automated sessions executed safe Bash tools with `auto` permissions. The semantic Router completed a live classification, and one TUI completed Main calls in two workspaces before restoring the first workspace without leaking chat state. PTY coverage runs in Apple Terminal, tmux, and Zellij profiles at narrow and wide sizes, including status/log equivalence, preserving the native output tail across status-detail round trips, and proving both inline and on-demand file memory after native-session rollover. The deterministic repository suite contains 1,338 tests across 136 files: 1,337 pass by default, while one quota-consuming real-Agent test is skipped and passes through `npm run test:real-agents`.
 
 Real Provider probes depend on valid local CLI credentials. In particular, authenticate the Claude CLI before selecting a Claude-compatible Worker, then run `parallel-codex-tui --doctor --probe-agents` to prove fresh and resumed calls on that machine.
 
@@ -420,15 +422,15 @@ critic = "anthropic_compat"
 
 ## Runtime Role Control
 
-While the TUI is idle, press `Ctrl+E` to configure Main, Judge, Actor, and Critic without editing TOML or restarting. Up/Down selects a role, Left/Right (or `[`/`]`) cycles its configured Worker Provider, `M` edits the model name with a Unicode-safe cursor, and `Tab` changes the persistence scope. Press Enter to apply the complete matrix, `X` to clear the saved override and inherit its parent scope, `R` to discard unsaved edits, and `Esc` or `Ctrl+E` to return. `Ctrl+Y` copies the visible matrix. A Provider switch resets that role to the Provider's configured default model; a blank model edit also means the Provider default.
+While the TUI is idle, press `Ctrl+E` to configure Main, Judge, Actor, and Critic without editing TOML or restarting. Up/Down selects a role, Left/Right (or `[`/`]`) cycles its configured Worker Provider, `M` edits the model name with a Unicode-safe cursor, and `Tab` changes the persistence scope. Press Enter to validate every selected CLI, environment, capability contract, and proxy before saving the complete matrix. `X` clears the saved override and inherits its parent scope, `R` discards unsaved edits, and `Esc` or `Ctrl+E` returns. `Ctrl+Y` copies the visible matrix. A Provider switch resets that role to the Provider's configured default model; a blank model edit also means the Provider default.
 
 The three scopes are explicit:
 
-- `next request` is stored in the current workspace at `.parallel-codex/role-configuration.next.json`, overrides every role once, and is removed only when a routed request consumes it.
-- `current task` is stored beside that Task's `meta.json`, applies to retries and same-Task follow-ups, and updates unfinished Feature assignments without deleting earlier Workers or logs.
+- `next request` is stored in the current workspace at `.parallel-codex/role-configuration.next.json`, overrides every role once, and is removed only when one routed request atomically claims it. Concurrent TUI instances cannot both consume it.
+- `current task` is stored beside that Task's `meta.json`, applies to retries and same-Task follow-ups, and updates inherited unfinished Feature assignments without deleting earlier Workers or logs. Explicit Feature overrides remain unchanged.
 - `future requests` is stored in the app root at `.parallel-codex/role-configuration.json` and becomes the default for new Main calls and Tasks across restarts.
 
-Every complex Turn writes the exact consumed matrix to `turns/<turn>/role-configuration.json`. Retries use that evidence instead of silently adopting a pending one-shot selection, native attach uses the selected Worker's persisted Provider/model, and status details show the active Turn matrix separately from historical Worker identity.
+Every complex Turn writes the exact consumed matrix to `turns/<turn>/role-configuration.json`. Retries use that evidence instead of silently adopting a pending one-shot selection, native attach uses the selected Worker's persisted Provider/model, and status details show the actual Turn, next-request, and future-default matrices separately from historical Worker identity.
 
 For a third-party command with its own syntax, inherit `generic` so parallel-codex-tui does not inject `--sandbox`, `--permission-mode`, or other built-in-only flags:
 
@@ -477,7 +479,7 @@ In chat, scroll long conversation history with the mouse wheel or PageUp/PageDow
 
 From Worker overview, press `F` to open the file-backed Feature board. It summarizes every planned feature by turn, state, blocked dependencies and open Critic findings while preserving descriptions and Actor replies from the same collaboration files. Use Up/Down, PageUp/PageDown, the mouse wheel, or `Tab` to select a feature; Enter opens the selected feature's collaboration timeline; `R` refreshes immediately; and `Esc` returns to Worker overview. When a timeline was opened from this board, `Esc` returns to the Feature board instead of skipping back to Workers. While the selected feature is running, press `P` twice to pause only its active Actor or Critic process, or press `X` twice to cancel it; the first press opens a confirmation and `Esc` keeps it running. A paused feature preserves completed peers and same-wave checkpoints; select it and press `Ctrl+R` to resume the same task, turn, and native Worker session. After cancellation, already-running peers finish, queued workers stop, and integration remains blocked, so a partial wave never reaches the live workspace. Once the task settles as cancelled, `Ctrl+R` retries the cancelled task with persisted worker sessions; completed peers are loaded from their same-wave checkpoints instead of running again. Checkpoint load, reuse, and recovery events appear in the collaboration timeline.
 
-For a failed, cancelled, or paused task, select an unfinished Feature and press `M` to edit its Provider assignment. `A` cycles that Feature's Actor through every `assignable` Worker Provider, `C` cycles its Critic, and `M` or `Esc` closes the assignment prompt. The choice is persisted in `features/<turn>-<feature>/assignment.json`, appears on the Feature board and collaboration artifacts, and takes effect on the next `Ctrl+R` retry. A changed role starts a new Provider-specific Worker while every previous Worker log and native-session record remains available. Assignment writes hold the same task lease as execution, so another live TUI cannot change a Feature while it is resuming.
+For a failed, cancelled, or paused task, select an unfinished Feature and press `M` to edit its assignment. `A` cycles that Feature's Actor through every `assignable` Worker Provider, `C` cycles its Critic, `1` edits the Actor model, `2` edits the Critic model, and `M` or `Esc` closes the prompt. The choice is persisted in `features/<turn>-<feature>/assignment.json`, appears on the Feature board and collaboration artifacts, and takes effect on the next `Ctrl+R` retry. A changed Provider or model starts a distinct Worker while every previous Worker log and native-session record remains available. Feature overrides survive later Task-default changes. Assignment writes hold the same task lease as execution, so another live TUI cannot change a Feature while it is resuming.
 
 From Worker overview, press `C` to open the file-backed Actor/Critic collaboration timeline. It merges `dialogue/actor-critic.jsonl`, feature status, Critic findings, Actor replies, finding resolution, and Wave events into one chronological view. The timeline follows new file evidence automatically and shows verified `fixed`/`open` counts when resolution evidence exists. Up/Down selects a collaboration event; `Enter` opens its complete event detail, including artifact paths from dialogue, status, Critic findings, Actor replies, and finding resolution; `U` filters to unresolved feature evidence; `Tab` cycles all features and each individual feature; `R` refreshes immediately; the mouse wheel or PageUp/PageDown scrolls history; and `Esc` returns to Worker overview.
 
@@ -537,12 +539,12 @@ The release job installs npm `^11.5.1`, runs on Node `24.15.x`, publishes the pr
 To publish a release, update `package.json` and `src/version.ts` to the same version, then push a matching tag:
 
 ```bash
-VERSION=0.3.0
+VERSION=0.3.1
 git tag "v$VERSION"
 git push origin "v$VERSION"
 ```
 
-You can also run the Release workflow manually and enter the same tag value. The release tag must match `package.json`; for example, package version `0.3.0` requires tag `v0.3.0`. Published tags such as `v0.2.10` are immutable and must not be moved or reused.
+You can also run the Release workflow manually and enter the same tag value. The release tag must match `package.json`; for example, package version `0.3.1` requires tag `v0.3.1`. Published tags such as `v0.2.10` are immutable and must not be moved or reused.
 
 ## Publishing Hygiene
 

package/dist/core/collaboration-timeline.js

@@ -133,7 +133,9 @@ async function readCollaborationFeatures(taskDir) {
             updatedAt: status.updated_at,
             ...(assignment ? {
                 actorEngine: assignment.actor_engine,
-                criticEngine: assignment.critic_engine
+                criticEngine: assignment.critic_engine,
+                actorModel: assignment.actor_model,
+                criticModel: assignment.critic_model
             } : {}),
             findings: findingEvidence.count,
             replies: replyEvidence.count,

package/dist/core/role-configuration.js

@@ -2,11 +2,12 @@ import { readdir } from "node:fs/promises";
 import { join } from "node:path";
 import { z } from "zod";
 import { pathExists, readJson, removeIfExists, writeJson } from "./file-store.js";
-import { EngineNameSchema } from "../domain/schemas.js";
+import { claimTaskRunLease, TaskRunLeaseConflictError } from "./process-ownership.js";
+import { EngineNameSchema, WorkerModelNameSchema } from "../domain/schemas.js";
 export const CONFIGURABLE_ROLES = ["main", "judge", "actor", "critic"];
 const RoleExecutionTargetSchema = z.object({
     engine: EngineNameSchema,
-    model: z.string().max(200)
+    model: WorkerModelNameSchema
 }).strict();
 const RoleExecutionSelectionSchema = z.object({
     main: RoleExecutionTargetSchema,
@@ -67,7 +68,7 @@ export class RoleConfigurationManager {
             return;
         }
         if (scope === "next") {
-            await writeRoleConfiguration(this.nextPath(), parsed);
+            await this.withNextConfigurationLease(() => writeRoleConfiguration(this.nextPath(), parsed));
             return;
         }
         if (!taskDir) {
@@ -83,7 +84,7 @@ export class RoleConfigurationManager {
             return;
         }
         if (scope === "next") {
-            await removeIfExists(this.nextPath());
+            await this.withNextConfigurationLease(() => removeIfExists(this.nextPath()));
             return;
         }
         if (!taskDir) {
@@ -93,12 +94,14 @@ export class RoleConfigurationManager {
     }
     async selectionForRequest(taskDir) {
         const taskSelection = await this.selectionForTask(taskDir);
-        const next = await readRoleConfigurationIfValid(this.nextPath(), this.config);
-        if (next) {
+        return this.withNextConfigurationLease(async () => {
+            const next = await readRoleConfigurationIfValid(this.nextPath(), this.config);
+            if (!next) {
+                return taskSelection;
+            }
             await removeIfExists(this.nextPath());
             return next;
-        }
-        return taskSelection;
+        });
     }
     async selectionForTask(taskDir) {
         const taskSelection = taskDir
@@ -126,12 +129,45 @@ export class RoleConfigurationManager {
     baselineRoles() {
         return cloneRoleSelection(this.baselineSelection);
     }
+    validate(roles) {
+        return parseRoleSelection(roles, this.config);
+    }
+    workspaceRootPath() {
+        return this.workspaceRoot;
+    }
     futurePath() {
         return roleFutureConfigurationPath(this.appRoot, this.config.dataDir);
     }
     nextPath() {
         return roleNextConfigurationPath(this.workspaceRoot, this.config.dataDir);
     }
+    nextLeaseDir() {
+        return join(this.workspaceRoot, this.config.dataDir, ".role-configuration-next-lock");
+    }
+    async withNextConfigurationLease(run) {
+        let lease = null;
+        for (let attempt = 0; attempt < 80; attempt += 1) {
+            try {
+                lease = await claimTaskRunLease(this.nextLeaseDir());
+                break;
+            }
+            catch (error) {
+                if (!(error instanceof TaskRunLeaseConflictError) || attempt === 79) {
+                    throw error;
+                }
+                await delay(25);
+            }
+        }
+        if (!lease) {
+            throw new Error("Timed out waiting to update the next-request role configuration.");
+        }
+        try {
+            return await run();
+        }
+        finally {
+            await lease.release();
+        }
+    }
     async readLatestTurnSelection(taskDir) {
         const turnsDir = join(taskDir, "turns");
         if (!(await pathExists(turnsDir))) {
@@ -236,3 +272,6 @@ function applyRoleEngines(config, roles) {
         config.pairing[role] = roles[role].engine;
     }
 }
+function delay(milliseconds) {
+    return new Promise((resolve) => setTimeout(resolve, milliseconds));
+}

package/dist/domain/schemas.js

@@ -170,10 +170,19 @@ export const FeatureStatusSchema = z.object({
     state: FeatureStateSchema,
     updated_at: z.string().datetime()
 });
+export const WorkerModelNameSchema = z.string()
+    .max(200)
+    .refine((value) => !/[\u0000-\u001f\u007f]/.test(value), {
+    message: "Model name cannot contain control characters"
+});
 export const FeatureAssignmentSchema = z.object({
     version: z.literal(1),
     actor_engine: EngineNameSchema,
     critic_engine: EngineNameSchema,
+    actor_model: WorkerModelNameSchema.default(""),
+    critic_model: WorkerModelNameSchema.default(""),
+    actor_override: z.boolean().default(false),
+    critic_override: z.boolean().default(false),
     updated_at: z.string().datetime()
 });
 export const TurnMetaSchema = z.object({

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

package/dist/tui/App.js

@@ -264,7 +264,7 @@ export function App({ config, orchestrator, cwd, initialTaskId = null, initialRo
         && (config.workers[selectedTaskSessionDetailWorker.engine]?.interactive.forkArgs.length ?? 0) > 0);
     const featureCanCancel = busy && (selectedBoardFeature?.state === "actor_running"
         || selectedBoardFeature?.state === "critic_running");
-    const featureCanReassign = assignableProviderIds.length > 1
+    const featureCanReassign = assignableProviderIds.length > 0
         && !busy
         && canRetryTask
         && selectedBoardFeature?.state !== "approved";
@@ -1396,6 +1396,24 @@ export function App({ config, orchestrator, cwd, initialTaskId = null, initialRo
                 const pendingAssignment = featureAssignmentPromptRef.current;
                 if (pendingAssignment) {
                     for (const featureChunk of featureChunks) {
+                        const modelEdit = featureAssignmentPromptRef.current?.modelEdit;
+                        if (modelEdit) {
+                            if (featureChunk === "\x1b") {
+                                updateFeatureAssignmentPrompt({ ...pendingAssignment, modelEdit: undefined });
+                                continue;
+                            }
+                            const update = applyChatInputChunk(modelEdit.value, featureChunk, modelEdit.cursor);
+                            if (update.submit !== null) {
+                                void reassignSelectedFeatureRef.current(pendingAssignment, modelEdit.role, update.submit);
+                            }
+                            else {
+                                updateFeatureAssignmentPrompt({
+                                    ...pendingAssignment,
+                                    modelEdit: { ...modelEdit, value: update.value, cursor: update.cursor }
+                                });
+                            }
+                            continue;
+                        }
                         if (featureChunk === "\x1b" || featureChunk === "m" || featureChunk === "M") {
                             updateFeatureAssignmentPrompt(null);
                             setFeatureBoardNotice(null);
@@ -1409,6 +1427,16 @@ export function App({ config, orchestrator, cwd, initialTaskId = null, initialRo
                             void reassignSelectedFeatureRef.current(pendingAssignment, "critic");
                             return;
                         }
+                        if (featureChunk === "1" || featureChunk === "2") {
+                            const feature = collaborationTimelineRef.current?.features.find((item) => item.id === pendingAssignment.featureId);
+                            const role = featureChunk === "1" ? "actor" : "critic";
+                            const value = role === "actor" ? feature?.actorModel ?? "" : feature?.criticModel ?? "";
+                            updateFeatureAssignmentPrompt({
+                                ...pendingAssignment,
+                                modelEdit: { role, value, cursor: Array.from(value).length }
+                            });
+                            return;
+                        }
                     }
                     return;
                 }
@@ -1468,7 +1496,7 @@ export function App({ config, orchestrator, cwd, initialTaskId = null, initialRo
                             featureId: feature.id,
                             title: feature.title
                         });
-                        setFeatureBoardNotice(`Reassign ${feature.title} · A Actor (${feature.actorEngine ?? config.pairing.actor}) · C Critic (${feature.criticEngine ?? config.pairing.critic})`);
+                        setFeatureBoardNotice(`Reassign ${feature.title} · A Actor (${featureTargetDisplay(config, feature.actorEngine ?? config.pairing.actor, feature.actorModel)}) · C Critic (${featureTargetDisplay(config, feature.criticEngine ?? config.pairing.critic, feature.criticModel)})`);
                         return;
                     }
                     if (featureChunk === "r" || featureChunk === "R") {
@@ -3087,7 +3115,7 @@ export function App({ config, orchestrator, cwd, initialTaskId = null, initialRo
         featureAssignmentPromptRef.current = next;
         setFeatureAssignmentPrompt(next);
     }
-    async function reassignSelectedFeature(prompt, role) {
+    async function reassignSelectedFeature(prompt, role, model) {
         const feature = collaborationTimelineRef.current?.features.find((item) => item.id === prompt.featureId);
         if (!feature) {
             setFeatureBoardNotice(`Feature no longer exists: ${prompt.featureId}`);
@@ -3097,15 +3125,22 @@ export function App({ config, orchestrator, cwd, initialTaskId = null, initialRo
         const current = role === "actor"
             ? feature.actorEngine ?? config.pairing.actor
             : feature.criticEngine ?? config.pairing.critic;
-        const engine = nextAssignableFeatureEngine(current, assignableProviderIds);
+        const engine = model === undefined
+            ? nextAssignableFeatureEngine(current, assignableProviderIds)
+            : current;
         try {
-            await orchestrator.reassignFeature({
+            const result = await orchestrator.reassignFeature({
                 taskId: prompt.taskId,
                 featureId: prompt.featureId,
                 role,
-                engine
+                engine,
+                ...(model === undefined ? {} : { model })
             });
-            setFeatureBoardNotice(`${role === "actor" ? "Actor" : "Critic"} reassigned to ${featureEngineDisplay(config, engine)} · Ctrl+R resumes the task.`);
+            updateFeatureAssignmentPrompt({ ...prompt, modelEdit: undefined });
+            const assignedModel = role === "actor"
+                ? result.assignment.actor_model
+                : result.assignment.critic_model;
+            setFeatureBoardNotice(`${role === "actor" ? "Actor" : "Critic"} reassigned to ${featureTargetDisplay(config, engine, assignedModel)} · Ctrl+R resumes the task.`);
             await refreshCollaborationTimeline(false);
         }
         catch (error) {
@@ -3383,6 +3418,12 @@ export function App({ config, orchestrator, cwd, initialTaskId = null, initialRo
             if (typeof orchestrator.updateRoleConfiguration !== "function") {
                 throw new Error("Role configuration is unavailable in this runtime");
             }
+            if (typeof orchestrator.validateRoleConfiguration === "function") {
+                const validation = await orchestrator.validateRoleConfiguration(draft);
+                if (!validation.ok) {
+                    throw new Error(formatRoleConfigurationPreflightFailure(validation.lines));
+                }
+            }
             const snapshot = await orchestrator.updateRoleConfiguration({
                 scope,
                 roles: draft,
@@ -3478,7 +3519,7 @@ export function App({ config, orchestrator, cwd, initialTaskId = null, initialRo
     if (view === "workspace") {
         return (_jsx(Box, { flexDirection: "column", height: terminalSize.rows, children: _jsx(WorkspacePicker, { cwd: cwd, choices: workspaceChoices, terminalHeight: terminalSize.rows, terminalWidth: terminalWidth, onCancel: closeWorkspacePicker, onSelect: (workspace) => void selectWorkspace(workspace) }) }));
     }
-    return (_jsx(AppShell, { view: view, cwd: cwd, taskId: activeTaskId, statusText: [visibleTaskStatus, visibleRouteSummary, configChange?.compact].filter(Boolean).join(" | "), contentHeight: contentHeight, showStatusBar: config.ui.showStatusBar, input: _jsx(InputBar, { mode: view === "worker" && workerSearch.open ? "worker-search" : view, ready: inputReady, busy: busy, routeFallback: Boolean(routeFallbackPrompt), collaborationDetail: collaborationDetailOpen, collaborationUnresolved: collaborationUnresolvedOnly, collaborationBack: collaborationReturnViewRef.current, featureCanCancel: featureCanCancel, featureCanPause: featureCanCancel, featureCanReassign: featureCanReassign, featureCancelConfirm: featureCancelPrompt?.action === "cancel", featurePauseConfirm: featureCancelPrompt?.action === "pause", featureAssignment: Boolean(featureAssignmentPrompt), taskSessionAction: sessionCenterMode === "conversations"
+    return (_jsx(AppShell, { view: view, cwd: cwd, taskId: activeTaskId, statusText: [visibleTaskStatus, visibleRouteSummary, configChange?.compact].filter(Boolean).join(" | "), contentHeight: contentHeight, showStatusBar: config.ui.showStatusBar, input: _jsx(InputBar, { mode: view === "worker" && workerSearch.open ? "worker-search" : view, ready: inputReady, busy: busy, routeFallback: Boolean(routeFallbackPrompt), collaborationDetail: collaborationDetailOpen, collaborationUnresolved: collaborationUnresolvedOnly, collaborationBack: collaborationReturnViewRef.current, featureCanCancel: featureCanCancel, featureCanPause: featureCanCancel, featureCanReassign: featureCanReassign, featureCancelConfirm: featureCancelPrompt?.action === "cancel", featurePauseConfirm: featureCancelPrompt?.action === "pause", featureAssignment: Boolean(featureAssignmentPrompt), featureEditingModel: featureAssignmentPrompt?.modelEdit ?? null, taskSessionAction: sessionCenterMode === "conversations"
                 ? mainConversationAction?.type === "rename"
                     ? { type: "rename", value: mainConversationAction.value, cursor: mainConversationAction.cursor }
                     : mainConversationAction?.type === "delete"
@@ -3494,7 +3535,7 @@ export function App({ config, orchestrator, cwd, initialTaskId = null, initialRo
                 ? workerSearch.query
                 : view === "native" || view === "router" || view === "workers" || view === "features" || view === "sessions" || view === "collaboration" || view === "status" || view === "roles" ? "" : input, cursor: workerSearch.open && view === "worker"
                 ? workerSearch.cursor
-                : view === "chat" ? inputCursor : undefined, terminalWidth: terminalWidth, onChange: view === "native" ? setNativeInput : setInput, onSubmit: view === "native" ? undefined : submit }), error: attachError, children: view === "roles" ? (_jsx(RoleConfigurationView, { snapshot: roleConfigurationSnapshot, draft: roleConfigurationDraft, scope: roleConfigurationScope, selectedRoleIndex: roleConfigurationSelectedIndex, loading: roleConfigurationLoading, saving: roleConfigurationSaving, notice: roleConfigurationNotice, error: roleConfigurationError, hasActiveTask: Boolean(activeTaskId), height: contentHeight, terminalWidth: terminalWidth })) : view === "status" ? (_jsx(StatusDetailView, { cwd: cwd, taskId: activeTaskId, mode: activeMode, busy: busy, canRetry: canRetryTask, taskStatus: visibleTaskStatus, routeStatus: visibleRouteStatus, routeReason: routePending ? undefined : lastRoute?.reason, pairing: config.pairing, roleSelection: activeRoleSelection, configStatus: configChange?.detail, configRestartRequired: configChange?.kind === "restart", workers: workers, selectedWorkerIndex: selectedWorkerIndex, height: contentHeight, terminalWidth: terminalWidth })) : view === "native" ? (_jsx(NativeAttachView, { attach: nativeAttach, viewportHeight: contentHeight })) : view === "sessions" ? (taskSessionDetails ? (_jsx(TaskSessionDetailView, { details: taskSessionDetails, selectedWorkerIndex: taskSessionDetailSelectedWorkerIndex, loading: taskSessionsLoading, error: taskSessionsError, notice: taskSessionDetailNotice, height: contentHeight, terminalWidth: terminalWidth })) : sessionCenterMode === "conversations" ? (_jsx(MainConversationsView, { conversations: mainConversations, selectedIndex: selectedMainConversationIndex, includeArchived: mainConversationsIncludeArchived, notice: taskSessionsNotice, action: mainConversationAction?.type === "rename"
+                : view === "chat" ? inputCursor : undefined, terminalWidth: terminalWidth, onChange: view === "native" ? setNativeInput : setInput, onSubmit: view === "native" ? undefined : submit }), error: attachError, children: view === "roles" ? (_jsx(RoleConfigurationView, { snapshot: roleConfigurationSnapshot, draft: roleConfigurationDraft, scope: roleConfigurationScope, selectedRoleIndex: roleConfigurationSelectedIndex, loading: roleConfigurationLoading, saving: roleConfigurationSaving, notice: roleConfigurationNotice, error: roleConfigurationError, hasActiveTask: Boolean(activeTaskId), height: contentHeight, terminalWidth: terminalWidth })) : view === "status" ? (_jsx(StatusDetailView, { cwd: cwd, taskId: activeTaskId, mode: activeMode, busy: busy, canRetry: canRetryTask, taskStatus: visibleTaskStatus, routeStatus: visibleRouteStatus, routeReason: routePending ? undefined : lastRoute?.reason, pairing: config.pairing, roleSelection: activeRoleSelection, roleConfigurationSnapshot: roleConfigurationSnapshot, configStatus: configChange?.detail, configRestartRequired: configChange?.kind === "restart", workers: workers, selectedWorkerIndex: selectedWorkerIndex, height: contentHeight, terminalWidth: terminalWidth })) : view === "native" ? (_jsx(NativeAttachView, { attach: nativeAttach, viewportHeight: contentHeight })) : view === "sessions" ? (taskSessionDetails ? (_jsx(TaskSessionDetailView, { details: taskSessionDetails, selectedWorkerIndex: taskSessionDetailSelectedWorkerIndex, loading: taskSessionsLoading, error: taskSessionsError, notice: taskSessionDetailNotice, height: contentHeight, terminalWidth: terminalWidth })) : sessionCenterMode === "conversations" ? (_jsx(MainConversationsView, { conversations: mainConversations, selectedIndex: selectedMainConversationIndex, includeArchived: mainConversationsIncludeArchived, notice: taskSessionsNotice, action: mainConversationAction?.type === "rename"
                 ? { type: "rename", title: mainConversationAction.title }
                 : mainConversationAction?.type === "delete"
                     ? { type: "delete", title: mainConversationAction.title }
@@ -4356,6 +4397,10 @@ function sessionDetailWorkerLabel(worker) {
 function featureEngineDisplay(config, engine) {
     return workerProviderLabel(config, engine);
 }
+function featureTargetDisplay(config, engine, model) {
+    const effectiveModel = model?.trim() || config.workers[engine]?.model.name || "default";
+    return `${featureEngineDisplay(config, engine)}/${effectiveModel}`;
+}
 function compactChatText(text, maxLength) {
     if (maxLength <= 5) {
         return takeChatTextStartByDisplayWidth(text, maxLength);
@@ -4745,6 +4790,15 @@ function compactNativeAttachRole(label) {
 function compactNativeSessionForTitle(sessionId, maxLength) {
     return compactEndByDisplayWidth(sessionId, Math.min(maxLength, 16));
 }
+export function formatRoleConfigurationPreflightFailure(lines) {
+    const clean = lines
+        .map((line) => line.replace(/[\u0000-\u001f\u007f]/g, " ").replace(/\s+/g, " ").trim())
+        .filter(Boolean);
+    const actionable = clean.filter((line) => (/\b(?:denied|error|failed|invalid|missing|unavailable|unsupported)\b/i.test(line)
+        || /\bnot (?:found|supported|available)\b/i.test(line)));
+    const detail = (actionable.length > 0 ? actionable : clean).slice(0, 4);
+    return ["Provider preflight failed", ...detail].join(" · ");
+}
 function isAbortError(error) {
     return error instanceof Error && error.name === "AbortError";
 }

package/dist/tui/FeatureBoardView.js

@@ -142,7 +142,10 @@ function featureBoardEvidenceText(timeline, feature, width) {
         ? `deps ${dependencies.map((item) => safeFeatureBoardText(item.title)).join(", ")}`
         : "independent";
     const assignmentText = feature.actorEngine && feature.criticEngine
-        ? `actor ${feature.actorEngine} · critic ${feature.criticEngine}`
+        ? [
+            `actor ${feature.actorEngine}/${feature.actorModel?.trim() || "default"}`,
+            `critic ${feature.criticEngine}/${feature.criticModel?.trim() || "default"}`
+        ].join(" · ")
         : "";
     const evidence = feature.latestFinding
         ? `finding · ${safeFeatureBoardText(feature.latestFinding)}`

package/dist/tui/InputBar.js

@@ -2,7 +2,7 @@ import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-run
 import { Box, Text } from "ink";
 import { compactEndByDisplayWidth, compactTailByDisplayWidth, displayWidth } from "./display-width.js";
 import { TUI_THEME } from "./theme.js";
-export function InputBar({ mode, ready = true, busy = false, routeFallback = false, collaborationDetail = false, collaborationUnresolved = false, collaborationBack = "workers", featureCanCancel = false, featureCanPause = false, featureCanReassign = false, featureCancelConfirm = false, featurePauseConfirm = false, featureAssignment = false, taskSessionAction = null, taskSessionsIncludeArchived = false, mainConversationSessions = false, taskSessionDetail = false, taskSessionDetailHasNative = false, taskSessionDetailCanFork = false, canRetry = false, hasWorkers = false, hasActiveTask = false, hasTaskResult = false, taskResultExpanded = false, chatScrollOffset = 0, chatMaxScrollOffset = 0, nativeClosed = false, searchMatchIndex = 0, searchMatchCount = 0, clipboardNotice = null, roleScope = "next", roleEditingModel = null, roleCanApply = true, roleSaving = false, roleHasOverride = false, value, cursor, terminalWidth: providedTerminalWidth, onChange, onSubmit }) {
+export function InputBar({ mode, ready = true, busy = false, routeFallback = false, collaborationDetail = false, collaborationUnresolved = false, collaborationBack = "workers", featureCanCancel = false, featureCanPause = false, featureCanReassign = false, featureCancelConfirm = false, featurePauseConfirm = false, featureAssignment = false, featureEditingModel = null, taskSessionAction = null, taskSessionsIncludeArchived = false, mainConversationSessions = false, taskSessionDetail = false, taskSessionDetailHasNative = false, taskSessionDetailCanFork = false, canRetry = false, hasWorkers = false, hasActiveTask = false, hasTaskResult = false, taskResultExpanded = false, chatScrollOffset = 0, chatMaxScrollOffset = 0, nativeClosed = false, searchMatchIndex = 0, searchMatchCount = 0, clipboardNotice = null, roleScope = "next", roleEditingModel = null, roleCanApply = true, roleSaving = false, roleHasOverride = false, value, cursor, terminalWidth: providedTerminalWidth, onChange, onSubmit }) {
     const terminalWidth = providedTerminalWidth ?? process.stdout.columns ?? 120;
     const fillRail = providedTerminalWidth !== undefined || typeof process.stdout.columns === "number";
     if (clipboardNotice) {
@@ -30,6 +30,13 @@ export function InputBar({ mode, ready = true, busy = false, routeFallback = fal
         const hints = roleConfigurationInputHints(terminalWidth, roleScope, roleCanApply, roleSaving, roleHasOverride);
         return (_jsxs(InputRail, { terminalWidth: terminalWidth, textWidth: displayWidth(`${hints.label}${hints.detail}`), fill: fillRail, children: [_jsx(Text, { backgroundColor: TUI_THEME.rail, color: roleSaving ? TUI_THEME.warning : TUI_THEME.accent, bold: true, children: hints.label }), hints.detail ? _jsx(Text, { backgroundColor: TUI_THEME.rail, color: TUI_THEME.muted, children: hints.detail }) : null] }));
     }
+    if (mode === "features" && featureEditingModel) {
+        const prefix = `${featureEditingModel.role} model > `;
+        const valueWidth = Math.max(1, terminalWidth - displayWidth(prefix) - 3);
+        const display = chatInputDisplayParts(featureEditingModel.value, featureEditingModel.cursor, valueWidth);
+        const textWidth = displayWidth(`${prefix}${display.before}|${display.after}`);
+        return (_jsxs(InputRail, { terminalWidth: terminalWidth, textWidth: textWidth, fill: fillRail, children: [_jsx(Text, { backgroundColor: TUI_THEME.rail, color: TUI_THEME.accent, bold: true, children: prefix }), _jsx(Text, { backgroundColor: TUI_THEME.rail, color: TUI_THEME.text, children: display.before }), _jsx(Text, { backgroundColor: TUI_THEME.rail, color: TUI_THEME.accent, bold: true, children: "|" }), _jsx(Text, { backgroundColor: TUI_THEME.rail, color: TUI_THEME.text, children: display.after })] }));
+    }
     if (mode === "status") {
         const hints = statusDetailInputHints(terminalWidth);
         return (_jsxs(InputRail, { terminalWidth: terminalWidth, textWidth: displayWidth(`${hints.label}${hints.detail}`), fill: fillRail, children: [_jsx(Text, { backgroundColor: TUI_THEME.rail, color: TUI_THEME.accent, bold: true, children: hints.label }), hints.detail ? _jsx(Text, { backgroundColor: TUI_THEME.rail, color: TUI_THEME.muted, children: hints.detail }) : null] }));
@@ -481,9 +488,9 @@ function workerOverviewInputHints(width) {
 function featureBoardInputHints(width, options) {
     if (options.assignment) {
         return selectInputHints(width, [
-            { label: "assign provider", detail: " · A Actor · C Critic · M/Esc done" },
-            { label: "assign", detail: " · A Actor · C Critic · Esc done" },
-            { label: "assign", detail: " · A actor · C critic" },
+            { label: "assign", detail: " · A/C provider · 1/2 model · M/Esc done" },
+            { label: "assign", detail: " · A/C provider · 1/2 model · Esc done" },
+            { label: "assign", detail: " · A/C provider · 1/2 model" },
             { label: "provider", detail: " · A · C · Esc" },
             { label: "provider", detail: "" },
             { label: "M", detail: "" }

package/dist/tui/StatusDetailView.js

@@ -24,10 +24,10 @@ export function statusDetailDisplayLines(input, width, height) {
             text: fitStatusDetailText(`workspace · ${basename(input.cwd) || input.cwd} · ${input.cwd}`, safeWidth),
             tone: "muted"
         },
-        {
-            text: fitStatusDetailText(rolePairingDetail(input.pairing, input.roleSelection), safeWidth),
-            tone: "text"
-        }
+        ...roleMatrixDetailLines(input).map((line) => ({
+            text: fitStatusDetailText(line.text, safeWidth),
+            tone: line.tone
+        }))
     ];
     if (input.configStatus?.trim()) {
         lines.push({
@@ -59,15 +59,36 @@ export function statusDetailDisplayLines(input, width, height) {
     }
     return lines.slice(0, maxLines);
 }
-function rolePairingDetail(pairing, selection) {
+function roleMatrixDetail(label, pairing, selection) {
     return [
-        "active roles",
+        label,
         rolePairingEntry("main", selection?.main.engine ?? pairing.main, selection?.main.model),
         rolePairingEntry("judge", selection?.judge.engine ?? pairing.judge, selection?.judge.model),
         rolePairingEntry("actor", selection?.actor.engine ?? pairing.actor, selection?.actor.model),
         rolePairingEntry("critic", selection?.critic.engine ?? pairing.critic, selection?.critic.model)
     ].join(" · ");
 }
+function roleMatrixDetailLines(input) {
+    const snapshot = input.roleConfigurationSnapshot;
+    const lines = [{
+            text: roleMatrixDetail("actual roles", input.pairing, input.roleSelection),
+            tone: "text"
+        }];
+    if (!snapshot) {
+        return lines;
+    }
+    const next = snapshot.next ?? snapshot.task ?? snapshot.future;
+    const source = snapshot.next ? "one shot" : snapshot.task ? "task default" : "future default";
+    lines.push({
+        text: roleMatrixDetail(`next roles (${source})`, input.pairing, next),
+        tone: snapshot.next ? "active" : "muted"
+    });
+    lines.push({
+        text: roleMatrixDetail("future roles", input.pairing, snapshot.future),
+        tone: "muted"
+    });
+    return lines;
+}
 function rolePairingEntry(role, engine, model) {
     return [role, engine, model?.trim()].filter(Boolean).join("/");
 }

package/dist/version.js

@@ -1 +1 @@
-export const version = "0.3.0";
+export const version = "0.3.1";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "parallel-codex-tui",
-  "version": "0.3.0",
+  "version": "0.3.1",
   "description": "A TypeScript TUI wrapper for routed parallel coding with Codex and Claude workers.",
   "license": "MIT",
   "type": "module",