parallel-codex-tui 0.1.4 → 0.1.6

package/dist/tui/App.js

@@ -3,9 +3,10 @@ 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, formatSelectedWorkerStatus, formatRouteStatus, formatStatusLine, formatWorkerRuntimeStatus } from "./status-line.js";
+import { effectiveWorkerWatchdog, formatRoutePendingStatus, formatRoutePendingSummaryStatus, formatRouteStatus, formatRouteSummaryStatus, formatStatusLine, formatWorkerRuntimeStatus } from "./status-line.js";
 import { applyChatInputChunk, insertChatPaste } from "./chat-input.js";
 import { chatRequestHistory, navigateChatDraftHistory } from "./chat-history.js";
 import { createChatPasteDecoder } from "./chat-paste.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, 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, 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";
@@ -28,8 +29,11 @@ import { moveWorkerSelection, WorkerOverviewView } from "./WorkerOverviewView.js
 import { FeatureBoardView, moveFeatureBoardSelection } from "./FeatureBoardView.js";
 import { CollaborationTimelineView, collaborationSelectionScrollOffset, collaborationTimelineEvents, moveCollaborationEventSelection, nextCollaborationFeatureIndex } from "./CollaborationTimelineView.js";
 import { moveTaskSessionSelection, TaskSessionsView } from "./TaskSessionsView.js";
+import { moveTaskSessionDetailSelection, TaskSessionDetailView } from "./TaskSessionDetailView.js";
 import { latestTaskResultMessageIndex, parseTaskResultSummary } from "./task-result.js";
-import { buildNativeAttachLaunch, startNativeAttachProcess } from "../workers/native-attach.js";
+import { buildNativeAttachLaunch, buildNativeForkLaunch, startNativeAttachProcess } from "../workers/native-attach.js";
+import { assignableWorkerProviderIds, workerProviderLabel, workerProviders } from "../workers/provider.js";
+import { StatusDetailView } from "./StatusDetailView.js";
 export function routeDecisionChatMessage(route) {
     return `route · ${route.mode} · ${route.source ?? "router"}\n${route.reason.trim()}`;
 }
