parallel-codex-tui 0.2.0 → 0.2.2

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

@@ -4,18 +4,18 @@ defaultMode = "auto"
 [router.codex]
 command = "codex"
 args = ["exec", "--ephemeral", "--ignore-rules", "-c", "model_reasoning_effort=low", "--skip-git-repo-check", "--sandbox", "read-only", "--color", "never", "-"]
-timeoutMs = 30000
+timeoutMs = 60000
 # Stop a silent Router before the total ceiling so one transient retry stays bounded.
-firstOutputTimeoutMs = 15000
+firstOutputTimeoutMs = 30000
 # Reset after every stdout/stderr chunk; timeoutMs remains the hard ceiling.
-idleTimeoutMs = 15000
+idleTimeoutMs = 30000
 # Stop a noisy or malformed classifier before it can grow Router memory without bound (1 KiB..16 MiB).
 maxOutputBytes = 1048576
 # Retry one transient Router failure before asking the user; 1 disables automatic retry.
 maxAttempts = 2
 retryDelayMs = 500
 # Active-task follow-ups fail safely to Main after this shorter Codex timeout.
-followUpTimeoutMs = 20000
+followUpTimeoutMs = 45000
 # Non-interactive fallback; the TUI pauses and asks before executing it.
 fallback = "simple"
 

package/README.md

@@ -6,7 +6,7 @@ Built with Codex-assisted development.
 
 ## Current Release
 
-`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.
+`v0.2.2` is available from [npm](https://www.npmjs.com/package/parallel-codex-tui/v/0.2.2) and as a [GitHub Release](https://github.com/allendred/parallel-codex-tui/releases/tag/v0.2.2). It automatically inherits the macOS system proxy when explicit proxy variables are absent, expands the default Router cold-start budget, and retains the single Up/Down request-history fix from `v0.2.1`.
 
 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.
 
@@ -20,7 +20,7 @@ Highlights:
 - 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, 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`.
+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,262 tests across 123 files; one quota-consuming real-Agent test is skipped by default 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.
 
@@ -205,7 +205,7 @@ The doctor output includes `preview:` and `semantic:` ANSI swatch rows so you ca
 - 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.
-- Chat drafts support Unicode-safe Left/Right, Home/End, Backspace, and Delete editing; Ctrl+Up/Down recalls persisted user requests and returns to the exact unsent draft, while plain Up/Down remains available to alternate-scroll wheel input. Long input stays on one row with the visible window centered around the logical cursor.
+- 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/`.
 - Task lifecycle is a checked state machine. A task enters `routed` only after the turn and route files are durable, and enters `ready_for_pair` only after Judge artifacts validate; invalid phase skips are rejected before metadata or event projections change. Persisted follow-up turns that still carry an older `done` state are recovered as cancelled and retryable on startup instead of being hidden as completed.
@@ -264,17 +264,17 @@ defaultMode = "auto"
 [router.codex]
 command = "codex"
 args = ["exec", "--ephemeral", "--ignore-rules", "-c", "model_reasoning_effort=low", "--skip-git-repo-check", "--sandbox", "read-only", "--color", "never", "-"]
-timeoutMs = 30000
-firstOutputTimeoutMs = 15000
-idleTimeoutMs = 15000
+timeoutMs = 60000
+firstOutputTimeoutMs = 30000
+idleTimeoutMs = 30000
 maxOutputBytes = 1048576
 maxAttempts = 2
 retryDelayMs = 500
-followUpTimeoutMs = 20000
+followUpTimeoutMs = 45000
 fallback = "simple"
 ```
 
