parallel-codex-tui 0.1.8 → 0.2.0

package/.parallel-codex/config.example.toml

@@ -32,6 +32,8 @@ fallback = "simple"
 maxParallelFeatures = 3
 # Maximum Actor/Critic revision rounds before the task is stopped for manual intervention (1..10).
 maxRevisionRounds = 3
+# Maximum automatic Judge DAG replans after isolated Feature merge conflicts (0..8).
+maxConflictReplans = 2
 
 [workers.codex]
 command = "codex"

package/README.md

@@ -6,22 +6,23 @@ Built with Codex-assisted development.
 
 ## Current Release
 
-`v0.1.8` is available from [npm](https://www.npmjs.com/package/parallel-codex-tui/v/0.1.8) and as a [GitHub Release](https://github.com/allendred/parallel-codex-tui/releases/tag/v0.1.8). It preserves the embedded native Agent scrollback when status details are opened and closed by skipping no-op xterm resizes, while still resizing both the screen and PTY after a real terminal size change.
+`v0.2.0` is available from [npm](https://www.npmjs.com/package/parallel-codex-tui/v/0.2.0) and as a [GitHub Release](https://github.com/allendred/parallel-codex-tui/releases/tag/v0.2.0). It adds automatic Judge-guided recovery for isolated Feature merge conflicts, a sanitized diagnostics bundle, longer restart soak coverage, and real multi-workspace Agent acceptance.
 
-The release retains the `v0.1.7` terminal behavior: it keeps terminal scrolling and copying available at the same time without requiring Shift. The outer TUI explicitly disables application mouse tracking, enters the alternate screen, and enables alternate scroll. Kitty and Zellij therefore keep ordinary left-drag selection while translating the wheel into cursor-scroll input for the active TUI view. `Ctrl+Y` remains an additional fallback that copies the visible chat, rendered Worker log, native Agent screen, or structured overview without changing terminal modes. Unicode text and Diff indentation are preserved.
+The release keeps terminal scrolling and copying available at the same time without requiring Shift. Ordinary left-drag selection remains owned by the terminal while alternate-scroll delivers the wheel to chat, Worker logs, and structured views. `Ctrl+Y` copies the visible view as a fallback. It preserves the embedded native Agent scrollback across status-detail round trips and real PTY resizes.
 
-The release also includes the stability, collaboration, session-management, Provider, TUI, and release work completed in `v0.1.5`:
+Highlights:
 
+- Judge produces validated requirements, acceptance criteria, and a dependency-aware Feature DAG. Actor/Critic pairs exchange checked JSONL findings and replies, followed by Wave Critic and final Judge acceptance.
+- A conflicting parallel wave is archived with its merge evidence and returned to the same Judge native session for a bounded DAG replan. The replacement plan must retain the same Feature IDs and serialize every conflicting pair; a deterministic serialized fallback is used when the Judge response is invalid.
+- Tasks retain every Turn, historical Worker log, native session binding, model snapshot, and collaboration artifact across follow-ups and restarts. A 20-turn soak verifies 80 ordered Workers before and after restart.
+- `--diagnostics` and `Ctrl+X` export bounded, redacted support evidence without prompts, role instructions, command arguments, source files, or environment-variable values.
 - Runtime preflight checks Codex, Claude, named third-party Providers, proxy reachability, workspace access, CLI capabilities, and native attach policy before work starts.
-- Judge produces validated requirements, acceptance criteria, and a dependency-aware Feature plan. Actor/Critic pairs exchange checked JSONL findings and replies across revision rounds, followed by Wave Critic and final Judge acceptance.
-- Tasks retain every Turn, Worker log, native session binding, model snapshot, and collaboration artifact across follow-ups and restarts. Sessions can be inspected, continued, forked, renamed, archived, exported, restored, or deleted from the TUI.
 - 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, status details, rendered Markdown/Diff/error logs, Unicode search, keyboard navigation, mouse scrolling, and configurable themes share one terminal UI system.
-- SQLite migrations and recovery backups, owned-process cleanup, ten-turn Worker-history recovery, packaged CLI installation, and cross-platform CI are covered by automated tests.
+- Worker overview, Feature board, collaboration timeline, Task center, 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. For `v0.1.8`, the persisted Tetris workspace was rechecked with 30 passing project tests, a passing browser smoke test, and a clean build. The repository suite passed 1,241 tests across 119 files, including PTY coverage for alternate-scroll delivery with every application mouse mode disabled and for preserving the native output tail across status-detail round trips. A local Zellij 0.44 probe confirmed that one wheel event becomes three cursor-up events while a left-button drag sends no mouse bytes to the app. The npm tarball was independently installed and returned `parallel-codex-tui 0.1.8`; its installed `node-pty` path also launched a child process successfully.
+Release acceptance includes a real three-Feature Tetris task with parallel Actor/Critic waves and final integration review. Real Codex and Claude probes both proved fresh and same-session resume calls, 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 and preserving the native output tail across status-detail round trips. The deterministic repository suite passed 1,256 tests across 122 files; one quota-consuming real-Agent test is skipped by default and passes through `npm run test:real-agents`.
 
-Real Provider probes still 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.
+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.
 
 ## Requirements
 
@@ -45,6 +46,8 @@ parallel-codex-tui --init
 parallel-codex-tui --doctor
 parallel-codex-tui --doctor --probe-agents
 parallel-codex-tui --doctor --probe-router
+parallel-codex-tui --diagnostics
+parallel-codex-tui --diagnostics ./support-bundle
 parallel-codex-tui --workspace /path/to/project
 parallel-codex-tui --theme aurora --workspace /path/to/project
 parallel-codex-tui --theme studio --workspace /path/to/project
@@ -85,11 +88,26 @@ parallel-codex-tui --help
 parallel-codex-tui --doctor
 parallel-codex-tui --doctor --probe-agents
 parallel-codex-tui --doctor --probe-router
+parallel-codex-tui --diagnostics
+parallel-codex-tui --diagnostics ./support-bundle
 parallel-codex-tui --version
 ```
 
 `--doctor` checks configured automated and interactive commands, `{env:NAME}` references, and the CLI help surfaces required for Codex exec/resume sandboxing and Claude print/resume permissions before workers start. Recognized standard CLI help that lacks a required option fails the check; an opaque wrapper keeps the compatible built-in profile's unverified warning, while an explicit `generic` capability contract is validated without guessing vendor-specific help. Doctor performs these checks for every named Worker Provider used by the active route, rejects an explicitly read-only Codex-compatible interactive sandbox when feature attach needs writable roots, and reminds you that native workspace trust remains an interactive decision. It reports proxy host/port reachability as a local-endpoint check, not as proof that the proxy upstream or model API is healthy. Add `--probe-agents` to make one minimal fresh request and, when configured, one same-session resume request through every active process Worker Provider. This explicit probe uses model quota, removes successful probe artifacts, preserves failed artifacts under `.parallel-codex/probes/`, and exits non-zero when a fresh or resumed request cannot be proven. Fresh sessions use the configured `freshSessionArgs`; Claude-compatible profiles default to a generated native `--session-id`, persisted only after the process emits output, so a silent failed launch cannot create a false resumable session. Add `--probe-router` to run one real classification through the configured Codex Router; the command exits non-zero when that live request falls back or fails. Doctor also reports the loaded TUI theme, core palette values, ANSI swatch previews, and color override values, including any temporary `--theme` override.
 
+## Diagnostics
+
+Export a support bundle without starting the TUI:
+
+```bash
+parallel-codex-tui --workspace /path/to/project --diagnostics
+parallel-codex-tui --workspace /path/to/project --diagnostics ./support-bundle
+```
+
+Without an explicit destination, the bundle is created under `.parallel-codex/diagnostics/<timestamp>/`. An explicit destination must not already exist. While the TUI is open, `Ctrl+X` creates the same bundle without interrupting chat, logs, Task center, or an active Worker; native attach keeps `Ctrl+X` available to the attached Agent.
+
+The bundle contains `manifest.json`, `report.md`, `report.json`, `doctor.txt`, `tasks.json`, `workers.json`, `router-audit.jsonl`, and bounded Worker log tails. It exports at most the latest 20 tasks, 200 Workers, 100 Router rows, and 200 lines or 64 KiB per Worker log. Workspace, app-root, and home paths are aliased; URL credentials and paths, authorization values, secret assignments, common token formats, and environment-variable values are redacted. Prompts, role instructions, command arguments, source files, and lifetime logs are excluded. Review the bundle before sharing it, because application output can still contain project-specific text that no automatic redactor can fully understand.
+
 ## Quick Start
 
 Create a local config in the app root:
@@ -128,12 +146,15 @@ Limit how many feature-level Actor or Critic agents may run at once:
 [orchestration]
 maxParallelFeatures = 3 # 1..8
 maxRevisionRounds = 3   # 1..10
+maxConflictReplans = 2  # 0..8
 ```
 
 Judge may plan up to eight dependency-aware features. The orchestrator keeps dependency order while running at most this many agents concurrently. When one worker fails, already-running peers are allowed to finish cleanly and queued features are not started.
 
 Actor and Critic reuse their native sessions across revision rounds. Blocking findings and Actor replies remain in the Feature JSONL mailbox; the task stops with an explicit error when `maxRevisionRounds` is exhausted.
 
+When isolated Features conflict during wave staging, `maxConflictReplans` controls how many times the same Judge native session may replace the remaining dependency DAG. Conflict evidence and every Judge response are archived under the turn workspace. Completed earlier waves remain integrated; only the conflicting and later waves are discarded and rerun. Old configs inherit the default value `2`, so no SQLite migration is required, but adding the field makes the policy explicit.
+
 Queued Feature workers remain `queued` until they acquire a concurrency slot. Their persisted state changes to `actor_running` or `critic_running` only after the Worker is registered as cancellable, then to `actor_done` or `critic_done` before that active registration is removed. As a result, only `actor_running` and `critic_running` expose Feature cancellation; queued and role-complete Features cannot present a cancel action that has no live process behind it.
 
 ## Theme
@@ -208,7 +229,7 @@ The doctor output includes `preview:` and `semantic:` ANSI swatch rows so you ca
 - Every staged wave gets a combined Wave Critic run in a disposable verification copy. It checks the full Judge acceptance criteria, cross-feature behavior, tests, and builds. A missing `APPROVED`/`REVISION_REQUIRED` decision fails safely instead of being treated as approval.
 - When combined verification requests changes, a session-backed Wave Actor fixes the integration workspace and the same Wave Critic native session reviews it again. Only an explicit final `APPROVED` allows the wave to reach the live workspace.
 - Wave Actor/Critic prompts, logs, immutable `verification-review-01.md`/`02.md` rounds, native session ids, minimized additional-directory permissions, and `verification.json` audit evidence are stored with the task and remain available through worker logs and native attach.
-- Overlapping edits fail the task without partially changing the live workspace. The chat error names the conflicting paths and points to marker files under the wave's `conflicts/` directory; `Ctrl+R` retries in the same task and native worker sessions.
+- Overlapping edits never partially change the live workspace. The orchestrator archives the conflicting paths and merge evidence, returns to `judging`, and asks the same Judge native session to serialize the affected Feature DAG. The replanned run keeps integrated earlier waves and every historical Worker log. If the bounded replan budget is exhausted or the replacement plan is invalid, the task fails with the evidence path and remains retryable through `Ctrl+R`.
 - If the live workspace changes after a wave baseline is captured, staging or commit stops with the changed paths instead of silently absorbing an escaped worker edit or overwriting concurrent user work.
 - Feature workspaces persist with the task so native attach can reopen the exact worker cwd. Delete an old task session when its audit trail and attachable workspaces are no longer needed.
 - Complex follow-ups stay in the active task, append a numbered turn, restore the same Judge session to re-clarify the new direction, and save a turn-local Judge snapshot. A new multi-feature plan can start parallel workers immediately.
@@ -227,7 +248,7 @@ The doctor output includes `preview:` and `semantic:` ANSI swatch rows so you ca
 - Terminal completion is evidence-guarded. The latest `supervisor-summary.md`, feature `decisions.md`, and approved feature states are published before task status can become `done`; duplicate task and feature state writes are idempotent, every real task transition records its `from` and `to` state, and a complete `done` task cannot regress unless a new follow-up turn has first been created. Each committed task state change carries a unique transition marker in `meta.json`; same-process retries repair missing projections immediately, and startup repairs a missing event or SQLite projection from that marker before another transition can replace it. Startup also audits legacy `done` tasks that have an integrated latest-turn checkpoint: missing summaries or unfinished feature states are recovered to `cancelled`, then `Ctrl+R` rebuilds final evidence without rerunning completed workers. Legacy log-only `done` sessions without integration proof remain untouched.
 - Simple follow-up questions run through the persistent Main native session with the active task directory, original request, up to five recent turn summaries, valid worker statuses, and log tails as file-backed context. They hold the active task lease while committing the route, taking that context snapshot, and running Main, so the answer cannot race an in-progress complex turn. A failed or cancelled Main answer replaces the transient `running` state with its real terminal state and releases both task and Main leases, so the next question can proceed. They do not start another Judge, Actor, or Critic turn.
 - Worker prompts, logs, status, and outputs are written to disk.
-- The bottom status line shows the active task state and feature progress such as `wave 1/2 · actor 2/3`, `wave 1/2 · integration 0/1`, and `wave 1/2 · verification 0/1`. While classification is running, it follows the real subprocess through `starting`, `waiting output`, `diagnostics`, `receiving`, `parsing`, and `stopping`, keeps live elapsed/limit progress, identifies a non-default Router runner, and identifies the path as `direct` or `via <proxy-host:port>`. Before output arrives it shows the active first-output deadline and total ceiling; after activity begins it shows total elapsed progress and the idle watchdog. As soon as a fresh initial or follow-up route settles, chat temporarily inserts a themed route rail with `route · <mode> · <source>` followed by the indented Router reason before Main or parallel execution finishes, then replaces it with the final answer or error without adding noise to persisted chat history. Task retry restores its saved route without announcing it as a new Router decision. The status line then replaces the wait state with the final route source, duration, or fallback cause.
+- The bottom status line shows the active task state and feature progress such as `wave 1/2 · actor 2/3`, `wave 1/2 · integration 0/1`, and `wave 1/2 · verification 0/1`. Chat, Worker logs, status details, and native attach derive this summary from the same persisted runtime snapshot, so changing views does not rename or reorder task state. While classification is running, it follows the real subprocess through `starting`, `waiting output`, `diagnostics`, `receiving`, `parsing`, and `stopping`, keeps live elapsed/limit progress, identifies a non-default Router runner, and identifies the path as `direct` or `via <proxy-host:port>`. Before output arrives it shows the active first-output deadline and total ceiling; after activity begins it shows total elapsed progress and the idle watchdog. As soon as a fresh initial or follow-up route settles, chat temporarily inserts a themed route rail with `route · <mode> · <source>` followed by the indented Router reason before Main or parallel execution finishes, then replaces it with the final answer or error without adding noise to persisted chat history. Task retry restores its saved route without announcing it as a new Router decision. The status line then replaces the wait state with the final route source, duration, or fallback cause.
 - Completed complex tasks open as a structured result at the top of the chat viewport. Requirements, the complete bounded Actor worklog, authoritative integrated changed paths, Critic review, verification evidence, and findings render as themed full-width sections instead of losing everything after each section's first line. Changed files come from the workspace integration result rather than an Actor claim; verification keeps the Critic decision and reported test/build evidence. Multi-feature delivery uses the same result protocol and includes combined Wave verification. Long results start at the title and scroll toward findings; `Ctrl+D` toggles the focused result between full detail and its five-line compact summary, and beginning the next message collapses it automatically. Result lookup follows the persisted task id, so restoring one task cannot display another task's result. Empty state and ordinary short chat remain adjacent to the input.
 - Restarting an existing task restores the latest persisted route evidence in the bottom status line, including fallback cause and duration. Follow-up Router classification has no task-side effects: it records the attempt in shared `routes.jsonl`, then a complex turn or simple question refreshes `sessions/<task>/latest-route.json` only after acquiring the task lease. A conflicting TUI leaves the previous committed route and turn files untouched. A corrupt latest-route record safely falls back to the latest worker turn and then the task's initial route record.
 - Task session ids are single `task-...` path segments. CLI `--task` input, persisted metadata, startup scanning, and SQLite rebuilding reject path separators and ignore a task whose `meta.json` id differs from its directory, so restoring a session cannot escape or alias the workspace session root.
@@ -451,6 +472,31 @@ In chat or worker-log views, press `Ctrl+O` to attach to the selected worker's n
 
 If a native resume fails because the underlying CLI reports that its context window is full, configure `fallback = "new"` under `[workers.<engine>.nativeSession]`. The old native session is archived as `native-session.retired.json`, removed from active use, and the worker is retried once with the normal fresh-session command. A valid retirement tombstone is also a cross-turn inheritance barrier: a retry or later turn cannot resurrect the same session from an older worker copy, while a newer replacement session remains reusable. A `process-cleanup-error` or `process-ownership-error` always blocks native-session fallback, even when the CLI output also mentions a full context window, so a fresh Worker cannot overlap an untracked or still-running resume process.
 
+## Testing
+
+Run the deterministic release checks from a source checkout:
+
+```bash
+npm test
+npm run test:stability
+npm run test:terminal-hosts
+npm run typecheck
+npm run build
+npm run verify:package
+```
+
+`test:stability` covers 20 same-task turns, 80 historical Workers, restart recovery, workspace switching, orphan cleanup, and interrupted startup. `test:terminal-hosts` uses real PTYs and exercises Apple Terminal, tmux, and Zellij profiles when those hosts are installed; unsupported hosts are reported as skipped.
+
+Real Agent acceptance is deliberately opt-in because it uses model quota and local credentials:
+
+```bash
+HTTP_PROXY=http://127.0.0.1:7890 \
+HTTPS_PROXY=http://127.0.0.1:7890 \
+npm run test:real-agents
+```
+
+The test performs real Main calls in two temporary workspaces through one running TUI, switches back, and verifies that each persisted `chat.jsonl` contains only its own response. Configure the corresponding Worker environment in local `config.toml` when the CLI does not inherit process proxy variables.
+
 ## Release
 
 GitHub Actions runs CI on Ubuntu with Node.js 24.15 and 26, plus macOS with Node.js 24.15, for pushes and pull requests to `main`. Every job also packs the release artifact, installs that tarball into a clean global prefix, and executes the installed `--version` and `--help` entrypoints.
@@ -470,12 +516,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.1.8
+VERSION=0.2.0
 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.1.8` requires tag `v0.1.8`. Published tags such as `v0.1.7` 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.2.0` requires tag `v0.2.0`. Published tags such as `v0.1.8` are immutable and must not be moved or reused.
 
 ## Publishing Hygiene
 
@@ -483,4 +529,6 @@ You can also run the Release workflow manually and enter the same tag value. The
 - `.parallel-codex/last-workspace` and `.parallel-codex/workspaces.json` are local workspace-selection state and are ignored.
 - `.parallel-codex/router/` contains local request classification audit records and is ignored.
 - `.parallel-codex/sessions/` contains the workspace chat transcript, task prompts, logs, native session ids, isolated feature workspaces, and conflict evidence; never commit it.
+- `.parallel-codex/diagnostics/` contains redacted support bundles and is ignored; review a bundle before sharing it.
+- `.parallel-codex/probes/` contains failed live Agent probe evidence and is ignored.
 - `docs/superpowers/` contains internal planning notes and is ignored for public releases.

package/dist/cli-args.js

@@ -2,7 +2,7 @@ import { resolve } from "node:path";
 import { homedir } from "node:os";
 import { normalizeTuiThemeName, TUI_THEME_NAMES } from "./tui/theme.js";
 import { TaskIdSchema } from "./domain/schemas.js";
-const allowedValueOptions = new Set(["--app-root", "--workspace", "-w", "--task", "-t", "--theme"]);
+const allowedValueOptions = new Set(["--app-root", "--workspace", "-w", "--task", "-t", "--theme", "--diagnostics"]);
 const allowedBooleanOptions = new Set(["--doctor", "--help", "-h", "--init", "--probe-agents", "--probe-router", "--themes", "--version", "-v"]);
 export function parseCliArgs(args, cwd) {
     const optionArgs = argsBeforeTerminator(args);
@@ -10,6 +10,8 @@ export function parseCliArgs(args, cwd) {
     const workspaceFlagIndex = lastFlagIndex(optionArgs, (arg) => arg === "--workspace" || arg.startsWith("--workspace=") || arg === "-w" || arg.startsWith("-w="));
     const taskFlagIndex = lastFlagIndex(optionArgs, (arg) => arg === "--task" || arg.startsWith("--task=") || arg === "-t" || arg.startsWith("-t="));
     const themeFlagIndex = lastFlagIndex(optionArgs, (arg) => arg === "--theme" || arg.startsWith("--theme="));
+    const diagnosticsFlagIndex = lastFlagIndex(optionArgs, (arg) => arg === "--diagnostics" || arg.startsWith("--diagnostics="));
+    const diagnostics = diagnosticsFlagIndex >= 0;
     const doctor = optionArgs.includes("--doctor");
     const help = optionArgs.includes("--help") || optionArgs.includes("-h");
     const init = optionArgs.includes("--init");
@@ -23,8 +25,12 @@ export function parseCliArgs(args, cwd) {
     const workspaceRoot = explicitWorkspace ? resolvePathArg(cwd, explicitWorkspace) : cwd;
     const taskId = flagValue(optionArgs, taskFlagIndex);
     const theme = cliThemeValue(flagValue(optionArgs, themeFlagIndex));
+    const diagnosticsValue = flagValue(optionArgs, diagnosticsFlagIndex);
+    const diagnosticsPath = diagnosticsValue ? resolvePathArg(cwd, diagnosticsValue) : null;
     return {
         appRoot,
+        diagnostics,
+        diagnosticsPath,
         doctor,
         explicitWorkspace,
         help,

package/dist/cli-help.js

@@ -10,6 +10,7 @@ Options:
       --themes            List built-in TUI theme palettes; combine with --theme to filter
       --init              Write .parallel-codex/config.toml if missing
       --doctor            Check config, agent commands, and theme palette preview
+      --diagnostics [dir] Export a sanitized support bundle; defaults inside the workspace
       --probe-agents      With --doctor, run fresh + resume probes (uses model quota)
       --probe-router      With --doctor, run one live Codex Router request
   -v, --version           Print the current version

package/dist/cli.js

@@ -14,6 +14,7 @@ import { prepareAppRoot } from "./core/app-root.js";
 import { formatConfigErrorMessage } from "./core/config-errors.js";
 import { configPath, loadConfig, withUiThemeOverride, writeDefaultConfig } from "./core/config.js";
 import { pathExists } from "./core/file-store.js";
+import { exportDiagnostics } from "./core/diagnostics.js";
 import { readRouterAudit } from "./core/router-audit.js";
 import { loadTaskSessionDetails as loadPersistedTaskSessionDetails } from "./core/task-session-details.js";
 import { listWorkspaceChoices } from "./core/workspace.js";
@@ -67,6 +68,24 @@ async function main() {
         process.stdout.write(result.text);
         process.exitCode = result.ok ? 0 : 1;
     }
+    else if (cliArgs.diagnostics) {
+        const workspaceRoot = await selectWorkspaceForCli({
+            appRoot: cliArgs.appRoot,
+            cwd: process.cwd(),
+            explicitWorkspace: cliArgs.explicitWorkspace,
+            interactive: false
+        });
+        const runtime = await createRuntime(cliArgs.appRoot, workspaceRoot);
+        try {
+            const result = await exportDiagnostics(cliArgs.appRoot, runtime, {
+                destinationPath: cliArgs.diagnosticsPath
+            });
+            console.log(`Diagnostics exported: ${result.path}`);
+        }
+        finally {
+            runtime.index.close();
+        }
+    }
     else if (cliArgs.init) {
         if (await pathExists(localConfigPath)) {
             console.log(`Config already exists: ${localConfigPath}`);
@@ -114,7 +133,7 @@ async function main() {
                 await state.runtime.sessions.setTaskArchived(taskId, archived);
             }, deleteTaskSession: async (taskId) => {
                 await state.runtime.sessions.deleteTask(taskId);
-            }, exportTaskSession: async (taskId) => (await state.runtime.sessions.exportTask(taskId)).path, loadCollaborationTimeline: (taskId) => state.runtime.sessions.readCollaborationTimeline(taskId), activateTaskSession: async (taskId) => {
+            }, exportTaskSession: async (taskId) => (await state.runtime.sessions.exportTask(taskId)).path, exportDiagnostics: async () => (await exportDiagnostics(cliArgs.appRoot, state.runtime)).path, loadCollaborationTimeline: (taskId) => state.runtime.sessions.readCollaborationTimeline(taskId), activateTaskSession: async (taskId) => {
                 if (!taskId) {
                     await state.runtime.index.setActiveTaskId(null);
                     return null;

package/dist/core/config.js

@@ -86,7 +86,8 @@ const CodexRouterConfigSchema = z.object({
 });
 const OrchestrationConfigSchema = z.object({
     maxParallelFeatures: z.number().int().min(1).max(8),
-    maxRevisionRounds: z.number().int().min(1).max(10)
+    maxRevisionRounds: z.number().int().min(1).max(10),
+    maxConflictReplans: z.number().int().min(0).max(8)
 }).strict();
 const UiConfigSchema = z.object({
     showStatusBar: z.boolean(),
@@ -177,7 +178,8 @@ export function defaultConfig(projectRoot) {
         },
         orchestration: {
             maxParallelFeatures: 3,
-            maxRevisionRounds: 3
+            maxRevisionRounds: 3,
+            maxConflictReplans: 2
         },
         workers: {
             codex: {

package/dist/core/diagnostics.js

@@ -0,0 +1,394 @@
+import { open, mkdtemp, rename, rm } from "node:fs/promises";
+import { homedir, platform, arch } from "node:os";
+import { basename, dirname, join } from "node:path";
+import { runDoctor } from "../doctor.js";
+import { version } from "../version.js";
+import { NativeSessionSchema } from "../domain/schemas.js";
+import { ensureDir, pathExists, readJson, writeJson, writeText } from "./file-store.js";
+import { readRouterAudit } from "./router-audit.js";
+import { sanitizeRouterText } from "./router-redaction.js";
+const DIAGNOSTICS_FORMAT = "parallel-codex-diagnostics-v1";
+const DEFAULT_TASK_LIMIT = 20;
+const DEFAULT_WORKER_LIMIT = 200;
+const DEFAULT_ROUTER_RECORD_LIMIT = 100;
+const DEFAULT_LOG_BYTES = 64 * 1024;
+const DEFAULT_LOG_LINES = 200;
+export async function exportDiagnostics(appRoot, runtime, options = {}) {
+    const now = options.now ?? (() => new Date());
+    const createdAt = now().toISOString();
+    const context = diagnosticsTextContext(appRoot, runtime.workspaceRoot);
+    const taskLimit = boundedLimit(options.taskLimit, DEFAULT_TASK_LIMIT, 100);
+    const workerLimit = boundedLimit(options.workerLimit, DEFAULT_WORKER_LIMIT, 1000);
+    const routerRecordLimit = boundedLimit(options.routerRecordLimit, DEFAULT_ROUTER_RECORD_LIMIT, 500);
+    const logBytes = boundedLimit(options.logBytes, DEFAULT_LOG_BYTES, 1024 * 1024);
+    const logLines = boundedLimit(options.logLines, DEFAULT_LOG_LINES, 2000);
+    const destination = await diagnosticsDestination(runtime, options.destinationPath ?? null, createdAt);
+    const stagingParent = dirname(destination);
+    await ensureDir(stagingParent);
+    if (await pathExists(destination)) {
+        throw new Error(`Diagnostics destination already exists: ${destination}`);
+    }
+    const staging = await mkdtemp(join(stagingParent, ".parallel-codex-diagnostics-"));
+    try {
+        const [activeTaskId, tasks, routerAudit, doctor] = await Promise.all([
+            runtime.index.activeTaskId(),
+            runtime.index.listTasks(taskLimit, { includeArchived: true }),
+            readRouterAudit(join(runtime.routerCwd, "routes.jsonl"), routerRecordLimit),
+            options.doctor
+                ? options.doctor()
+                : runDoctor(appRoot, runtime.workspaceRoot, options.env ?? process.env)
+        ]);
+        const workerRecords = [];
+        let omittedWorkers = 0;
+        for (let taskIndex = 0; taskIndex < tasks.length; taskIndex += 1) {
+            const task = tasks[taskIndex];
+            if (!task) {
+                continue;
+            }
+            const taskWorkers = await runtime.orchestrator.listTaskWorkers(task.id);
+            const remaining = Math.max(0, workerLimit - workerRecords.length);
+            const selected = taskWorkers.length <= remaining
+                ? taskWorkers
+                : latestWorkers(taskWorkers, remaining);
+            omittedWorkers += taskWorkers.length - selected.length;
+            for (const worker of selected) {
+                workerRecords.push(await exportWorkerLog(staging, task.id, worker, context, logBytes, logLines));
+            }
+            if (workerRecords.length >= workerLimit) {
+                omittedWorkers += tasks
+                    .slice(taskIndex + 1)
+                    .reduce((total, remainingTask) => total + remainingTask.workerCount, 0);
+                break;
+            }
+        }
+        const safeTasks = sanitizeDiagnosticsValue(tasks, context);
+        const safeWorkers = sanitizeDiagnosticsValue(workerRecords, context);
+        const safeRouterAudit = sanitizeDiagnosticsValue(routerAudit, context);
+        const safeDoctorText = sanitizeDiagnosticsText(doctor.text, context);
+        const config = diagnosticsConfigSummary(runtime.config, options.env ?? process.env, context);
+        const report = {
+            format: DIAGNOSTICS_FORMAT,
+            createdAt,
+            app: {
+                name: "parallel-codex-tui",
+                version,
+                node: process.versions.node,
+                platform: platform(),
+                arch: arch()
+            },
+            workspace: "$WORKSPACE",
+            appRoot: appRoot === runtime.workspaceRoot ? "$WORKSPACE" : "$APP_ROOT",
+            sessionIndex: {
+                schemaVersion: runtime.index.schemaVersion(),
+                recovery: sanitizeDiagnosticsValue(runtime.index.recovery, context),
+                activeTaskId: activeTaskId ?? null
+            },
+            startupRecovery: sanitizeDiagnosticsValue({
+                pendingTaskCreations: runtime.pendingTaskCreations,
+                workspaceCommitRecovery: runtime.workspaceCommitRecovery,
+                recoveredTasks: runtime.recoveredTasks
+            }, context),
+            config,
+            doctor: {
+                ok: doctor.ok,
+                path: "doctor.txt"
+            },
+            tasks: {
+                path: "tasks.json",
+                exported: tasks.length,
+                limit: taskLimit
+            },
+            workers: {
+                path: "workers.json",
+                exported: workerRecords.length,
+                omitted: omittedWorkers,
+                limit: workerLimit
+            },
+            routerAudit: {
+                path: "router-audit.jsonl",
+                exported: routerAudit.length,
+                limit: routerRecordLimit
+            },
+            logs: {
+                exported: workerRecords.filter((worker) => worker.log).length,
+                maxBytesPerWorker: logBytes,
+                maxLinesPerWorker: logLines
+            }
+        };
+        await writeJson(join(staging, "report.json"), report);
+        await writeJson(join(staging, "tasks.json"), safeTasks);
+        await writeJson(join(staging, "workers.json"), safeWorkers);
+        await writeText(join(staging, "doctor.txt"), ensureTrailingNewline(safeDoctorText));
+        await writeText(join(staging, "router-audit.jsonl"), safeRouterAudit.map((record) => JSON.stringify(record)).join("\n") + (safeRouterAudit.length > 0 ? "\n" : ""));
+        await writeText(join(staging, "report.md"), diagnosticsMarkdownReport(report, config));
+        await writeJson(join(staging, "manifest.json"), {
+            format: DIAGNOSTICS_FORMAT,
+            created_at: createdAt,
+            report: "report.json",
+            redaction: {
+                enabled: true,
+                pathAliases: ["$WORKSPACE", "$APP_ROOT", "~"],
+                secrets: "URL credentials and paths, authorization values, secret assignments, and common raw token formats",
+                configValues: "Environment variable values, prompts, role instructions, command arguments, and source files are excluded",
+                logs: `Only the latest ${logLines} lines and ${logBytes} bytes per Worker are eligible for export`
+            }
+        });
+        await rename(staging, destination);
+        return {
+            path: destination,
+            createdAt,
+            taskCount: tasks.length,
+            workerCount: workerRecords.length,
+            logCount: workerRecords.filter((worker) => worker.log).length
+        };
+    }
+    catch (error) {
+        await rm(staging, { force: true, recursive: true });
+        throw error;
+    }
+}
+async function diagnosticsDestination(runtime, requested, createdAt) {
+    if (requested) {
+        return requested;
+    }
+    const root = join(runtime.workspaceRoot, runtime.config.dataDir, "diagnostics");
+    await ensureDir(root);
+    const stamp = createdAt.replace(/[^0-9]/g, "").slice(0, 14);
+    let destination = join(root, stamp);
+    for (let suffix = 2; await pathExists(destination); suffix += 1) {
+        destination = join(root, `${stamp}-${suffix}`);
+    }
+    return destination;
+}
+async function exportWorkerLog(staging, taskId, worker, context, maxBytes, maxLines) {
+    const workerSegment = safePathSegment(worker.id);
+    const relativeLogPath = join("logs", safePathSegment(taskId), `${workerSegment}.log`);
+    const tail = await readBoundedTextTail(worker.logPath, maxBytes, maxLines);
+    if (tail) {
+        await writeText(join(staging, relativeLogPath), ensureTrailingNewline(sanitizeDiagnosticsText(tail.text, context)));
+    }
+    return {
+        taskId,
+        id: worker.id,
+        ...(worker.featureId ? { featureId: worker.featureId } : {}),
+        role: worker.role,
+        engine: worker.engine,
+        label: sanitizeDiagnosticsText(worker.label, context),
+        status: worker.runtimeStatus
+            ? sanitizeDiagnosticsValue(worker.runtimeStatus, context)
+            : null,
+        nativeSession: await readNativeSession(worker),
+        log: tail
+            ? {
+                path: relativeLogPath,
+                sourceBytes: tail.sourceBytes,
+                exportedBytes: Buffer.byteLength(sanitizeDiagnosticsText(tail.text, context), "utf8"),
+                exportedLines: tail.text.split("\n").length,
+                truncated: tail.truncated
+            }
+            : null
+    };
+}
+async function readNativeSession(worker) {
+    try {
+        return await readJson(join(dirname(worker.statusPath), "native-session.json"), NativeSessionSchema);
+    }
+    catch (error) {
+        if (error.code === "ENOENT") {
+            return null;
+        }
+        return null;
+    }
+}
+async function readBoundedTextTail(path, maxBytes, maxLines) {
+    let handle;
+    try {
+        handle = await open(path, "r");
+    }
+    catch (error) {
+        if (error.code === "ENOENT") {
+            return null;
+        }
+        throw error;
+    }
+    try {
+        const sourceBytes = (await handle.stat()).size;
+        const requested = Math.min(sourceBytes, maxBytes);
+        const start = Math.max(0, sourceBytes - requested);
+        const buffer = Buffer.alloc(requested);
+        const { bytesRead } = await handle.read(buffer, 0, requested, start);
+        let text = buffer.subarray(0, bytesRead).toString("utf8");
+        let truncated = start > 0;
+        if (start > 0) {
+            const firstNewline = text.indexOf("\n");
+            if (firstNewline >= 0) {
+                text = text.slice(firstNewline + 1);
+            }
+        }
+        const lines = text.split("\n");
+        if (lines.length > maxLines) {
+            text = lines.slice(-maxLines).join("\n");
+            truncated = true;
+        }
+        if (truncated) {
+            text = `[earlier log content omitted]\n${text}`;
+        }
+        return { text, sourceBytes, truncated };
+    }
+    finally {
+        await handle.close();
+    }
+}
+function diagnosticsConfigSummary(config, env, context) {
+    return {
+        dataDir: sanitizeDiagnosticsText(config.dataDir, context),
+        router: {
+            mode: config.router.defaultMode,
+            command: commandName(config.router.codex.command),
+            argumentCount: config.router.codex.args.length,
+            timeoutMs: config.router.codex.timeoutMs,
+            firstOutputTimeoutMs: config.router.codex.firstOutputTimeoutMs,
+            idleTimeoutMs: config.router.codex.idleTimeoutMs,
+            followUpTimeoutMs: config.router.codex.followUpTimeoutMs,
+            maxOutputBytes: config.router.codex.maxOutputBytes,
+            maxAttempts: config.router.codex.maxAttempts,
+            retryDelayMs: config.router.codex.retryDelayMs,
+            fallback: config.router.codex.fallback,
+            environment: environmentSummary(config.router.codex.env, env),
+            proxyVariables: proxyVariableNames(config.router.codex.env)
+        },
+        orchestration: config.orchestration,
+        pairing: config.pairing,
+        providers: Object.entries(config.workers).map(([id, worker]) => ({
+            id,
+            command: commandName(worker.command),
+            interactiveCommand: commandName(worker.interactive.command),
+            argumentCount: worker.args.length,
+            assignable: worker.assignable,
+            model: sanitizeDiagnosticsText(worker.model.name || "default", context),
+            modelProvider: sanitizeDiagnosticsText(worker.model.provider || "default", context),
+            modelArgumentCount: worker.model.args.length,
+            environment: environmentSummary(worker.model.env, env),
+            proxyVariables: proxyVariableNames(worker.model.env),
+            capabilities: {
+                profile: worker.capabilities.profile,
+                writableDirectoryArguments: worker.capabilities.writableDirArgs.length > 0,
+                freshSessionArguments: worker.capabilities.freshSessionArgs.length > 0
+            },
+            nativeSession: {
+                enabled: worker.nativeSession.enabled,
+                detectSessionId: worker.nativeSession.detectSessionId,
+                fallback: worker.nativeSession.fallback,
+                resumeArgumentCount: worker.nativeSession.resumeArgs.length,
+                forkSupported: worker.interactive.forkArgs.length > 0
+            },
+            timeouts: {
+                totalMs: worker.timeoutMs ?? null,
+                firstOutputMs: worker.firstOutputTimeoutMs ?? null,
+                idleMs: worker.idleTimeoutMs ?? null
+            }
+        })),
+        ui: {
+            theme: config.ui.theme,
+            showStatusBar: config.ui.showStatusBar,
+            autoOpenFailedWorker: config.ui.autoOpenFailedWorker,
+            colorOverrides: Object.keys(config.ui.colors).sort()
+        }
+    };
+}
+function diagnosticsMarkdownReport(report, config) {
+    const providers = config.providers
+        .map((provider) => `- ${provider.id}: ${provider.command} · ${provider.modelProvider}/${provider.model}`)
+        .join("\n");
+    return `# parallel-codex-tui diagnostics
+
+- Created: ${report.createdAt}
+- Version: ${report.app.version}
+- Runtime: Node ${report.app.node} · ${report.app.platform}/${report.app.arch}
+- Workspace: ${report.workspace}
+- Active task: ${report.sessionIndex.activeTaskId ?? "none"}
+- Doctor: ${report.doctor.ok ? "ok" : "needs attention"}
+- Tasks: ${report.tasks.exported}
+- Workers: ${report.workers.exported}${report.workers.omitted ? ` (${report.workers.omitted} omitted by limit)` : ""}
+- Logs: ${report.logs.exported} bounded tails
+- Router audit rows: ${report.routerAudit.exported}
+
+## Providers
+
+${providers || "- none"}
+
+## Privacy
+
+This bundle is sanitized. It excludes environment values, prompts, role instructions, command arguments, source files, and complete lifetime logs. Review the bundle before sharing it.
+`;
+}
+function diagnosticsTextContext(appRoot, workspaceRoot) {
+    return {
+        aliases: [
+            { path: workspaceRoot, alias: "$WORKSPACE" },
+            { path: appRoot, alias: "$APP_ROOT" },
+            { path: homedir(), alias: "~" }
+        ]
+            .filter(({ path }) => path.length > 1)
+            .sort((left, right) => right.path.length - left.path.length)
+    };
+}
+export function sanitizeDiagnosticsText(value, context) {
+    let sanitized = sanitizeRouterText(value);
+    for (const entry of context.aliases) {
+        sanitized = sanitized.split(entry.path).join(entry.alias);
+    }
+    return sanitized;
+}
+function sanitizeDiagnosticsValue(value, context) {
+    if (typeof value === "string") {
+        return sanitizeDiagnosticsText(value, context);
+    }
+    if (Array.isArray(value)) {
+        return value.map((entry) => sanitizeDiagnosticsValue(entry, context));
+    }
+    if (value && typeof value === "object") {
+        return Object.fromEntries(Object.entries(value).map(([key, entry]) => [
+            key,
+            sanitizeDiagnosticsValue(entry, context)
+        ]));
+    }
+    return value;
+}
+function environmentSummary(values, env) {
+    return Object.entries(values).map(([name, value]) => ({
+        name,
+        configured: true,
+        referencedVariables: [...value.matchAll(/\$\{([A-Z_][A-Z0-9_]*)\}/gi)].map((match) => ({
+            name: match[1] ?? "",
+            present: Boolean(env[match[1] ?? ""])
+        }))
+    }));
+}
+function proxyVariableNames(values) {
+    return Object.keys(values).filter((name) => /^(?:HTTP|HTTPS|ALL)_PROXY$/i.test(name)).sort();
+}
+function commandName(command) {
+    return basename(command) || command;
+}
+function latestWorkers(workers, limit) {
+    if (limit <= 0) {
+        return [];
+    }
+    return [...workers]
+        .sort((left, right) => ((right.runtimeStatus?.last_event_at ?? "").localeCompare(left.runtimeStatus?.last_event_at ?? "")
+        || right.id.localeCompare(left.id)))
+        .slice(0, limit);
+}
+function safePathSegment(value) {
+    return value.replace(/[^A-Za-z0-9._-]+/g, "_").slice(0, 180) || "unknown";
+}
+function boundedLimit(value, fallback, maximum) {
+    if (!Number.isFinite(value)) {
+        return fallback;
+    }
+    return Math.min(maximum, Math.max(1, Math.trunc(value ?? fallback)));
+}
+function ensureTrailingNewline(value) {
+    return value.endsWith("\n") ? value : `${value}\n`;
+}

package/dist/core/task-state-machine.js

@@ -6,7 +6,7 @@ const TASK_STATE_TRANSITIONS = {
     actor_running: new Set(["critic_running", "verifying", "paused", "failed", "cancelled"]),
     critic_running: new Set(["revision_needed", "integrating", "paused", "failed", "cancelled"]),
     revision_needed: new Set(["actor_running", "paused", "failed", "cancelled"]),
-    integrating: new Set(["actor_running", "verifying", "paused", "done", "failed", "cancelled"]),
+    integrating: new Set(["judging", "actor_running", "verifying", "paused", "done", "failed", "cancelled"]),
     verifying: new Set(["revision_needed", "integrating", "paused", "done", "failed", "cancelled"]),
     paused: new Set(["routed", "judging", "ready_for_pair", "failed", "cancelled"]),
     done: new Set(["routed", "cancelled"]),

package/dist/orchestrator/collaboration-channel.js

@@ -58,7 +58,7 @@ export async function createFeatureChannel(input) {
     await ensureDir(dir);
     await ensureDir(join(input.task.dir, "dialogue"));
     if (input.resume) {
-        await ensureFeatureChannelFiles(input, channel);
+        await ensureFeatureChannelFiles(input, channel, input.refreshDefinition ?? false);
         const repairedState = await repairFeatureStatus(channel);
         if (repairedState) {
             await appendFeatureDialogue(channel, "feature.status_recovered", "actor", `Recovered Feature status as ${repairedState} while preserving collaboration evidence.`);
@@ -76,7 +76,7 @@ export async function createFeatureChannel(input) {
     await appendFeatureDialogue(channel, "feature.created", "actor", "Feature mailbox created for the current turn.");
     return channel;
 }
-async function ensureFeatureChannelFiles(input, channel) {
+async function ensureFeatureChannelFiles(input, channel, refreshDefinition) {
     const files = [
         [channel.specPath, buildFeatureSpec(input, channel)],
         [channel.actorWorklogPath, ""],
@@ -84,7 +84,7 @@ async function ensureFeatureChannelFiles(input, channel) {
         [channel.criticFindingsPath, ""]
     ];
     for (const [path, initialContent] of files) {
-        if (!(await pathExists(path))) {
+        if ((refreshDefinition && path === channel.specPath) || !(await pathExists(path))) {
             await writeText(path, initialContent);
         }
     }

package/dist/orchestrator/orchestrator.js

@@ -1,4 +1,4 @@
-import { readdir } from "node:fs/promises";
+import { cp, readdir } from "node:fs/promises";
 import { join } from "node:path";
 import { appendJsonLine, ensureDir, pathExists, readJson, readTextIfExists, removeIfExists, writeJson, writeText } from "../core/file-store.js";
 import { runWithLeaseFinalization } from "../core/lease-finalization.js";
@@ -16,7 +16,7 @@ import { validateFinalJudgeAcceptance } from "./final-acceptance.js";
 import { featureExecutionWaves, parseFeaturePlan } from "./feature-plan.js";
 import { JUDGE_REQUIRED_ARTIFACTS, JUDGE_VALIDATION_FILE, validateJudgeArtifacts } from "./judge-artifacts.js";
 import { buildSupervisorSummary } from "./supervisor-summary.js";
-import { ParallelWorkspaceManager } from "./workspace-sandbox.js";
+import { ParallelWorkspaceManager, WorkspaceMergeConflictError } from "./workspace-sandbox.js";
 const PREVIOUS_TURN_SUMMARY_LIMIT = 5;
 const PREVIOUS_TURN_SUMMARY_LENGTH = 600;
 const JUDGE_ARTIFACTS = [
@@ -431,7 +431,7 @@ export class Orchestrator {
                     criticEngine: route.critic_engine,
                     resume: input.retry
                 })));
-                return await this.runFeaturePlan(input, task, route, turn, workers, judge, featurePlan, features);
+                return await this.runFeaturePlanWithConflictReplan(input, task, route, turn, workers, judge, featurePlan, features);
             }
             const feature = await createFeatureChannel({
                 task,
@@ -477,7 +477,7 @@ export class Orchestrator {
                     criticEngine: route.critic_engine,
                     resume: input.retry
                 })));
-                return await this.runFeaturePlan(input, task, route, turn, workers, judge, featurePlan, features);
+                return await this.runFeaturePlanWithConflictReplan(input, task, route, turn, workers, judge, featurePlan, features);
             }
             const feature = await createFeatureChannel({
                 task,
@@ -558,6 +558,127 @@ export class Orchestrator {
             throw new Error(`Invalid feature plan at ${sourcePath}: ${errorMessage(error)}`);
         }
     }
+    async runFeaturePlanWithConflictReplan(input, task, route, turn, workers, judge, plan, features) {
+        let currentInput = input;
+        let currentJudge = judge;
+        let currentPlan = plan;
+        let currentFeatures = features;
+        let replanRound = 0;
+        const workspaceManager = new ParallelWorkspaceManager({
+            workspaceRoot: input.cwd,
+            taskDir: task.dir,
+            dataDir: this.config.dataDir
+        });
+        while (true) {
+            try {
+                return await this.runFeaturePlan(currentInput, task, route, turn, workers, currentJudge, currentPlan, currentFeatures);
+            }
+            catch (error) {
+                if (!(error instanceof WorkspaceMergeConflictError)
+                    || error.wave === undefined
+                    || !error.featureId
+                    || error.waveFeatureIds.length < 2) {
+                    throw error;
+                }
+                if (replanRound >= this.config.orchestration.maxConflictReplans) {
+                    throw new Error(`${error.message} Automatic Judge replan limit exhausted after ${replanRound} `
+                        + `${replanRound === 1 ? "round" : "rounds"}.`, { cause: error });
+                }
+                replanRound += 1;
+                const definitionIds = conflictDefinitionIds(currentPlan, currentFeatures, error.waveFeatureIds);
+                if (definitionIds.length < 2) {
+                    throw error;
+                }
+                const reportPath = join(turn.dir, `feature-replan-${String(replanRound).padStart(2, "0")}.json`);
+                const conflictArchiveDir = join(turn.dir, "conflicts", `replan-${String(replanRound).padStart(2, "0")}`);
+                await ensureDir(join(turn.dir, "conflicts"));
+                await cp(error.conflictDir, conflictArchiveDir, { recursive: true, force: true });
+                const requestedAt = new Date().toISOString();
+                const report = {
+                    version: 1,
+                    state: "requested",
+                    round: replanRound,
+                    requested_at: requestedAt,
+                    reason: "workspace-merge-conflict",
+                    wave: error.wave,
+                    conflict_paths: error.paths,
+                    conflict_evidence: conflictArchiveDir,
+                    conflicting_feature_id: error.featureId,
+                    wave_feature_ids: error.waveFeatureIds,
+                    definition_ids: definitionIds,
+                    previous_plan: currentPlan
+                };
+                await writeJson(reportPath, report);
+                await this.sessions.appendEvent(task, "feature.conflict_replan_requested", `Judge replan ${replanRound}/${this.config.orchestration.maxConflictReplans} requested for wave ${error.wave}: ${definitionIds.join(", ")}`);
+                await Promise.all(currentFeatures
+                    .filter((feature) => error.waveFeatureIds.includes(feature.id))
+                    .map((feature) => appendFeatureDialogue(feature, "judge.conflict_replan_requested", "judge", `Workspace conflict in ${error.paths.join(", ")}; Judge is replanning the Feature DAG.`, { report: reportPath, conflicts: conflictArchiveDir })));
+                await this.sessions.updateTaskStatus(task, "judging");
+                currentInput.onStatus?.({
+                    taskId: task.id,
+                    judge: `replanning ${replanRound}/${this.config.orchestration.maxConflictReplans}`,
+                    actor: "waiting",
+                    critic: "waiting"
+                });
+                await this.clearTurnJudgeArtifacts(turn);
+                const replanContext = {
+                    round: replanRound,
+                    reportPath,
+                    conflictPaths: error.paths,
+                    waveFeatureIds: definitionIds,
+                    previousFeatureIds: currentPlan.features.map((feature) => feature.id)
+                };
+                const judgeWorker = await this.runJudge({ ...currentInput, retry: true }, task, route.judge_engine, workers, turn, replanContext);
+                const revisedJudge = await this.snapshotJudgeArtifacts(judgeWorker, turn);
+                let judgePlan = null;
+                let judgePlanError = "";
+                try {
+                    judgePlan = await this.loadFeaturePlan(revisedJudge, turn);
+                }
+                catch (planError) {
+                    judgePlanError = errorMessage(planError);
+                }
+                const judgePlanAccepted = Boolean(judgePlan
+                    && sameFeatureIds(currentPlan, judgePlan)
+                    && conflictFeaturesAreSerialized(judgePlan, definitionIds));
+                const revisedPlan = judgePlanAccepted
+                    ? judgePlan
+                    : serializeConflictWave(currentPlan, definitionIds);
+                await writeJson(join(turn.dir, "feature-plan.json"), revisedPlan);
+                await workspaceManager.discardWavesFrom(turn.turnId, error.wave);
+                const revisedFeatures = await Promise.all(revisedPlan.features.map((feature) => createFeatureChannel({
+                    task,
+                    turn,
+                    request: input.request,
+                    judgeDir: revisedJudge.dir,
+                    feature,
+                    actorEngine: route.actor_engine,
+                    criticEngine: route.critic_engine,
+                    resume: true,
+                    refreshDefinition: true
+                })));
+                await this.sessions.updateTaskStatus(task, "ready_for_pair");
+                await writeJson(reportPath, {
+                    ...report,
+                    state: "applied",
+                    applied_at: new Date().toISOString(),
+                    source: judgePlanAccepted ? "judge" : "supervisor-serialization-fallback",
+                    ...(judgePlanError ? { judge_plan_error: judgePlanError } : {}),
+                    ...(judgePlan && !judgePlanAccepted ? { rejected_judge_plan: judgePlan } : {}),
+                    revised_plan: revisedPlan
+                });
+                await this.sessions.appendEvent(task, "feature.conflict_replan_applied", `Applied ${judgePlanAccepted ? "Judge" : "supervisor fallback"} DAG replan ${replanRound}; wave ${error.wave} will resume from isolated workspaces`);
+                await Promise.all(revisedFeatures
+                    .filter((feature) => error.waveFeatureIds.includes(feature.id))
+                    .map((feature) => appendFeatureDialogue(feature, "judge.conflict_replan_applied", "judge", `Replanned dependencies: ${feature.dependsOn.length > 0 ? feature.dependsOn.join(", ") : "none"}.`, { report: reportPath, plan: join(turn.dir, "feature-plan.json") })));
+                currentInput = { ...currentInput, retry: true };
+                currentJudge = revisedJudge;
+                currentPlan = revisedPlan;
+                features.splice(0, features.length, ...revisedFeatures);
+                currentFeatures = features;
+            }
+        }
+    }
     async runFeaturePlan(input, task, route, turn, workers, judge, plan, features) {
         const channels = new Map(plan.features.map((definition, index) => [definition.id, features[index]]));
         const assignments = new Map(await Promise.all(features.map(async (feature) => [
@@ -1294,21 +1415,22 @@ export class Orchestrator {
         throwIfCancelled(input.signal);
         return readTextIfExists(outputLogPath);
     }
-    async runJudge(input, task, engine, workers, turn) {
+    async runJudge(input, task, engine, workers, turn, replan) {
         const workerId = taskWorkerId("judge", engine, turn.turnId);
         const judgeFiles = this.workerFiles(task, workerId);
         const judge = await this.sessions.initializeWorker(task, {
             workerId,
             role: "judge",
             engine,
-            preserveOutput: input.retry,
+            preserveOutput: input.retry || Boolean(replan),
             prompt: buildJudgePrompt({
                 request: input.request,
                 taskDir: task.dir,
                 workerDir: judgeFiles.dir,
                 workspaceDir: input.cwd,
                 turn: await this.promptTurnContext(task, turn),
-                role: this.config.roles.judge
+                role: this.config.roles.judge,
+                replan
             })
         });
         this.recordWorker(input, workers, {
@@ -2196,6 +2318,47 @@ function requiredChannel(channels, definition) {
     }
     return channel;
 }
+function conflictDefinitionIds(plan, channels, channelIds) {
+    const definitionByChannel = new Map(channels.map((channel, index) => [
+        channel.id,
+        plan.features[index]?.id
+    ]));
+    return [...new Set(channelIds
+            .map((channelId) => definitionByChannel.get(channelId))
+            .filter((id) => Boolean(id)))];
+}
+function sameFeatureIds(previous, revised) {
+    const previousIds = previous.features.map((feature) => feature.id).sort();
+    const revisedIds = revised.features.map((feature) => feature.id).sort();
+    return previousIds.length === revisedIds.length
+        && previousIds.every((id, index) => id === revisedIds[index]);
+}
+function conflictFeaturesAreSerialized(plan, featureIds) {
+    const waveByFeature = new Map();
+    for (const [waveIndex, wave] of featureExecutionWaves(plan).entries()) {
+        for (const feature of wave) {
+            waveByFeature.set(feature.id, waveIndex);
+        }
+    }
+    const waveIndexes = featureIds.map((id) => waveByFeature.get(id));
+    return waveIndexes.every((index) => index !== undefined)
+        && new Set(waveIndexes).size === featureIds.length;
+}
+function serializeConflictWave(plan, featureIds) {
+    const serializedIds = new Set(featureIds);
+    let previousId = null;
+    const features = plan.features.map((feature) => {
+        if (!serializedIds.has(feature.id)) {
+            return feature;
+        }
+        const dependsOn = previousId
+            ? [...new Set([...feature.depends_on, previousId])]
+            : feature.depends_on;
+        previousId = feature.id;
+        return { ...feature, depends_on: dependsOn };
+    });
+    return parseFeaturePlan({ version: 1, features });
+}
 function requiredFeatureAssignment(assignments, channel) {
     const assignment = assignments.get(channel.id);
     if (!assignment) {

package/dist/orchestrator/prompts.js

@@ -53,6 +53,20 @@ export function buildJudgePrompt(input) {
         "Use safe lowercase ids made from letters, numbers, and hyphens.",
         "List dependencies in \"depends_on\"; independent features can run in parallel.",
         "Example: {\"version\":1,\"features\":[{\"id\":\"ui\",\"title\":\"UI\",\"description\":\"Build the interface\",\"depends_on\":[]}]}",
+        ...(input.replan ? [
+            "",
+            `# Conflict replan ${input.replan.round}`,
+            "",
+            `Conflict report: ${input.replan.reportPath}`,
+            `Conflicting paths: ${input.replan.conflictPaths.join(", ")}`,
+            `Features from the conflicting wave: ${input.replan.waveFeatureIds.join(", ")}`,
+            "The previous parallel DAG produced an isolated merge conflict; the live workspace was not changed by that wave.",
+            "Read the conflict report and rewrite the Judge artifacts for a safe retry.",
+            `Preserve exactly these feature ids: ${input.replan.previousFeatureIds.join(", ")}.`,
+            "Do not add, remove, or rename Features during this replan.",
+            "Use depends_on to serialize the Features from the conflicting wave so they no longer execute together.",
+            "Keep unrelated safe Features parallel when their dependencies allow it."
+        ] : []),
         "",
         "User request:",
         input.request,

package/dist/orchestrator/workspace-sandbox.js

@@ -10,13 +10,21 @@ const LIVE_COMMIT_PROTOCOL = "atomic-claim-v1";
 export class WorkspaceMergeConflictError extends Error {
     paths;
     conflictDir;
-    constructor(paths, conflictDir) {
+    wave;
+    featureId;
+    waveFeatureIds;
+    integratedFeatureIds;
+    constructor(paths, conflictDir, context = {}) {
         const count = paths.length;
         super(`Workspace integration conflict in ${count} ${count === 1 ? "path" : "paths"}: ${paths.join(", ")}. `
             + `The live workspace was not changed. Conflict evidence: ${conflictDir}`);
         this.name = "WorkspaceMergeConflictError";
         this.paths = paths;
         this.conflictDir = conflictDir;
+        this.wave = context.wave;
+        this.featureId = context.featureId;
+        this.waveFeatureIds = [...(context.waveFeatureIds ?? [])];
+        this.integratedFeatureIds = [...(context.integratedFeatureIds ?? [])];
     }
 }
 export class WorkspaceLiveMutationError extends Error {
@@ -163,7 +171,7 @@ export class ParallelWorkspaceManager {
         await rm(wave.integrationDir, { recursive: true, force: true });
         await rm(wave.verificationDir, { recursive: true, force: true });
         await cloneTree(wave.baselineDir, wave.stagingDir);
-        for (const featureId of wave.featureIds) {
+        for (const [featureIndex, featureId] of wave.featureIds.entries()) {
             const featureDir = wave.featureDirs.get(featureId);
             if (!featureDir) {
                 throw new Error(`Feature workspace missing for ${featureId}`);
@@ -171,7 +179,12 @@ export class ParallelWorkspaceManager {
             const featureConflictDir = join(wave.conflictDir, featureId);
             const plan = await planWorkspaceMerge(wave.baselineDir, featureDir, wave.stagingDir, featureConflictDir, (path) => this.excludeRelativePath(path));
             if (plan.conflicts.length > 0) {
-                throw new WorkspaceMergeConflictError(plan.conflicts, featureConflictDir);
+                throw new WorkspaceMergeConflictError(plan.conflicts, featureConflictDir, {
+                    wave: wave.wave,
+                    featureId,
+                    waveFeatureIds: wave.featureIds,
+                    integratedFeatureIds: wave.featureIds.slice(0, featureIndex)
+                });
             }
             await applyMergePlan(wave.stagingDir, plan);
         }
@@ -187,6 +200,29 @@ export class ParallelWorkspaceManager {
         });
         return { changedPaths };
     }
+    async discardWavesFrom(turnId, firstWave) {
+        if (!/^\d{4,}$/.test(turnId)) {
+            throw new Error(`Unsafe workspace turn id: ${turnId}`);
+        }
+        if (!Number.isInteger(firstWave) || firstWave < 1) {
+            throw new Error(`Workspace wave must be a positive integer: ${firstWave}`);
+        }
+        const turnRoot = join(this.taskDir, "workspaces", `turn-${turnId}`);
+        if (!(await pathIsDirectory(turnRoot))) {
+            return;
+        }
+        for (const entry of await readdir(turnRoot, { withFileTypes: true })) {
+            if (!entry.isDirectory()) {
+                continue;
+            }
+            const match = entry.name.match(/^wave-(\d+)$/);
+            if (match && Number(match[1] ?? 0) >= firstWave) {
+                await rm(join(turnRoot, entry.name), { recursive: true, force: true });
+            }
+        }
+        await rm(join(turnRoot, "final-verification"), { recursive: true, force: true });
+        await rm(join(turnRoot, "final-verification.json"), { force: true });
+    }
     async prepareVerificationWorkspace(wave) {
         await rm(wave.verificationDir, { recursive: true, force: true });
         await cloneTree(wave.integrationDir, wave.verificationDir);

package/dist/tui/App.js

@@ -19,7 +19,7 @@ import { TerminalOutput } from "./TerminalOutput.js";
 import { NativeTerminalScreen } from "./terminal-screen.js";
 import { WorkerOutputView } from "./WorkerOutputView.js";
 import { compactEndByDisplayWidth, displayWidth, wrapByDisplayWidth } from "./display-width.js";
-import { isAttachShortcut, isCopyShortcut, isExitShortcut, isLogsShortcut, isNewTaskShortcut, isRouterDiagnosticsShortcut, isStatusDetailsShortcut, isTaskResultShortcut, isTaskSessionsShortcut, isWorkerOverviewShortcut, isWorkerSearchShortcut, isWorkspaceShortcut, mouseScrollDelta, rawHistoryDelta, rawPageScrollDelta, rawPlainArrowDelta, scrollDelta, workerLogJumpKind } from "./keyboard.js";
+import { isAttachShortcut, isCopyShortcut, isDiagnosticsShortcut, isExitShortcut, isLogsShortcut, isNewTaskShortcut, isRouterDiagnosticsShortcut, isStatusDetailsShortcut, isTaskResultShortcut, isTaskSessionsShortcut, isWorkerOverviewShortcut, isWorkerSearchShortcut, isWorkspaceShortcut, mouseScrollDelta, rawHistoryDelta, rawPageScrollDelta, rawPlainArrowDelta, scrollDelta, workerLogJumpKind } from "./keyboard.js";
 import { createRawInputDecoder, tokenizeRawInput } from "./raw-input-decoder.js";
 import { decodeHtmlEntities } from "./markdown-text.js";
 import { configureTuiTheme, TUI_THEME } from "./theme.js";
@@ -48,7 +48,7 @@ const EMPTY_WORKER_NAVIGATION_TARGETS = {
     errorOffsets: [],
     diffOffsets: []
 };
-export function App({ config, orchestrator, cwd, initialTaskId = null, initialRoute = null, initialWorkers, initialCanRetryTask = false, initialMessages = [], persistChatMessage, workspaceChoices = [], switchWorkspace, loadRouterDiagnostics, loadTaskSessions, loadTaskSessionDetails, renameTaskSession, setTaskSessionArchived, deleteTaskSession, exportTaskSession, loadCollaborationTimeline, activateTaskSession, prepareNativeAttach, prepareNativeFork, startNativeAttach, copyToClipboard = copyTextToClipboard, shutdownSignal }) {
+export function App({ config, orchestrator, cwd, initialTaskId = null, initialRoute = null, initialWorkers, initialCanRetryTask = false, initialMessages = [], persistChatMessage, workspaceChoices = [], switchWorkspace, loadRouterDiagnostics, loadTaskSessions, loadTaskSessionDetails, renameTaskSession, setTaskSessionArchived, deleteTaskSession, exportTaskSession, exportDiagnostics, loadCollaborationTimeline, activateTaskSession, prepareNativeAttach, prepareNativeFork, startNativeAttach, copyToClipboard = copyTextToClipboard, shutdownSignal }) {
     configureTuiTheme({
         theme: config.ui.theme,
         colors: config.ui.colors
@@ -123,6 +123,7 @@ export function App({ config, orchestrator, cwd, initialTaskId = null, initialRo
     const nativeAttachRef = useRef(nativeAttach);
     const nativeAttachRequestSequenceRef = useRef(0);
     const clipboardNoticeTimerRef = useRef(null);
+    const diagnosticsExportingRef = useRef(false);
     const copyTextByViewRef = useRef({ chat: "", worker: "" });
     const messagesRef = useRef([...initialMessages]);
     const activeRunControllerRef = useRef(null);
@@ -185,6 +186,7 @@ export function App({ config, orchestrator, cwd, initialTaskId = null, initialRo
     const refreshTaskSessionDetailsRef = useRef(refreshTaskSessionDetails);
     const openTaskSessionDetailWorkerRef = useRef(openTaskSessionDetailWorker);
     const copyVisibleViewRef = useRef(copyVisibleView);
+    const exportDiagnosticsRef = useRef(exportDiagnosticsBundle);
     const workspaceReturnViewRef = useRef("chat");
     const routerReturnViewRef = useRef("chat");
     const workerOverviewReturnViewRef = useRef("chat");
@@ -372,6 +374,7 @@ export function App({ config, orchestrator, cwd, initialTaskId = null, initialRo
         refreshTaskSessionDetailsRef.current = refreshTaskSessionDetails;
         openTaskSessionDetailWorkerRef.current = openTaskSessionDetailWorker;
         copyVisibleViewRef.current = copyVisibleView;
+        exportDiagnosticsRef.current = exportDiagnosticsBundle;
     });
     useEffect(() => {
         if ((view !== "collaboration" && view !== "features") || !activeTaskId || !loadCollaborationTimeline) {
@@ -696,6 +699,12 @@ export function App({ config, orchestrator, cwd, initialTaskId = null, initialRo
                 void copyVisibleViewRef.current();
                 return;
             }
+            if (currentView !== "workspace"
+                && currentView !== "native"
+                && tokenizeRawInput(chunk).some((inputChunk) => isDiagnosticsShortcut(inputChunk, {}))) {
+                void exportDiagnosticsRef.current();
+                return;
+            }
             if (currentView === "chat" && routeFallbackPromptRef.current) {
                 const fallbackChunks = tokenizeRawInput(chunk);
                 if (fallbackChunks.some((fallbackChunk) => isExitShortcut(fallbackChunk, {}))) {
@@ -1555,6 +1564,46 @@ export function App({ config, orchestrator, cwd, initialTaskId = null, initialRo
             setAttachError(`Copy failed · ${error instanceof Error ? error.message : String(error)}`);
         }
     }
+    async function exportDiagnosticsBundle() {
+        if (diagnosticsExportingRef.current) {
+            return;
+        }
+        if (!exportDiagnostics) {
+            setAttachError("Diagnostics export is unavailable");
+            return;
+        }
+        diagnosticsExportingRef.current = true;
+        if (clipboardNoticeTimerRef.current) {
+            clearTimeout(clipboardNoticeTimerRef.current);
+            clipboardNoticeTimerRef.current = null;
+        }
+        setAttachError(null);
+        setClipboardNotice({ state: "copying", text: "exporting sanitized diagnostics" });
+        try {
+            const path = await exportDiagnostics();
+            if (!mountedRef.current) {
+                return;
+            }
+            setClipboardNotice({ state: "copied", text: `diagnostics exported · ${path}` });
+            clipboardNoticeTimerRef.current = setTimeout(() => {
+                if (!mountedRef.current) {
+                    return;
+                }
+                clipboardNoticeTimerRef.current = null;
+                setClipboardNotice(null);
+            }, 2600);
+        }
+        catch (error) {
+            if (!mountedRef.current) {
+                return;
+            }
+            setClipboardNotice(null);
+            setAttachError(`Diagnostics export failed · ${error instanceof Error ? error.message : String(error)}`);
+        }
+        finally {
+            diagnosticsExportingRef.current = false;
+        }
+    }
     function visibleClipboardPayload(currentView) {
         if (currentView === "chat") {
             return { label: "chat", text: copyTextByViewRef.current.chat };

package/dist/tui/InputBar.js

@@ -415,7 +415,8 @@ function workerInputHints(width) {
 }
 function statusDetailInputHints(width) {
     return selectInputHints(width, [
-        { label: "status", detail: " · ^S/Esc back · ^C exit" },
+        { label: "status", detail: " · ^X diagnostics · ^S/Esc back · ^C exit" },
+        { label: "status", detail: " · ^X diag · ^S/Esc back · ^C exit" },
         { label: "status", detail: " · ^S back · ^C exit" },
         { label: "status", detail: " · ^S back" },
         { label: "status", detail: "" },

package/dist/tui/keyboard.js

@@ -34,6 +34,9 @@ export function isWorkerSearchShortcut(input, key) {
 export function isCopyShortcut(input, key) {
     return (key.ctrl === true && input.toLowerCase() === "y") || input === "\u0019";
 }
+export function isDiagnosticsShortcut(input, key) {
+    return (key.ctrl === true && input.toLowerCase() === "x") || input === "\u0018";
+}
 export function workerLogJumpKind(input) {
     if (input === "e" || input === "E") {
         return "error";

package/dist/version.js

@@ -1 +1 @@
-export const version = "0.1.8";
+export const version = "0.2.0";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "parallel-codex-tui",
-  "version": "0.1.8",
+  "version": "0.2.0",
   "description": "A TypeScript TUI wrapper for routed parallel coding with Codex and Claude workers.",
   "license": "MIT",
   "type": "module",
@@ -41,8 +41,14 @@
     "postbuild": "node -e \"require('node:fs').chmodSync('dist/cli.js', 0o755)\"",
     "prepack": "npm run build",
     "pretest": "node scripts/fix-node-pty-permissions.mjs",
+    "pretest:stability": "node scripts/fix-node-pty-permissions.mjs",
+    "pretest:terminal-hosts": "node scripts/fix-node-pty-permissions.mjs",
+    "pretest:real-agents": "node scripts/fix-node-pty-permissions.mjs",
     "verify:package": "node scripts/verify-package.mjs",
     "test": "vitest run",
+    "test:stability": "vitest run tests/cli-worker-history-smoke.test.ts tests/cli-workspace-switch-smoke.test.ts tests/cli-orphan-process-recovery-smoke.test.ts tests/cli-startup-recovery-smoke.test.ts",
+    "test:terminal-hosts": "vitest run tests/cli-terminal-host-compat-smoke.test.ts",
+    "test:real-agents": "PCT_REAL_AGENT_TESTS=1 vitest run tests/cli-real-multi-workspace.test.ts",
     "test:watch": "vitest",
     "typecheck": "tsc --noEmit -p tsconfig.typecheck.json",
     "lint": "tsc --noEmit -p tsconfig.typecheck.json"