@@ -44,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, renameTaskSession, setTaskSessionArchived, deleteTaskSession, exportTaskSession, loadCollaborationTimeline, activateTaskSession, prepareNativeAttach, 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
@@ -70,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({
@@ -95,9 +100,13 @@ export function App({ config, orchestrator, cwd, initialTaskId = null, initialRo
     const [taskSessionsNotice, setTaskSessionsNotice] = useState(null);
     const [taskSessionsIncludeArchived, setTaskSessionsIncludeArchived] = useState(false);
     const [taskSessionAction, setTaskSessionAction] = useState(null);
+    const [taskSessionDetails, setTaskSessionDetails] = useState(null);
+    const [taskSessionDetailSelectedWorkerIndex, setTaskSessionDetailSelectedWorkerIndex] = useState(0);
+    const [taskSessionDetailNotice, setTaskSessionDetailNotice] = useState(null);
     const [collaborationTimeline, setCollaborationTimeline] = useState(null);
     const [featureBoardSelectedIndex, setFeatureBoardSelectedIndex] = useState(0);
     const [featureCancelPrompt, setFeatureCancelPrompt] = useState(null);
+    const [featureAssignmentPrompt, setFeatureAssignmentPrompt] = useState(null);
     const [featureBoardNotice, setFeatureBoardNotice] = useState(null);
     const [collaborationLoading, setCollaborationLoading] = useState(false);
     const [collaborationError, setCollaborationError] = useState(null);
@@ -113,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);
@@ -121,6 +132,7 @@ export function App({ config, orchestrator, cwd, initialTaskId = null, initialRo
     const inputCursorRef = useRef(inputCursor);
     const viewRef = useRef(view);
     const busyRef = useRef(busy);
+    const canRetryTaskRef = useRef(initialCanRetryTask);
     const routeFallbackPromptRef = useRef(null);
     const routeFallbackResolverRef = useRef(null);
     const workersRef = useRef(workers);
@@ -137,9 +149,12 @@ export function App({ config, orchestrator, cwd, initialTaskId = null, initialRo
     const taskSessionsLoadingRef = useRef(taskSessionsLoading);
     const taskSessionsIncludeArchivedRef = useRef(taskSessionsIncludeArchived);
     const taskSessionActionRef = useRef(taskSessionAction);
+    const taskSessionDetailsRef = useRef(null);
+    const taskSessionDetailSelectedWorkerIndexRef = useRef(0);
     const collaborationTimelineRef = useRef(null);
     const featureBoardSelectedIndexRef = useRef(0);
     const featureCancelPromptRef = useRef(null);
+    const featureAssignmentPromptRef = useRef(null);
     const collaborationFeatureIndexRef = useRef(-1);
     const collaborationSelectedEventIdRef = useRef(null);
     const collaborationDetailOpenRef = useRef(false);
@@ -157,6 +172,7 @@ export function App({ config, orchestrator, cwd, initialTaskId = null, initialRo
     const openTaskSessionsRef = useRef(openTaskSessions);
     const openFeatureBoardRef = useRef(openFeatureBoard);
     const confirmFeatureCancellationRef = useRef(confirmFeatureCancellation);
+    const reassignSelectedFeatureRef = useRef(reassignSelectedFeature);
     const openCollaborationTimelineRef = useRef(openCollaborationTimeline);
     const refreshCollaborationTimelineRef = useRef(refreshCollaborationTimeline);
     const activateSelectedTaskSessionRef = useRef(activateSelectedTaskSession);
@@ -165,11 +181,16 @@ export function App({ config, orchestrator, cwd, initialTaskId = null, initialRo
     const archiveSelectedTaskSessionRef = useRef(archiveSelectedTaskSession);
     const deleteSelectedTaskSessionRef = useRef(deleteSelectedTaskSession);
     const exportSelectedTaskSessionRef = useRef(exportSelectedTaskSession);
+    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");
     const taskSessionsReturnViewRef = useRef("chat");
     const collaborationReturnViewRef = useRef("workers");
+    const statusReturnViewRef = useRef("chat");
     const collaborationLoadSequenceRef = useRef(0);
     const routerLoadSequenceRef = useRef(0);
     const taskSessionsLoadSequenceRef = useRef(0);
@@ -183,34 +204,31 @@ export function App({ config, orchestrator, cwd, initialTaskId = null, initialRo
     const contentHeight = appContentHeight(terminalSize.rows, Boolean(attachError), config.ui.showStatusBar);
     const outputHeight = Math.max(1, contentHeight);
     const terminalWidth = terminalSize.columns;
-    const workerActivityPolicies = useMemo(() => ({
-        codex: {
-            timeoutMs: config.workers.codex.timeoutMs,
-            idleTimeoutMs: config.workers.codex.idleTimeoutMs,
-            firstOutputTimeoutMs: config.workers.codex.firstOutputTimeoutMs
-        },
-        claude: {
-            timeoutMs: config.workers.claude.timeoutMs,
-            idleTimeoutMs: config.workers.claude.idleTimeoutMs,
-            firstOutputTimeoutMs: config.workers.claude.firstOutputTimeoutMs
-        },
-        mock: {
-            timeoutMs: config.workers.mock.timeoutMs,
-            idleTimeoutMs: config.workers.mock.idleTimeoutMs,
-            firstOutputTimeoutMs: config.workers.mock.firstOutputTimeoutMs
-        }
-    }), [config.workers.claude, config.workers.codex, config.workers.mock]);
+    const workerActivityPolicies = useMemo(() => Object.fromEntries(workerProviders(config).map(({ id, config: provider }) => [id, {
+            timeoutMs: provider.timeoutMs,
+            idleTimeoutMs: provider.idleTimeoutMs,
+            firstOutputTimeoutMs: provider.firstOutputTimeoutMs
+        }])), [config.workers]);
+    const assignableProviderIds = useMemo(() => assignableWorkerProviderIds(config), [config.workers]);
     const selectedBoardFeature = collaborationTimeline?.features[featureBoardSelectedIndex];
+    const selectedTaskSessionDetailWorker = taskSessionDetails?.workers[taskSessionDetailSelectedWorkerIndex];
+    const taskSessionDetailHasNative = Boolean(selectedTaskSessionDetailWorker?.nativeSession && !taskSessionDetails?.task.archived_at);
+    const taskSessionDetailCanFork = Boolean(taskSessionDetailHasNative
+        && selectedTaskSessionDetailWorker
+        && (config.workers[selectedTaskSessionDetailWorker.engine]?.interactive.forkArgs.length ?? 0) > 0);
     const featureCanCancel = busy && (selectedBoardFeature?.state === "actor_running"
         || selectedBoardFeature?.state === "critic_running");
+    const featureCanReassign = assignableProviderIds.length > 1
+        && !busy
+        && canRetryTask
+        && selectedBoardFeature?.state !== "approved";
     const visibleStatus = statusLineWithWorkerRefs(status, workers);
-    const selectedWorkerStatus = formatSelectedWorkerStatus(visibleStatus, selectedWorkerIndex);
-    const visibleWorkerStatus = view === "chat" || view === "router" || view === "sessions" || view === "features" || view === "collaboration"
-        ? ""
-        : selectedWorkerStatus;
     const visibleRouteStatus = routePending
         ? formatRoutePendingStatus(routePending, routeElapsedMs)
         : formatRouteStatus(lastRoute);
+    const visibleRouteSummary = routePending
+        ? formatRoutePendingSummaryStatus(routePending, routeElapsedMs)
+        : formatRouteSummaryStatus(lastRoute);
     const visibleTaskStatus = routePending && !activeTaskId ? "" : formatStatusLine(visibleStatus);
     const workerRefreshKey = workers.map((worker) => `${worker.id}\u0000${worker.statusPath}`).join("\u0001");
     const taskResultMessageIndex = useMemo(() => activeTaskId ? latestTaskResultMessageIndex(messages, activeTaskId) : -1, [activeTaskId, messages]);
@@ -245,6 +263,9 @@ export function App({ config, orchestrator, cwd, initialTaskId = null, initialRo
     useEffect(() => {
         busyRef.current = busy;
     }, [busy]);
+    useEffect(() => {
+        canRetryTaskRef.current = canRetryTask;
+    }, [canRetryTask]);
     useEffect(() => {
         taskResultExpandedRef.current = taskResultExpanded;
     }, [taskResultExpanded]);
@@ -281,6 +302,12 @@ export function App({ config, orchestrator, cwd, initialTaskId = null, initialRo
     useEffect(() => {
         taskSessionActionRef.current = taskSessionAction;
     }, [taskSessionAction]);
+    useEffect(() => {
+        taskSessionDetailsRef.current = taskSessionDetails;
+    }, [taskSessionDetails]);
+    useEffect(() => {
+        taskSessionDetailSelectedWorkerIndexRef.current = taskSessionDetailSelectedWorkerIndex;
+    }, [taskSessionDetailSelectedWorkerIndex]);
     useEffect(() => {
         featureBoardSelectedIndexRef.current = featureBoardSelectedIndex;
     }, [featureBoardSelectedIndex]);
@@ -341,6 +368,10 @@ export function App({ config, orchestrator, cwd, initialTaskId = null, initialRo
         archiveSelectedTaskSessionRef.current = archiveSelectedTaskSession;
         deleteSelectedTaskSessionRef.current = deleteSelectedTaskSession;
         exportSelectedTaskSessionRef.current = exportSelectedTaskSession;
+        openSelectedTaskSessionDetailsRef.current = openSelectedTaskSessionDetails;
+        refreshTaskSessionDetailsRef.current = refreshTaskSessionDetails;
+        openTaskSessionDetailWorkerRef.current = openTaskSessionDetailWorker;
+        copyVisibleViewRef.current = copyVisibleView;
     });
     useEffect(() => {
         if ((view !== "collaboration" && view !== "features") || !activeTaskId || !loadCollaborationTimeline) {
@@ -560,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[?1000h\x1b[?1006h");
         const commitChatInputUpdate = (update, previousValue, previousCursor) => {
             if (update.exit) {
                 activeRunControllerRef.current?.abort();
@@ -608,11 +639,18 @@ export function App({ config, orchestrator, cwd, initialTaskId = null, initialRo
             setTaskSessionsError(null);
             setSelectedTaskSessionIndex(nextIndex);
         };
+        const moveSelectedTaskSessionDetailWorker = (delta, wrap = false) => {
+            const nextIndex = moveTaskSessionDetailSelection(taskSessionDetailSelectedWorkerIndexRef.current, delta, taskSessionDetailsRef.current?.workers.length ?? 0, wrap);
+            taskSessionDetailSelectedWorkerIndexRef.current = nextIndex;
+            setTaskSessionDetailNotice(null);
+            setTaskSessionDetailSelectedWorkerIndex(nextIndex);
+        };
         const moveSelectedFeature = (delta, wrap = false) => {
             const nextIndex = moveFeatureBoardSelection(featureBoardSelectedIndexRef.current, delta, collaborationTimelineRef.current?.features.length ?? 0, wrap);
             featureBoardSelectedIndexRef.current = nextIndex;
             setCollaborationError(null);
             updateFeatureCancelPrompt(null);
+            updateFeatureAssignmentPrompt(null);
             setFeatureBoardNotice(null);
             setFeatureBoardSelectedIndex(nextIndex);
         };
@@ -650,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, {}))) {
@@ -657,6 +699,13 @@ export function App({ config, orchestrator, cwd, initialTaskId = null, initialRo
                     exitRef.current();
                     return;
                 }
+                if (fallbackChunks.some((fallbackChunk) => isStatusDetailsShortcut(fallbackChunk, {}))) {
+                    statusReturnViewRef.current = "chat";
+                    viewRef.current = "status";
+                    setAttachError(null);
+                    setView("status");
+                    return;
+                }
                 for (const fallbackChunk of fallbackChunks) {
                     if (fallbackChunk === "\x1b") {
                         settleRouteFallbackChoice("cancel");
@@ -680,12 +729,72 @@ export function App({ config, orchestrator, cwd, initialTaskId = null, initialRo
             if (currentView === "workspace") {
                 return;
             }
+            if (currentView === "status") {
+                if (isExitShortcut(chunk, {})) {
+                    activeRunControllerRef.current?.abort();
+                    exitRef.current();
+                    return;
+                }
+                if (isStatusDetailsShortcut(chunk, {}) || chunk === "\x1b") {
+                    viewRef.current = statusReturnViewRef.current;
+                    setView(statusReturnViewRef.current);
+                }
+                return;
+            }
+            if (isStatusDetailsShortcut(chunk, {})) {
+                statusReturnViewRef.current = currentView;
+                viewRef.current = "status";
+                setAttachError(null);
+                setView("status");
+                return;
+            }
             if (currentView === "sessions") {
                 if (isExitShortcut(chunk, {})) {
                     activeRunControllerRef.current?.abort();
                     exitRef.current();
                     return;
                 }
+                if (taskSessionDetailsRef.current) {
+                    if (isTaskSessionsShortcut(chunk, {}) || chunk === "\x1b") {
+                        taskSessionDetailsRef.current = null;
+                        taskSessionDetailSelectedWorkerIndexRef.current = 0;
+                        setTaskSessionDetails(null);
+                        setTaskSessionDetailSelectedWorkerIndex(0);
+                        setTaskSessionDetailNotice(null);
+                        setTaskSessionsError(null);
+                        return;
+                    }
+                    if (taskSessionsLoadingRef.current) {
+                        return;
+                    }
+                    if (chunk === "r" || chunk === "R") {
+                        void refreshTaskSessionDetailsRef.current();
+                        return;
+                    }
+                    if (chunk === "c" || chunk === "C" || chunk === "\u000f") {
+                        void openTaskSessionDetailWorkerRef.current("resume");
+                        return;
+                    }
+                    if (chunk === "b" || chunk === "B") {
+                        void openTaskSessionDetailWorkerRef.current("fork");
+                        return;
+                    }
+                    if (chunk === "\r" || chunk === "\n") {
+                        void openTaskSessionDetailWorkerRef.current("logs");
+                        return;
+                    }
+                    if (chunk === "\t") {
+                        moveSelectedTaskSessionDetailWorker(1, true);
+                        return;
+                    }
+                    const detailSelectionDelta = -(rawHistoryDelta(chunk)
+                        + rawPageScrollDelta(chunk, Math.max(1, outputHeight - 2))
+                        + mouseScrollDelta(chunk, 1));
+                    if (detailSelectionDelta !== 0) {
+                        moveSelectedTaskSessionDetailWorker(detailSelectionDelta);
+                    }
+                    return;
+                }
                 const sessionAction = taskSessionActionRef.current;
                 if (sessionAction) {
                     if (chunk === "\x1b") {
@@ -787,6 +896,10 @@ export function App({ config, orchestrator, cwd, initialTaskId = null, initialRo
                     void exportSelectedTaskSessionRef.current();
                     return;
                 }
+                if (chunk === "i" || chunk === "I") {
+                    void openSelectedTaskSessionDetailsRef.current();
+                    return;
+                }
                 if (chunk === "h" || chunk === "H") {
                     const includeArchived = !taskSessionsIncludeArchivedRef.current;
                     taskSessionsIncludeArchivedRef.current = includeArchived;
@@ -826,13 +939,33 @@ export function App({ config, orchestrator, cwd, initialTaskId = null, initialRo
                             setFeatureBoardNotice(null);
                             return;
                         }
-                        if (featureChunk === "x" || featureChunk === "X") {
+                        if ((pendingCancel.action === "cancel" && (featureChunk === "x" || featureChunk === "X"))
+                            || (pendingCancel.action === "pause" && (featureChunk === "p" || featureChunk === "P"))) {
                             void confirmFeatureCancellationRef.current(pendingCancel);
                             return;
                         }
                     }
                     return;
                 }
+                const pendingAssignment = featureAssignmentPromptRef.current;
+                if (pendingAssignment) {
+                    for (const featureChunk of featureChunks) {
+                        if (featureChunk === "\x1b" || featureChunk === "m" || featureChunk === "M") {
+                            updateFeatureAssignmentPrompt(null);
+                            setFeatureBoardNotice(null);
+                            return;
+                        }
+                        if (featureChunk === "a" || featureChunk === "A") {
+                            void reassignSelectedFeatureRef.current(pendingAssignment, "actor");
+                            return;
+                        }
+                        if (featureChunk === "c" || featureChunk === "C") {
+                            void reassignSelectedFeatureRef.current(pendingAssignment, "critic");
+                            return;
+                        }
+                    }
+                    return;
+                }
                 for (const featureChunk of featureChunks) {
                     if (featureChunk === "\x1b" || isWorkerOverviewShortcut(featureChunk, {})) {
                         setCollaborationError(null);
@@ -855,11 +988,43 @@ export function App({ config, orchestrator, cwd, initialTaskId = null, initialRo
                             setFeatureBoardNotice("Selected feature has no active Actor/Critic to cancel.");
                             return;
                         }
-                        const prompt = { taskId, featureId: feature.id, title: feature.title };
+                        const prompt = { action: "cancel", taskId, featureId: feature.id, title: feature.title };
                         updateFeatureCancelPrompt(prompt);
                         setFeatureBoardNotice(`Cancel ${feature.title}? Active peers will finish; integration stays blocked.`);
                         return;
                     }
+                    if (featureChunk === "p" || featureChunk === "P") {
+                        const taskId = activeTaskIdRef.current;
+                        const feature = collaborationTimelineRef.current?.features[featureBoardSelectedIndexRef.current];
+                        const pausable = busyRef.current
+                            && (feature?.state === "actor_running" || feature?.state === "critic_running");
+                        if (!taskId || !feature || !pausable) {
+                            setFeatureBoardNotice("Selected feature has no active Actor/Critic to pause.");
+                            return;
+                        }
+                        const prompt = { action: "pause", taskId, featureId: feature.id, title: feature.title };
+                        updateFeatureCancelPrompt(prompt);
+                        setFeatureBoardNotice(`Pause ${feature.title}? Completed peer checkpoints will be kept.`);
+                        return;
+                    }
+                    if (featureChunk === "m" || featureChunk === "M") {
+                        const taskId = activeTaskIdRef.current;
+                        const feature = collaborationTimelineRef.current?.features[featureBoardSelectedIndexRef.current];
+                        const reassignable = !busyRef.current
+                            && canRetryTaskRef.current
+                            && feature?.state !== "approved";
+                        if (!taskId || !feature || !reassignable) {
+                            setFeatureBoardNotice("Pause or stop the task before reassigning this Feature.");
+                            return;
+                        }
+                        updateFeatureAssignmentPrompt({
+                            taskId,
+                            featureId: feature.id,
+                            title: feature.title
+                        });
+                        setFeatureBoardNotice(`Reassign ${feature.title} · A Actor (${feature.actorEngine ?? config.pairing.actor}) · C Critic (${feature.criticEngine ?? config.pairing.critic})`);
+                        return;
+                    }
                     if (featureChunk === "r" || featureChunk === "R") {
                         setFeatureBoardNotice(null);
                         void refreshCollaborationTimelineRef.current(false);
@@ -1322,7 +1487,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[?1000l\x1b[?2004l");
             setRawMode(false);
         };
     }, [outputHeight, setRawMode, stdinEvents]);
@@ -1337,6 +1502,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(() => {
@@ -1354,6 +1523,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)) {
@@ -1396,18 +1652,19 @@ export function App({ config, orchestrator, cwd, initialTaskId = null, initialRo
             void attachSelectedWorker(worker);
         }
     }, { isActive: view === "worker" && !workerSearch.open });
-    async function attachSelectedWorker(worker) {
+    async function attachSelectedWorker(worker, mode = "resume") {
         const requestSequence = nativeAttachRequestSequenceRef.current + 1;
         nativeAttachRequestSequenceRef.current = requestSequence;
         const attachIsCurrent = () => (mountedRef.current && nativeAttachRequestSequenceRef.current === requestSequence);
         setAttachError(null);
         try {
-            const launch = await (prepareNativeAttach
-                ? prepareNativeAttach(worker)
-                : buildNativeAttachLaunch({
-                    config,
-                    worker
-                }));
+            const launch = await (mode === "fork"
+                ? prepareNativeFork
+                    ? prepareNativeFork(worker)
+                    : buildNativeForkLaunch({ config, worker })
+                : prepareNativeAttach
+                    ? prepareNativeAttach(worker)
+                    : buildNativeAttachLaunch({ config, worker }));
             if (!attachIsCurrent()) {
                 return;
             }
@@ -1445,7 +1702,12 @@ export function App({ config, orchestrator, cwd, initialTaskId = null, initialRo
                     if (!attachIsCurrent()) {
                         return;
                     }
-                    void screen.write(`\r\n${nativeAttachExitLine(code, screen.dimensions().cols)}\r\n`).then(() => {
+                    const failureHint = nativeAttachFailureHint(screen.snapshot(), code, worker.engine);
+                    const closeOutput = [
+                        nativeAttachExitLine(code, screen.dimensions().cols),
+                        ...(failureHint ? [failureHint] : [])
+                    ].join("\r\n");
+                    void screen.write(`\r\n${closeOutput}\r\n`).then(() => {
                         if (!attachIsCurrent()) {
                             return;
                         }
@@ -1705,11 +1967,20 @@ export function App({ config, orchestrator, cwd, initialTaskId = null, initialRo
         setRouteAnnouncement(null);
         setLastRoute(null);
         try {
-            const result = await orchestrator.retryTask({
+            const selectedPausedFeature = viewRef.current === "features"
+                ? collaborationTimelineRef.current?.features[featureBoardSelectedIndexRef.current]
+                : null;
+            const retryInput = {
                 taskId,
                 cwd,
                 ...createRunCallbacks(controller, { announceRoute: false })
-            });
+            };
+            const result = selectedPausedFeature?.state === "paused"
+                ? await orchestrator.resumeFeature({
+                    ...retryInput,
+                    featureId: selectedPausedFeature.id
+                })
+                : await orchestrator.retryTask(retryInput);
             activeTaskIdRef.current = taskId;
             setActiveTaskId(taskId);
             setActiveMode("complex");
@@ -1833,6 +2104,11 @@ export function App({ config, orchestrator, cwd, initialTaskId = null, initialRo
         setAttachError(null);
         setTaskSessionsError(null);
         setTaskSessionsNotice(null);
+        taskSessionDetailsRef.current = null;
+        taskSessionDetailSelectedWorkerIndexRef.current = 0;
+        setTaskSessionDetails(null);
+        setTaskSessionDetailSelectedWorkerIndex(0);
+        setTaskSessionDetailNotice(null);
         updateTaskSessionAction(null);
         await refreshTaskSessions(activeTaskIdRef.current);
     }
@@ -1943,7 +2219,7 @@ export function App({ config, orchestrator, cwd, initialTaskId = null, initialRo
             return exportTaskSession(selected.id);
         }, (path) => `Exported · ${path}`, selected.id);
     }
-    async function activateSelectedTaskSession() {
+    async function openSelectedTaskSessionDetails() {
         if (busyRef.current || taskSessionsLoadingRef.current) {
             return;
         }
@@ -1951,9 +2227,103 @@ export function App({ config, orchestrator, cwd, initialTaskId = null, initialRo
         if (!selected) {
             return;
         }
+        taskSessionsLoadingRef.current = true;
+        setTaskSessionsLoading(true);
+        setTaskSessionsError(null);
+        setTaskSessionDetailNotice(null);
+        const sequence = taskSessionsLoadSequenceRef.current + 1;
+        taskSessionsLoadSequenceRef.current = sequence;
+        try {
+            if (!loadTaskSessionDetails) {
+                throw new Error("Task session details are unavailable");
+            }
+            const details = await loadTaskSessionDetails(selected);
+            if (taskSessionsLoadSequenceRef.current !== sequence) {
+                return;
+            }
+            taskSessionDetailsRef.current = details;
+            taskSessionDetailSelectedWorkerIndexRef.current = 0;
+            setTaskSessionDetails(details);
+            setTaskSessionDetailSelectedWorkerIndex(0);
+        }
+        catch (error) {
+            if (taskSessionsLoadSequenceRef.current === sequence) {
+                setTaskSessionsError(error instanceof Error ? error.message : String(error));
+            }
+        }
+        finally {
+            if (taskSessionsLoadSequenceRef.current === sequence) {
+                taskSessionsLoadingRef.current = false;
+                setTaskSessionsLoading(false);
+            }
+        }
+    }
+    async function refreshTaskSessionDetails() {
+        const current = taskSessionDetailsRef.current;
+        if (!current || taskSessionsLoadingRef.current || !loadTaskSessionDetails) {
+            return;
+        }
+        const selectedWorkerId = current.workers[taskSessionDetailSelectedWorkerIndexRef.current]?.id;
+        taskSessionsLoadingRef.current = true;
+        setTaskSessionsLoading(true);
+        setTaskSessionsError(null);
+        const sequence = taskSessionsLoadSequenceRef.current + 1;
+        taskSessionsLoadSequenceRef.current = sequence;
+        try {
+            const details = await loadTaskSessionDetails(current.task);
+            if (taskSessionsLoadSequenceRef.current !== sequence) {
+                return;
+            }
+            const selectedIndex = selectedWorkerId
+                ? Math.max(0, details.workers.findIndex((worker) => worker.id === selectedWorkerId))
+                : 0;
+            taskSessionDetailsRef.current = details;
+            taskSessionDetailSelectedWorkerIndexRef.current = selectedIndex;
+            setTaskSessionDetails(details);
+            setTaskSessionDetailSelectedWorkerIndex(selectedIndex);
+            setTaskSessionDetailNotice("Session hierarchy refreshed");
+        }
+        catch (error) {
+            if (taskSessionsLoadSequenceRef.current === sequence) {
+                setTaskSessionsError(error instanceof Error ? error.message : String(error));
+            }
+        }
+        finally {
+            if (taskSessionsLoadSequenceRef.current === sequence) {
+                taskSessionsLoadingRef.current = false;
+                setTaskSessionsLoading(false);
+            }
+        }
+    }
+    async function openTaskSessionDetailWorker(mode) {
+        const details = taskSessionDetailsRef.current;
+        const detailWorker = details?.workers[taskSessionDetailSelectedWorkerIndexRef.current];
+        if (!details || !detailWorker || taskSessionsLoadingRef.current) {
+            return;
+        }
+        if (mode !== "logs" && !detailWorker.nativeSession) {
+            setTaskSessionDetailNotice(`No native session recorded for ${sessionDetailWorkerLabel(detailWorker)}`);
+            return;
+        }
+        const worker = await activateTaskSessionRecord(details.task, detailWorker.id, "worker");
+        if (worker && mode !== "logs") {
+            await attachSelectedWorkerRef.current(worker, mode === "fork" ? "fork" : "resume");
+        }
+    }
+    async function activateSelectedTaskSession() {
+        const selected = taskSessionsRef.current[selectedTaskSessionIndexRef.current];
+        if (!selected) {
+            return;
+        }
+        await activateTaskSessionRecord(selected, null, "chat");
+    }
+    async function activateTaskSessionRecord(selected, preferredWorkerId, targetView) {
+        if (busyRef.current || taskSessionsLoadingRef.current) {
+            return null;
+        }
         if (selected.archived_at) {
             setTaskSessionsError(`Unarchive ${selected.title} before restoring it`);
-            return;
+            return null;
         }
         taskSessionsLoadingRef.current = true;
         setTaskSessionsLoading(true);
@@ -1966,7 +2336,7 @@ export function App({ config, orchestrator, cwd, initialTaskId = null, initialRo
             }
             const restored = await activateTaskSession(selected.id);
             if (taskSessionsLoadSequenceRef.current !== sequence) {
-                return;
+                return null;
             }
             if (!restored) {
                 throw new Error(`Task session not found: ${selected.id}`);
@@ -1981,19 +2351,28 @@ export function App({ config, orchestrator, cwd, initialTaskId = null, initialRo
             setTaskResultExpanded(latestTaskResultMessageIndex(messagesRef.current, restored.taskId) >= 0);
             workersRef.current = restored.workers;
             setWorkers(restored.workers);
-            selectedWorkerIndexRef.current = 0;
-            setSelectedWorkerIndex(0);
+            const preferredWorkerIndex = preferredWorkerId
+                ? restored.workers.findIndex((worker) => worker.id === preferredWorkerId)
+                : -1;
+            if (preferredWorkerId && preferredWorkerIndex < 0) {
+                throw new Error(`Worker is no longer available: ${preferredWorkerId}`);
+            }
+            const nextWorkerIndex = preferredWorkerIndex >= 0 ? preferredWorkerIndex : 0;
+            selectedWorkerIndexRef.current = nextWorkerIndex;
+            setSelectedWorkerIndex(nextWorkerIndex);
             setWorkerScrollOffset(0);
             autoSelectedFailedWorkerRef.current = false;
             userSelectedWorkerRef.current = false;
             setAttachError(null);
-            viewRef.current = "chat";
-            setView("chat");
+            viewRef.current = targetView;
+            setView(targetView);
+            return restored.workers[nextWorkerIndex] ?? null;
         }
         catch (error) {
             if (taskSessionsLoadSequenceRef.current === sequence) {
                 setTaskSessionsError(error instanceof Error ? error.message : String(error));
             }
+            return null;
         }
         finally {
             if (taskSessionsLoadSequenceRef.current === sequence) {
@@ -2006,17 +2385,51 @@ export function App({ config, orchestrator, cwd, initialTaskId = null, initialRo
         featureCancelPromptRef.current = next;
         setFeatureCancelPrompt(next);
     }
+    function updateFeatureAssignmentPrompt(next) {
+        featureAssignmentPromptRef.current = next;
+        setFeatureAssignmentPrompt(next);
+    }
+    async function reassignSelectedFeature(prompt, role) {
+        const feature = collaborationTimelineRef.current?.features.find((item) => item.id === prompt.featureId);
+        if (!feature) {
+            setFeatureBoardNotice(`Feature no longer exists: ${prompt.featureId}`);
+            updateFeatureAssignmentPrompt(null);
+            return;
+        }
+        const current = role === "actor"
+            ? feature.actorEngine ?? config.pairing.actor
+            : feature.criticEngine ?? config.pairing.critic;
+        const engine = nextAssignableFeatureEngine(current, assignableProviderIds);
+        try {
+            await orchestrator.reassignFeature({
+                taskId: prompt.taskId,
+                featureId: prompt.featureId,
+                role,
+                engine
+            });
+            setFeatureBoardNotice(`${role === "actor" ? "Actor" : "Critic"} reassigned to ${featureEngineDisplay(config, engine)} · Ctrl+R resumes the task.`);
+            await refreshCollaborationTimeline(false);
+        }
+        catch (error) {
+            setFeatureBoardNotice(`Reassign failed for ${prompt.title}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
     async function confirmFeatureCancellation(prompt) {
         updateFeatureCancelPrompt(null);
         setAttachError(null);
         try {
-            const result = await orchestrator.cancelFeature(prompt.taskId, prompt.featureId);
+            const result = prompt.action === "pause"
+                ? await orchestrator.pauseFeature(prompt.taskId, prompt.featureId)
+                : await orchestrator.cancelFeature(prompt.taskId, prompt.featureId);
             setFeatureBoardNotice(result.requested
-                ? `Cancellation requested for ${prompt.title} · ${result.role ?? "worker"} stopping; active peers will finish.`
+                ? prompt.action === "pause"
+                    ? `Pause requested for ${prompt.title} · ${result.role ?? "worker"} stopping; checkpoints stay resumable.`
+                    : `Cancellation requested for ${prompt.title} · ${result.role ?? "worker"} stopping; active peers will finish.`
                 : `No active Actor/Critic for ${prompt.title}; refresh and try again.`);
         }
         catch (error) {
-            setFeatureBoardNotice(`Cancel failed for ${prompt.title}: ${error instanceof Error ? error.message : String(error)}`);
+            const action = prompt.action === "pause" ? "Pause" : "Cancel";
+            setFeatureBoardNotice(`${action} failed for ${prompt.title}: ${error instanceof Error ? error.message : String(error)}`);
         }
     }
     async function openFeatureBoard() {
@@ -2032,6 +2445,7 @@ export function App({ config, orchestrator, cwd, initialTaskId = null, initialRo
         setAttachError(null);
         setCollaborationError(null);
         updateFeatureCancelPrompt(null);
+        updateFeatureAssignmentPrompt(null);
         setFeatureBoardNotice(null);
         collaborationTimelineRef.current = null;
         setCollaborationTimeline(null);
@@ -2219,19 +2633,19 @@ 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, visibleWorkerStatus, visibleRouteStatus].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, featureCancelConfirm: Boolean(featureCancelPrompt), taskSessionAction: taskSessionAction?.type === "rename"
+    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"
                 ? { type: "rename", value: taskSessionAction.value, cursor: taskSessionAction.cursor }
                 : taskSessionAction?.type === "delete"
                     ? { type: "delete", title: taskSessionAction.title }
-                    : null, taskSessionsIncludeArchived: taskSessionsIncludeArchived, 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" ? "" : input, cursor: workerSearch.open && view === "worker"
+                : 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 === "native" ? (_jsx(NativeAttachView, { attach: nativeAttach, viewportHeight: contentHeight })) : view === "sessions" ? (_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, 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 }
-                    : null, loading: taskSessionsLoading, error: taskSessionsError, height: contentHeight, terminalWidth: terminalWidth })) : view === "features" ? (_jsx(FeatureBoardView, { timeline: collaborationTimeline, selectedIndex: featureBoardSelectedIndex, loading: collaborationLoading, error: collaborationError, notice: featureBoardNotice, height: contentHeight, terminalWidth: terminalWidth })) : view === "collaboration" ? (_jsx(CollaborationTimelineView, { timeline: collaborationTimeline, featureIndex: collaborationFeatureIndex, selectedEventId: collaborationSelectedEventId, detailOpen: collaborationDetailOpen, unresolvedOnly: collaborationUnresolvedOnly, loading: collaborationLoading, error: collaborationError, scrollOffset: collaborationScrollOffset, height: contentHeight, terminalWidth: terminalWidth, onViewportChange: ({ offset, maxOffset }) => {
+                    : null, loading: taskSessionsLoading, error: taskSessionsError, height: contentHeight, terminalWidth: terminalWidth }))) : view === "features" ? (_jsx(FeatureBoardView, { timeline: collaborationTimeline, selectedIndex: featureBoardSelectedIndex, loading: collaborationLoading, error: collaborationError, notice: featureBoardNotice, height: contentHeight, terminalWidth: terminalWidth })) : view === "collaboration" ? (_jsx(CollaborationTimelineView, { timeline: collaborationTimeline, featureIndex: collaborationFeatureIndex, selectedEventId: collaborationSelectedEventId, detailOpen: collaborationDetailOpen, unresolvedOnly: collaborationUnresolvedOnly, loading: collaborationLoading, error: collaborationError, scrollOffset: collaborationScrollOffset, height: contentHeight, terminalWidth: terminalWidth, onViewportChange: ({ offset, maxOffset }) => {
                 collaborationMaxScrollOffsetRef.current = maxOffset;
                 setCollaborationMaxScrollOffset(maxOffset);
                 if (offset !== collaborationScrollOffset) {
@@ -2250,7 +2664,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);
                 }
@@ -2262,7 +2680,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,
@@ -2274,6 +2692,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 })] }));
@@ -3046,6 +3468,21 @@ function compactChatTaskId(taskId) {
     }
     return taskId.startsWith("task-") ? taskId.slice("task-".length) : taskId;
 }
+export function nextAssignableFeatureEngine(current, providers = ["codex", "claude"]) {
+    const available = [...new Set(providers)];
+    if (available.length === 0) {
+        return current;
+    }
+    const currentIndex = available.indexOf(current);
+    return available[(currentIndex + 1 + available.length) % available.length] ?? current;
+}
+function sessionDetailWorkerLabel(worker) {
+    const role = `${worker.role.slice(0, 1).toUpperCase()}${worker.role.slice(1)}`;
+    return `${role} (${worker.engine})${worker.featureTitle ? ` · ${worker.featureTitle}` : ""}`;
+}
+function featureEngineDisplay(config, engine) {
+    return workerProviderLabel(config, engine);
+}
 function compactChatText(text, maxLength) {
     if (maxLength <= 5) {
         return takeChatTextStartByDisplayWidth(text, maxLength);
@@ -3364,6 +3801,27 @@ export function nativeAttachExitLine(code, nativeTerminalCols) {
     ];
     return firstNativeTitleThatFits(candidates, contentWidth);
 }
+export function nativeAttachFailureHint(output, code, providerId = "codex") {
+    if (code === 0) {
+        return null;
+    }
+    if (/effective permissions do not allow additional writable roots|error adding directories|read-only sandbox/i.test(output)) {
+        return `fix · set workers.${providerId}.interactive.args sandbox to workspace-write or danger-full-access, then reattach`;
+    }
+    if (/not inside a trusted directory|trusted directory/i.test(output)) {
+        return "fix · open Codex once in this workspace and approve directory trust, then reattach";
+    }
+    if (/unexpected argument ['\"]?--skip-git-repo-check|--skip-git-repo-check.*not found/i.test(output)) {
+        return `fix · remove --skip-git-repo-check from workers.${providerId}.interactive.args, then reattach`;
+    }
+    if (/stdin is not a terminal/i.test(output)) {
+        return "fix · native attach requires its embedded PTY; reopen it with Ctrl+O instead of piping codex resume";
+    }
+    if (/permission denied|\bEACCES\b|\bEPERM\b/i.test(output)) {
+        return "fix · grant the terminal read/write access to the workspace and .parallel-codex directories, then reattach";
+    }
+    return null;
+}
 function withNativeTitleSuffix(candidates, suffix) {
     const cleanSuffix = suffix?.trim();
     if (!cleanSuffix) {