-Set `defaultMode = "simple"` / `defaultMode = "complex"` to force one path. In `auto` mode, routing is semantic through an ephemeral, low-reasoning Codex run. Only `simple` and `complex` are accepted route modes; harmless casing and surrounding whitespace are normalized, while invalid JSON or an unknown mode uses the configured fallback and appears as `invalid output` in the status bar. `fallback = "simple"` or `fallback = "complex"` supplies the non-interactive fallback path; the safe default is `simple` and there is no keyword-only router. `firstOutputTimeoutMs` stops a silent process, `idleTimeoutMs` resets after every stdout or stderr chunk, and `timeoutMs` remains the hard ceiling even while output continues. `maxOutputBytes` bounds combined Router stdout and stderr in memory; exceeding it stops the process tree and reports invalid output instead of waiting for a timeout. The 1 MiB default can be configured from 1 KiB through 16 MiB. The 15-second first-output and idle defaults stay below the 30-second total ceiling, so their failure kinds remain visible. Two repeated silent starts settle in about 30.5 seconds instead of two full 30-second waits; an idle deadline begins after the latest output, while the hard ceiling still bounds every attempt. A watchdog only runs separately when its limit is lower than the active initial or follow-up total timeout, avoiding competing timers at the same deadline.
+Set `defaultMode = "simple"` / `defaultMode = "complex"` to force one path. In `auto` mode, routing is semantic through an ephemeral, low-reasoning Codex run. Only `simple` and `complex` are accepted route modes; harmless casing and surrounding whitespace are normalized, while invalid JSON or an unknown mode uses the configured fallback and appears as `invalid output` in the status bar. `fallback = "simple"` or `fallback = "complex"` supplies the non-interactive fallback path; the safe default is `simple` and there is no keyword-only router. `firstOutputTimeoutMs` stops a silent process, `idleTimeoutMs` resets after every stdout or stderr chunk, and `timeoutMs` remains the hard ceiling even while output continues. `maxOutputBytes` bounds combined Router stdout and stderr in memory; exceeding it stops the process tree and reports invalid output instead of waiting for a timeout. The 1 MiB default can be configured from 1 KiB through 16 MiB. The 30-second first-output and idle defaults stay below the 60-second total ceiling, leaving room for a proxied Codex cold start while preserving distinct failure evidence. An idle deadline begins after the latest output, while the hard ceiling still bounds every attempt. A watchdog only runs separately when its limit is lower than the active initial or follow-up total timeout, avoiding competing timers at the same deadline.
 
 On POSIX systems the Router command runs in its own process group. Timeout, cancellation, and stdin failure send `SIGTERM`, wait briefly for graceful cleanup, then use `SIGKILL` when any group member remains. A retry, fallback choice, or completed cancellation is not exposed until that command tree is confirmed stopped, so a previous classifier cannot overlap the next Router or Worker. If termination cannot be verified after `SIGKILL`, the request fails closed instead of continuing around a live process.
 
@@ -290,7 +290,7 @@ Every new Router fallback persists an authoritative `router_failure_kind` alongs
 
 ### Proxy Environment
 
