parallel-codex-tui 0.2.4 → 0.2.5

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

@@ -77,12 +77,13 @@ fallback = "new"
 
 [workers.claude]
 command = "claude"
-# Main uses Claude auto mode for non-interactive tools. Isolated roles are still clamped to acceptEdits.
+# Claude auto mode lets safe non-interactive tools run while retaining permission checks.
 args = ["--print", "--permission-mode", "auto", "--output-format", "text"]
-# timeoutMs is the hard ceiling; first output owns silent startup and idle starts after actual output.
+# Claude text output is buffered until completion, so timeoutMs is the effective startup ceiling.
+# A shorter firstOutputTimeoutMs is used only with --output-format stream-json.
 # timeoutMs = 2700000
 # idleTimeoutMs = 300000
-firstOutputTimeoutMs = 120000
+# firstOutputTimeoutMs = 2700000
 
 # [workers.claude.model]
 # name = "claude-sonnet"
@@ -157,10 +158,10 @@ freshSessionArgs = []
 # args = ["run", "--stdin"]
 
 [pairing]
-main = "claude"
+main = "codex"
 judge = "codex"
 actor = "codex"
-critic = "codex"
+critic = "claude"
 
 [roles.main]
 title = "Main"

package/README.md

@@ -6,21 +6,22 @@ Built with Codex-assisted development.
 
 ## Current Release
 
