parallel-codex-tui 0.1.4 → 0.1.5

package/dist/tui/TaskSessionsView.js

@@ -105,7 +105,7 @@ function taskSessionSummary(tasks, width) {
         const group = taskSessionStatusGroup(task.status);
         counts.set(group, (counts.get(group) ?? 0) + 1);
     }
-    const parts = ["running", "done", "failed", "cancelled"].flatMap((group) => {
+    const parts = ["running", "paused", "done", "failed", "cancelled"].flatMap((group) => {
         const count = counts.get(group) ?? 0;
         return count > 0 ? [`${count} ${group}`] : [];
     });
@@ -149,7 +149,7 @@ function clampTaskIndex(index, count) {
     return Math.min(Math.max(0, count - 1), Math.max(0, Math.trunc(index)));
 }
 function taskSessionStatusGroup(status) {
-    if (status === "done" || status === "failed" || status === "cancelled") {
+    if (status === "paused" || status === "done" || status === "failed" || status === "cancelled") {
         return status;
     }
     return "running";
@@ -165,6 +165,9 @@ function taskSessionStatusTone(task) {
     if (status === "done") {
         return "success";
     }
+    if (status === "paused") {
+        return "warning";
+    }
     if (status === "failed") {
         return "danger";
     }

package/dist/tui/WorkerOutputView.js

@@ -2882,6 +2882,7 @@ function shouldDropNoisyProcessLine(trimmed, line) {
         /^202\d-\d\d-\d\dT.*codex_models_manager::manager/.test(trimmed) ||
         /^reasoning summaries:/i.test(trimmed) ||
         /^session id:/i.test(trimmed) ||
+        /^collab:\s*(?:wait|waiting)$/i.test(trimmed) ||
         /^[⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏]$/.test(trimmed) ||
         line === "--------");
 }

package/dist/tui/WorkerOverviewView.js

@@ -158,18 +158,37 @@ function workerOverviewWorkerText(worker, selected, width) {
     const marker = selected ? "> " : "  ";
     const label = safeWorkerOverviewText(worker.label);
     const state = worker.runtimeStatus?.state ?? "waiting";
+    const turn = workerOverviewTurnLabel(worker);
+    const model = workerOverviewModelLabel(worker);
     const phase = humanizeWorkerOverviewPhase(worker.runtimeStatus?.phase ?? "status pending");
     const session = worker.runtimeStatus?.native_session_id ? "session" : "";
     const summary = safeWorkerOverviewText(worker.runtimeStatus?.summary ?? "");
     const identity = `${worker.role}/${worker.engine}`;
     return fitWorkerOverviewCandidates([
-        [marker + label, state, phase, session, summary].filter(Boolean).join(" · "),
-        [marker + label, state, phase, session].filter(Boolean).join(" · "),
-        [marker + label, state, session].filter(Boolean).join(" · "),
-        [marker + identity, state].join(" · "),
+        [marker + label, turn, state, model, phase, session, summary].filter(Boolean).join(" · "),
+        [marker + label, turn, state, model, phase, session].filter(Boolean).join(" · "),
+        [marker + label, turn, state, model, session].filter(Boolean).join(" · "),
+        [marker + identity, turn, state, model].filter(Boolean).join(" · "),
+        [marker + identity, turn, state].filter(Boolean).join(" · "),
         marker.trimEnd()
     ], width);
 }
+export function workerOverviewTurnLabel(worker) {
+    if (worker.role === "main") {
+        return "";
+    }
+    const suffix = worker.id.startsWith(`${worker.role}-${worker.engine}`)
+        ? worker.id.slice(`${worker.role}-${worker.engine}`.length).replace(/^-/, "")
+        : "";
+    const turn = suffix.match(/^(?:final-|wave-)?(\d{4})(?:-|$)/)?.[1];
+    return `turn ${Number(turn ?? "0001")}`;
+}
+function workerOverviewModelLabel(worker) {
+    const provider = safeWorkerOverviewText(worker.runtimeStatus?.model_provider ?? "");
+    const model = safeWorkerOverviewText(worker.runtimeStatus?.model_name ?? "");
+    const selection = [provider, model].filter(Boolean).join("/");
+    return selection ? `model ${selection}` : "";
+}
 function workerOverviewWindowStart(selected, count, visibleCount) {
     if (visibleCount <= 0 || count <= visibleCount) {
         return 0;

package/dist/tui/keyboard.js

@@ -25,6 +25,9 @@ export function isTaskSessionsShortcut(input, key) {
 export function isTaskResultShortcut(input, key) {
     return (key.ctrl === true && input.toLowerCase() === "d") || input === "\u0004";
 }
+export function isStatusDetailsShortcut(input, key) {
+    return (key.ctrl === true && input.toLowerCase() === "s") || input === "\u0013";
+}
 export function isWorkerSearchShortcut(input, key) {
     return (key.ctrl === true && input.toLowerCase() === "f") || input === "\u0006";
 }

package/dist/tui/status-line.js

@@ -129,6 +129,45 @@ export function formatRouteStatus(route) {
     }
     return `route ${details.join(" · ")}`;
 }
+export function formatRouteSummaryStatus(route) {
+    if (!route) {
+        return "";
+    }
+    const details = [route.mode];
+    if (route.source === "forced") {
+        details.push("forced");
+    }
+    else if (route.source === "fallback") {
+        details.push("fallback");
+        const cause = route.router_failure_kind && route.router_failure_kind !== "unknown"
+            ? route.router_failure_kind
+            : classifyRouterFailure(route.reason) ?? "unknown";
+        details.push(cause === "timeout" ? "timeout" : cause.replaceAll("-", " "));
+    }
+    else if (route.router_recovered_from) {
+        details.push("recovered");
+    }
+    return `route ${details.join(" · ")}`;
+}
+export function formatRoutePendingSummaryStatus(state, elapsedMs) {
+    if (!state) {
+        return "";
+    }
+    if (state.mode !== "auto") {
+        return `route ${state.mode} · forced`;
+    }
+    if (state.phase === "retrying") {
+        return `route retry ${state.attempt}/${state.maxAttempts}`;
+    }
+    const details = [routePendingPhaseLabel(state)];
+    if (state.attempt > 1) {
+        details.push(`try ${state.attempt}`);
+    }
+    if (typeof elapsedMs === "number") {
+        details.push(formatRouteElapsed(Math.max(0, elapsedMs)));
+    }
+    return `route ${details.join(" · ")}`;
+}
 function routeRecoveryLabel(route) {
     if (!route.router_recovered_from) {
         return null;
@@ -378,6 +417,9 @@ function compactStatus(status) {
     if (state === "cancelled" || state === "canceled") {
         return "stop";
     }
+    if (state === "paused") {
+        return "wait";
+    }
     if (state === "waiting" || state === "queued") {
         return "wait";
     }

package/dist/version.js

@@ -1 +1 @@
-export const version = "0.1.4";
+export const version = "0.1.5";

package/dist/workers/capabilities.js

@@ -1,5 +1,6 @@
 import { execFile } from "node:child_process";
 import { basename } from "node:path";
+import { workerProvider } from "./provider.js";
 export async function diagnoseAgentCapabilities(config, env, options) {
     const targets = capabilityTargets(config, options);
     const runner = options.runner ?? runCapabilityCommand;
@@ -33,7 +34,7 @@ function capabilityTargets(config, options) {
         }, "automated");
     }
     for (const engine of [...new Set(options.workerEngines)]) {
-        const worker = config.workers[engine];
+        const worker = workerProvider(config, engine).config;
         addTarget(engine, worker.command, worker.capabilities, "automated");
         if (worker.nativeSession.enabled) {
             addTarget(engine, worker.command, worker.capabilities, "resume");
@@ -79,7 +80,7 @@ async function diagnoseCapabilityTarget(target, config, env, runner, timeoutMs)
         }
     }
     if (target.capabilities.profile === "codex" && target.surfaces.has("native")) {
-        const sandbox = configuredCodexSandbox(config.workers.codex.interactive.args);
+        const sandbox = configuredCodexSandbox(workerProvider(config, target.engine).config.interactive.args);
         if (sandbox === "read-only") {
             incompatible.push("native resume uses read-only but feature attach requires writable --add-dir roots");
         }
@@ -139,7 +140,7 @@ function capabilityProbeSpecs(target) {
     return specs;
 }
 function configuredCapabilityIssues(target, config) {
-    const worker = config.workers[target.engine];
+    const worker = workerProvider(config, target.engine).config;
     const issues = [];
     if (target.surfaces.has("resume")
         && worker.nativeSession.enabled

package/dist/workers/live-probe.js

@@ -3,12 +3,13 @@ import { mkdir, mkdtemp, rm } from "node:fs/promises";
 import { join } from "node:path";
 import { ensureDir, readTextIfExists, writeText } from "../core/file-store.js";
 import { createWorkerRegistry, getAdapter } from "./registry.js";
+import { workerProvider } from "./provider.js";
 export async function runLiveAgentProbes(config, workspaceRoot, engines, options = {}) {
     const activeEngines = [...new Set(engines)];
     if (activeEngines.length === 0) {
         return {
             ok: true,
-            lines: ["agent live probe: skipped (no Codex or Claude workers active)"]
+            lines: ["agent live probe: skipped (no process Worker providers active)"]
         };
     }
     const probesRoot = join(workspaceRoot, config.dataDir, "probes");
@@ -39,7 +40,7 @@ export async function runLiveAgentProbes(config, workspaceRoot, engines, options
 }
 async function probeEngine(config, registry, engine, runRoot, nonce, timeoutOverride) {
     const startedAt = Date.now();
-    const worker = config.workers[engine];
+    const worker = workerProvider(config, engine).config;
     const adapter = getAdapter(registry, engine);
     const cwd = join(runRoot, `${engine}-workspace`);
     await mkdir(cwd, { recursive: true });
@@ -106,7 +107,7 @@ async function probeEngine(config, registry, engine, runRoot, nonce, timeoutOver
     };
 }
 async function probeSpec(input) {
-    const worker = input.config.workers[input.engine];
+    const worker = workerProvider(input.config, input.engine).config;
     await mkdir(input.dir, { recursive: true });
     const promptPath = join(input.dir, "prompt.md");
     await writeText(promptPath, `${input.challenge.prompt}\n`);

package/dist/workers/mock-adapter.js

@@ -11,11 +11,28 @@ export class MockWorkerAdapter {
         await setStatus(spec, "running", "mock-running", `${spec.role} mock worker running`, nativeSessionId);
         await appendText(spec.outputLogPath, `[mock:${spec.role}] started\n`);
         if (spec.role === "judge") {
-            await writeText(join(spec.filesDir, "requirements.md"), "# Requirements\n\n- [R-001] Mock requirements derived from the user request.\n");
-            await writeText(join(spec.filesDir, "plan.md"), "# Plan\n\n1. [P-001] Implement the scoped change.\n2. [P-002] Run focused verification.\n");
-            await writeText(join(spec.filesDir, "acceptance.md"), "# Acceptance\n\n- [A-001] [R-001] Focused tests pass for the requested behavior.\n");
-            await writeText(join(spec.filesDir, "actor-brief.md"), "# Actor Brief\n\nImplement the requested change and write a worklog.\n");
-            await writeText(join(spec.filesDir, "critic-brief.md"), "# Critic Brief\n\nReview the Actor output against acceptance criteria.\n");
+            if (spec.prompt.includes("# Role:") && spec.prompt.includes("· Final acceptance")) {
+                const criterionIds = promptJsonArray(spec.prompt, "Required acceptance criterion ids");
+                const changedPaths = promptJsonArray(spec.prompt, "Authoritative changed paths");
+                await writeJson(join(spec.filesDir, "final-acceptance.json"), {
+                    version: 1,
+                    decision: "approved",
+                    summary: "Mock Final Judge verified every acceptance criterion.",
+                    acceptance: criterionIds.map((criterionId) => ({
+                        criterion_id: criterionId,
+                        status: "passed",
+                        evidence: "Mock verification completed."
+                    })),
+                    changed_paths: changedPaths
+                });
+            }
+            else {
+                await writeText(join(spec.filesDir, "requirements.md"), "# Requirements\n\n- [R-001] Mock requirements derived from the user request.\n");
+                await writeText(join(spec.filesDir, "plan.md"), "# Plan\n\n1. [P-001] Implement the scoped change.\n2. [P-002] Run focused verification.\n");
+                await writeText(join(spec.filesDir, "acceptance.md"), "# Acceptance\n\n- [A-001] [R-001] Focused tests pass for the requested behavior.\n");
+                await writeText(join(spec.filesDir, "actor-brief.md"), "# Actor Brief\n\nImplement the requested change and write a worklog.\n");
+                await writeText(join(spec.filesDir, "critic-brief.md"), "# Critic Brief\n\nReview the Actor output against acceptance criteria.\n");
+            }
         }
         if (spec.role === "actor") {
             await writeText(join(spec.filesDir, "worklog.md"), "# Worklog\n\n- Mock actor completed the implementation.\n");
@@ -69,6 +86,19 @@ function featureDirFromPrompt(prompt) {
     const line = prompt.split("\n").find((item) => item.startsWith("Feature directory: "));
     return line ? line.replace("Feature directory: ", "").trim() : null;
 }
+function promptJsonArray(prompt, label) {
+    const line = prompt.split("\n").find((item) => item.startsWith(`${label}: `));
+    if (!line) {
+        return [];
+    }
+    try {
+        const value = JSON.parse(line.slice(label.length + 2));
+        return Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
+    }
+    catch {
+        return [];
+    }
+}
 async function setStatus(spec, state, phase, summary, nativeSessionId) {
     const status = {
         worker_id: spec.workerId,
@@ -76,6 +106,8 @@ async function setStatus(spec, state, phase, summary, nativeSessionId) {
         ...(spec.featureTitle ? { feature_title: spec.featureTitle } : {}),
         role: spec.role,
         engine: spec.engine,
+        ...(spec.modelConfig?.name.trim() ? { model_name: spec.modelConfig.name.trim() } : {}),
+        ...(spec.modelConfig?.provider.trim() ? { model_provider: spec.modelConfig.provider.trim() } : {}),
         state,
         phase,
         last_event_at: new Date().toISOString(),

package/dist/workers/native-attach.js

@@ -7,12 +7,26 @@ import { spawn } from "node-pty";
 import { pathExists, pathIsDirectory, readJson, readTextIfExists, removeIfExists, writeJson } from "../core/file-store.js";
 import { NativeSessionSchema, TaskMetaSchema } from "../domain/schemas.js";
 import { detectResumeSessionId } from "./native-session-detection.js";
+import { workerProvider } from "./provider.js";
 const require = createRequire(import.meta.url);
 export async function buildNativeAttachLaunch(input) {
-    const nativeSession = await readWorkerNativeSession(input.worker);
-    const workerConfig = input.config.workers[input.worker.engine];
+    return buildNativeSessionLaunch(input, "resume");
+}
+export async function buildNativeForkLaunch(input) {
+    return buildNativeSessionLaunch(input, "fork");
+}
+async function buildNativeSessionLaunch(input, mode) {
+    const workerConfig = workerProvider(input.config, input.worker.engine).config;
+    const nativeSession = await readWorkerNativeSession(input.worker, workerConfig.capabilities.profile);
     const modelConfig = workerConfig.model;
     const env = modelEnvironment(modelConfig);
+    const interactiveArgs = mode === "fork"
+        ? workerConfig.interactive.forkArgs
+        : workerConfig.interactive.args;
+    if (mode === "fork" && interactiveArgs.length === 0) {
+        throw new Error(`Native session fork is not configured for ${input.worker.engine}. `
+            + `Set workers.${input.worker.engine}.interactive.forkArgs with a {sessionId} template.`);
+    }
     const workerDir = dirname(input.worker.statusPath);
     const taskDir = dirname(workerDir);
     if (!(await pathExists(nativeSession.cwd))) {
@@ -34,16 +48,17 @@ export async function buildNativeAttachLaunch(input) {
         command: workerConfig.interactive.command,
         args: nativeAttachArgs({
             args: [
-                ...workerConfig.interactive.args,
+                ...interactiveArgs,
                 ...modelConfig.args
             ].map((arg) => renderTemplate(arg, nativeSession.session_id, modelConfig)),
+            providerId: input.worker.engine,
             capabilities: workerConfig.capabilities,
             additionalDirs
         }),
         ...(Object.keys(env).length > 0 ? { env } : {}),
         cwd: nativeSession.cwd,
         sessionId: nativeSession.session_id,
-        label: input.worker.label
+        label: mode === "fork" ? `${input.worker.label} · fork` : input.worker.label
     };
 }
 function nativeAttachArgs(input) {
@@ -51,18 +66,18 @@ function nativeAttachArgs(input) {
         return input.args;
     }
     const args = input.capabilities.profile === "codex"
-        ? withCodexWritableSandbox(input.args)
+        ? withCodexWritableSandbox(input.args, input.providerId)
         : input.args;
     return [
         ...args,
         ...[...new Set(input.additionalDirs)].flatMap((directory) => (input.capabilities.writableDirArgs.map((arg) => arg.replaceAll("{dir}", directory))))
     ];
 }
-function withCodexWritableSandbox(args) {
+function withCodexWritableSandbox(args, providerId) {
     const sandbox = codexSandboxSelection(args);
     if (sandbox === "read-only") {
         throw new Error("Codex native attach cannot use recorded worker directories with a read-only sandbox. "
-            + "Set workers.codex.interactive.args to workspace-write or danger-full-access.");
+            + `Set workers.${providerId}.interactive.args to workspace-write or danger-full-access.`);
     }
     return sandbox ? args : [...args, "--sandbox", "workspace-write"];
 }
@@ -144,17 +159,17 @@ function ensureNodePtySpawnHelperExecutable() {
         chmodSync(helperPath, 0o755);
     }
 }
-async function readWorkerNativeSession(worker) {
+async function readWorkerNativeSession(worker, profile) {
     const workerDir = dirname(worker.statusPath);
     const nativePath = join(workerDir, "native-session.json");
     const record = await readAttachNativeSessionIfValid(nativePath);
     if (!record) {
-        const recoveredCodex = await recoverCodexNativeSession(worker, workerDir);
+        const recoveredCodex = await recoverCodexNativeSession(worker, workerDir, profile);
         if (recoveredCodex) {
             await writeJson(nativePath, NativeSessionSchema.parse(recoveredCodex));
             return recoveredCodex;
         }
-        const recovered = await recoverClaudeNativeSession(worker, workerDir);
+        const recovered = await recoverClaudeNativeSession(worker, workerDir, profile);
         if (recovered) {
             await writeJson(nativePath, NativeSessionSchema.parse(recovered));
             return recovered;
@@ -181,8 +196,8 @@ async function readAttachNativeSessionIfValid(nativePath) {
         return null;
     }
 }
-async function recoverCodexNativeSession(worker, workerDir) {
-    if (worker.engine !== "codex") {
+async function recoverCodexNativeSession(worker, workerDir, profile) {
+    if (profile !== "codex") {
         return null;
     }
     const taskDir = dirname(workerDir);
@@ -197,7 +212,7 @@ async function recoverCodexNativeSession(worker, workerDir) {
     }
     const now = new Date().toISOString();
     return {
-        engine: "codex",
+        engine: worker.engine,
         role: worker.role,
         worker_id: worker.id,
         session_id: sessionId,
@@ -208,8 +223,8 @@ async function recoverCodexNativeSession(worker, workerDir) {
         source: "output-detected"
     };
 }
-async function recoverClaudeNativeSession(worker, workerDir) {
-    if (worker.engine !== "claude") {
+async function recoverClaudeNativeSession(worker, workerDir, profile) {
+    if (profile !== "claude") {
         return null;
     }
     const prompt = await readTextIfExists(join(workerDir, "prompt.md"));
@@ -229,7 +244,7 @@ async function recoverClaudeNativeSession(worker, workerDir) {
         return null;
     }
     return {
-        engine: "claude",
+        engine: worker.engine,
         role: worker.role,
         worker_id: worker.id,
         session_id: match.sessionId,
@@ -324,5 +339,5 @@ function renderTemplate(value, sessionId, modelConfig) {
         .replace(/\{env:([A-Za-z_][A-Za-z0-9_]*)\}/g, (_match, name) => process.env[name] ?? "");
 }
 export function supportsNativeAttach(engine) {
-    return engine === "codex" || engine === "claude" || engine === "mock";
+    return Boolean(engine);
 }

package/dist/workers/process-adapter.js

@@ -745,6 +745,8 @@ async function setStatus(spec, state, phase, summary, nativeSessionId) {
         ...(spec.featureTitle ? { feature_title: spec.featureTitle } : {}),
         role: spec.role,
         engine: spec.engine,
+        ...(spec.modelConfig?.name.trim() ? { model_name: spec.modelConfig.name.trim() } : {}),
+        ...(spec.modelConfig?.provider.trim() ? { model_provider: spec.modelConfig.provider.trim() } : {}),
         state,
         phase,
         last_event_at: new Date().toISOString(),

package/dist/workers/provider.js

@@ -0,0 +1,26 @@
+export function workerProvider(config, id) {
+    const provider = config.workers[id];
+    if (!provider) {
+        throw new Error(`Worker provider is not configured: ${id}`);
+    }
+    return { id, config: provider };
+}
+export function workerProviders(config) {
+    return Object.entries(config.workers)
+        .map(([id, provider]) => ({ id, config: provider }))
+        .sort((left, right) => left.id.localeCompare(right.id));
+}
+export function assignableWorkerProviderIds(config) {
+    return workerProviders(config)
+        .filter((provider) => provider.config.assignable)
+        .map((provider) => provider.id);
+}
+export function workerProviderLabel(config, id) {
+    const provider = config.workers[id];
+    if (!provider) {
+        return id;
+    }
+    const model = provider.model.name.trim();
+    const remote = provider.model.provider.trim();
+    return [id, model, remote].filter(Boolean).join("/");
+}

package/dist/workers/registry.js

@@ -1,29 +1,19 @@
 import { MockWorkerAdapter } from "./mock-adapter.js";
 import { ProcessWorkerAdapter } from "./process-adapter.js";
+import { workerProviders } from "./provider.js";
 export function createWorkerRegistry(config) {
-    return new Map([
-        ["mock", new MockWorkerAdapter()],
-        [
-            "codex",
-            new ProcessWorkerAdapter(config.workers.codex.command, config.workers.codex.args, "codex", {
-                timeoutMs: config.workers.codex.timeoutMs,
-                idleTimeoutMs: config.workers.codex.idleTimeoutMs,
-                firstOutputTimeoutMs: config.workers.codex.firstOutputTimeoutMs,
-                model: config.workers.codex.model,
-                capabilities: config.workers.codex.capabilities
+    return new Map(workerProviders(config).map(({ id, config: provider }) => [
+        id,
+        id === "mock"
+            ? new MockWorkerAdapter()
+            : new ProcessWorkerAdapter(provider.command, provider.args, id, {
+                timeoutMs: provider.timeoutMs,
+                idleTimeoutMs: provider.idleTimeoutMs,
+                firstOutputTimeoutMs: provider.firstOutputTimeoutMs,
+                model: provider.model,
+                capabilities: provider.capabilities
             })
-        ],
-        [
-            "claude",
-            new ProcessWorkerAdapter(config.workers.claude.command, config.workers.claude.args, "claude", {
-                timeoutMs: config.workers.claude.timeoutMs,
-                idleTimeoutMs: config.workers.claude.idleTimeoutMs,
-                firstOutputTimeoutMs: config.workers.claude.firstOutputTimeoutMs,
-                model: config.workers.claude.model,
-                capabilities: config.workers.claude.capabilities
-            })
-        ]
-    ]);
+    ]));
 }
 export function getAdapter(registry, engine) {
     const adapter = registry.get(engine);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "parallel-codex-tui",
-  "version": "0.1.4",
+  "version": "0.1.5",
   "description": "A TypeScript TUI wrapper for routed parallel coding with Codex and Claude workers.",
   "license": "MIT",
   "type": "module",
@@ -40,6 +40,7 @@
     "build": "tsc -p tsconfig.json",
     "postbuild": "node -e \"require('node:fs').chmodSync('dist/cli.js', 0o755)\"",
     "prepack": "npm run build",
+    "pretest": "node scripts/fix-node-pty-permissions.mjs",
     "verify:package": "node scripts/verify-package.mjs",
     "test": "vitest run",
     "test:watch": "vitest",
@@ -64,5 +65,10 @@
     "tsx": "^4.19.0",
     "typescript": "^5.8.0",
     "vitest": "^3.2.0"
+  },
+  "allowScripts": {
+    "esbuild@0.28.1": true,
+    "fsevents@2.3.3": true,
+    "node-pty@1.1.0": true
   }
 }