-Some CLI runtimes do not inherit the macOS System Settings proxy. Configure the router explicitly when direct OpenAI connections are blocked:
+On macOS, startup automatically inherits enabled HTTP, HTTPS, SOCKS, and bypass settings from System Settings when the corresponding process environment variables are absent. Explicit shell variables and local config remain authoritative. Set `PARALLEL_CODEX_INHERIT_SYSTEM_PROXY=0` to opt out. Configure provider-specific values explicitly when one agent needs a different route:
 
 ```toml
 [router.codex.env]
@@ -308,7 +308,7 @@ NO_PROXY = "localhost,127.0.0.1"
 
 `router.codex.env` applies only to semantic classification. `workers.<id>.model.env` applies to fresh/resumed runs and embedded native attach for that named Worker Provider. Keep these values in local `config.toml`, which is ignored by Git.
 
-Run `parallel-codex-tui --doctor` after changing proxy settings. Doctor checks referenced environment variables, reports when a macOS system proxy is not inherited by Codex subprocesses, and labels configured proxy host/port checks as local-endpoint reachability without printing credentials. Then run `parallel-codex-tui --doctor --probe-router` when you also need to verify the real Codex Router path through that proxy; this explicit probe can take up to `router.codex.timeoutMs`. A timed-out request is identified as `first output timeout`, `idle timeout after stdout/stderr`, or `total timeout`; `via <proxy-host:port>` remains context, not a claim that the proxy caused the failure. The audit never exposes the proxy URL or credentials.
+Run `parallel-codex-tui --doctor` after changing proxy settings. Doctor checks referenced environment variables and labels inherited or configured proxy host/port checks as local-endpoint reachability without printing credentials. If system-proxy detection is unavailable, Doctor reports that the macOS proxy was not inherited and points to the explicit config table. Then run `parallel-codex-tui --doctor --probe-router` when you also need to verify the real Codex Router path through that proxy; this explicit probe can take up to `router.codex.timeoutMs`. A timed-out request is identified as `first output timeout`, `idle timeout after stdout/stderr`, or `total timeout`; `via <proxy-host:port>` remains context, not a claim that the proxy caused the failure. The audit never exposes the proxy URL or credentials.
 
 ## Mock Mode
 
@@ -452,7 +452,7 @@ Keep `[router.codex]` on `read-only`; routing only classifies requests and does
 
 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.
 
-In chat, scroll long conversation history with the mouse wheel, plain Up/Down, or PageUp/PageDown; sending a new message returns to the latest reply. 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. Use Ctrl+Up/Down for persisted request history. `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, 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.
 
 `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 +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.2.0
+VERSION=0.2.2
 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.0` requires tag `v0.2.0`. Published tags such as `v0.1.8` 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.2` requires tag `v0.2.2`. Published tags such as `v0.2.1` are immutable and must not be moved or reused.
 
 ## Publishing Hygiene
 

package/dist/cli.js

@@ -16,6 +16,7 @@ import { configPath, loadConfig, withUiThemeOverride, writeDefaultConfig } from
 import { pathExists } from "./core/file-store.js";
 import { exportDiagnostics } from "./core/diagnostics.js";
 import { readRouterAudit } from "./core/router-audit.js";
+import { inheritMacSystemProxy } from "./core/system-proxy.js";
 import { loadTaskSessionDetails as loadPersistedTaskSessionDetails } from "./core/task-session-details.js";
 import { listWorkspaceChoices } from "./core/workspace.js";
 import { runDoctor, runRuntimePreflight } from "./doctor.js";
@@ -40,6 +41,9 @@ async function main() {
         process.exit(1);
     }
     const cliArgs = parseCliArgs(rawArgs, process.cwd());
+    if (!cliArgs.help && !cliArgs.themes && !cliArgs.version && !cliArgs.init) {
+        await inheritMacSystemProxy(process.env);
+    }
     if (!cliArgs.help && !cliArgs.themes && !cliArgs.version) {
         await prepareAppRoot(cliArgs.appRoot);
     }

package/dist/core/config.js

@@ -74,13 +74,13 @@ const CodexRouterConfigSchema = z.object({
         "never",
         "-"
     ]),
-    timeoutMs: z.number().int().positive().default(30000),
-    firstOutputTimeoutMs: z.number().int().positive().default(15000),
-    idleTimeoutMs: z.number().int().positive().default(15000),
+    timeoutMs: z.number().int().positive().default(60000),
+    firstOutputTimeoutMs: z.number().int().positive().default(30000),
+    idleTimeoutMs: z.number().int().positive().default(30000),
     maxOutputBytes: z.number().int().min(1024).max(16 * 1024 * 1024).default(1024 * 1024),
     maxAttempts: z.number().int().min(1).max(3).default(2),
     retryDelayMs: z.number().int().min(0).max(10000).default(500),
-    followUpTimeoutMs: z.number().int().positive().max(120000).default(20000),
+    followUpTimeoutMs: z.number().int().positive().max(120000).default(45000),
     fallback: z.enum(["simple", "complex"]).default("simple"),
     env: z.record(z.string()).default({})
 });
@@ -165,13 +165,13 @@ export function defaultConfig(projectRoot) {
                     "never",
                     "-"
                 ],
-                timeoutMs: 30000,
-                firstOutputTimeoutMs: 15000,
-                idleTimeoutMs: 15000,
+                timeoutMs: 60000,
+                firstOutputTimeoutMs: 30000,
+                idleTimeoutMs: 30000,
                 maxOutputBytes: 1024 * 1024,
                 maxAttempts: 2,
                 retryDelayMs: 500,
-                followUpTimeoutMs: 20000,
+                followUpTimeoutMs: 45000,
                 fallback: "simple",
                 env: {}
             }

package/dist/core/system-proxy.js

@@ -0,0 +1,79 @@
+import { execFile } from "node:child_process";
+const proxyEnvironmentNames = ["HTTP_PROXY", "HTTPS_PROXY", "ALL_PROXY"];
+export async function inheritMacSystemProxy(env = process.env, options = {}) {
+    if ((options.platform ?? process.platform) !== "darwin" || systemProxyInheritanceDisabled(env)) {
+        return [];
+    }
+    const output = await (options.readSettings ?? readMacSystemProxySettings)();
+    const settings = parseMacSystemProxySettings(output);
+    if (!settings.http && !settings.https && !settings.socks) {
+        return [];
+    }
+    const inherited = {
+        HTTP_PROXY: settings.http ? proxyUrl("http", settings.http) : null,
+        HTTPS_PROXY: settings.https ? proxyUrl("http", settings.https) : null,
+        ALL_PROXY: settings.socks ? proxyUrl("socks5h", settings.socks) : null
+    };
+    const applied = [];
+    for (const name of proxyEnvironmentNames) {
+        const value = inherited[name];
+        if (!value || environmentHasName(env, name)) {
+            continue;
+        }
+        env[name] = value;
+        applied.push(name);
+    }
+    if (settings.exceptions.length > 0 && !environmentHasName(env, "NO_PROXY")) {
+        env.NO_PROXY = settings.exceptions.join(",");
+        applied.push("NO_PROXY");
+    }
+    return applied;
+}
+export function parseMacSystemProxySettings(output) {
+    return {
+        http: parseProxyEndpoint(output, "HTTP"),
+        https: parseProxyEndpoint(output, "HTTPS"),
+        socks: parseProxyEndpoint(output, "SOCKS"),
+        exceptions: parseProxyExceptions(output)
+    };
+}
+function parseProxyEndpoint(output, prefix) {
+    const enabled = output.match(new RegExp(`\\b${prefix}Enable\\s*:\\s*(\\d+)`))?.[1] === "1";
+    const host = output.match(new RegExp(`\\b${prefix}Proxy\\s*:\\s*(\\S+)`))?.[1];
+    const port = Number(output.match(new RegExp(`\\b${prefix}Port\\s*:\\s*(\\d+)`))?.[1]);
+    return enabled && host && Number.isInteger(port) && port > 0 ? { host, port } : null;
+}
+function parseProxyExceptions(output) {
+    const block = output.match(/ExceptionsList\s*:\s*<array>\s*\{([\s\S]*?)\n\s*\}/)?.[1] ?? "";
+    const exceptions = [...block.matchAll(/^\s*\d+\s*:\s*(.+?)\s*$/gm)]
+        .map((match) => normalizeProxyException(match[1] ?? ""))
+        .filter((value) => Boolean(value));
+    return [...new Set(exceptions)];
+}
+function normalizeProxyException(value) {
+    const normalized = value.trim();
+    if (!normalized) {
+        return null;
+    }
+    if (normalized === "<local>") {
+        return "localhost";
+    }
+    return normalized.startsWith("*.") ? normalized.slice(1) : normalized;
+}
+function proxyUrl(protocol, endpoint) {
+    const host = endpoint.host.includes(":") ? `[${endpoint.host}]` : endpoint.host;
+    return `${protocol}://${host}:${endpoint.port}`;
+}
+function environmentHasName(env, name) {
+    return Object.entries(env).some(([candidate, value]) => (candidate.toUpperCase() === name && Boolean(value?.trim())));
+}
+function systemProxyInheritanceDisabled(env) {
+    return /^(?:0|false|no|off)$/i.test(env.PARALLEL_CODEX_INHERIT_SYSTEM_PROXY?.trim() ?? "");
+}
+function readMacSystemProxySettings() {
+    return new Promise((resolve) => {
+        execFile("scutil", ["--proxy"], { timeout: 1000 }, (error, stdout) => {
+            resolve(error ? "" : stdout);
+        });
+    });
+}

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, isDiagnosticsShortcut, 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, rawChatScrollArrowDelta, 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";
@@ -1389,7 +1389,7 @@ export function App({ config, orchestrator, cwd, initialTaskId = null, initialRo
                     return;
                 }
                 const wheelDelta = mouseScrollDelta(chunk, 3);
-                const arrowScrollDelta = rawPlainArrowDelta(chunk);
+                const arrowScrollDelta = rawChatScrollArrowDelta(chunk);
                 const pageDelta = rawPageScrollDelta(chunk, Math.max(1, outputHeight - 1));
                 const historyDelta = wheelDelta + arrowScrollDelta + pageDelta;
                 if (historyDelta !== 0 && chatMaxScrollOffsetRef.current > 0) {

package/dist/tui/keyboard.js

@@ -79,6 +79,11 @@ export function rawPlainArrowDelta(input) {
     }
     return delta;
 }
+export function rawChatScrollArrowDelta(input) {
+    const delta = rawPlainArrowDelta(input);
+    // Alternate-scroll wheels arrive as arrow bursts; one arrow remains a draft-history keypress.
+    return Math.abs(delta) > 1 ? delta : 0;
+}
 export function mouseScrollDelta(input, linesPerWheel = 3) {
     let delta = 0;
     for (const match of input.matchAll(/\x1b\[<(\d+);\d+;\d+[mM]/g)) {

package/dist/version.js

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

package/package.json

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