parallel-codex-tui 0.1.4 → 0.1.6

package/dist/doctor.js

@@ -16,6 +16,7 @@ import { formatTuiThemePreview } from "./tui/theme-preview.js";
 import { resolveTuiTheme } from "./tui/theme.js";
 import { diagnoseAgentCapabilities } from "./workers/capabilities.js";
 import { runLiveAgentProbes } from "./workers/live-probe.js";
+import { workerProvider } from "./workers/provider.js";
 export async function runDoctor(appRoot, workspaceRoot, env = process.env, options = {}) {
     const lines = ["parallel-codex-tui doctor"];
     let ok = true;
@@ -63,6 +64,51 @@ export async function runDoctor(appRoot, workspaceRoot, env = process.env, optio
         lines.push(`router retry: ${config.router.codex.maxAttempts} attempts; transient only; ${config.router.codex.retryDelayMs}ms backoff (TUI routing; live probe runs once)`);
         lines.push(`router budget: total ${config.router.codex.timeoutMs}ms; follow-up ${config.router.codex.followUpTimeoutMs}ms; first output ${config.router.codex.firstOutputTimeoutMs}ms; idle ${config.router.codex.idleTimeoutMs}ms`);
     }
+    const preflight = await runRuntimePreflight(config, preparedWorkspace, env, {
+        includeRouter,
+        ...(options.capabilityRunner ? { capabilityRunner: options.capabilityRunner } : {}),
+        ...(options.capabilityTimeoutMs ? { capabilityTimeoutMs: options.capabilityTimeoutMs } : {})
+    });
+    lines.push(...preflight.lines);
+    ok = ok && preflight.ok;
+    if (options.probeAgents) {
+        if (ok) {
+            const liveAgents = await runLiveAgentProbes(config, preparedWorkspace, configuredWorkerEngines(config), options.liveAgentProbeOptions);
+            lines.push(...liveAgents.lines);
+            ok = ok && liveAgents.ok;
+        }
+        else {
+            lines.push("agent live probe: skipped (preflight failed)");
+        }
+    }
+    else {
+        lines.push("agent live probe: not run (add --probe-agents; may use model quota)");
+    }
+    if (options.probeRouter) {
+        const probe = await runRouterProbe(config, appRoot, options.routeRunner);
+        lines.push(probe.line);
+        ok = ok && probe.ok;
+    }
+    else if (config.router.defaultMode === "auto") {
+        lines.push("router live probe: not run (add --probe-router)");
+    }
+    return {
+        ok,
+        text: `${lines.join("\n")}\n`
+    };
+}
+export async function runRuntimePreflight(config, workspaceRoot, env = process.env, options = {}) {
+    const includeRouter = options.includeRouter ?? config.router.defaultMode === "auto";
+    const lines = [];
+    let ok = true;
+    try {
+        await access(workspaceRoot, constants.R_OK | constants.W_OK | constants.X_OK);
+        lines.push("workspace permissions: ok (read/write/search)");
+    }
+    catch {
+        ok = false;
+        lines.push(`workspace permissions: denied (${workspaceRoot}; need read/write/search)`);
+    }
     const availableCommands = new Set();
     for (const command of configuredCommands(config, includeRouter)) {
         if (await commandExists(command, env)) {
@@ -92,45 +138,24 @@ export async function runDoctor(appRoot, workspaceRoot, env = process.env, optio
     });
     lines.push(...capabilityDiagnostics.lines);
     ok = ok && capabilityDiagnostics.ok;
-    const proxyDiagnostics = await diagnoseProxyEnvironment(config, env, await detectMacSystemProxy(), canConnectProxy, { includeRouter });
+    const systemProxy = options.systemProxy !== undefined
+        ? options.systemProxy
+        : await detectMacSystemProxy();
+    const proxyDiagnostics = await diagnoseProxyEnvironment(config, env, systemProxy, options.proxyConnector ?? canConnectProxy, { includeRouter });
     lines.push(...proxyDiagnostics.lines);
     ok = ok && proxyDiagnostics.ok;
-    if (options.probeAgents) {
-        if (ok) {
-            const liveAgents = await runLiveAgentProbes(config, preparedWorkspace, configuredWorkerEngines(config), options.liveAgentProbeOptions);
-            lines.push(...liveAgents.lines);
-            ok = ok && liveAgents.ok;
-        }
-        else {
-            lines.push("agent live probe: skipped (preflight failed)");
-        }
-    }
-    else {
-        lines.push("agent live probe: not run (add --probe-agents; may use model quota)");
-    }
-    if (options.probeRouter) {
-        const probe = await runRouterProbe(config, appRoot, options.routeRunner);
-        lines.push(probe.line);
-        ok = ok && probe.ok;
-    }
-    else if (config.router.defaultMode === "auto") {
-        lines.push("router live probe: not run (add --probe-router)");
-    }
-    return {
-        ok,
-        text: `${lines.join("\n")}\n`
-    };
+    return { ok, lines };
 }
 export async function diagnoseProxyEnvironment(config, env, systemProxy, connect = canConnectProxy, options = {}) {
     const contexts = [];
     if (options.includeRouter ?? config.router.defaultMode === "auto") {
         contexts.push({ label: "router proxy", env: config.router.codex.env, table: "router.codex.env" });
     }
-    if (configuredWorkerEngines(config).includes("codex")) {
+    for (const engine of configuredWorkerEngines(config)) {
         contexts.push({
-            label: "workers.codex proxy",
-            env: config.workers.codex.model.env,
-            table: "workers.codex.model.env"
+            label: `workers.${engine} proxy`,
+            env: workerProvider(config, engine).config.model.env,
+            table: `workers.${engine}.model.env`
         });
     }
     const connectionCache = new Map();
@@ -300,11 +325,8 @@ function themeSummary(effectiveTheme, configTheme, cliTheme) {
     }
     return effectiveTheme;
 }
-function configuredEngines(config, options) {
+function configuredWorkerEngines(config) {
     const engines = new Set();
-    if (options.includeRouter) {
-        engines.add("router-codex");
-    }
     if (config.router.defaultMode === "auto") {
         engines.add(config.pairing.main);
         engines.add(config.pairing.judge);
@@ -319,10 +341,7 @@ function configuredEngines(config, options) {
         engines.add(config.pairing.actor);
         engines.add(config.pairing.critic);
     }
-    return Array.from(engines);
-}
-function configuredWorkerEngines(config) {
-    return configuredEngines(config, { includeRouter: false }).filter((engine) => engine === "codex" || engine === "claude");
+    return [...engines].filter((engine) => engine !== "mock");
 }
 function configuredEnvironmentChecks(config, env, includeRouter) {
     const checks = [];
@@ -338,7 +357,7 @@ function configuredEnvironmentChecks(config, env, includeRouter) {
         }
     }
     for (const engine of configuredWorkerEngines(config)) {
-        const worker = engine === "codex" ? config.workers.codex : config.workers.claude;
+        const worker = workerProvider(config, engine).config;
         for (const [key, value] of Object.entries(worker.model.env)) {
             for (const envName of referencedEnvNames(value)) {
                 checks.push({

package/dist/domain/schemas.js

@@ -1,6 +1,10 @@
 import { z } from "zod";
 export const RouteModeSchema = z.enum(["simple", "complex"]);
-export const EngineNameSchema = z.enum(["codex", "claude", "mock"]);
+export const EngineNameSchema = z
+    .string()
+    .min(1)
+    .max(48)
+    .regex(/^[a-z][a-z0-9_]*$/, "Worker id must start with a lowercase letter and contain only lowercase letters, digits or _");
 export const WorkerRoleSchema = z.enum(["main", "judge", "actor", "critic"]);
 export const RouterFailureStageSchema = z.enum([
     "spawn",
@@ -49,6 +53,7 @@ export const TaskStateSchema = z.enum([
     "revision_needed",
     "integrating",
     "verifying",
+    "paused",
     "done",
     "failed",
     "cancelled"
@@ -80,6 +85,7 @@ export const FeatureStateSchema = z.enum([
     "revision_needed",
     "integrating",
     "verifying",
+    "paused",
     "approved",
     "failed",
     "cancelled"
@@ -141,6 +147,8 @@ export const WorkerStatusSchema = z.object({
     feature_title: z.string().min(1).optional(),
     role: WorkerRoleSchema,
     engine: EngineNameSchema,
+    model_name: z.string().optional(),
+    model_provider: z.string().optional(),
     state: WorkerStateSchema,
     phase: z.string().min(1),
     last_event_at: z.string().datetime(),
@@ -157,6 +165,12 @@ export const FeatureStatusSchema = z.object({
     state: FeatureStateSchema,
     updated_at: z.string().datetime()
 });
+export const FeatureAssignmentSchema = z.object({
+    version: z.literal(1),
+    actor_engine: EngineNameSchema,
+    critic_engine: EngineNameSchema,
+    updated_at: z.string().datetime()
+});
 export const TurnMetaSchema = z.object({
     task_id: TaskIdSchema,
     turn_id: z.string().regex(/^\d{4}$/),

package/dist/orchestrator/collaboration-channel.js

@@ -1,7 +1,7 @@
 import { join } from "node:path";
 import { z } from "zod";
 import { appendJsonLine, ensureDir, pathExists, readJson, readTextIfExists, writeJson, writeText } from "../core/file-store.js";
-import { FeatureStatusSchema } from "../domain/schemas.js";
+import { FeatureAssignmentSchema, FeatureStatusSchema } from "../domain/schemas.js";
 const CriticFindingRecordSchema = z.object({
     id: z.string().trim().min(1),
     severity: z.string().trim().optional(),
@@ -52,7 +52,8 @@ export async function createFeatureChannel(input) {
         actorRepliesPath: join(dir, "actor-replies.jsonl"),
         criticFindingsPath: join(dir, "critic-findings.jsonl"),
         findingResolutionPath: join(dir, "finding-resolution.json"),
-        decisionsPath: join(dir, "decisions.md")
+        decisionsPath: join(dir, "decisions.md"),
+        assignmentPath: join(dir, "assignment.json")
     };
     await ensureDir(dir);
     await ensureDir(join(input.task.dir, "dialogue"));
@@ -68,6 +69,9 @@ export async function createFeatureChannel(input) {
     await writeText(channel.actorWorklogPath, "");
     await writeText(channel.actorRepliesPath, "");
     await writeText(channel.criticFindingsPath, "");
+    if (input.actorEngine && input.criticEngine) {
+        await writeFeatureAssignment(channel, input.actorEngine, input.criticEngine);
+    }
     await updateFeatureStatus(channel, "created");
     await appendFeatureDialogue(channel, "feature.created", "actor", "Feature mailbox created for the current turn.");
     return channel;
@@ -84,6 +88,32 @@ async function ensureFeatureChannelFiles(input, channel) {
             await writeText(path, initialContent);
         }
     }
+    if (!(await pathExists(channel.assignmentPath)) && input.actorEngine && input.criticEngine) {
+        await writeFeatureAssignment(channel, input.actorEngine, input.criticEngine);
+    }
+}
+export async function readFeatureAssignment(channel, fallback) {
+    try {
+        return await readJson(channel.assignmentPath, FeatureAssignmentSchema);
+    }
+    catch {
+        return FeatureAssignmentSchema.parse({
+            version: 1,
+            actor_engine: fallback.actor,
+            critic_engine: fallback.critic,
+            updated_at: new Date(0).toISOString()
+        });
+    }
+}
+export async function writeFeatureAssignment(channel, actorEngine, criticEngine) {
+    const assignment = FeatureAssignmentSchema.parse({
+        version: 1,
+        actor_engine: actorEngine,
+        critic_engine: criticEngine,
+        updated_at: new Date().toISOString()
+    });
+    await writeJson(channel.assignmentPath, assignment);
+    return assignment;
 }
 export function featurePromptContext(channel) {
     return {
@@ -97,7 +127,8 @@ export function featurePromptContext(channel) {
         actorWorklogPath: channel.actorWorklogPath,
         actorRepliesPath: channel.actorRepliesPath,
         criticFindingsPath: channel.criticFindingsPath,
-        decisionsPath: channel.decisionsPath
+        decisionsPath: channel.decisionsPath,
+        assignmentPath: channel.assignmentPath
     };
 }
 export async function updateFeatureStatus(channel, state) {
@@ -339,6 +370,7 @@ function buildFeatureSpec(input, channel) {
         '- Critic writes one JSON object per blocking issue to critic-findings.jsonl: {"id":"C-001","severity":"blocker","summary":"what must change"}.',
         '- Actor replies to each fixed finding in actor-replies.jsonl: {"finding_id":"C-001","status":"fixed","notes":"what changed"}.',
         "- Supervisor writes the final decision summary to decisions.md.",
+        "- assignment.json records the Actor and Critic engines selected for retries.",
         ""
     ].join("\n");
 }

package/dist/orchestrator/final-acceptance.js

@@ -0,0 +1,86 @@
+import { z } from "zod";
+const FinalAcceptanceItemSchema = z.object({
+    criterion_id: z.string().regex(/^A-\d{1,4}$/),
+    status: z.enum(["passed", "failed"]),
+    evidence: z.string().trim().min(1).max(4000)
+}).strict();
+export const FinalJudgeAcceptanceSchema = z.object({
+    version: z.literal(1),
+    decision: z.enum(["approved", "rejected"]),
+    summary: z.string().trim().min(1).max(4000),
+    acceptance: z.array(FinalAcceptanceItemSchema).min(1).max(100),
+    changed_paths: z.array(z.string().trim().min(1).max(1000)).max(10000)
+}).strict();
+export function validateFinalJudgeAcceptance(input, expectedCriterionIds, expectedChangedPaths) {
+    const parsed = FinalJudgeAcceptanceSchema.safeParse(input);
+    if (!parsed.success) {
+        return {
+            acceptance: null,
+            report: {
+                version: 1,
+                state: "invalid",
+                decision: "unknown",
+                issues: parsed.error.issues.map((issue) => `${issue.path.join(".") || "root"}: ${issue.message}`)
+            }
+        };
+    }
+    const acceptance = parsed.data;
+    const issues = [];
+    const actualIds = acceptance.acceptance.map((item) => item.criterion_id);
+    const duplicateIds = repeated(actualIds);
+    if (duplicateIds.length > 0) {
+        issues.push(`duplicate acceptance criteria: ${duplicateIds.join(", ")}`);
+    }
+    const expectedIds = [...new Set(expectedCriterionIds)].sort();
+    const uniqueActualIds = [...new Set(actualIds)].sort();
+    const missingIds = expectedIds.filter((id) => !uniqueActualIds.includes(id));
+    const unknownIds = uniqueActualIds.filter((id) => !expectedIds.includes(id));
+    if (missingIds.length > 0) {
+        issues.push(`missing acceptance criteria: ${missingIds.join(", ")}`);
+    }
+    if (unknownIds.length > 0) {
+        issues.push(`unknown acceptance criteria: ${unknownIds.join(", ")}`);
+    }
+    const failedIds = acceptance.acceptance
+        .filter((item) => item.status === "failed")
+        .map((item) => item.criterion_id);
+    if (acceptance.decision === "approved" && failedIds.length > 0) {
+        issues.push(`approved decision contains failed criteria: ${failedIds.join(", ")}`);
+    }
+    if (acceptance.decision === "rejected" && failedIds.length === 0) {
+        issues.push("rejected decision must identify at least one failed criterion");
+    }
+    const expectedPaths = [...new Set(expectedChangedPaths)].sort();
+    const actualPaths = [...new Set(acceptance.changed_paths)].sort();
+    if (acceptance.changed_paths.length !== actualPaths.length) {
+        issues.push(`duplicate changed paths: ${repeated(acceptance.changed_paths).join(", ")}`);
+    }
+    const missingPaths = expectedPaths.filter((path) => !actualPaths.includes(path));
+    const unknownPaths = actualPaths.filter((path) => !expectedPaths.includes(path));
+    if (missingPaths.length > 0) {
+        issues.push(`missing changed paths: ${missingPaths.join(", ")}`);
+    }
+    if (unknownPaths.length > 0) {
+        issues.push(`unknown changed paths: ${unknownPaths.join(", ")}`);
+    }
+    return {
+        acceptance,
+        report: {
+            version: 1,
+            state: issues.length === 0 ? "valid" : "invalid",
+            decision: acceptance.decision,
+            issues
+        }
+    };
+}
+function repeated(values) {
+    const seen = new Set();
+    const duplicates = new Set();
+    for (const value of values) {
+        if (seen.has(value)) {
+            duplicates.add(value);
+        }
+        seen.add(value);
+    }
+    return [...duplicates].sort();
+}