-`v0.2.4` is available from [npm](https://www.npmjs.com/package/parallel-codex-tui/v/0.2.4) and as a [GitHub Release](https://github.com/allendred/parallel-codex-tui/releases/tag/v0.2.4). Codex Router, Main, and automated Workers now place the non-interactive approval policy at the required root position as `-a never ... exec`, while retaining `read-only` routing and `workspace-write` coding sandboxes. Isolated Codex roles also replace unsafe or interactive approval arguments; native attach remains interactive. The Claude Main permission fix from `v0.2.3` remains included.
+`v0.2.5` is available from [npm](https://www.npmjs.com/package/parallel-codex-tui/v/0.2.5) and as a [GitHub Release](https://github.com/allendred/parallel-codex-tui/releases/tag/v0.2.5). Main chat now extracts only the final Codex answer while retaining the complete CLI transcript in `output.log`; legacy transcript-shaped chat records are cleaned when displayed without rewriting their file-backed evidence. Workspace integration ignores known host metadata such as `.DS_Store` and AppleDouble files while continuing to reject real concurrent project edits.
 
-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 default role map is Main/Judge/Actor on Codex and Critic on Claude. Status details show the complete active role map separately from each historical Worker's persisted Provider/model. Config monitoring labels Router-only edits as active on the next request and marks role, Worker, model, permission, or UI changes as requiring restart. Claude text/JSON print runs are recognized as buffered work, use the total deadline instead of a false first-output deadline, and run safe isolated tools through non-interactive `auto` permissions. The `v0.2.4` non-interactive Codex permission placement remains included. The release keeps terminal scrolling and copying available at the same time without requiring Shift and preserves the embedded native Agent scrollback across status-detail round trips and real PTY resizes.
 
 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.
+- Main responses, raw process evidence, active role configuration, and historical Worker identity now have separate display and persistence paths.
 - `--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.
 - 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, 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. Real Codex and Claude probes both proved fresh and same-session resume calls; Codex fresh and resume runs executed workspace writes with root-level `-a never`, and a Claude Main session executed safe Bash tools before and after resume with `auto` permissions. 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,265 tests across 123 files; one quota-consuming real-Agent test is skipped by default and passes through `npm run test:real-agents`.
+Release acceptance includes a real three-Feature Tetris task with parallel Actor/Critic waves and final integration review. A clean `v0.2.5` task also ran Codex Judge and Actor, a buffered Claude Critic that independently executed `node --test` and `npm test`, atomic integration, and a resumed Codex Judge that independently passed all seven acceptance criteria. Real Codex and Claude probes both proved fresh and same-session resume calls; Codex fresh and resume runs executed workspace writes with root-level `-a never`, and Claude automated sessions executed safe Bash tools with `auto` permissions. 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 contains 1,281 tests across 127 files: 1,280 pass by default, while one quota-consuming real-Agent test is skipped and passes through `npm run test:real-agents`.
 
 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.
 
@@ -204,7 +205,7 @@ The doctor output includes `preview:` and `semantic:` ANSI swatch rows so you ca
 - Router classification only receives the user request; workspace selection and session files are kept out of the router prompt.
 - Simple requests stay in the main TUI flow and do not create Judge, Actor, or Critic workers.
 - Consecutive simple requests reuse the main worker's native session across app restarts when the CLI exposes a session id.
-- The workspace chat transcript is appended to `.parallel-codex/sessions/main/chat.jsonl`; startup restores the latest 200 valid messages and skips isolated corrupt rows. The shared tail reader reads JSONL backward in bounded chunks, so a long-running chat does not require loading its lifetime transcript and a partial or oversized final row cannot hide earlier valid messages.
+- The workspace chat transcript is appended to `.parallel-codex/sessions/main/chat.jsonl`; startup restores the latest 200 valid messages and skips isolated corrupt rows. Main stores only the extracted final answer in new chat records while retaining the raw Codex/Claude process transcript in the Main Worker's `output.log`. Legacy Codex transcript records are reduced to their final answer at read time without changing the original JSONL. The shared tail reader reads JSONL backward in bounded chunks, so a long-running chat does not require loading its lifetime transcript and a partial or oversized final row cannot hide earlier valid messages.
 - Chat drafts support Unicode-safe Left/Right, Home/End, Backspace, and Delete editing. A single Up/Down recalls persisted user requests and returns to the exact unsent draft; Ctrl+Up/Down remains available, while repeated alternate-scroll arrow bursts continue to scroll chat. Long input stays on one row with the visible window centered around the logical cursor.
 - Bracketed multiline paste stays in one draft instead of submitting the first line; logical line breaks and tabs appear as `↵` and `⇥` in the single-row input until the complete request is submitted.
 - Complex requests create a session under `.parallel-codex/sessions/`.
@@ -223,7 +224,7 @@ The doctor output includes `preview:` and `semantic:` ANSI swatch rows so you ca
 - Parallel Actor, Critic, and revision batches honor `[orchestration].maxParallelFeatures` (default `3`).
 - Each planned feature gets an isolated Actor implementation workspace, a disposable Critic review clone, worker directories, logs, status, native session ids, and a mailbox under `features/<turn>-<feature>`; the shared dialogue remains in `dialogue/actor-critic.jsonl`. Concurrent text and JSONL appends inside one TUI are serialized per resolved file path, preserving call order without blocking independent feature files; one failed append does not poison later writes.
 - Feature revision mailboxes are a checked protocol rather than prompt-only convention. A `REVISION_REQUIRED` Critic must write one `{"id":"C-001","severity":"blocker","summary":"..."}` row per blocker to `critic-findings.jsonl`; the revision Actor must write matching `{"finding_id":"C-001","status":"fixed","notes":"..."}` rows to `actor-replies.jsonl`. Missing, malformed, unacknowledged, or contradictory findings stop the task before live integration. The Supervisor snapshots pending, inconsistent, and approved fixed/open state in `finding-resolution.json`; the collaboration timeline retains the original findings and replies as history and uses resolution evidence instead of counting every reply as a fix.
-- Parallel workspace isolation works for both Git and non-Git projects. A wave records `baseline`, per-feature `features/` workspaces, refreshable `reviews/` copies, `staging`, and conflict evidence under `sessions/<task>/workspaces/turn-<turn>/wave-<wave>/` while excluding `.git` and the configured runtime data directory.
+- Parallel workspace isolation works for both Git and non-Git projects. A wave records `baseline`, per-feature `features/` workspaces, refreshable `reviews/` copies, `staging`, and conflict evidence under `sessions/<task>/workspaces/turn-<turn>/wave-<wave>/` while excluding `.git`, the configured runtime data directory, and known host metadata (`.DS_Store`, AppleDouble, Spotlight/Trash indexes, `Thumbs.db`, and `desktop.ini`). Source files outside that narrow list still trigger the live-mutation guard.
 - Feature Critic implementation writes are discarded with the review clone. After an Actor revision, the same Critic native session rechecks a freshly cloned review path; only Actor workspace changes can enter staging.
 - Approved feature changes are three-way merged into a task-owned integration workspace first; independent edits to the same text file are combined automatically. The live workspace remains unchanged during this stage.
 - 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.
@@ -236,7 +237,7 @@ The doctor output includes `preview:` and `semantic:` ANSI swatch rows so you ca
 - Every numbered turn keeps its own immutable Judge, Actor, and Critic worker directories. Later turns use suffixed ids such as `judge-codex-0002`; the log viewer retains earlier workers, cycles them in turn order, and restores the same order after restart. The new worker record may reuse the prior native session id without overwriting the prior turn's prompt, status, log, or native-session metadata.
 - `Ctrl+N` leaves the active complex task intact on disk while clearing its live context, worker selection, retry state, and status so the next complex request creates an independent task from turn `0001`.
 - Single-feature follow-ups reuse the same Actor/Critic native sessions when available while moving them to the new turn's isolated workspace; prompts include up to five prior turn summaries as file-backed memory. A failed follow-up retry reuses a complete saved Judge plan, or restores Judge first when the earlier Judge run never produced one.
-- Automated Judge, Actor, Critic, Wave Actor, and Wave Critic runs enforce process-level isolation: Codex is clamped to root-level `-a never` plus `workspace-write`, and Claude is clamped to `acceptEdits`, even when private command arguments request interactive approval or contain a broader bypass mode. Native attach remains an explicit interactive path.
+- Automated Judge, Actor, Critic, Wave Actor, and Wave Critic runs enforce process-level isolation: Codex is clamped to root-level `-a never` plus `workspace-write`, and Claude is clamped to non-interactive `auto`, even when private command arguments request manual approval or contain a broader bypass mode. Native attach remains an explicit interactive path.
 - Pressing `Esc` while a request is running stops the router or active worker and records an interrupted complex task as `cancelled`; exiting the outer TUI also terminates the active run.
 - Failed and cancelled tasks expose `Ctrl+R` retry. Retry keeps the same task and turn, reuses recorded native worker sessions, preserves prior output behind a retry separator, does not route the request again, and reuses the persisted feature dependency plan. A complete Judge snapshot and fully integrated waves are skipped; an unchanged in-progress wave reuses successful Actor and Critic checkpoints and runs only unfinished workers. If the live workspace no longer matches the saved baseline, the stale wave checkpoint is rejected and rebuilt from the current project before workers continue.
 - The shared Main chat holds its own `sessions/main/run-owner.json` lease across prompt initialization, native-session reuse, and Worker completion. A second TUI is rejected before it can clear or overwrite the active Main prompt, log, status, or native session, and startup native-session reconciliation skips a Main session owned by another live TUI. After a hard exit, startup atomically claims the stale Main lease, terminates every verifiable orphan process group, marks active Main Workers `cancelled`, preserves native session ids, and records recovery before exposing the runtime. An unverifiable or still-running Main process blocks startup without changing its status or checkpoints.
@@ -363,7 +364,7 @@ args = ["--resume", "{sessionId}"]
 forkArgs = ["--resume", "{sessionId}", "--fork-session"]
 ```
 
-`model.args` and `model.env` apply to both automated worker runs and embedded native attach sessions. Native attach appends the rendered model arguments after `interactive.args`, so third-party `{model}` and `{provider}` selections remain active when you press `Ctrl+O`. Codex Router and non-interactive Codex Workers use the root option `-a never` before `exec`, so they cannot stall on an approval UI the outer TUI cannot deliver; Router remains `read-only`, while coding Workers stay inside `workspace-write`. Isolated Codex roles remove broader bypass flags and replace any configured approval mode with this bounded policy. The dangerous `--dangerously-bypass-approvals-and-sandbox` mode is never required. Native Codex attach remains interactive. Claude Main uses `auto` so safe tool calls can complete in print mode; isolated Claude coding roles are still clamped to `acceptEdits`. When a command genuinely needs interactive approval, Main points to `Ctrl+O` instead of claiming that a chat reply can grant permission.
+`model.args` and `model.env` apply to both automated worker runs and embedded native attach sessions. Native attach appends the rendered model arguments after `interactive.args`, so third-party `{model}` and `{provider}` selections remain active when you press `Ctrl+O`. Codex Router and non-interactive Codex Workers use the root option `-a never` before `exec`, so they cannot stall on an approval UI the outer TUI cannot deliver; Router remains `read-only`, while coding Workers stay inside `workspace-write`. Isolated Codex roles remove broader bypass flags and replace any configured approval mode with this bounded policy. The dangerous `--dangerously-bypass-approvals-and-sandbox` mode is never required. Native Codex attach remains interactive. Claude automated roles use `auto`, allowing safe test and edit commands while retaining Claude's permission checks; commands that still require interactive approval must be continued through `Ctrl+O` instead of being falsely approved in chat.
 
 `model.provider` names the remote model service; `capabilities.profile` describes the local CLI protocol. Worker Provider IDs are lowercase names using letters, digits, or `_`; excluding `-` keeps generated Worker directory names unambiguous. Existing `codex`, `claude`, and `mock` IDs remain compatible, while additional profiles can inherit `codex`, `claude`, another named profile, or conservative `generic` defaults.
 
@@ -450,9 +451,9 @@ instructions = ["Implement small verified changes.", "Record decisions in worklo
 
 Keep `[router.codex]` on `read-only`; routing only classifies requests and does not need project writes. Automated Judge/Actor/Critic runs also clamp unsafe Codex or Claude permission flags to their isolated workspace policy, so a private `danger-full-access` or bypass flag cannot silently defeat live-workspace isolation. Use native attach for deliberate interactive host-level work such as Docker or OrbStack access.
 
-The process adapter sends each role prompt to stdin and records stdout/stderr in `output.log`. Worker success is separate from the operating-system exit code: a total, first-output, idle, or stdin watchdog failure remains failed even when the terminated CLI handles `SIGTERM` and exits with code `0`, so the next role never starts from a timed-out checkpoint. `firstOutputTimeoutMs` owns silent startup, `idleTimeoutMs` starts only after real stdout/stderr activity, and `timeoutMs` remains the hard ceiling; equal or longer secondary watchdogs do not race the total deadline.
+The process adapter sends each role prompt to stdin and records stdout/stderr in `output.log`. Worker success is separate from the operating-system exit code: a total, first-output, idle, or stdin watchdog failure remains failed even when the terminated CLI handles `SIGTERM` and exits with code `0`, so the next role never starts from a timed-out checkpoint. `firstOutputTimeoutMs` owns silent startup, `idleTimeoutMs` starts only after real stdout/stderr activity, and `timeoutMs` remains the hard ceiling; equal or longer secondary watchdogs do not race the total deadline. Claude `--print` with `text` or `json` emits only its final result, so those launches display `working · buffered` and use `timeoutMs` without arming a separate first-output watchdog. Claude `stream-json` remains streaming and retains the configured first-output deadline.
 
-In chat, scroll long conversation history with the mouse wheel or PageUp/PageDown; sending a new message returns to the latest reply. A single Up/Down recalls persisted request history, and Ctrl+Up/Down remains an alternative. The outer TUI never enables application mouse tracking, so ordinary left-drag selection and system copy work without Shift while alternate-scroll keeps the wheel active in chat and Worker logs. `Ctrl+Y` also copies the current visible chat, rendered Worker log, native Agent screen, or structured overview without changing terminal modes. macOS uses `pbcopy`; Linux uses `wl-copy`, `xclip`, or `xsel` when available and falls back to OSC 52. After a complex task completes, use the same controls to move through its structured result and press `Ctrl+D` to toggle details. Press `Ctrl+N` to preserve the current session and start a new task, `Ctrl+W` to open worker logs, and `Tab` to cycle the selected worker when workers exist. `Ctrl+S` opens the same status detail view from chat, logs, Worker overview, or an embedded native session; it keeps the footer compact while exposing the complete route, reason, selected Provider/model, phase, activity timestamp, and native session. Press `Ctrl+S` or `Esc` to return without interrupting the underlying Worker. While a request is running, press `Esc` to stop it. After a failed or cancelled task, press `Ctrl+R` to retry the same turn or `Ctrl+N` to start independently. In worker-log views, scroll with the mouse wheel, Up/Down, or PageUp/PageDown, press `Tab` to cycle workers, `Ctrl+N` to start a new task, and `Esc` to return to chat.
+In chat, scroll long conversation history with the mouse wheel or PageUp/PageDown; sending a new message returns to the latest reply. A single Up/Down recalls persisted request history, and Ctrl+Up/Down remains an alternative. The outer TUI never enables application mouse tracking, so ordinary left-drag selection and system copy work without Shift while alternate-scroll keeps the wheel active in chat and Worker logs. `Ctrl+Y` also copies the current visible chat, rendered Worker log, native Agent screen, or structured overview without changing terminal modes. macOS uses `pbcopy`; Linux uses `wl-copy`, `xclip`, or `xsel` when available and falls back to OSC 52. After a complex task completes, use the same controls to move through its structured result and press `Ctrl+D` to toggle details. Press `Ctrl+N` to preserve the current session and start a new task, `Ctrl+W` to open worker logs, and `Tab` to cycle the selected worker when workers exist. `Ctrl+S` opens the same status detail view from chat, logs, Worker overview, or an embedded native session; it keeps the footer compact while exposing the complete route, reason, active Main/Judge/Actor/Critic Provider map, selected historical Provider/model, phase, activity timestamp, native session, and config effective/restart state. Press `Ctrl+S` or `Esc` to return without interrupting the underlying Worker. While a request is running, press `Esc` to stop it. After a failed or cancelled task, press `Ctrl+R` to retry the same turn or `Ctrl+N` to start independently. In worker-log views, scroll with the mouse wheel, Up/Down, or PageUp/PageDown, press `Tab` to cycle workers, `Ctrl+N` to start a new task, and `Esc` to return to chat.
 
 `Ctrl+B` opens a live Worker overview without replacing the `Ctrl+W` log shortcut. It summarizes every Judge, Actor, and Critic by turn, role, named Provider, persisted model, state, phase, latest summary, and native-session availability. The selected active worker gets a live activity line showing its first-output deadline while starting and its idle deadline after output begins. The line stays muted while healthy, changes to warning for the final 20% and danger once overdue. Up/Down, PageUp/PageDown, the mouse wheel, or `Tab` changes the selected worker; Enter or `Ctrl+W` opens its rendered log, `Ctrl+O` attaches to its native session, and `Esc` returns to the originating chat or log view. Router diagnostics and the project picker also return to the overview when opened from there.
 
@@ -516,12 +517,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.2.4
+VERSION=0.2.5
 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.2.4` requires tag `v0.2.4`. Published tags such as `v0.2.3` 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.5` requires tag `v0.2.5`. Published tags such as `v0.2.4` are immutable and must not be moved or reused.
 
 ## Publishing Hygiene
 

package/dist/cli.js

@@ -179,7 +179,7 @@ async function main() {
             }, persistChatMessage: (message, taskId) => state.runtime.sessions.appendChatMessage({
                 ...message,
                 taskId
-            }) }, state.runtime.workspaceRoot));
+            }), reloadConfig: async () => withUiThemeOverride(await loadConfig(cliArgs.appRoot), cliArgs.theme) }, state.runtime.workspaceRoot));
         const removeSigintHandler = installInteractiveSigintExitHandler(() => shutdownController.abort());
         enterInteractiveTerminal();
         try {

package/dist/core/config.js

@@ -4,6 +4,7 @@ import { join } from "node:path";
 import { z } from "zod";
 import { EngineNameSchema } from "../domain/schemas.js";
 import { pathExists, readTextIfExists, writeText } from "./file-store.js";
+import { workerBuffersOutputUntilCompletion } from "./worker-output-policy.js";
 import { normalizeTuiThemeColorValue, normalizeTuiThemeName, TUI_THEME_FIELDS, TUI_THEME_NAMES } from "../tui/theme.js";
 const NativeSessionConfigSchema = z.object({
     enabled: z.boolean().default(true),
@@ -220,7 +221,7 @@ export function defaultConfig(projectRoot) {
                 assignable: true,
                 timeoutMs: 45 * 60 * 1000,
                 idleTimeoutMs: 5 * 60 * 1000,
-                firstOutputTimeoutMs: 2 * 60 * 1000,
+                firstOutputTimeoutMs: 45 * 60 * 1000,
                 model: {
                     name: "",
                     provider: "",
@@ -273,10 +274,10 @@ export function defaultConfig(projectRoot) {
             }
         },
         pairing: {
-            main: "claude",
+            main: "codex",
             judge: "codex",
             actor: "codex",
-            critic: "codex"
+            critic: "claude"
         },
         roles: {
             main: {
@@ -404,7 +405,7 @@ function resolveWorkerConfigs(builtins, configured) {
                     parent = resolve(parentId);
                 }
             }
-            const worker = mergeWorkerConfig(parent, override);
+            const worker = normalizeBufferedWorkerTimeout(mergeWorkerConfig(parent, override));
             resolved.set(id, worker);
             return worker;
         }
@@ -476,6 +477,20 @@ function mergeWorkerConfig(base, override) {
         }
     };
 }
+function normalizeBufferedWorkerTimeout(worker) {
+    const launchArgs = [
+        worker.args,
+        ...(worker.nativeSession.enabled ? [worker.nativeSession.resumeArgs] : [])
+    ];
+    const buffersOutput = launchArgs.some((args) => (workerBuffersOutputUntilCompletion(worker.capabilities.profile, args)));
+    if (!buffersOutput || !worker.timeoutMs || worker.firstOutputTimeoutMs === worker.timeoutMs) {
+        return worker;
+    }
+    return {
+        ...worker,
+        firstOutputTimeoutMs: worker.timeoutMs
+    };
+}
 export function withUiThemeOverride(config, theme) {
     if (!theme) {
         return config;

package/dist/core/main-response.js

@@ -0,0 +1,78 @@
+const ANSI_CSI_PATTERN = /\x1b\[[0-?]*[ -/]*[@-~]/g;
+const ANSI_OSC_PATTERN = /\x1b\][^\x07]*(?:\x07|\x1b\\)/g;
+const CODEX_HEADER_PATTERN = /^OpenAI Codex v\S+/;
+const CODEX_COMMAND_PATTERN = /^\$\s+.*\bcodex(?:\s|$)/i;
+const TOKEN_COUNT_PATTERN = /^[\d][\d,._ ]*$/;
+/**
+ * Keeps process transcripts in output.log while returning only the response that
+ * belongs in chat. Codex writes its UI transcript to stderr and repeats the final
+ * response on stdout, so the cleanest answer normally follows "tokens used".
+ */
+export function extractMainResponse(outputLog) {
+    const normalized = stripTerminalControls(outputLog).replace(/\r\n?/g, "\n");
+    const lines = normalized.split("\n");
+    const isCodexTranscript = linesAreCodexTranscript(lines);
+    if (isCodexTranscript) {
+        const extracted = extractCodexFinalResponse(lines);
+        if (extracted) {
+            return extracted;
+        }
+    }
+    return lines
+        .filter((line) => !line.startsWith("$ "))
+        .filter((line) => !line.startsWith("[mock:main]"))
+        .join("\n")
+        .trim();
+}
+export function sanitizePersistedMainMessage(from, text) {
+    if (from !== "system" || !linesAreCodexTranscript(stripTerminalControls(text).split(/\r?\n/))) {
+        return text;
+    }
+    return extractMainResponse(text);
+}
+function linesAreCodexTranscript(lines) {
+    return lines.some((line) => CODEX_HEADER_PATTERN.test(line.trim()))
+        || lines.some((line) => CODEX_COMMAND_PATTERN.test(line.trim()));
+}
+function extractCodexFinalResponse(lines) {
+    const tokensUsedIndex = findLastLine(lines, (line) => line.trim().toLowerCase() === "tokens used");
+    if (tokensUsedIndex >= 0) {
+        const trailing = trimBlankLines(lines.slice(tokensUsedIndex + 1));
+        if (trailing[0] && TOKEN_COUNT_PATTERN.test(trailing[0].trim())) {
+            trailing.shift();
+        }
+        const stdoutResponse = trimBlankLines(trailing).join("\n").trim();
+        if (stdoutResponse) {
+            return stdoutResponse;
+        }
+        const assistantIndex = findLastLine(lines.slice(0, tokensUsedIndex), (line) => line.trim().toLowerCase() === "codex");
+        if (assistantIndex >= 0) {
+            return trimBlankLines(lines.slice(assistantIndex + 1, tokensUsedIndex)).join("\n").trim();
+        }
+    }
+    return "";
+}
+function findLastLine(lines, predicate) {
+    for (let index = lines.length - 1; index >= 0; index -= 1) {
+        if (predicate(lines[index] ?? "")) {
+            return index;
+        }
+    }
+    return -1;
+}
+function trimBlankLines(lines) {
+    let start = 0;
+    let end = lines.length;
+    while (start < end && !(lines[start] ?? "").trim()) {
+        start += 1;
+    }
+    while (end > start && !(lines[end - 1] ?? "").trim()) {
+        end -= 1;
+    }
+    return lines.slice(start, end);
+}
+function stripTerminalControls(text) {
+    return text
+        .replace(ANSI_CSI_PATTERN, "")
+        .replace(ANSI_OSC_PATTERN, "");
+}

package/dist/core/session-manager.js

@@ -4,6 +4,7 @@ import { basename, dirname, join } from "node:path";
 import { z } from "zod";
 import { appendJsonLine, appendText, ensureDir, pathExists, readJson, readRecentJsonLines, readTextIfExists, removeIfExists, writeJson, writeText } from "./file-store.js";
 import { runWithLeaseFinalization } from "./lease-finalization.js";
+import { sanitizePersistedMainMessage } from "./main-response.js";
 import { formatTaskTimestamp, taskDir, taskSessionIdIsValid } from "./paths.js";
 import { sessionsRoot } from "./paths.js";
 import { loadCollaborationTimeline } from "./collaboration-timeline.js";
@@ -212,7 +213,11 @@ export class SessionManager {
         const boundedLimit = Number.isFinite(limit)
             ? Math.min(1000, Math.max(0, Math.trunc(limit)))
             : 200;
-        return readRecentJsonLines(join(this.mainSessionDir(), "chat.jsonl"), ChatRecordSchema, boundedLimit);
+        const records = await readRecentJsonLines(join(this.mainSessionDir(), "chat.jsonl"), ChatRecordSchema, boundedLimit);
+        return records.map((record) => ({
+            ...record,
+            text: sanitizePersistedMainMessage(record.from, record.text)
+        }));
     }
     taskFromId(taskId) {
         const dir = taskDir(this.projectRoot, this.dataDir, taskId);

package/dist/core/worker-output-policy.js

@@ -0,0 +1,19 @@
+export function workerBuffersOutputUntilCompletion(profile, args) {
+    if (profile !== "claude" || !args.some((arg) => arg === "--print" || arg === "-p")) {
+        return false;
+    }
+    const outputFormat = readOptionValue(args, "--output-format");
+    return outputFormat === undefined || outputFormat === "text" || outputFormat === "json";
+}
+function readOptionValue(args, option) {
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (arg === option) {
+            return args[index + 1]?.trim().toLowerCase();
+        }
+        if (arg?.startsWith(`${option}=`)) {
+            return arg.slice(option.length + 1).trim().toLowerCase();
+        }
+    }
+    return undefined;
+}

package/dist/orchestrator/orchestrator.js

@@ -2,6 +2,7 @@ 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";
+import { extractMainResponse } from "../core/main-response.js";
 import { claimTaskRunLease, TaskRunLeaseConflictError } from "../core/process-ownership.js";
 import { routerRuntimeDir } from "../core/paths.js";
 import { classifyRouterFailure, routerFallbackIsTransient } from "../core/router-audit.js";
@@ -2235,14 +2236,6 @@ async function recoverWorkerFileFromWorkspace(sourcePath, targetPath) {
     }
     await mirrorWorkerFileToFeature(sourcePath, targetPath);
 }
-function extractMainResponse(outputLog) {
-    return outputLog
-        .split("\n")
-        .filter((line) => !line.startsWith("$ "))
-        .filter((line) => !line.startsWith("[mock:main]"))
-        .join("\n")
-        .trim();
-}
 function emptyMainResponseSummary() {
     return "简单对话通道没有收到可显示回复。";
 }

package/dist/orchestrator/workspace-sandbox.js

@@ -7,6 +7,8 @@ const MAX_TEXT_MERGE_BYTES = 10 * 1024 * 1024;
 const FEATURE_ID_PATTERN = /^[a-z0-9][a-z0-9-]{0,63}$/;
 const COMMIT_ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9-]{0,63}$/;
 const LIVE_COMMIT_PROTOCOL = "atomic-claim-v1";
+const HOST_METADATA_FILES = new Set([".DS_Store", "Thumbs.db", "desktop.ini"]);
+const HOST_METADATA_DIRECTORIES = new Set([".Spotlight-V100", ".Trashes", ".fseventsd"]);
 export class WorkspaceMergeConflictError extends Error {
     paths;
     conflictDir;
@@ -405,10 +407,18 @@ export class ParallelWorkspaceManager {
         if (segments.includes(".git")) {
             return true;
         }
+        if (isHostMetadataPath(segments)) {
+            return true;
+        }
         return Boolean(this.dataRelativePath
             && (path === this.dataRelativePath || path.startsWith(`${this.dataRelativePath}${sep}`)));
     }
 }
+function isHostMetadataPath(segments) {
+    return segments.some((segment) => (HOST_METADATA_FILES.has(segment)
+        || HOST_METADATA_DIRECTORIES.has(segment)
+        || segment.startsWith("._")));
+}
 async function readJsonRecord(path) {
     try {
         const value = JSON.parse(await readFile(path, "utf8"));

package/dist/tui/App.js

@@ -34,6 +34,7 @@ import { latestTaskResultMessageIndex, parseTaskResultSummary } from "./task-res
 import { buildNativeAttachLaunch, buildNativeForkLaunch, startNativeAttachProcess } from "../workers/native-attach.js";
 import { assignableWorkerProviderIds, workerProviderLabel, workerProviders } from "../workers/provider.js";
 import { StatusDetailView } from "./StatusDetailView.js";
+import { runtimeConfigChange } from "./runtime-config-state.js";
 export function routeDecisionChatMessage(route) {
     return `route · ${route.mode} · ${route.source ?? "router"}\n${route.reason.trim()}`;
 }
@@ -48,7 +49,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, exportDiagnostics, loadCollaborationTimeline, activateTaskSession, prepareNativeAttach, prepareNativeFork, startNativeAttach, copyToClipboard = copyTextToClipboard, shutdownSignal }) {
+export function App({ config, orchestrator, cwd, initialTaskId = null, initialRoute = null, initialWorkers, initialCanRetryTask = false, initialMessages = [], persistChatMessage, reloadConfig, 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
@@ -74,6 +75,7 @@ export function App({ config, orchestrator, cwd, initialTaskId = null, initialRo
     const [activeMode, setActiveMode] = useState(initialTaskId ? "complex" : null);
     const [canRetryTask, setCanRetryTask] = useState(initialCanRetryTask);
     const [attachError, setAttachError] = useState(null);
+    const [configChange, setConfigChange] = useState(null);
     const [clipboardNotice, setClipboardNotice] = useState(null);
     const [nativeInput, setNativeInput] = useState("");
     const [workerScrollOffset, setWorkerScrollOffset] = useState(0);
@@ -250,6 +252,43 @@ export function App({ config, orchestrator, cwd, initialTaskId = null, initialRo
             process.stdout.off("resize", updateTerminalSize);
         };
     }, []);
+    useEffect(() => {
+        if (!reloadConfig) {
+            return;
+        }
+        let active = true;
+        let loading = false;
+        const refresh = async () => {
+            if (loading) {
+                return;
+            }
+            loading = true;
+            try {
+                const latest = await reloadConfig();
+                if (active) {
+                    setConfigChange(runtimeConfigChange(config, latest));
+                }
+            }
+            catch (error) {
+                if (active) {
+                    setConfigChange({
+                        kind: "restart",
+                        detail: `config · invalid · ${error instanceof Error ? error.message : String(error)}`,
+                        compact: "config invalid"
+                    });
+                }
+            }
+            finally {
+                loading = false;
+            }
+        };
+        void refresh();
+        const interval = setInterval(() => void refresh(), 1500);
+        return () => {
+            active = false;
+            clearInterval(interval);
+        };
+    }, [config, reloadConfig]);
     useEffect(() => {
         inputCursorRef.current = inputCursor;
     }, [inputCursor]);
@@ -2689,7 +2728,7 @@ export function App({ config, orchestrator, cwd, initialTaskId = null, initialRo
     if (view === "workspace") {
         return (_jsx(Box, { flexDirection: "column", height: terminalSize.rows, children: _jsx(WorkspacePicker, { cwd: cwd, choices: workspaceChoices, terminalHeight: terminalSize.rows, terminalWidth: terminalWidth, onCancel: closeWorkspacePicker, onSelect: (workspace) => void selectWorkspace(workspace) }) }));
     }
-    return (_jsx(AppShell, { view: view, cwd: cwd, taskId: activeTaskId, statusText: [visibleTaskStatus, visibleRouteSummary].filter(Boolean).join(" | "), contentHeight: contentHeight, showStatusBar: config.ui.showStatusBar, input: _jsx(InputBar, { mode: view === "worker" && workerSearch.open ? "worker-search" : view, ready: inputReady, busy: busy, routeFallback: Boolean(routeFallbackPrompt), collaborationDetail: collaborationDetailOpen, collaborationUnresolved: collaborationUnresolvedOnly, collaborationBack: collaborationReturnViewRef.current, featureCanCancel: featureCanCancel, featureCanPause: featureCanCancel, featureCanReassign: featureCanReassign, featureCancelConfirm: featureCancelPrompt?.action === "cancel", featurePauseConfirm: featureCancelPrompt?.action === "pause", featureAssignment: Boolean(featureAssignmentPrompt), taskSessionAction: taskSessionAction?.type === "rename"
+    return (_jsx(AppShell, { view: view, cwd: cwd, taskId: activeTaskId, statusText: [visibleTaskStatus, visibleRouteSummary, configChange?.compact].filter(Boolean).join(" | "), contentHeight: contentHeight, showStatusBar: config.ui.showStatusBar, input: _jsx(InputBar, { mode: view === "worker" && workerSearch.open ? "worker-search" : view, ready: inputReady, busy: busy, routeFallback: Boolean(routeFallbackPrompt), collaborationDetail: collaborationDetailOpen, collaborationUnresolved: collaborationUnresolvedOnly, collaborationBack: collaborationReturnViewRef.current, featureCanCancel: featureCanCancel, featureCanPause: featureCanCancel, featureCanReassign: featureCanReassign, featureCancelConfirm: featureCancelPrompt?.action === "cancel", featurePauseConfirm: featureCancelPrompt?.action === "pause", featureAssignment: Boolean(featureAssignmentPrompt), taskSessionAction: taskSessionAction?.type === "rename"
                 ? { type: "rename", value: taskSessionAction.value, cursor: taskSessionAction.cursor }
                 : taskSessionAction?.type === "delete"
                     ? { type: "delete", title: taskSessionAction.title }
@@ -2697,7 +2736,7 @@ export function App({ config, orchestrator, cwd, initialTaskId = null, initialRo
                 ? workerSearch.query
                 : view === "native" || view === "router" || view === "workers" || view === "features" || view === "sessions" || view === "collaboration" || view === "status" ? "" : input, cursor: workerSearch.open && view === "worker"
                 ? workerSearch.cursor
-                : view === "chat" ? inputCursor : undefined, terminalWidth: terminalWidth, onChange: view === "native" ? setNativeInput : setInput, onSubmit: view === "native" ? undefined : submit }), error: attachError, children: view === "status" ? (_jsx(StatusDetailView, { cwd: cwd, taskId: activeTaskId, mode: activeMode, busy: busy, canRetry: canRetryTask, taskStatus: visibleTaskStatus, routeStatus: visibleRouteStatus, routeReason: routePending ? undefined : lastRoute?.reason, workers: workers, selectedWorkerIndex: selectedWorkerIndex, height: contentHeight, terminalWidth: terminalWidth })) : view === "native" ? (_jsx(NativeAttachView, { attach: nativeAttach, viewportHeight: contentHeight })) : view === "sessions" ? (taskSessionDetails ? (_jsx(TaskSessionDetailView, { details: taskSessionDetails, selectedWorkerIndex: taskSessionDetailSelectedWorkerIndex, loading: taskSessionsLoading, error: taskSessionsError, notice: taskSessionDetailNotice, height: contentHeight, terminalWidth: terminalWidth })) : (_jsx(TaskSessionsView, { tasks: taskSessions, activeTaskId: activeTaskId, selectedIndex: selectedTaskSessionIndex, includeArchived: taskSessionsIncludeArchived, notice: taskSessionsNotice, action: taskSessionAction?.type === "rename"
+                : view === "chat" ? inputCursor : undefined, terminalWidth: terminalWidth, onChange: view === "native" ? setNativeInput : setInput, onSubmit: view === "native" ? undefined : submit }), error: attachError, children: view === "status" ? (_jsx(StatusDetailView, { cwd: cwd, taskId: activeTaskId, mode: activeMode, busy: busy, canRetry: canRetryTask, taskStatus: visibleTaskStatus, routeStatus: visibleRouteStatus, routeReason: routePending ? undefined : lastRoute?.reason, pairing: config.pairing, configStatus: configChange?.detail, configRestartRequired: configChange?.kind === "restart", workers: workers, selectedWorkerIndex: selectedWorkerIndex, height: contentHeight, terminalWidth: terminalWidth })) : view === "native" ? (_jsx(NativeAttachView, { attach: nativeAttach, viewportHeight: contentHeight })) : view === "sessions" ? (taskSessionDetails ? (_jsx(TaskSessionDetailView, { details: taskSessionDetails, selectedWorkerIndex: taskSessionDetailSelectedWorkerIndex, loading: taskSessionsLoading, error: taskSessionsError, notice: taskSessionDetailNotice, height: contentHeight, terminalWidth: terminalWidth })) : (_jsx(TaskSessionsView, { tasks: taskSessions, activeTaskId: activeTaskId, selectedIndex: selectedTaskSessionIndex, includeArchived: taskSessionsIncludeArchived, notice: taskSessionsNotice, action: taskSessionAction?.type === "rename"
                 ? { type: "rename", title: taskSessionAction.title }
                 : taskSessionAction?.type === "delete"
                     ? { type: "delete", title: taskSessionAction.title }

package/dist/tui/StatusBar.js

@@ -275,18 +275,24 @@ function currentStatusValueCandidates(text) {
     ].filter(Boolean)));
 }
 function compactCurrentStatusDetail(detail) {
+    if (/^working\s+·\s+buffered$/i.test(detail)) {
+        return "run buffered";
+    }
     const progress = detail.match(/^(waiting output|responding)\s+·\s+(\d+(?:\.\d+)?s)\s*\/\s*(\d+(?:\.\d+)?(?:ms|s|m))\s+(?:first|idle)$/i);
     if (progress) {
         const state = progress[1]?.toLowerCase() === "responding" ? "reply" : "wait";
         return `${state} ${progress[2]}/${progress[3]}`;
     }
-    const state = detail.match(/^(starting|running|run|done|failed|fail|waiting|wait|queued|stopping|stop|idle|cancelled|canceled)\b/i)?.[1]?.toLowerCase();
+    const state = detail.match(/^(starting|working|running|run|done|failed|fail|waiting|wait|queued|stopping|stop|idle|cancelled|canceled)\b/i)?.[1]?.toLowerCase();
     if (state === "starting") {
         return "start";
     }
     if (state === "running") {
         return "run";
     }
+    if (state === "working") {
+        return "run";
+    }
     if (state === "failed") {
         return "fail";
     }
@@ -763,7 +769,7 @@ function parseMainEngineStatus(part) {
     };
 }
 function runtimeStatusTone(status) {
-    if (status === "run" || status === "running" || status === "starting" || status === "responding") {
+    if (status === "run" || status === "running" || status === "working" || status === "starting" || status === "responding") {
         return "run";
     }
     if (status === "done") {

package/dist/tui/StatusDetailView.js

@@ -23,8 +23,18 @@ export function statusDetailDisplayLines(input, width, height) {
         {
             text: fitStatusDetailText(`workspace · ${basename(input.cwd) || input.cwd} · ${input.cwd}`, safeWidth),
             tone: "muted"
+        },
+        {
+            text: fitStatusDetailText(rolePairingDetail(input.pairing), safeWidth),
+            tone: "text"
         }
     ];
+    if (input.configStatus?.trim()) {
+        lines.push({
+            text: fitStatusDetailText(input.configStatus, safeWidth),
+            tone: input.configRestartRequired ? "warning" : "success"
+        });
+    }
     if (input.routeStatus.trim()) {
         lines.push({
             text: fitStatusDetailText(input.routeStatus.trim(), safeWidth),
@@ -49,6 +59,15 @@ export function statusDetailDisplayLines(input, width, height) {
     }
     return lines.slice(0, maxLines);
 }
+function rolePairingDetail(pairing) {
+    return [
+        "active roles",
+        `main/${pairing.main}`,
+        `judge/${pairing.judge}`,
+        `actor/${pairing.actor}`,
+        `critic/${pairing.critic}`
+    ].join(" · ");
+}
 function taskDetail(input) {
     if (!input.taskId) {
         return "task · none";

package/dist/tui/WorkerOverviewView.js

@@ -80,6 +80,12 @@ export function workerOverviewActivityLine(worker, nowMs, policy) {
             tone: "warning"
         };
     }
+    if (status.phase === "process-buffered") {
+        return {
+            text: `activity · working ${formatWorkerActivityDuration(ageMs)} · output buffered until completion`,
+            tone: "muted"
+        };
+    }
     const starting = status.state === "starting";
     const limitMs = effectiveWorkerWatchdog(starting ? policy.firstOutputTimeoutMs : policy.idleTimeoutMs, policy.timeoutMs);
     const activity = starting ? "started" : "output";

package/dist/tui/runtime-config-state.js

@@ -0,0 +1,21 @@
+export function runtimeConfigChange(active, latest) {
+    if (runtimeConfigFingerprint(active) !== runtimeConfigFingerprint(latest)) {
+        return {
+            kind: "restart",
+            detail: "config · roles/workers changed · restart required",
+            compact: "config restart"
+        };
+    }
+    if (JSON.stringify(active.router) !== JSON.stringify(latest.router)) {
+        return {
+            kind: "router",
+            detail: "config · router changed · active on next request",
+            compact: "config router live"
+        };
+    }
+    return null;
+}
+function runtimeConfigFingerprint(config) {
+    const { router: _router, ...runtime } = config;
+    return JSON.stringify(runtime);
+}

package/dist/tui/status-line.js

@@ -45,6 +45,9 @@ function formatMainStatus(status, progress) {
     if (progress.phase === "initialized") {
         return "starting";
     }
+    if (progress.phase === "process-buffered") {
+        return "working · buffered";
+    }
     if (progress.phase === "process-starting" || progress.phase === "native-resume-fallback") {
         return formatMainWaitProgress("waiting output", progress.elapsedMs, progress.firstOutputTimeoutMs, "first");
     }

package/dist/version.js

@@ -1 +1 @@
-export const version = "0.2.4";
+export const version = "0.2.5";

package/dist/workers/process-adapter.js

@@ -4,6 +4,7 @@ import { StringDecoder } from "node:string_decoder";
 import { appendText, writeJson } from "../core/file-store.js";
 import { clearWorkerProcessRecord, writeWorkerProcessRecord } from "../core/process-ownership.js";
 import { terminateProcessTree } from "../core/process-tree.js";
+import { workerBuffersOutputUntilCompletion } from "../core/worker-output-policy.js";
 import { detectNativeSessionId } from "./native-session-detection.js";
 const WORKER_DIAGNOSTIC_TAIL_CHARS = 64 * 1024;
 const RESUME_DETECTION_OVERLAP_CHARS = 512;
@@ -32,7 +33,8 @@ export class ProcessWorkerAdapter {
             modelConfig: model
         };
         const first = await this.runAttempt(runSpec, launch, {
-            initialNativeSessionId: launch.initialNativeSessionId
+            initialNativeSessionId: launch.initialNativeSessionId,
+            outputBufferedUntilCompletion: workerBuffersOutputUntilCompletion(capabilities.profile, launch.args)
         });
         if (!shouldFallbackToNewNativeSession(first, runSpec.nativeSessionConfig)) {
             return first.result;
@@ -49,7 +51,8 @@ export class ProcessWorkerAdapter {
         }, freshLaunch, {
             initialNativeSessionId: freshLaunch.initialNativeSessionId,
             startPhase: "native-resume-fallback",
-            startSummary: `${this.command} starting fresh session after unrecoverable native resume`
+            startSummary: `${this.command} starting fresh session after unrecoverable native resume`,
+            outputBufferedUntilCompletion: workerBuffersOutputUntilCompletion(capabilities.profile, freshLaunch.args)
         })).result;
     }
     async runAttempt(runSpec, launch, options = {}) {
@@ -64,7 +67,13 @@ export class ProcessWorkerAdapter {
             await appendText(runSpec.outputLogPath, "Process cancelled by user before start\n");
             return { result, output: "", launch };
         }
-        await setStatus(runSpec, "starting", options.startPhase ?? "process-starting", options.startSummary ?? `Starting ${this.command}`);
+        const startPhase = options.outputBufferedUntilCompletion
+            ? "process-buffered"
+            : options.startPhase ?? "process-starting";
+        const startSummary = options.startSummary ?? `Starting ${this.command}`;
+        await setStatus(runSpec, "starting", startPhase, options.outputBufferedUntilCompletion
+            ? `${startSummary}; text output is buffered until completion`
+            : startSummary);
         await appendText(runSpec.outputLogPath, `$ ${formatShellCommand(this.command, launch.args)}\n`);
         return new Promise((resolve, reject) => {
             const detached = process.platform !== "win32";
@@ -456,7 +465,9 @@ export class ProcessWorkerAdapter {
                     failAndTerminate("process-timeout", `${this.command} exceeded ${runSpec.timeoutMs}ms`, `\nProcess timed out after ${runSpec.timeoutMs}ms\n`);
                 }, runSpec.timeoutMs);
             }
-            if (runSpec.firstOutputTimeoutMs
+            if (!options.outputBufferedUntilCompletion
+                &&
+                    runSpec.firstOutputTimeoutMs
                 && runSpec.firstOutputTimeoutMs > 0
                 && (!runSpec.timeoutMs || runSpec.timeoutMs <= 0 || runSpec.firstOutputTimeoutMs < runSpec.timeoutMs)) {
                 firstOutputTimeout = setTimeout(() => {
@@ -540,7 +551,7 @@ function enforceWorkerIsolationArgs(args, profile, enforce) {
         return enforceCodexWorkspaceSandbox(args);
     }
     if (profile === "claude") {
-        return enforceClaudeEditPermissions(args);
+        return enforceClaudeAutoPermissions(args);
     }
     return args;
 }
@@ -586,7 +597,7 @@ function enforceCodexWorkspaceSandbox(args) {
     }
     return result;
 }
-function enforceClaudeEditPermissions(args) {
+function enforceClaudeAutoPermissions(args) {
     const result = [];
     let hasPermissionMode = false;
     for (let index = 0; index < args.length; index += 1) {
@@ -595,20 +606,20 @@ function enforceClaudeEditPermissions(args) {
             continue;
         }
         if (arg === "--permission-mode") {
-            result.push(arg, "acceptEdits");
+            result.push(arg, "auto");
             hasPermissionMode = true;
             index += 1;
             continue;
         }
         if (arg.startsWith("--permission-mode=")) {
-            result.push("--permission-mode=acceptEdits");
+            result.push("--permission-mode=auto");
             hasPermissionMode = true;
             continue;
         }
         result.push(arg);
     }
     if (!hasPermissionMode) {
-        result.push("--permission-mode", "acceptEdits");
+        result.push("--permission-mode", "auto");
     }
     return result;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "parallel-codex-tui",
-  "version": "0.2.4",
+  "version": "0.2.5",
   "description": "A TypeScript TUI wrapper for routed parallel coding with Codex and Claude workers.",
   "license": "MIT",
   "type": "module",