parallel-codex-tui 0.2.10 → 0.3.0

package/dist/orchestrator/orchestrator.js

@@ -5,6 +5,7 @@ import { runWithLeaseFinalization } from "../core/lease-finalization.js";
 import { extractMainResponse } from "../core/main-response.js";
 import { claimTaskRunLease, TaskRunLeaseConflictError } from "../core/process-ownership.js";
 import { routerRuntimeDir } from "../core/paths.js";
+import { RoleConfigurationManager, roleSelectionWithEngines } from "../core/role-configuration.js";
 import { classifyRouterFailure, routerFallbackIsTransient } from "../core/router-audit.js";
 import { sanitizeRouterText } from "../core/router-redaction.js";
 import { routeRequestWithCodex, routerCommandLabel, routerProxyContext } from "../core/router.js";
@@ -59,6 +60,7 @@ export class Orchestrator {
     routerConfigLoader;
     dependencies;
     activeFeatureRuns = new Map();
+    roleConfiguration;
     constructor(config, sessions, workers, routeRunner, routerCwd = routerRuntimeDir(config.projectRoot, config.dataDir), routerConfigLoader, dependencies = {}) {
         this.config = config;
         this.sessions = sessions;
@@ -67,17 +69,21 @@ export class Orchestrator {
         this.routerCwd = routerCwd;
         this.routerConfigLoader = routerConfigLoader;
         this.dependencies = dependencies;
+        this.roleConfiguration = dependencies.roleConfiguration ?? RoleConfigurationManager.transient(config);
     }
     async handleRequest(input) {
         throwIfCancelled(input.signal);
-        const route = await this.routeRequest(input.request, input.cwd, input.signal, "initial", input.onRouteStart, input.onRouteFallback, input.onRouteProgress);
+        const routed = await this.routeRequest(input.request, input.cwd, input.signal, "initial", input.onRouteStart, input.onRouteFallback, input.onRouteProgress);
+        const roleSelection = input.roleSelection ?? await this.roleConfiguration.selectionForRequest();
+        const route = routeWithRoleSelection(routed, roleSelection);
         input.onRoute?.(route);
         throwIfCancelled(input.signal);
         const workers = [];
+        const executionInput = { ...input, roleSelection };
         if (route.mode === "simple") {
             try {
                 input.onStatus?.({ taskId: "main", main: "starting" });
-                const output = await this.runMain(input, workers);
+                const output = await this.runMain(executionInput, workers);
                 input.onStatus?.({ taskId: "main", main: "done" });
                 return {
                     mode: "simple",
@@ -104,18 +110,20 @@ export class Orchestrator {
             userPath: join(task.dir, "turns", "0001", "user.md"),
             routePath: join(task.dir, "turns", "0001", "route.json")
         };
-        return this.withTaskRunLease(task, () => this.runInitialTask(input, task, route, turn, workers));
+        await this.roleConfiguration.writeTurnSelection(turn.dir, roleSelectionWithEngines(route, roleSelection));
+        return this.withTaskRunLease(task, () => this.runInitialTask(executionInput, task, route, turn, workers));
     }
     async handleTaskTurn(input) {
         throwIfCancelled(input.signal);
         const task = this.sessions.taskFromId(input.taskId);
-        const route = input.route ?? await this.routeRequest(input.request, input.cwd, input.signal, "follow-up", input.onRouteStart, input.onRouteFallback, input.onRouteProgress);
+        const roleSelection = input.roleSelection ?? await this.roleConfiguration.selectionForRequest(task.dir);
+        const route = routeWithRoleSelection(input.route ?? await this.routeRequest(input.request, input.cwd, input.signal, "follow-up", input.onRouteStart, input.onRouteFallback, input.onRouteProgress), roleSelection);
         if (!input.route) {
             input.onRoute?.(route);
         }
         throwIfCancelled(input.signal);
         if (route.mode === "simple") {
-            return this.answerTaskQuestion({ ...input, route });
+            return this.answerTaskQuestion({ ...input, route, roleSelection });
         }
         return this.withTaskRunLease(task, async () => {
             throwIfCancelled(input.signal);
@@ -124,8 +132,9 @@ export class Orchestrator {
                 request: input.request,
                 route
             });
+            await this.roleConfiguration.writeTurnSelection(turn.dir, roleSelectionWithEngines(route, roleSelection));
             const workers = [];
-            return this.runPairTask(input, task, route, turn, workers);
+            return this.runPairTask({ ...input, roleSelection }, task, route, turn, workers);
         });
     }
     async retryTask(input) {
@@ -189,6 +198,84 @@ export class Orchestrator {
             return { featureId: input.featureId, assignment };
         });
     }
+    async roleConfigurationSnapshot(taskId) {
+        const task = taskId ? this.sessions.taskFromId(taskId) : null;
+        if (task && !(await pathExists(task.dir))) {
+            throw new Error(`Task session not found: ${taskId}`);
+        }
+        return this.roleConfiguration.snapshot(task?.dir);
+    }
+    async updateRoleConfiguration(input) {
+        if (input.scope !== "task") {
+            await this.roleConfiguration.apply(input.scope, input.roles);
+            return this.roleConfigurationSnapshot(input.taskId);
+        }
+        const taskId = input.taskId;
+        if (!taskId) {
+            throw new Error("No active Task is available for a current-task role configuration.");
+        }
+        const task = this.sessions.taskFromId(taskId);
+        if (!(await pathExists(task.dir))) {
+            throw new Error(`Task session not found: ${taskId}`);
+        }
+        return this.withTaskRunLease(task, async () => {
+            await this.roleConfiguration.apply("task", input.roles, task.dir);
+            await this.synchronizeRetryRoleConfiguration(task, input.roles);
+            await this.sessions.appendEvent(task, "task.role_configuration_changed", "Current Task role configuration updated");
+            return this.roleConfiguration.snapshot(task.dir);
+        });
+    }
+    async clearRoleConfiguration(scope, taskId) {
+        if (scope !== "task") {
+            await this.roleConfiguration.clear(scope);
+            return this.roleConfigurationSnapshot(taskId);
+        }
+        if (!taskId) {
+            throw new Error("No active Task is available for a current-task role configuration.");
+        }
+        const task = this.sessions.taskFromId(taskId);
+        if (!(await pathExists(task.dir))) {
+            throw new Error(`Task session not found: ${taskId}`);
+        }
+        return this.withTaskRunLease(task, async () => {
+            await this.roleConfiguration.clear("task", task.dir);
+            const roles = await this.roleConfiguration.selectionForTask(task.dir);
+            await this.synchronizeRetryRoleConfiguration(task, roles);
+            await this.sessions.appendEvent(task, "task.role_configuration_cleared", "Current Task role configuration reset");
+            return this.roleConfiguration.snapshot(task.dir);
+        });
+    }
+    async synchronizeRetryRoleConfiguration(task, roles) {
+        const meta = await readTaskMetaIfValid(task.metaPath);
+        if (!meta || !new Set(["failed", "cancelled", "paused"]).has(meta.status)) {
+            return;
+        }
+        const turn = await this.sessions.latestTurn(task);
+        if (!turn) {
+            return;
+        }
+        const route = routeWithRoleSelection(await readJson(turn.routePath, RouteDecisionSchema), roles);
+        const executionRoles = roleSelectionWithEngines(route, roles);
+        await writeJson(turn.routePath, route);
+        await this.sessions.recordLatestRoute(task, route);
+        await this.roleConfiguration.writeTurnSelection(turn.dir, executionRoles);
+        const featuresDir = join(task.dir, "features");
+        if (!(await pathExists(featuresDir))) {
+            return;
+        }
+        const entries = await readdir(featuresDir, { withFileTypes: true });
+        for (const entry of entries) {
+            if (!entry.isDirectory()) {
+                continue;
+            }
+            const featureDir = join(featuresDir, entry.name);
+            const status = await readFeatureStatusIfValid(join(featureDir, "status.json"));
+            if (!status || status.task_id !== task.id || status.state === "approved") {
+                continue;
+            }
+            await writeFeatureAssignment({ assignmentPath: join(featureDir, "assignment.json") }, executionRoles.actor.engine, executionRoles.critic.engine);
+        }
+    }
     async resumeTaskRun(input, pausedFeatureId) {
         throwIfCancelled(input.signal);
         const task = this.sessions.taskFromId(input.taskId);
@@ -226,11 +313,15 @@ export class Orchestrator {
                 throw new Error(`Task ${input.taskId} turn ${turn.turnId} has no request to retry.`);
             }
             const route = await readJson(turn.routePath, RouteDecisionSchema);
+            const roleSelection = await this.roleConfiguration.readTurnSelection(turn.dir)
+                ?? roleSelectionWithEngines(route, await this.roleConfiguration.selectionForTask(task.dir));
+            await this.roleConfiguration.writeTurnSelection(turn.dir, roleSelection);
             const executionInput = {
                 ...input,
                 request,
                 cwd: meta.cwd,
-                retry: true
+                retry: true,
+                roleSelection
             };
             const workers = [];
             input.onRoute?.(route);
@@ -311,14 +402,18 @@ export class Orchestrator {
     }
     async routeTaskFollowUp(input) {
         throwIfCancelled(input.signal);
-        const route = await this.routeRequest(input.request, input.cwd, input.signal, "follow-up", input.onRouteStart, input.onRouteFallback, input.onRouteProgress);
+        const routed = await this.routeRequest(input.request, input.cwd, input.signal, "follow-up", input.onRouteStart, input.onRouteFallback, input.onRouteProgress);
+        const task = this.sessions.taskFromId(input.taskId);
+        const roleSelection = input.roleSelection ?? await this.roleConfiguration.selectionForRequest(task.dir);
+        const route = routeWithRoleSelection(routed, roleSelection);
         input.onRoute?.(route);
         throwIfCancelled(input.signal);
         return {
             mode: route.mode,
             taskId: route.mode === "complex" ? input.taskId : null,
             reason: route.reason,
-            route
+            route,
+            roleSelection
         };
     }
     async answerTaskQuestion(input) {
@@ -327,7 +422,11 @@ export class Orchestrator {
         if (!(await pathExists(task.dir))) {
             throw new Error(`Task session not found: ${input.taskId}`);
         }
-        return this.withTaskRunLease(task, () => this.answerTaskQuestionWithLease(input, task));
+        const roleSelection = input.roleSelection ?? await this.roleConfiguration.selectionForRequest(task.dir);
+        return this.withTaskRunLease(task, () => this.answerTaskQuestionWithLease({
+            ...input,
+            roleSelection
+        }, task));
     }
     async answerTaskQuestionWithLease(input, task) {
         throwIfCancelled(input.signal);
@@ -1357,7 +1456,8 @@ export class Orchestrator {
     }
     async runMain(input, workers, context, taskId = null) {
         throwIfCancelled(input.signal);
-        const engine = this.config.pairing.main;
+        const target = input.roleSelection?.main ?? this.roleConfiguration.futureRoles().main;
+        const engine = target.engine;
         const dir = this.sessions.mainSessionDir();
         let lease;
         try {
@@ -1427,6 +1527,7 @@ export class Orchestrator {
             outputLogPath,
             statusPath,
             prompt,
+            modelConfig: this.roleConfiguration.modelForTarget(input.roleSelection?.main ?? this.roleConfiguration.futureRoles().main),
             signal: input.signal,
             onStatus: (runtimeStatus) => {
                 this.recordWorker(input, workers, { ...worker, runtimeStatus });
@@ -1473,6 +1574,7 @@ export class Orchestrator {
             outputLogPath: judge.outputLogPath,
             statusPath: judge.statusPath,
             prompt: await readTextIfExists(judge.promptPath),
+            modelConfig: await this.roleConfiguration.modelForTurn(turn.dir, "judge", engine),
             signal: input.signal
         }, "task", await this.previousTurnWorker(task, "judge", engine, turn.turnId));
         ensureWorkerSuccess(result);
@@ -1548,6 +1650,7 @@ export class Orchestrator {
             outputLogPath: finalJudge.outputLogPath,
             statusPath: finalJudge.statusPath,
             prompt: await readTextIfExists(finalJudge.promptPath),
+            modelConfig: await this.roleConfiguration.modelForTurn(turn.dir, "judge", engine),
             signal: input.signal
         }, "task", initialJudge);
         ensureWorkerSuccess(result);
@@ -1623,6 +1726,7 @@ export class Orchestrator {
             outputLogPath: actor.outputLogPath,
             statusPath: actor.statusPath,
             prompt: await readTextIfExists(actor.promptPath),
+            modelConfig: await this.roleConfiguration.modelForTurn(turn.dir, "actor", engine),
             signal: input.signal
         }, task, feature, featureScoped
             ? undefined
@@ -1683,6 +1787,7 @@ export class Orchestrator {
             outputLogPath: critic.outputLogPath,
             statusPath: critic.statusPath,
             prompt: await readTextIfExists(critic.promptPath),
+            modelConfig: await this.roleConfiguration.modelForTurn(turn.dir, "critic", engine),
             signal: input.signal
         }, task, feature, featureScoped
             ? undefined
@@ -1741,6 +1846,7 @@ export class Orchestrator {
             outputLogPath: critic.outputLogPath,
             statusPath: critic.statusPath,
             prompt: await readTextIfExists(critic.promptPath),
+            modelConfig: await this.roleConfiguration.modelForTurn(turn.dir, "critic", engine),
             signal: input.signal
         });
         ensureWorkerSuccess(result);
@@ -1791,6 +1897,7 @@ export class Orchestrator {
             outputLogPath: actor.outputLogPath,
             statusPath: actor.statusPath,
             prompt: await readTextIfExists(actor.promptPath),
+            modelConfig: await this.roleConfiguration.modelForTurn(turn.dir, "actor", engine),
             signal: input.signal
         });
         ensureWorkerSuccess(result);
@@ -1896,6 +2003,7 @@ export class Orchestrator {
         }
         return adapter.run({
             ...spec,
+            modelConfig: spec.modelConfig ?? workerProvider(this.config, engine).config.model,
             nativeSession: existing,
             nativeSessionConfig: workerProvider(this.config, engine).config.nativeSession,
             onNativeSession: async (sessionId) => {
@@ -2260,6 +2368,14 @@ async function readWorkerStatusIfValid(statusPath) {
         return null;
     }
 }
+async function readFeatureStatusIfValid(statusPath) {
+    try {
+        return await readJson(statusPath, FeatureStatusSchema);
+    }
+    catch {
+        return null;
+    }
+}
 async function readTaskMetaIfValid(metaPath) {
     if (!(await pathExists(metaPath))) {
         return null;
@@ -2698,3 +2814,11 @@ function judgeValidationError(turn, report) {
 function errorMessage(error) {
     return error instanceof Error ? error.message : String(error);
 }
+function routeWithRoleSelection(route, roles) {
+    return RouteDecisionSchema.parse({
+        ...route,
+        judge_engine: roles.judge.engine,
+        actor_engine: roles.actor.engine,
+        critic_engine: roles.critic.engine
+    });
+}