parallel-codex-tui 0.1.4 → 0.1.6

package/dist/core/config.js

@@ -2,6 +2,7 @@ import { parse } from "@iarna/toml";
 import { readFile } from "node:fs/promises";
 import { join } from "node:path";
 import { z } from "zod";
+import { EngineNameSchema } from "../domain/schemas.js";
 import { pathExists, readTextIfExists, writeText } from "./file-store.js";
 import { normalizeTuiThemeColorValue, normalizeTuiThemeName, TUI_THEME_FIELDS, TUI_THEME_NAMES } from "../tui/theme.js";
 const NativeSessionConfigSchema = z.object({
@@ -38,7 +39,16 @@ const WorkerCapabilitiesConfigSchema = z.object({
 });
 const InteractiveCommandSchema = z.object({
     command: z.string().min(1),
-    args: z.array(z.string()).default([])
+    args: z.array(z.string()).default([]),
+    forkArgs: z.array(z.string()).default([])
+}).superRefine((value, context) => {
+    if (value.forkArgs.length > 0 && !value.forkArgs.some((arg) => arg.includes("{sessionId}"))) {
+        context.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ["forkArgs"],
+            message: "forkArgs must include a {sessionId} template"
+        });
+    }
 });
 const RolePromptConfigSchema = z.object({
     title: z.string().min(1),
@@ -75,7 +85,8 @@ const CodexRouterConfigSchema = z.object({
     env: z.record(z.string()).default({})
 });
 const OrchestrationConfigSchema = z.object({
-    maxParallelFeatures: z.number().int().min(1).max(8)
+    maxParallelFeatures: z.number().int().min(1).max(8),
+    maxRevisionRounds: z.number().int().min(1).max(10)
 }).strict();
 const UiConfigSchema = z.object({
     showStatusBar: z.boolean(),
@@ -86,6 +97,7 @@ const UiConfigSchema = z.object({
 const WorkerCommandSchema = z.object({
     command: z.string().min(1),
     args: z.array(z.string()).default([]),
+    assignable: z.boolean().default(true),
     timeoutMs: z.number().int().positive().optional(),
     idleTimeoutMs: z.number().int().positive().optional(),
     firstOutputTimeoutMs: z.number().int().positive().optional(),
@@ -106,12 +118,12 @@ const AppConfigSchema = z.object({
         codex: WorkerCommandSchema,
         claude: WorkerCommandSchema,
         mock: WorkerCommandSchema
-    }),
+    }).catchall(WorkerCommandSchema),
     pairing: z.object({
-        main: z.enum(["codex", "claude", "mock"]),
-        judge: z.enum(["codex", "claude", "mock"]),
-        actor: z.enum(["codex", "claude", "mock"]),
-        critic: z.enum(["codex", "claude", "mock"])
+        main: EngineNameSchema,
+        judge: EngineNameSchema,
+        actor: EngineNameSchema,
+        critic: EngineNameSchema
     }),
     roles: z.object({
         main: RolePromptConfigSchema,
@@ -120,6 +132,16 @@ const AppConfigSchema = z.object({
         critic: RolePromptConfigSchema
     }),
     ui: UiConfigSchema
+}).superRefine((config, context) => {
+    for (const [role, workerId] of Object.entries(config.pairing)) {
+        if (!config.workers[workerId]) {
+            context.addIssue({
+                code: z.ZodIssueCode.custom,
+                path: ["pairing", role],
+                message: `Unknown Worker profile: ${workerId}`
+            });
+        }
+    }
 });
 export function defaultConfig(projectRoot) {
     return {
@@ -154,12 +176,14 @@ export function defaultConfig(projectRoot) {
             }
         },
         orchestration: {
-            maxParallelFeatures: 3
+            maxParallelFeatures: 3,
+            maxRevisionRounds: 3
         },
         workers: {
             codex: {
                 command: "codex",
                 args: ["exec", "--skip-git-repo-check", "--sandbox", "workspace-write", "--color", "never", "-"],
+                assignable: true,
                 timeoutMs: 45 * 60 * 1000,
                 idleTimeoutMs: 5 * 60 * 1000,
                 firstOutputTimeoutMs: 2 * 60 * 1000,
@@ -182,12 +206,14 @@ export function defaultConfig(projectRoot) {
                 },
                 interactive: {
                     command: "codex",
-                    args: ["resume", "{sessionId}"]
+                    args: ["resume", "{sessionId}"],
+                    forkArgs: ["fork", "{sessionId}"]
                 }
             },
             claude: {
                 command: "claude",
                 args: ["--print", "--permission-mode", "acceptEdits", "--output-format", "text"],
+                assignable: true,
                 timeoutMs: 45 * 60 * 1000,
                 idleTimeoutMs: 5 * 60 * 1000,
                 firstOutputTimeoutMs: 2 * 60 * 1000,
@@ -210,12 +236,14 @@ export function defaultConfig(projectRoot) {
                 },
                 interactive: {
                     command: "claude",
-                    args: ["--resume", "{sessionId}"]
+                    args: ["--resume", "{sessionId}"],
+                    forkArgs: ["--resume", "{sessionId}", "--fork-session"]
                 }
             },
             mock: {
                 command: "mock",
                 args: [],
+                assignable: false,
                 model: {
                     name: "",
                     provider: "",
@@ -235,7 +263,8 @@ export function defaultConfig(projectRoot) {
                 },
                 interactive: {
                     command: "mock",
-                    args: ["resume", "{sessionId}"]
+                    args: ["resume", "{sessionId}"],
+                    forkArgs: []
                 }
             }
         },
@@ -302,80 +331,7 @@ export async function loadConfig(projectRoot) {
             ...base.orchestration,
             ...(parsed.orchestration ?? {})
         },
-        workers: {
-            codex: {
-                ...base.workers.codex,
-                ...(parsed.workers?.codex ?? {}),
-                model: {
-                    ...base.workers.codex.model,
-                    ...(parsed.workers?.codex?.model ?? {}),
-                    env: {
-                        ...base.workers.codex.model.env,
-                        ...(parsed.workers?.codex?.model?.env ?? {})
-                    }
-                },
-                capabilities: {
-                    ...base.workers.codex.capabilities,
-                    ...(parsed.workers?.codex?.capabilities ?? {})
-                },
-                nativeSession: {
-                    ...base.workers.codex.nativeSession,
-                    ...(parsed.workers?.codex?.nativeSession ?? {})
-                },
-                interactive: {
-                    ...base.workers.codex.interactive,
-                    ...(parsed.workers?.codex?.interactive ?? {})
-                }
-            },
-            claude: {
-                ...base.workers.claude,
-                ...(parsed.workers?.claude ?? {}),
-                model: {
-                    ...base.workers.claude.model,
-                    ...(parsed.workers?.claude?.model ?? {}),
-                    env: {
-                        ...base.workers.claude.model.env,
-                        ...(parsed.workers?.claude?.model?.env ?? {})
-                    }
-                },
-                capabilities: {
-                    ...base.workers.claude.capabilities,
-                    ...(parsed.workers?.claude?.capabilities ?? {})
-                },
-                nativeSession: {
-                    ...base.workers.claude.nativeSession,
-                    ...(parsed.workers?.claude?.nativeSession ?? {})
-                },
-                interactive: {
-                    ...base.workers.claude.interactive,
-                    ...(parsed.workers?.claude?.interactive ?? {})
-                }
-            },
-            mock: {
-                ...base.workers.mock,
-                ...(parsed.workers?.mock ?? {}),
-                model: {
-                    ...base.workers.mock.model,
-                    ...(parsed.workers?.mock?.model ?? {}),
-                    env: {
-                        ...base.workers.mock.model.env,
-                        ...(parsed.workers?.mock?.model?.env ?? {})
-                    }
-                },
-                capabilities: {
-                    ...base.workers.mock.capabilities,
-                    ...(parsed.workers?.mock?.capabilities ?? {})
-                },
-                nativeSession: {
-                    ...base.workers.mock.nativeSession,
-                    ...(parsed.workers?.mock?.nativeSession ?? {})
-                },
-                interactive: {
-                    ...base.workers.mock.interactive,
-                    ...(parsed.workers?.mock?.interactive ?? {})
-                }
-            }
-        },
+        workers: resolveWorkerConfigs(base.workers, parsed.workers ?? {}),
         pairing: {
             ...base.pairing,
             ...(parsed.pairing ?? {})
@@ -409,6 +365,113 @@ export async function loadConfig(projectRoot) {
     };
     return AppConfigSchema.parse(merged);
 }
+function resolveWorkerConfigs(builtins, configured) {
+    const resolved = new Map();
+    const resolving = new Set();
+    const ids = [...new Set([...Object.keys(builtins), ...Object.keys(configured)])];
+    const resolve = (id) => {
+        const cached = resolved.get(id);
+        if (cached) {
+            return cached;
+        }
+        if (!EngineNameSchema.safeParse(id).success) {
+            throw new Error(`Invalid Worker profile id: ${id}`);
+        }
+        if (resolving.has(id)) {
+            throw new Error(`Circular Worker profile inheritance: ${[...resolving, id].join(" -> ")}`);
+        }
+        resolving.add(id);
+        try {
+            const override = configured[id] ?? {};
+            const builtin = builtins[id];
+            if (builtin && override.extends) {
+                throw new Error(`Built-in Worker profile ${id} cannot declare extends`);
+            }
+            let parent = builtin;
+            if (!parent) {
+                const parentId = override.extends?.trim();
+                if (!parentId || parentId === "generic") {
+                    parent = genericWorkerConfig(id, override.command);
+                }
+                else {
+                    if (!builtins[parentId] && !configured[parentId]) {
+                        throw new Error(`Unknown Worker profile inherited by ${id}: ${parentId}`);
+                    }
+                    parent = resolve(parentId);
+                }
+            }
+            const worker = mergeWorkerConfig(parent, override);
+            resolved.set(id, worker);
+            return worker;
+        }
+        finally {
+            resolving.delete(id);
+        }
+    };
+    for (const id of ids) {
+        resolve(id);
+    }
+    return Object.fromEntries(resolved);
+}
+function genericWorkerConfig(id, command = id) {
+    return {
+        command,
+        args: [],
+        assignable: true,
+        timeoutMs: 45 * 60 * 1000,
+        idleTimeoutMs: 5 * 60 * 1000,
+        firstOutputTimeoutMs: 2 * 60 * 1000,
+        model: {
+            name: "",
+            provider: "",
+            args: [],
+            env: {}
+        },
+        capabilities: {
+            profile: "generic",
+            writableDirArgs: [],
+            freshSessionArgs: []
+        },
+        nativeSession: {
+            enabled: false,
+            resumeArgs: [],
+            detectSessionId: false,
+            fallback: "fail"
+        },
+        interactive: {
+            command,
+            args: [],
+            forkArgs: []
+        }
+    };
+}
+function mergeWorkerConfig(base, override) {
+    const { extends: _extends, ...values } = override;
+    return {
+        ...base,
+        ...values,
+        model: {
+            ...base.model,
+            ...(override.model ?? {}),
+            env: {
+                ...base.model.env,
+                ...(override.model?.env ?? {})
+            }
+        },
+        capabilities: {
+            ...base.capabilities,
+            ...(override.capabilities ?? {})
+        },
+        nativeSession: {
+            ...base.nativeSession,
+            ...(override.nativeSession ?? {})
+        },
+        interactive: {
+            ...base.interactive,
+            ...(override.interactive ?? {})
+        }
+    };
+}
 export function withUiThemeOverride(config, theme) {
     if (!theme) {
         return config;
@@ -428,24 +491,6 @@ function assertObjectSections(parsed) {
         ["router.codex.env", parsed.router?.codex?.env],
         ["orchestration", parsed.orchestration],
         ["workers", parsed.workers],
-        ["workers.codex", parsed.workers?.codex],
-        ["workers.codex.model", parsed.workers?.codex?.model],
-        ["workers.codex.model.env", parsed.workers?.codex?.model?.env],
-        ["workers.codex.capabilities", parsed.workers?.codex?.capabilities],
-        ["workers.codex.nativeSession", parsed.workers?.codex?.nativeSession],
-        ["workers.codex.interactive", parsed.workers?.codex?.interactive],
-        ["workers.claude", parsed.workers?.claude],
-        ["workers.claude.model", parsed.workers?.claude?.model],
-        ["workers.claude.model.env", parsed.workers?.claude?.model?.env],
-        ["workers.claude.capabilities", parsed.workers?.claude?.capabilities],
-        ["workers.claude.nativeSession", parsed.workers?.claude?.nativeSession],
-        ["workers.claude.interactive", parsed.workers?.claude?.interactive],
-        ["workers.mock", parsed.workers?.mock],
-        ["workers.mock.model", parsed.workers?.mock?.model],
-        ["workers.mock.model.env", parsed.workers?.mock?.model?.env],
-        ["workers.mock.capabilities", parsed.workers?.mock?.capabilities],
-        ["workers.mock.nativeSession", parsed.workers?.mock?.nativeSession],
-        ["workers.mock.interactive", parsed.workers?.mock?.interactive],
         ["pairing", parsed.pairing],
         ["roles", parsed.roles],
         ["roles.main", parsed.roles?.main],
@@ -455,6 +500,19 @@ function assertObjectSections(parsed) {
         ["ui", parsed.ui],
         ["ui.colors", parsed.ui?.colors]
     ];
+    if (isPlainObject(parsed.workers)) {
+        for (const [id, value] of Object.entries(parsed.workers)) {
+            sections.push([`workers.${id}`, value]);
+            if (!isPlainObject(value)) {
+                continue;
+            }
+            const worker = value;
+            sections.push([`workers.${id}.model`, worker.model], [`workers.${id}.capabilities`, worker.capabilities], [`workers.${id}.nativeSession`, worker.nativeSession], [`workers.${id}.interactive`, worker.interactive]);
+            if (isPlainObject(worker.model)) {
+                sections.push([`workers.${id}.model.env`, worker.model.env]);
+            }
+        }
+    }
     for (const [path, value] of sections) {
         if (value !== undefined && !isPlainObject(value)) {
             throw new Error(`Invalid config section [${path}]: expected a table`);

package/dist/core/router.js

@@ -93,7 +93,7 @@ function annotateRoute(route, source, startedAt, telemetry, proxyContext, router
         ...routerProxyRouteFields(proxyContext),
         ...(routerCommand ? { router_command: routerCommand } : {}),
         source,
-        duration_ms: Math.max(0, Date.now() - startedAt)
+        duration_ms: source === "forced" ? 0 : Math.max(0, Date.now() - startedAt)
     };
 }
 export function routerCommandLabel(command) {