parallel-codex-tui 0.1.5 → 0.1.7

package/README.md

@@ -4,6 +4,23 @@ A standalone TypeScript TUI wrapper for routed parallel coding workflows. It kee
 
 Built with Codex-assisted development.
 
+## Current Release
+
+`v0.1.7` is available from [npm](https://www.npmjs.com/package/parallel-codex-tui/v/0.1.7) and as a [GitHub Release](https://github.com/allendred/parallel-codex-tui/releases/tag/v0.1.7). 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 also includes the stability, collaboration, session-management, Provider, TUI, and release work completed in `v0.1.5`:
+
+- 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.
+
+Release acceptance included a real three-Feature Tetris task with parallel Actor/Critic waves, final integration review, 43 project tests, 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. 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 package was independently installed and returned `parallel-codex-tui 0.1.7`.
+
+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.
+
 ## Requirements
 
 - Node.js 24.15+.
@@ -165,7 +182,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; Up/Down recalls persisted user requests and returns to the exact unsent draft. 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; 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.
 - 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.
@@ -412,7 +429,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 or PageUp/PageDown; sending a new message returns to the latest reply. 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 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, 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.
 
 `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.
 
@@ -434,12 +451,12 @@ If a native resume fails because the underlying CLI reports that its context win
 
 ## Release
 
-GitHub Actions runs CI on Ubuntu with Node.js 24.15 and 26, plus macOS with Node.js 26, 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.
+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.
 
 Releases publish to npm through npm Trusted Publishing with GitHub OIDC. Do not configure `NPM_TOKEN` for the release workflow. In npm, configure Trusted Publishing for organization/user `allendred`, repository `parallel-codex-tui`, workflow filename `release.yml`, and allowed action `npm publish`. The package already exists on npm, so future releases can use Trusted Publishing directly. You can also configure the trust relationship from an authenticated npm CLI session:
 
 ```bash
-npm install -g npm@^11.15.0
+npm install -g npm@^11.5.1
 npm trust github parallel-codex-tui --repo allendred/parallel-codex-tui --file release.yml --allow-publish --dry-run
 npm trust github parallel-codex-tui --repo allendred/parallel-codex-tui --file release.yml --allow-publish --yes
 ```
@@ -451,11 +468,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
-git tag v0.1.5
-git push origin v0.1.5
+VERSION=0.1.7
+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.5` requires tag `v0.1.5`.
+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.7` requires tag `v0.1.7`. Published tags such as `v0.1.6` are immutable and must not be moved or reused.
 
 ## Publishing Hygiene
 

package/dist/cli.js

@@ -158,12 +158,14 @@ async function main() {
                 taskId
             }) }, state.runtime.workspaceRoot));
         const removeSigintHandler = installInteractiveSigintExitHandler(() => shutdownController.abort());
+        enterInteractiveTerminal();
         try {
             instance = render(appElement(current), { exitOnCtrlC: false });
             await instance.waitUntilExit();
         }
         finally {
             removeSigintHandler();
+            restoreInteractiveTerminal();
             retryDeferredWorkspaceClosures(deferredWorkspaceClosures);
         }
     }
@@ -291,7 +293,12 @@ function restoreInteractiveTerminal() {
     }
     process.stdin.pause();
     if (process.stdout.isTTY) {
-        process.stdout.write("\x1b[?1006l\x1b[?1002l\x1b[?1000l\x1b[?2004l\x1b[?25h");
+        process.stdout.write("\x1b[?1006l\x1b[?1003l\x1b[?1002l\x1b[?1000l\x1b[?1007l\x1b[?1049l\x1b[?2004l\x1b[?25h");
+    }
+}
+function enterInteractiveTerminal() {
+    if (process.stdout.isTTY) {
+        process.stdout.write("\x1b[?1049h\x1b[?1007h\x1b[?1006l\x1b[?1003l\x1b[?1002l\x1b[?1000l");
     }
 }
 function formatStartupError(error) {

package/dist/core/clipboard.js

@@ -0,0 +1,97 @@
+import { spawn } from "node:child_process";
+const MAX_CLIPBOARD_CHARACTERS = 200_000;
+export async function copyTextToClipboard(text, options = {}) {
+    const value = normalizeClipboardText(text);
+    if (!value) {
+        throw new Error("No visible text to copy");
+    }
+    const platform = options.platform ?? process.platform;
+    const env = options.env ?? process.env;
+    const runCommand = options.runCommand ?? runClipboardCommand;
+    for (const candidate of clipboardCommands(platform, env)) {
+        try {
+            await runCommand(candidate.command, candidate.args, value);
+            return { method: candidate.method, characters: Array.from(value).length };
+        }
+        catch {
+            // Try the next local clipboard integration before falling back to OSC 52.
+        }
+    }
+    const writeTerminal = options.writeTerminal ?? ((sequence) => {
+        process.stdout.write(sequence);
+    });
+    writeTerminal(osc52ClipboardSequence(value));
+    return { method: "osc52", characters: Array.from(value).length };
+}
+export function normalizeClipboardText(text) {
+    const lines = text
+        .replace(/\x1b\][^\x07]*(?:\x07|\x1b\\)/g, "")
+        .replace(/\x1b\[[0-?]*[ -/]*[@-~]/g, "")
+        .replace(/\r\n?/g, "\n")
+        .replace(/[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f]/g, "")
+        .split("\n")
+        .map((line) => line.trimEnd());
+    while (lines[0] === "") {
+        lines.shift();
+    }
+    while (lines.at(-1) === "") {
+        lines.pop();
+    }
+    const clean = lines.join("\n");
+    return Array.from(clean).slice(0, MAX_CLIPBOARD_CHARACTERS).join("");
+}
+export function osc52ClipboardSequence(text) {
+    return `\x1b]52;c;${Buffer.from(text, "utf8").toString("base64")}\x07`;
+}
+function clipboardCommands(platform, env) {
+    if (platform === "darwin") {
+        return [{ method: "pbcopy", command: "/usr/bin/pbcopy", args: [] }];
+    }
+    if (platform !== "linux") {
+        return [];
+    }
+    return [
+        ...(env.WAYLAND_DISPLAY
+            ? [{ method: "wl-copy", command: "wl-copy", args: [] }]
+            : []),
+        ...(env.DISPLAY
+            ? [
+                { method: "xclip", command: "xclip", args: ["-selection", "clipboard"] },
+                { method: "xsel", command: "xsel", args: ["--clipboard", "--input"] }
+            ]
+            : [])
+    ];
+}
+function runClipboardCommand(command, args, text) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(command, args, {
+            env: process.env,
+            stdio: ["pipe", "ignore", "pipe"]
+        });
+        let stderr = "";
+        let settled = false;
+        const finish = (error) => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            if (error) {
+                reject(error);
+            }
+            else {
+                resolve();
+            }
+        };
+        child.stderr?.on("data", (chunk) => {
+            stderr += String(chunk);
+        });
+        child.on("error", (error) => finish(error));
+        child.on("close", (code) => {
+            finish(code === 0
+                ? undefined
+                : new Error(`${command} exited ${code ?? "without a code"}${stderr.trim() ? `: ${stderr.trim()}` : ""}`));
+        });
+        child.stdin?.on("error", (error) => finish(error));
+        child.stdin?.end(text);
+    });
+}

package/dist/tui/App.js

@@ -3,6 +3,7 @@ import { useEffect, useMemo, useRef, useState } from "react";
 import { basename } from "node:path";
 import { Box, Text, useApp, useInput, useStdin } from "ink";
 import { Lexer } from "marked";
+import { copyTextToClipboard } from "../core/clipboard.js";
 import { readJson } from "../core/file-store.js";
 import { WorkerStatusSchema } from "../domain/schemas.js";
 import { effectiveWorkerWatchdog, formatRoutePendingStatus, formatRoutePendingSummaryStatus, formatRouteStatus, formatRouteSummaryStatus, formatStatusLine, formatWorkerRuntimeStatus } from "./status-line.js";
@@ -18,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, isExitShortcut, isLogsShortcut, isNewTaskShortcut, isRouterDiagnosticsShortcut, isStatusDetailsShortcut, isTaskResultShortcut, isTaskSessionsShortcut, isWorkerOverviewShortcut, isWorkerSearchShortcut, isWorkspaceShortcut, mouseScrollDelta, rawHistoryDelta, rawPageScrollDelta, scrollDelta, workerLogJumpKind } from "./keyboard.js";
+import { isAttachShortcut, isCopyShortcut, 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";
@@ -47,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, 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, loadCollaborationTimeline, activateTaskSession, prepareNativeAttach, prepareNativeFork, startNativeAttach, copyToClipboard = copyTextToClipboard, shutdownSignal }) {
     configureTuiTheme({
         theme: config.ui.theme,
         colors: config.ui.colors
@@ -73,6 +74,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 [clipboardNotice, setClipboardNotice] = useState(null);
     const [nativeInput, setNativeInput] = useState("");
     const [workerScrollOffset, setWorkerScrollOffset] = useState(0);
     const [workerSearch, setWorkerSearch] = useState({
@@ -120,6 +122,8 @@ export function App({ config, orchestrator, cwd, initialTaskId = null, initialRo
     const mountedRef = useRef(true);
     const nativeAttachRef = useRef(nativeAttach);
     const nativeAttachRequestSequenceRef = useRef(0);
+    const clipboardNoticeTimerRef = useRef(null);
+    const copyTextByViewRef = useRef({ chat: "", worker: "" });
     const messagesRef = useRef([...initialMessages]);
     const activeRunControllerRef = useRef(null);
     const activeTaskIdRef = useRef(initialTaskId);
@@ -180,6 +184,7 @@ export function App({ config, orchestrator, cwd, initialTaskId = null, initialRo
     const openSelectedTaskSessionDetailsRef = useRef(openSelectedTaskSessionDetails);
     const refreshTaskSessionDetailsRef = useRef(refreshTaskSessionDetails);
     const openTaskSessionDetailWorkerRef = useRef(openTaskSessionDetailWorker);
+    const copyVisibleViewRef = useRef(copyVisibleView);
     const workspaceReturnViewRef = useRef("chat");
     const routerReturnViewRef = useRef("chat");
     const workerOverviewReturnViewRef = useRef("chat");
@@ -366,6 +371,7 @@ export function App({ config, orchestrator, cwd, initialTaskId = null, initialRo
         openSelectedTaskSessionDetailsRef.current = openSelectedTaskSessionDetails;
         refreshTaskSessionDetailsRef.current = refreshTaskSessionDetails;
         openTaskSessionDetailWorkerRef.current = openTaskSessionDetailWorker;
+        copyVisibleViewRef.current = copyVisibleView;
     });
     useEffect(() => {
         if ((view !== "collaboration" && view !== "features") || !activeTaskId || !loadCollaborationTimeline) {
@@ -585,7 +591,7 @@ export function App({ config, orchestrator, cwd, initialTaskId = null, initialRo
     }, [config.ui.autoOpenFailedWorker, status?.taskId, workerActivityPolicies, workerRefreshKey]);
     useEffect(() => {
         setRawMode(true);
-        process.stdout.write("\x1b[?2004h\x1b[?1000h\x1b[?1002h\x1b[?1006h");
+        process.stdout.write("\x1b[?2004h\x1b[?1006l\x1b[?1003l\x1b[?1002l\x1b[?1000l");
         const commitChatInputUpdate = (update, previousValue, previousCursor) => {
             if (update.exit) {
                 activeRunControllerRef.current?.abort();
@@ -682,6 +688,10 @@ export function App({ config, orchestrator, cwd, initialTaskId = null, initialRo
                 return;
             }
             const currentView = viewRef.current;
+            if (currentView !== "workspace" && tokenizeRawInput(chunk).some((inputChunk) => isCopyShortcut(inputChunk, {}))) {
+                void copyVisibleViewRef.current();
+                return;
+            }
             if (currentView === "chat" && routeFallbackPromptRef.current) {
                 const fallbackChunks = tokenizeRawInput(chunk);
                 if (fallbackChunks.some((fallbackChunk) => isExitShortcut(fallbackChunk, {}))) {
@@ -1057,6 +1067,7 @@ export function App({ config, orchestrator, cwd, initialTaskId = null, initialRo
                     }
                     if (collaborationDetailOpenRef.current) {
                         const detailDelta = mouseScrollDelta(timelineChunk, 3)
+                            + rawPlainArrowDelta(timelineChunk)
                             + rawPageScrollDelta(timelineChunk, Math.max(1, outputHeight - 3));
                         if (detailDelta !== 0) {
                             setCollaborationScrollOffset((current) => (nextScrollOffset(current, -detailDelta, collaborationMaxScrollOffsetRef.current)));
@@ -1223,6 +1234,7 @@ export function App({ config, orchestrator, cwd, initialTaskId = null, initialRo
                         return;
                     }
                     const routeDelta = mouseScrollDelta(routerChunk, 3)
+                        + rawPlainArrowDelta(routerChunk)
                         + rawPageScrollDelta(routerChunk, Math.max(1, outputHeight - 1));
                     if (routeDelta !== 0) {
                         setRouterScrollOffset((current) => (nextScrollOffset(current, -routeDelta, routerMaxScrollOffsetRef.current)));
@@ -1298,7 +1310,7 @@ export function App({ config, orchestrator, cwd, initialTaskId = null, initialRo
                         setView("chat");
                         return;
                     }
-                    const delta = mouseScrollDelta(workerChunk, 3);
+                    const delta = mouseScrollDelta(workerChunk, 3) + rawPlainArrowDelta(workerChunk);
                     if (delta !== 0) {
                         setWorkerScrollOffset((current) => nextScrollOffset(current, delta, null));
                     }
@@ -1364,8 +1376,9 @@ export function App({ config, orchestrator, cwd, initialTaskId = null, initialRo
                     return;
                 }
                 const wheelDelta = mouseScrollDelta(chunk, 3);
+                const arrowScrollDelta = rawPlainArrowDelta(chunk);
                 const pageDelta = rawPageScrollDelta(chunk, Math.max(1, outputHeight - 1));
-                const historyDelta = wheelDelta + pageDelta;
+                const historyDelta = wheelDelta + arrowScrollDelta + pageDelta;
                 if (historyDelta !== 0 && chatMaxScrollOffsetRef.current > 0) {
                     setChatScrollOffset((current) => {
                         const next = nextScrollOffset(current, taskResultExpandedRef.current ? -historyDelta : historyDelta, chatMaxScrollOffsetRef.current);
@@ -1414,7 +1427,7 @@ export function App({ config, orchestrator, cwd, initialTaskId = null, initialRo
                     void retryRef.current();
                     return;
                 }
-                const draftHistoryDelta = rawHistoryDelta(chunk);
+                const draftHistoryDelta = rawHistoryDelta(chunk) - arrowScrollDelta;
                 if (draftHistoryDelta !== 0) {
                     if (busyRef.current) {
                         return;
@@ -1477,7 +1490,7 @@ export function App({ config, orchestrator, cwd, initialTaskId = null, initialRo
             stdinEvents.removeListener("input", handleRawInput);
             rawInputDecoderRef.current.end();
             chatPasteDecoderRef.current.reset();
-            process.stdout.write("\x1b[?1006l\x1b[?1002l\x1b[?1000l\x1b[?2004l");
+            process.stdout.write("\x1b[?1006l\x1b[?1003l\x1b[?1002l\x1b[?1000l\x1b[?2004l");
             setRawMode(false);
         };
     }, [outputHeight, setRawMode, stdinEvents]);
@@ -1492,6 +1505,10 @@ export function App({ config, orchestrator, cwd, initialTaskId = null, initialRo
             collaborationLoadSequenceRef.current += 1;
             routerLoadSequenceRef.current += 1;
             taskSessionsLoadSequenceRef.current += 1;
+            if (clipboardNoticeTimerRef.current) {
+                clearTimeout(clipboardNoticeTimerRef.current);
+                clipboardNoticeTimerRef.current = null;
+            }
         };
     }, []);
     useEffect(() => {
@@ -1509,6 +1526,93 @@ export function App({ config, orchestrator, cwd, initialTaskId = null, initialRo
         shutdownSignal.addEventListener("abort", shutdown, { once: true });
         return () => shutdownSignal.removeEventListener("abort", shutdown);
     }, [shutdownSignal]);
+    async function copyVisibleView() {
+        const payload = visibleClipboardPayload(viewRef.current);
+        if (!payload?.text.trim()) {
+            setAttachError("No visible text to copy in this view");
+            return;
+        }
+        if (clipboardNoticeTimerRef.current) {
+            clearTimeout(clipboardNoticeTimerRef.current);
+            clipboardNoticeTimerRef.current = null;
+        }
+        setAttachError(null);
+        setClipboardNotice({ state: "copying", text: `copying visible ${payload.label}` });
+        try {
+            await copyToClipboard(payload.text);
+            setClipboardNotice({ state: "copied", text: `copied visible ${payload.label} · wheel still active` });
+            clipboardNoticeTimerRef.current = setTimeout(() => {
+                clipboardNoticeTimerRef.current = null;
+                setClipboardNotice(null);
+            }, 1800);
+        }
+        catch (error) {
+            setClipboardNotice(null);
+            setAttachError(`Copy failed · ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    function visibleClipboardPayload(currentView) {
+        if (currentView === "chat") {
+            return { label: "chat", text: copyTextByViewRef.current.chat };
+        }
+        if (currentView === "worker") {
+            return { label: "logs", text: copyTextByViewRef.current.worker };
+        }
+        if (currentView === "native") {
+            return { label: "native output", text: nativeAttachRef.current?.screen.snapshot() ?? "" };
+        }
+        if (currentView === "status") {
+            return {
+                label: "status",
+                text: [cwd, activeTaskIdRef.current, visibleTaskStatus, visibleRouteSummary]
+                    .filter(Boolean)
+                    .join("\n")
+            };
+        }
+        if (currentView === "workers") {
+            return {
+                label: "workers",
+                text: workersRef.current.map((worker) => [
+                    worker.label,
+                    worker.runtimeStatus?.state,
+                    worker.runtimeStatus?.phase,
+                    worker.runtimeStatus?.summary
+                ].filter(Boolean).join(" · ")).join("\n")
+            };
+        }
+        if (currentView === "features") {
+            return {
+                label: "features",
+                text: (collaborationTimelineRef.current?.features ?? []).map((feature) => [
+                    feature.id,
+                    feature.title,
+                    feature.state
+                ].filter(Boolean).join(" · ")).join("\n")
+            };
+        }
+        if (currentView === "sessions") {
+            const details = taskSessionDetailsRef.current;
+            return {
+                label: "sessions",
+                text: details
+                    ? details.workers.map((worker) => [worker.id, worker.role, worker.engine, worker.state].join(" · ")).join("\n")
+                    : taskSessionsRef.current.map((task) => [task.id, task.title, task.status].join(" · ")).join("\n")
+            };
+        }
+        if (currentView === "router") {
+            return { label: "routes", text: routerRecords.map((record) => JSON.stringify(record)).join("\n") };
+        }
+        if (currentView === "collaboration") {
+            const timeline = collaborationTimelineRef.current;
+            return {
+                label: "timeline",
+                text: timeline
+                    ? collaborationTimelineEvents(timeline, collaborationFeatureIndexRef.current, collaborationUnresolvedOnlyRef.current).map((event) => JSON.stringify(event)).join("\n")
+                    : ""
+            };
+        }
+        return null;
+    }
     useInput((inputKey, key) => {
         if (view === "worker") {
             if (isExitShortcut(inputKey, key)) {
@@ -2536,7 +2640,7 @@ export function App({ config, orchestrator, cwd, initialTaskId = null, initialRo
                 ? { type: "rename", value: taskSessionAction.value, cursor: taskSessionAction.cursor }
                 : taskSessionAction?.type === "delete"
                     ? { type: "delete", title: taskSessionAction.title }
-                    : null, taskSessionsIncludeArchived: taskSessionsIncludeArchived, taskSessionDetail: Boolean(taskSessionDetails), taskSessionDetailHasNative: taskSessionDetailHasNative, taskSessionDetailCanFork: taskSessionDetailCanFork, canRetry: canRetryTask, hasWorkers: workers.length > 0, hasActiveTask: Boolean(activeTaskId), hasTaskResult: hasTaskResult, taskResultExpanded: taskResultExpanded, chatScrollOffset: chatScrollOffset, chatMaxScrollOffset: chatMaxScrollOffset, nativeClosed: view === "native" && nativeAttach?.closedCode !== null, searchMatchIndex: workerSearch.matchIndex, searchMatchCount: workerNavigationTargets.searchOffsets.length, value: workerSearch.open && view === "worker"
+                    : null, taskSessionsIncludeArchived: taskSessionsIncludeArchived, taskSessionDetail: Boolean(taskSessionDetails), taskSessionDetailHasNative: taskSessionDetailHasNative, taskSessionDetailCanFork: taskSessionDetailCanFork, canRetry: canRetryTask, hasWorkers: workers.length > 0, hasActiveTask: Boolean(activeTaskId), hasTaskResult: hasTaskResult, taskResultExpanded: taskResultExpanded, chatScrollOffset: chatScrollOffset, chatMaxScrollOffset: chatMaxScrollOffset, nativeClosed: view === "native" && nativeAttach?.closedCode !== null, searchMatchIndex: workerSearch.matchIndex, searchMatchCount: workerNavigationTargets.searchOffsets.length, clipboardNotice: clipboardNotice, value: workerSearch.open && view === "worker"
                 ? workerSearch.query
                 : view === "native" || view === "router" || view === "workers" || view === "features" || view === "sessions" || view === "collaboration" || view === "status" ? "" : input, cursor: workerSearch.open && view === "worker"
                 ? workerSearch.cursor
@@ -2563,7 +2667,11 @@ export function App({ config, orchestrator, cwd, initialTaskId = null, initialRo
                     chatScrollOffsetRef.current = offset;
                     setChatScrollOffset(offset);
                 }
-            } })) : (_jsx(WorkerOutputView, { title: workerTitle(workers, selectedWorkerIndex), role: workers[selectedWorkerIndex]?.role, featureId: workers[selectedWorkerIndex]?.featureId, logPath: workers[selectedWorkerIndex]?.logPath ?? null, scrollOffset: workerScrollOffset, searchQuery: workerSearch.open ? workerSearch.query : "", searchMatchIndex: workerSearch.matchIndex, height: Math.max(1, outputHeight - 1), terminalWidth: terminalWidth, onNavigationChange: updateWorkerNavigationTargets, onViewportChange: ({ offset }) => {
+            }, onCopyTextChange: (text) => {
+                copyTextByViewRef.current.chat = text;
+            } })) : (_jsx(WorkerOutputView, { title: workerTitle(workers, selectedWorkerIndex), role: workers[selectedWorkerIndex]?.role, featureId: workers[selectedWorkerIndex]?.featureId, logPath: workers[selectedWorkerIndex]?.logPath ?? null, scrollOffset: workerScrollOffset, searchQuery: workerSearch.open ? workerSearch.query : "", searchMatchIndex: workerSearch.matchIndex, height: Math.max(1, outputHeight - 1), terminalWidth: terminalWidth, onNavigationChange: updateWorkerNavigationTargets, onCopyTextChange: (text) => {
+                copyTextByViewRef.current.worker = text;
+            }, onViewportChange: ({ offset }) => {
                 if (offset !== workerScrollOffset) {
                     setWorkerScrollOffset(offset);
                 }
@@ -2575,7 +2683,7 @@ function readTerminalSize() {
         rows: Math.max(1, Math.trunc(process.stdout.rows || 30))
     };
 }
-export function ChatView({ messages, cwd, activeTaskId, terminalWidth = process.stdout.columns || 120, viewportHeight, scrollOffset = 0, expandedTaskResult = false, onViewportChange }) {
+export function ChatView({ messages, cwd, activeTaskId, terminalWidth = process.stdout.columns || 120, viewportHeight, scrollOffset = 0, expandedTaskResult = false, onViewportChange, onCopyTextChange }) {
     const height = viewportHeight ? Math.max(1, viewportHeight) : undefined;
     const viewport = useMemo(() => chatMessageViewport(messages, terminalWidth, height ?? 12, scrollOffset, {
         expandedTaskResult,
@@ -2587,6 +2695,10 @@ export function ChatView({ messages, cwd, activeTaskId, terminalWidth = process.
             maxOffset: viewport.maxOffset
         });
     }, [onViewportChange, viewport.clampedOffset, viewport.maxOffset]);
+    const visibleCopyText = viewport.lines.map((line) => line.text).join("\n");
+    useEffect(() => {
+        onCopyTextChange?.(visibleCopyText);
+    }, [onCopyTextChange, visibleCopyText]);
     if (messages.length === 0) {
         const spacerLines = chatViewportSpacerLineCount(1, height);
         return (_jsxs(Box, { flexDirection: "column", height: height, children: [_jsx(ChatViewportSpacerLines, { count: spacerLines, terminalWidth: terminalWidth }), _jsx(ChatEmptyState, { cwd: cwd, activeTaskId: activeTaskId, terminalWidth: terminalWidth })] }));

package/dist/tui/InputBar.js

@@ -2,9 +2,14 @@ import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-run
 import { Box, Text } from "ink";
 import { compactEndByDisplayWidth, compactTailByDisplayWidth, displayWidth } from "./display-width.js";
 import { TUI_THEME } from "./theme.js";
-export function InputBar({ mode, ready = true, busy = false, routeFallback = false, collaborationDetail = false, collaborationUnresolved = false, collaborationBack = "workers", featureCanCancel = false, featureCanPause = false, featureCanReassign = false, featureCancelConfirm = false, featurePauseConfirm = false, featureAssignment = false, taskSessionAction = null, taskSessionsIncludeArchived = false, taskSessionDetail = false, taskSessionDetailHasNative = false, taskSessionDetailCanFork = false, canRetry = false, hasWorkers = false, hasActiveTask = false, hasTaskResult = false, taskResultExpanded = false, chatScrollOffset = 0, chatMaxScrollOffset = 0, nativeClosed = false, searchMatchIndex = 0, searchMatchCount = 0, value, cursor, terminalWidth: providedTerminalWidth, onChange, onSubmit }) {
+export function InputBar({ mode, ready = true, busy = false, routeFallback = false, collaborationDetail = false, collaborationUnresolved = false, collaborationBack = "workers", featureCanCancel = false, featureCanPause = false, featureCanReassign = false, featureCancelConfirm = false, featurePauseConfirm = false, featureAssignment = false, taskSessionAction = null, taskSessionsIncludeArchived = false, taskSessionDetail = false, taskSessionDetailHasNative = false, taskSessionDetailCanFork = false, canRetry = false, hasWorkers = false, hasActiveTask = false, hasTaskResult = false, taskResultExpanded = false, chatScrollOffset = 0, chatMaxScrollOffset = 0, nativeClosed = false, searchMatchIndex = 0, searchMatchCount = 0, clipboardNotice = null, value, cursor, terminalWidth: providedTerminalWidth, onChange, onSubmit }) {
     const terminalWidth = providedTerminalWidth ?? process.stdout.columns ?? 120;
     const fillRail = providedTerminalWidth !== undefined || typeof process.stdout.columns === "number";
+    if (clipboardNotice) {
+        const contentWidth = Math.max(1, terminalWidth - (terminalWidth > 1 ? 2 : 0));
+        const text = compactEndByDisplayWidth(clipboardNotice.text, contentWidth);
+        return (_jsx(InputRail, { terminalWidth: terminalWidth, textWidth: displayWidth(text), fill: fillRail, children: _jsx(Text, { backgroundColor: TUI_THEME.rail, color: clipboardNotice.state === "copied" ? TUI_THEME.success : TUI_THEME.warning, bold: true, children: text }) }));
+    }
     if (mode === "worker-search") {
         const suffix = workerSearchInputSuffix(terminalWidth, searchMatchIndex, searchMatchCount);
         const prefix = terminalWidth < 4 ? "/" : "/ ";

package/dist/tui/WorkerOutputView.js

@@ -39,7 +39,7 @@ export function workerOutputNavigationTargets(lines, height, query = "") {
     }
     return { searchOffsets, searchLineIndexes, errorOffsets, diffOffsets };
 }
-export function WorkerOutputView({ title, role, featureId, logPath, scrollOffset = 0, height = 24, terminalWidth = Number(process.stdout.columns) || 120, searchQuery = "", searchMatchIndex = 0, onViewportChange, onNavigationChange }) {
+export function WorkerOutputView({ title, role, featureId, logPath, scrollOffset = 0, height = 24, terminalWidth = Number(process.stdout.columns) || 120, searchQuery = "", searchMatchIndex = 0, onViewportChange, onNavigationChange, onCopyTextChange }) {
     const nanoOutput = isNanoWorkerOutputWidth(terminalWidth);
     const contentKey = workerOutputContentKey(role, featureId, logPath, nanoOutput);
     const [contentState, setContentState] = useState({ key: "", lines: [] });
@@ -155,6 +155,7 @@ export function WorkerOutputView({ title, role, featureId, logPath, scrollOffset
         preferLatestSection: selection.clampedOffset === 0 && selection.maxOffset > 0
     });
     const visibleLines = displayLines.slice(start, end);
+    const visibleCopyText = visibleLines.map((line) => line.text).join("\n");
     const topPaddingLines = start > rawStart
         ? 0
         : workerOutputTailTopPaddingLines(selection.clampedOffset, selection.maxOffset, visibleLines.length, height);
@@ -176,6 +177,9 @@ export function WorkerOutputView({ title, role, featureId, logPath, scrollOffset
         navigationTargets.searchOffsets.join(","),
         onNavigationChange
     ]);
+    useEffect(() => {
+        onCopyTextChange?.(visibleCopyText);
+    }, [onCopyTextChange, visibleCopyText]);
     const scrollLabel = workerOutputScrollDisplay(selection.clampedOffset, selection.maxOffset, terminalWidth);
     const normalizedSearchQuery = searchQuery.trim();
     const navigationLabel = normalizedSearchQuery

package/dist/tui/keyboard.js

@@ -31,6 +31,9 @@ export function isStatusDetailsShortcut(input, key) {
 export function isWorkerSearchShortcut(input, key) {
     return (key.ctrl === true && input.toLowerCase() === "f") || input === "\u0006";
 }
+export function isCopyShortcut(input, key) {
+    return (key.ctrl === true && input.toLowerCase() === "y") || input === "\u0019";
+}
 export function workerLogJumpKind(input) {
     if (input === "e" || input === "E") {
         return "error";
@@ -65,6 +68,14 @@ export function rawHistoryDelta(input) {
     }
     return delta;
 }
+export function rawPlainArrowDelta(input) {
+    let delta = 0;
+    for (const match of input.matchAll(/\x1b(?:O([AB])|\[([AB]))/g)) {
+        const direction = match[1] ?? match[2];
+        delta += direction === "A" ? 1 : -1;
+    }
+    return delta;
+}
 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.1.5";
+export const version = "0.1.7";

package/package.json

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