parallel-codex-tui 0.1.3 → 0.1.4

package/dist/tui/App.js

@@ -1,70 +1,253 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { useEffect, useRef, useState } from "react";
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+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 { readJson } from "../core/file-store.js";
 import { WorkerStatusSchema } from "../domain/schemas.js";
-import { formatSelectedWorkerStatus, formatStatusLine, formatWorkerRuntimeStatus } from "./status-line.js";
-import { applyChatInputChunk } from "./chat-input.js";
+import { effectiveWorkerWatchdog, formatRoutePendingStatus, formatSelectedWorkerStatus, formatRouteStatus, 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";
 import { AppShell } from "./AppShell.js";
 import { InputBar } from "./InputBar.js";
 import { applyNativeInputChunk } from "./native-input.js";
 import { nextScrollOffset } from "./scrolling.js";
-import { chooseSubmitTarget, nextSubmitMemoryState, shouldClearWorkersForSubmit } from "./task-memory.js";
+import { chooseSubmitTarget, currentSubmitMemoryState, newTaskMemoryState, nextSubmitMemoryState, shouldClearWorkersForSubmit } from "./task-memory.js";
 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, mouseScrollDelta, scrollDelta } from "./keyboard.js";
-import { createRawInputDecoder } from "./raw-input-decoder.js";
+import { isAttachShortcut, isExitShortcut, isLogsShortcut, isNewTaskShortcut, isRouterDiagnosticsShortcut, 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";
+import { WorkspacePicker } from "../cli-workspace-picker.js";
+import { RouterDiagnosticsView, routerDiagnosticsPolicy } from "./RouterDiagnosticsView.js";
+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 { latestTaskResultMessageIndex, parseTaskResultSummary } from "./task-result.js";
 import { buildNativeAttachLaunch, startNativeAttachProcess } from "../workers/native-attach.js";
-const NATIVE_PANEL_BACKGROUND = "ansi256(235)";
-const NATIVE_PANEL_TITLE_BACKGROUND = "ansi256(24)";
-export function App({ config, orchestrator, cwd, initialTaskId = null, prepareNativeAttach, startNativeAttach }) {
+export function routeDecisionChatMessage(route) {
+    return `route · ${route.mode} · ${route.source ?? "router"}\n${route.reason.trim()}`;
+}
+const NO_WORKERS_ATTACH_MESSAGE = "No workers yet · start a complex task before attaching";
+const NO_WORKERS_LOGS_MESSAGE = "No workers yet · start a complex task before opening logs";
+const NO_WORKERS_OVERVIEW_MESSAGE = "No workers yet · start a complex task before opening overview";
+const NO_ACTIVE_COLLABORATION_MESSAGE = "No active task · restore a task before opening timeline";
+const NO_ACTIVE_FEATURES_MESSAGE = "No active task · restore a task before opening features";
+const EMPTY_WORKER_NAVIGATION_TARGETS = {
+    searchOffsets: [],
+    searchLineIndexes: [],
+    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 }) {
+    configureTuiTheme({
+        theme: config.ui.theme,
+        colors: config.ui.colors
+    });
     const [input, setInput] = useState("");
-    const [messages, setMessages] = useState([]);
+    const [inputCursor, setInputCursor] = useState(0);
+    const [inputReady, setInputReady] = useState(false);
+    const [terminalSize, setTerminalSize] = useState(readTerminalSize);
+    const [messages, setMessages] = useState(() => [...initialMessages]);
+    const [taskResultExpanded, setTaskResultExpanded] = useState(() => (Boolean(initialTaskId) && latestTaskResultMessageIndex(initialMessages, initialTaskId) >= 0));
     const [busy, setBusy] = useState(false);
-    const [status, setStatus] = useState(initialTaskId ? { taskId: initialTaskId } : null);
+    const [status, setStatus] = useState(() => restoredWorkerStatusLine(initialTaskId, initialWorkers));
+    const [lastRoute, setLastRoute] = useState(initialRoute);
+    const [routePending, setRoutePending] = useState(null);
+    const [routeAnnouncement, setRouteAnnouncement] = useState(null);
+    const [routeElapsedMs, setRouteElapsedMs] = useState(0);
+    const [routeFallbackPrompt, setRouteFallbackPrompt] = useState(null);
     const [view, setView] = useState("chat");
-    const [workers, setWorkers] = useState([]);
+    const [workers, setWorkers] = useState(() => [...(initialWorkers ?? [])]);
     const [selectedWorkerIndex, setSelectedWorkerIndex] = useState(0);
+    const [workerClockMs, setWorkerClockMs] = useState(() => Date.now());
     const [activeTaskId, setActiveTaskId] = useState(initialTaskId);
     const [activeMode, setActiveMode] = useState(initialTaskId ? "complex" : null);
+    const [canRetryTask, setCanRetryTask] = useState(initialCanRetryTask);
     const [attachError, setAttachError] = useState(null);
     const [nativeInput, setNativeInput] = useState("");
     const [workerScrollOffset, setWorkerScrollOffset] = useState(0);
-    const [workerMaxScrollOffset, setWorkerMaxScrollOffset] = useState(0);
+    const [workerSearch, setWorkerSearch] = useState({
+        open: false,
+        query: "",
+        cursor: 0,
+        matchIndex: 0
+    });
+    const [workerNavigationTargets, setWorkerNavigationTargets] = useState(EMPTY_WORKER_NAVIGATION_TARGETS);
+    const [chatScrollOffset, setChatScrollOffset] = useState(0);
+    const [chatMaxScrollOffset, setChatMaxScrollOffset] = useState(0);
+    const [routerRecords, setRouterRecords] = useState([]);
+    const [routerPolicy, setRouterPolicy] = useState(() => routerDiagnosticsPolicy(config.router));
+    const [routerLoading, setRouterLoading] = useState(false);
+    const [routerError, setRouterError] = useState(null);
+    const [routerScope, setRouterScope] = useState("all");
+    const [routerScrollOffset, setRouterScrollOffset] = useState(0);
+    const [routerMaxScrollOffset, setRouterMaxScrollOffset] = useState(0);
+    const [taskSessions, setTaskSessions] = useState([]);
+    const [selectedTaskSessionIndex, setSelectedTaskSessionIndex] = useState(0);
+    const [taskSessionsLoading, setTaskSessionsLoading] = useState(false);
+    const [taskSessionsError, setTaskSessionsError] = useState(null);
+    const [taskSessionsNotice, setTaskSessionsNotice] = useState(null);
+    const [taskSessionsIncludeArchived, setTaskSessionsIncludeArchived] = useState(false);
+    const [taskSessionAction, setTaskSessionAction] = useState(null);
+    const [collaborationTimeline, setCollaborationTimeline] = useState(null);
+    const [featureBoardSelectedIndex, setFeatureBoardSelectedIndex] = useState(0);
+    const [featureCancelPrompt, setFeatureCancelPrompt] = useState(null);
+    const [featureBoardNotice, setFeatureBoardNotice] = useState(null);
+    const [collaborationLoading, setCollaborationLoading] = useState(false);
+    const [collaborationError, setCollaborationError] = useState(null);
+    const [collaborationFeatureIndex, setCollaborationFeatureIndex] = useState(-1);
+    const [collaborationSelectedEventId, setCollaborationSelectedEventId] = useState(null);
+    const [collaborationDetailOpen, setCollaborationDetailOpen] = useState(false);
+    const [collaborationUnresolvedOnly, setCollaborationUnresolvedOnly] = useState(false);
+    const [collaborationScrollOffset, setCollaborationScrollOffset] = useState(0);
+    const [collaborationMaxScrollOffset, setCollaborationMaxScrollOffset] = useState(0);
     const [nativeAttach, setNativeAttach] = useState(null);
     const { exit } = useApp();
     const { setRawMode, internal_eventEmitter: stdinEvents } = useStdin();
+    const mountedRef = useRef(true);
     const nativeAttachRef = useRef(nativeAttach);
+    const nativeAttachRequestSequenceRef = useRef(0);
+    const messagesRef = useRef([...initialMessages]);
+    const activeRunControllerRef = useRef(null);
+    const activeTaskIdRef = useRef(initialTaskId);
     const nativeInputRef = useRef(nativeInput);
     const inputRef = useRef(input);
+    const inputCursorRef = useRef(inputCursor);
     const viewRef = useRef(view);
     const busyRef = useRef(busy);
+    const routeFallbackPromptRef = useRef(null);
+    const routeFallbackResolverRef = useRef(null);
     const workersRef = useRef(workers);
     const selectedWorkerIndexRef = useRef(selectedWorkerIndex);
-    const workerMaxScrollOffsetRef = useRef(workerMaxScrollOffset);
+    const workerSearchRef = useRef(workerSearch);
+    const workerNavigationTargetsRef = useRef(workerNavigationTargets);
+    const workerJumpIndexRef = useRef({ error: -1, diff: -1 });
+    const chatScrollOffsetRef = useRef(chatScrollOffset);
+    const chatMaxScrollOffsetRef = useRef(chatMaxScrollOffset);
+    const taskResultExpandedRef = useRef(taskResultExpanded);
+    const routerMaxScrollOffsetRef = useRef(routerMaxScrollOffset);
+    const taskSessionsRef = useRef(taskSessions);
+    const selectedTaskSessionIndexRef = useRef(selectedTaskSessionIndex);
+    const taskSessionsLoadingRef = useRef(taskSessionsLoading);
+    const taskSessionsIncludeArchivedRef = useRef(taskSessionsIncludeArchived);
+    const taskSessionActionRef = useRef(taskSessionAction);
+    const collaborationTimelineRef = useRef(null);
+    const featureBoardSelectedIndexRef = useRef(0);
+    const featureCancelPromptRef = useRef(null);
+    const collaborationFeatureIndexRef = useRef(-1);
+    const collaborationSelectedEventIdRef = useRef(null);
+    const collaborationDetailOpenRef = useRef(false);
+    const collaborationUnresolvedOnlyRef = useRef(false);
+    const collaborationMaxScrollOffsetRef = useRef(0);
     const autoSelectedFailedWorkerRef = useRef(false);
     const userSelectedWorkerRef = useRef(false);
     const attachSelectedWorkerRef = useRef(attachSelectedWorker);
     const submitRef = useRef(submit);
+    const retryRef = useRef(retryActiveTask);
+    const newTaskRef = useRef(startNewTask);
+    const openWorkspacePickerRef = useRef(openWorkspacePicker);
+    const openRouterDiagnosticsRef = useRef(openRouterDiagnostics);
+    const openWorkerOverviewRef = useRef(openWorkerOverview);
+    const openTaskSessionsRef = useRef(openTaskSessions);
+    const openFeatureBoardRef = useRef(openFeatureBoard);
+    const confirmFeatureCancellationRef = useRef(confirmFeatureCancellation);
+    const openCollaborationTimelineRef = useRef(openCollaborationTimeline);
+    const refreshCollaborationTimelineRef = useRef(refreshCollaborationTimeline);
+    const activateSelectedTaskSessionRef = useRef(activateSelectedTaskSession);
+    const refreshTaskSessionsRef = useRef(refreshTaskSessions);
+    const renameSelectedTaskSessionRef = useRef(renameSelectedTaskSession);
+    const archiveSelectedTaskSessionRef = useRef(archiveSelectedTaskSession);
+    const deleteSelectedTaskSessionRef = useRef(deleteSelectedTaskSession);
+    const exportSelectedTaskSessionRef = useRef(exportSelectedTaskSession);
+    const workspaceReturnViewRef = useRef("chat");
+    const routerReturnViewRef = useRef("chat");
+    const workerOverviewReturnViewRef = useRef("chat");
+    const taskSessionsReturnViewRef = useRef("chat");
+    const collaborationReturnViewRef = useRef("workers");
+    const collaborationLoadSequenceRef = useRef(0);
+    const routerLoadSequenceRef = useRef(0);
+    const taskSessionsLoadSequenceRef = useRef(0);
     const exitRef = useRef(exit);
     const rawInputDecoderRef = useRef(createRawInputDecoder());
-    const contentHeight = appContentHeight(process.stdout.rows || 30, Boolean(attachError));
+    const chatPasteDecoderRef = useRef(createChatPasteDecoder());
+    const chatDraftHistoryRef = useRef({
+        offset: 0,
+        draft: { value: "", cursor: 0 }
+    });
+    const contentHeight = appContentHeight(terminalSize.rows, Boolean(attachError), config.ui.showStatusBar);
     const outputHeight = Math.max(1, contentHeight);
-    const terminalWidth = process.stdout.columns || 120;
-    const selectedWorkerStatus = formatSelectedWorkerStatus(status, selectedWorkerIndex);
-    const visibleWorkerStatus = view === "chat" ? "" : selectedWorkerStatus;
+    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 selectedBoardFeature = collaborationTimeline?.features[featureBoardSelectedIndex];
+    const featureCanCancel = busy && (selectedBoardFeature?.state === "actor_running"
+        || selectedBoardFeature?.state === "critic_running");
+    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 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]);
+    const visibleChatMessages = useMemo(() => routeAnnouncement ? [...messages, routeAnnouncement] : messages, [messages, routeAnnouncement]);
+    const hasTaskResult = taskResultMessageIndex >= 0;
     useEffect(() => {
         inputRef.current = input;
     }, [input]);
+    useEffect(() => {
+        const updateTerminalSize = () => {
+            const next = readTerminalSize();
+            setTerminalSize((current) => (current.columns === next.columns && current.rows === next.rows ? current : next));
+        };
+        process.stdout.on("resize", updateTerminalSize);
+        updateTerminalSize();
+        return () => {
+            process.stdout.off("resize", updateTerminalSize);
+        };
+    }, []);
+    useEffect(() => {
+        inputCursorRef.current = inputCursor;
+    }, [inputCursor]);
+    useEffect(() => {
+        messagesRef.current = messages;
+    }, [messages]);
+    useEffect(() => {
+        activeTaskIdRef.current = activeTaskId;
+    }, [activeTaskId]);
     useEffect(() => {
         viewRef.current = view;
     }, [view]);
     useEffect(() => {
         busyRef.current = busy;
     }, [busy]);
+    useEffect(() => {
+        taskResultExpandedRef.current = taskResultExpanded;
+    }, [taskResultExpanded]);
     useEffect(() => {
         exitRef.current = exit;
     }, [exit]);
@@ -75,38 +258,167 @@ export function App({ config, orchestrator, cwd, initialTaskId = null, prepareNa
         selectedWorkerIndexRef.current = selectedWorkerIndex;
     }, [selectedWorkerIndex]);
     useEffect(() => {
-        workerMaxScrollOffsetRef.current = workerMaxScrollOffset;
-    }, [workerMaxScrollOffset]);
+        chatScrollOffsetRef.current = chatScrollOffset;
+    }, [chatScrollOffset]);
+    useEffect(() => {
+        chatMaxScrollOffsetRef.current = chatMaxScrollOffset;
+    }, [chatMaxScrollOffset]);
+    useEffect(() => {
+        routerMaxScrollOffsetRef.current = routerMaxScrollOffset;
+    }, [routerMaxScrollOffset]);
+    useEffect(() => {
+        taskSessionsRef.current = taskSessions;
+    }, [taskSessions]);
+    useEffect(() => {
+        selectedTaskSessionIndexRef.current = selectedTaskSessionIndex;
+    }, [selectedTaskSessionIndex]);
+    useEffect(() => {
+        taskSessionsLoadingRef.current = taskSessionsLoading;
+    }, [taskSessionsLoading]);
+    useEffect(() => {
+        taskSessionsIncludeArchivedRef.current = taskSessionsIncludeArchived;
+    }, [taskSessionsIncludeArchived]);
+    useEffect(() => {
+        taskSessionActionRef.current = taskSessionAction;
+    }, [taskSessionAction]);
+    useEffect(() => {
+        featureBoardSelectedIndexRef.current = featureBoardSelectedIndex;
+    }, [featureBoardSelectedIndex]);
+    useEffect(() => {
+        if (!featureCancelPrompt) {
+            return;
+        }
+        const selected = collaborationTimeline?.features[featureBoardSelectedIndex];
+        const stillActive = busy
+            && selected?.id === featureCancelPrompt.featureId
+            && (selected.state === "actor_running" || selected.state === "critic_running");
+        if (!stillActive) {
+            updateFeatureCancelPrompt(null);
+            setFeatureBoardNotice(null);
+        }
+    }, [busy, collaborationTimeline, featureBoardSelectedIndex, featureCancelPrompt]);
+    useEffect(() => {
+        collaborationSelectedEventIdRef.current = collaborationSelectedEventId;
+    }, [collaborationSelectedEventId]);
+    useEffect(() => {
+        collaborationDetailOpenRef.current = collaborationDetailOpen;
+    }, [collaborationDetailOpen]);
+    useEffect(() => {
+        collaborationUnresolvedOnlyRef.current = collaborationUnresolvedOnly;
+    }, [collaborationUnresolvedOnly]);
+    useEffect(() => {
+        chatScrollOffsetRef.current = 0;
+        setChatScrollOffset(0);
+    }, [messages.length]);
+    useEffect(() => {
+        if (!routePending || routePending.mode !== "auto") {
+            setRouteElapsedMs(0);
+            return;
+        }
+        const updateElapsed = () => {
+            setRouteElapsedMs(Math.min(routePending.timeoutMs, Date.now() - routePending.startedAtMs));
+        };
+        updateElapsed();
+        const interval = setInterval(updateElapsed, 250);
+        return () => clearInterval(interval);
+    }, [routePending]);
     useEffect(() => {
         attachSelectedWorkerRef.current = attachSelectedWorker;
         submitRef.current = submit;
+        retryRef.current = retryActiveTask;
+        newTaskRef.current = startNewTask;
+        openWorkspacePickerRef.current = openWorkspacePicker;
+        openRouterDiagnosticsRef.current = openRouterDiagnostics;
+        openWorkerOverviewRef.current = openWorkerOverview;
+        openTaskSessionsRef.current = openTaskSessions;
+        openFeatureBoardRef.current = openFeatureBoard;
+        confirmFeatureCancellationRef.current = confirmFeatureCancellation;
+        openCollaborationTimelineRef.current = openCollaborationTimeline;
+        refreshCollaborationTimelineRef.current = refreshCollaborationTimeline;
+        activateSelectedTaskSessionRef.current = activateSelectedTaskSession;
+        refreshTaskSessionsRef.current = refreshTaskSessions;
+        renameSelectedTaskSessionRef.current = renameSelectedTaskSession;
+        archiveSelectedTaskSessionRef.current = archiveSelectedTaskSession;
+        deleteSelectedTaskSessionRef.current = deleteSelectedTaskSession;
+        exportSelectedTaskSessionRef.current = exportSelectedTaskSession;
     });
+    useEffect(() => {
+        if ((view !== "collaboration" && view !== "features") || !activeTaskId || !loadCollaborationTimeline) {
+            return;
+        }
+        const interval = setInterval(() => {
+            void refreshCollaborationTimelineRef.current(false);
+        }, 1500);
+        return () => clearInterval(interval);
+    }, [activeTaskId, loadCollaborationTimeline, view]);
+    useEffect(() => {
+        if (view !== "workers") {
+            return;
+        }
+        const tick = () => setWorkerClockMs(Date.now());
+        tick();
+        const interval = setInterval(tick, 1000);
+        return () => clearInterval(interval);
+    }, [view]);
     useEffect(() => {
         nativeAttachRef.current = nativeAttach;
     }, [nativeAttach]);
+    useEffect(() => {
+        const screen = nativeAttach?.screen;
+        const nativeProcess = nativeAttach?.process;
+        if (view !== "native" || !screen || !nativeProcess) {
+            return;
+        }
+        const resizeNativeAttach = () => {
+            const cols = nativeAttachTerminalColumns(process.stdout.columns || 120);
+            const rows = nativeAttachTerminalRows(process.stdout.rows || 30, Boolean(attachError), config.ui.showStatusBar);
+            screen.resize(cols, rows);
+            nativeProcess.resize(cols, rows);
+            setNativeAttach((current) => current && current.screen === screen
+                ? {
+                    ...current,
+                    launch: { ...current.launch, cols, rows },
+                    snapshot: screen.snapshot()
+                }
+                : current);
+        };
+        process.stdout.on("resize", resizeNativeAttach);
+        resizeNativeAttach();
+        return () => {
+            process.stdout.off("resize", resizeNativeAttach);
+        };
+    }, [attachError, config.ui.showStatusBar, nativeAttach?.process, nativeAttach?.screen, view]);
     useEffect(() => {
         nativeInputRef.current = nativeInput;
     }, [nativeInput]);
     useEffect(() => {
-        if (!initialTaskId) {
+        if (!initialTaskId || activeTaskId !== initialTaskId || initialWorkers !== undefined) {
             return;
         }
         const taskId = initialTaskId;
         let active = true;
         async function loadInitialWorkers() {
             try {
-                const restored = await orchestrator.listTaskWorkers(taskId);
-                if (!active || restored.length === 0) {
+                const [restored, retryable] = await Promise.all([
+                    orchestrator.listTaskWorkers(taskId),
+                    orchestrator.canRetryTask(taskId)
+                ]);
+                if (!active || activeTaskIdRef.current !== taskId) {
+                    return;
+                }
+                setCanRetryTask(retryable);
+                if (restored.length === 0) {
                     return;
                 }
                 setWorkers(restored);
+                setStatus(restoredWorkerStatusLine(taskId, restored));
                 selectedWorkerIndexRef.current = 0;
                 autoSelectedFailedWorkerRef.current = false;
                 userSelectedWorkerRef.current = false;
                 setSelectedWorkerIndex(0);
             }
             catch (error) {
-                if (active) {
+                if (active && activeTaskIdRef.current === taskId) {
                     setAttachError(error instanceof Error ? error.message : String(error));
                 }
             }
@@ -115,60 +427,126 @@ export function App({ config, orchestrator, cwd, initialTaskId = null, prepareNa
         return () => {
             active = false;
         };
-    }, [initialTaskId, orchestrator]);
+    }, [activeTaskId, initialTaskId, initialWorkers, orchestrator]);
     useEffect(() => {
         if (workers.length === 0 || !status) {
             return;
         }
         let active = true;
+        let refreshInFlight = false;
         async function refreshWorkerStatuses() {
-            const updates = await Promise.all(workers.map(async (worker) => {
-                try {
-                    const workerStatus = await readJson(worker.statusPath, WorkerStatusSchema);
-                    return {
-                        label: worker.label,
-                        role: worker.role,
-                        state: workerStatus.state,
-                        status: formatWorkerRuntimeStatus(workerStatus)
-                    };
-                }
-                catch {
-                    return null;
-                }
-            }));
-            if (!active) {
+            if (refreshInFlight) {
                 return;
             }
-            setStatus((current) => {
-                if (!current) {
-                    return current;
+            refreshInFlight = true;
+            try {
+                const updates = await Promise.all(workers.map(async (worker) => {
+                    try {
+                        const workerStatus = await readJson(worker.statusPath, WorkerStatusSchema);
+                        return {
+                            id: worker.id,
+                            label: worker.label,
+                            role: worker.role,
+                            engine: worker.engine,
+                            state: workerStatus.state,
+                            status: formatWorkerRuntimeStatus(workerStatus),
+                            runtimeStatus: workerStatus
+                        };
+                    }
+                    catch {
+                        return null;
+                    }
+                }));
+                if (!active) {
+                    return;
                 }
-                const next = { ...current };
-                next.workers = updates
+                const currentWorkersById = new Map(workersRef.current.map((worker) => [worker.id, worker]));
+                const effectiveUpdates = updates.map((update) => {
+                    if (!update) {
+                        return null;
+                    }
+                    const currentWorker = currentWorkersById.get(update.id);
+                    const currentRuntime = currentWorker?.runtimeStatus;
+                    if (!currentWorker || !currentRuntime || !newerTerminalRuntime(currentRuntime, update.runtimeStatus)) {
+                        return update;
+                    }
+                    return {
+                        id: currentWorker.id,
+                        label: currentWorker.label,
+                        role: currentWorker.role,
+                        engine: currentWorker.engine,
+                        state: currentRuntime.state,
+                        status: formatWorkerRuntimeStatus(currentRuntime),
+                        runtimeStatus: currentRuntime
+                    };
+                });
+                setStatus((current) => {
+                    if (!current) {
+                        return current;
+                    }
+                    const next = { ...current };
+                    next.workers = effectiveUpdates
+                        .filter((update) => update !== null)
+                        .map((update) => ({
+                        label: update.label,
+                        status: update.status
+                    }));
+                    for (const update of effectiveUpdates) {
+                        if (update) {
+                            if (update.role === "main"
+                                && terminalMainStatus(current.main)
+                                && activeWorkerRuntime(update.runtimeStatus)) {
+                                continue;
+                            }
+                            next[update.role] = update.status;
+                            if (update.role === "main") {
+                                next.mainEngine = update.engine;
+                                next.mainProgress = mainWorkerProgress(update.runtimeStatus, workerActivityPolicies[update.engine]);
+                            }
+                        }
+                    }
+                    return next;
+                });
+                const runtimeStatusById = new Map(effectiveUpdates
                     .filter((update) => update !== null)
-                    .map((update) => ({
-                    label: update.label,
-                    status: update.status
-                }));
-                for (const update of updates) {
-                    if (update) {
-                        next[update.role] = update.status;
+                    .map((update) => [update.id, update.runtimeStatus]));
+                setWorkers((current) => {
+                    let changed = false;
+                    const next = current.map((worker) => {
+                        const runtimeStatus = runtimeStatusById.get(worker.id);
+                        if (!runtimeStatus
+                            || sameWorkerRuntimeStatus(worker.runtimeStatus, runtimeStatus)
+                            || newerTerminalRuntime(worker.runtimeStatus, runtimeStatus)) {
+                            return worker;
+                        }
+                        changed = true;
+                        return { ...worker, runtimeStatus };
+                    });
+                    if (changed) {
+                        workersRef.current = next;
+                    }
+                    return changed ? next : current;
+                });
+                const failedWorkerIndex = effectiveUpdates.findIndex((update) => update?.state === "failed");
+                if (config.ui.autoOpenFailedWorker &&
+                    failedWorkerIndex >= 0 &&
+                    !autoSelectedFailedWorkerRef.current &&
+                    !userSelectedWorkerRef.current) {
+                    autoSelectedFailedWorkerRef.current = true;
+                    selectedWorkerIndexRef.current = failedWorkerIndex;
+                    setSelectedWorkerIndex(failedWorkerIndex);
+                    setWorkerScrollOffset(0);
+                    if (viewRef.current !== "native" &&
+                        viewRef.current !== "router" &&
+                        viewRef.current !== "sessions" &&
+                        viewRef.current !== "workers" &&
+                        viewRef.current !== "workspace") {
+                        setView("worker");
                     }
                 }
-                return next;
-            });
-            const failedWorkerIndex = updates.findIndex((update) => update?.state === "failed");
-            if (config.ui.autoOpenFailedWorker &&
-                failedWorkerIndex >= 0 &&
-                !autoSelectedFailedWorkerRef.current &&
-                !userSelectedWorkerRef.current) {
-                autoSelectedFailedWorkerRef.current = true;
-                selectedWorkerIndexRef.current = failedWorkerIndex;
-                setSelectedWorkerIndex(failedWorkerIndex);
-                setWorkerScrollOffset(0);
-                if (viewRef.current !== "native") {
-                    setView("worker");
-                }
+            }
+            finally {
+                refreshInFlight = false;
             }
         }
         void refreshWorkerStatuses();
@@ -179,45 +557,681 @@ export function App({ config, orchestrator, cwd, initialTaskId = null, prepareNa
             active = false;
             clearInterval(interval);
         };
-    }, [config.ui.autoOpenFailedWorker, status?.taskId, workers]);
+    }, [config.ui.autoOpenFailedWorker, status?.taskId, workerActivityPolicies, workerRefreshKey]);
     useEffect(() => {
         setRawMode(true);
-        process.stdout.write("\x1b[?1000h\x1b[?1002h\x1b[?1006h");
+        process.stdout.write("\x1b[?2004h\x1b[?1000h\x1b[?1002h\x1b[?1006h");
+        const commitChatInputUpdate = (update, previousValue, previousCursor) => {
+            if (update.exit) {
+                activeRunControllerRef.current?.abort();
+                exitRef.current();
+                return false;
+            }
+            if (busyRef.current) {
+                return false;
+            }
+            if (taskResultExpandedRef.current
+                && update.value !== previousValue
+                && update.value.length > 0) {
+                taskResultExpandedRef.current = false;
+                setTaskResultExpanded(false);
+                chatScrollOffsetRef.current = 0;
+                setChatScrollOffset(0);
+            }
+            inputRef.current = update.value;
+            inputCursorRef.current = update.cursor;
+            setInput(update.value);
+            setInputCursor(update.cursor);
+            if (update.value !== previousValue || update.cursor !== previousCursor || update.submit !== null) {
+                chatDraftHistoryRef.current = {
+                    offset: 0,
+                    draft: { value: update.value, cursor: update.cursor }
+                };
+            }
+            if (update.submit !== null) {
+                void submitRef.current(update.submit);
+                return false;
+            }
+            return true;
+        };
+        const moveSelectedWorker = (delta, wrap = false) => {
+            const nextIndex = moveWorkerSelection(selectedWorkerIndexRef.current, delta, workersRef.current.length, wrap);
+            selectedWorkerIndexRef.current = nextIndex;
+            userSelectedWorkerRef.current = true;
+            setAttachError(null);
+            setSelectedWorkerIndex(nextIndex);
+            setWorkerScrollOffset(0);
+        };
+        const moveSelectedTaskSession = (delta, wrap = false) => {
+            const nextIndex = moveTaskSessionSelection(selectedTaskSessionIndexRef.current, delta, taskSessionsRef.current.length, wrap);
+            selectedTaskSessionIndexRef.current = nextIndex;
+            setTaskSessionsError(null);
+            setSelectedTaskSessionIndex(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);
+            setFeatureBoardNotice(null);
+            setFeatureBoardSelectedIndex(nextIndex);
+        };
+        const commitWorkerSearch = (next) => {
+            workerSearchRef.current = next;
+            setWorkerSearch(next);
+        };
+        const closeWorkerSearch = () => {
+            commitWorkerSearch({ ...workerSearchRef.current, open: false });
+        };
+        const cycleWorkerSearch = (delta) => {
+            const offsets = workerNavigationTargetsRef.current.searchOffsets;
+            if (offsets.length === 0) {
+                return;
+            }
+            const current = workerSearchRef.current;
+            const nextIndex = ((current.matchIndex + delta) % offsets.length + offsets.length) % offsets.length;
+            commitWorkerSearch({ ...current, matchIndex: nextIndex });
+            setWorkerScrollOffset(offsets[nextIndex] ?? 0);
+        };
+        const jumpWorkerLog = (kind) => {
+            const offsets = kind === "error"
+                ? workerNavigationTargetsRef.current.errorOffsets
+                : workerNavigationTargetsRef.current.diffOffsets;
+            if (offsets.length === 0) {
+                return;
+            }
+            const nextIndex = (workerJumpIndexRef.current[kind] + 1) % offsets.length;
+            workerJumpIndexRef.current[kind] = nextIndex;
+            setWorkerScrollOffset(offsets[nextIndex] ?? 0);
+        };
         const handleRawInput = (data) => {
             const chunk = rawInputDecoderRef.current.write(Buffer.isBuffer(data) ? data : String(data ?? ""));
             if (!chunk) {
                 return;
             }
             const currentView = viewRef.current;
-            if (currentView === "worker") {
+            if (currentView === "chat" && routeFallbackPromptRef.current) {
+                const fallbackChunks = tokenizeRawInput(chunk);
+                if (fallbackChunks.some((fallbackChunk) => isExitShortcut(fallbackChunk, {}))) {
+                    activeRunControllerRef.current?.abort();
+                    exitRef.current();
+                    return;
+                }
+                for (const fallbackChunk of fallbackChunks) {
+                    if (fallbackChunk === "\x1b") {
+                        settleRouteFallbackChoice("cancel");
+                        return;
+                    }
+                    if (fallbackChunk === "1" || fallbackChunk === "m" || fallbackChunk === "M") {
+                        settleRouteFallbackChoice("main");
+                        return;
+                    }
+                    if (fallbackChunk === "2" || fallbackChunk === "p" || fallbackChunk === "P") {
+                        settleRouteFallbackChoice("parallel");
+                        return;
+                    }
+                    if (fallbackChunk === "r" || fallbackChunk === "R") {
+                        settleRouteFallbackChoice("retry");
+                        return;
+                    }
+                }
+                return;
+            }
+            if (currentView === "workspace") {
+                return;
+            }
+            if (currentView === "sessions") {
                 if (isExitShortcut(chunk, {})) {
+                    activeRunControllerRef.current?.abort();
                     exitRef.current();
                     return;
                 }
-                if (chunk === "\x1b") {
-                    userSelectedWorkerRef.current = true;
-                    setView("chat");
+                const sessionAction = taskSessionActionRef.current;
+                if (sessionAction) {
+                    if (chunk === "\x1b") {
+                        updateTaskSessionAction(null);
+                        setTaskSessionsError(null);
+                        return;
+                    }
+                    if (taskSessionsLoadingRef.current) {
+                        return;
+                    }
+                    if (sessionAction.type === "rename") {
+                        const update = applyChatInputChunk(sessionAction.value, chunk, sessionAction.cursor);
+                        if (update.submit !== null) {
+                            void renameSelectedTaskSessionRef.current({
+                                ...sessionAction,
+                                value: update.submit,
+                                cursor: Array.from(update.submit).length
+                            });
+                        }
+                        else {
+                            updateTaskSessionAction({
+                                ...sessionAction,
+                                value: update.value,
+                                cursor: update.cursor
+                            });
+                        }
+                        return;
+                    }
+                    if (chunk === "d" || chunk === "D") {
+                        void deleteSelectedTaskSessionRef.current(sessionAction);
+                    }
+                    return;
+                }
+                if (isTaskSessionsShortcut(chunk, {}) || chunk === "\x1b") {
+                    setTaskSessionsError(null);
+                    setTaskSessionsNotice(null);
+                    viewRef.current = taskSessionsReturnViewRef.current;
+                    setView(taskSessionsReturnViewRef.current);
+                    return;
+                }
+                if (taskSessionsLoadingRef.current) {
+                    return;
+                }
+                if (isRouterDiagnosticsShortcut(chunk, {})) {
+                    void openRouterDiagnosticsRef.current();
+                    return;
+                }
+                if (isWorkspaceShortcut(chunk, {}) && !busyRef.current) {
+                    openWorkspacePickerRef.current();
+                    return;
+                }
+                if (isNewTaskShortcut(chunk, {}) && !busyRef.current) {
+                    if (activeTaskIdRef.current) {
+                        void newTaskRef.current();
+                    }
+                    else {
+                        viewRef.current = "chat";
+                        setView("chat");
+                    }
+                    return;
+                }
+                const selectedSession = taskSessionsRef.current[selectedTaskSessionIndexRef.current];
+                if (chunk === "r" || chunk === "R") {
+                    if (selectedSession) {
+                        updateTaskSessionAction({
+                            type: "rename",
+                            taskId: selectedSession.id,
+                            title: selectedSession.title,
+                            value: selectedSession.title,
+                            cursor: Array.from(selectedSession.title).length
+                        });
+                        setTaskSessionsError(null);
+                        setTaskSessionsNotice(null);
+                    }
+                    return;
+                }
+                if (chunk === "a" || chunk === "A") {
+                    void archiveSelectedTaskSessionRef.current();
+                    return;
+                }
+                if (chunk === "d" || chunk === "D") {
+                    if (selectedSession) {
+                        if (selectedSession.id === activeTaskIdRef.current) {
+                            setTaskSessionsError("Start a new task before deleting the active session");
+                        }
+                        else {
+                            updateTaskSessionAction({
+                                type: "delete",
+                                taskId: selectedSession.id,
+                                title: selectedSession.title
+                            });
+                            setTaskSessionsError(null);
+                            setTaskSessionsNotice(null);
+                        }
+                    }
+                    return;
+                }
+                if (chunk === "e" || chunk === "E") {
+                    void exportSelectedTaskSessionRef.current();
+                    return;
+                }
+                if (chunk === "h" || chunk === "H") {
+                    const includeArchived = !taskSessionsIncludeArchivedRef.current;
+                    taskSessionsIncludeArchivedRef.current = includeArchived;
+                    setTaskSessionsIncludeArchived(includeArchived);
+                    setTaskSessionsNotice(includeArchived ? "Archived sessions shown" : "Archived sessions hidden");
+                    void refreshTaskSessionsRef.current(selectedSession?.id ?? null);
+                    return;
+                }
+                if (chunk === "\r" || chunk === "\n") {
+                    void activateSelectedTaskSessionRef.current();
+                    return;
+                }
+                if (chunk === "\t") {
+                    moveSelectedTaskSession(1, true);
+                    return;
+                }
+                const selectionDelta = -(rawHistoryDelta(chunk)
+                    + rawPageScrollDelta(chunk, Math.max(1, outputHeight - 2))
+                    + mouseScrollDelta(chunk, 1));
+                if (selectionDelta !== 0) {
+                    moveSelectedTaskSession(selectionDelta);
+                }
+                return;
+            }
+            if (currentView === "features") {
+                const featureChunks = tokenizeRawInput(chunk);
+                if (featureChunks.some((featureChunk) => isExitShortcut(featureChunk, {}))) {
+                    activeRunControllerRef.current?.abort();
+                    exitRef.current();
+                    return;
+                }
+                const pendingCancel = featureCancelPromptRef.current;
+                if (pendingCancel) {
+                    for (const featureChunk of featureChunks) {
+                        if (featureChunk === "\x1b") {
+                            updateFeatureCancelPrompt(null);
+                            setFeatureBoardNotice(null);
+                            return;
+                        }
+                        if (featureChunk === "x" || featureChunk === "X") {
+                            void confirmFeatureCancellationRef.current(pendingCancel);
+                            return;
+                        }
+                    }
+                    return;
+                }
+                for (const featureChunk of featureChunks) {
+                    if (featureChunk === "\x1b" || isWorkerOverviewShortcut(featureChunk, {})) {
+                        setCollaborationError(null);
+                        setFeatureBoardNotice(null);
+                        viewRef.current = "workers";
+                        setView("workers");
+                        return;
+                    }
+                    if (featureChunk === "\u0012" && !busyRef.current) {
+                        setFeatureBoardNotice(null);
+                        void retryRef.current();
+                        return;
+                    }
+                    if (featureChunk === "x" || featureChunk === "X") {
+                        const taskId = activeTaskIdRef.current;
+                        const feature = collaborationTimelineRef.current?.features[featureBoardSelectedIndexRef.current];
+                        const cancellable = busyRef.current
+                            && (feature?.state === "actor_running" || feature?.state === "critic_running");
+                        if (!taskId || !feature || !cancellable) {
+                            setFeatureBoardNotice("Selected feature has no active Actor/Critic to cancel.");
+                            return;
+                        }
+                        const prompt = { taskId, featureId: feature.id, title: feature.title };
+                        updateFeatureCancelPrompt(prompt);
+                        setFeatureBoardNotice(`Cancel ${feature.title}? Active peers will finish; integration stays blocked.`);
+                        return;
+                    }
+                    if (featureChunk === "r" || featureChunk === "R") {
+                        setFeatureBoardNotice(null);
+                        void refreshCollaborationTimelineRef.current(false);
+                        continue;
+                    }
+                    if (featureChunk === "\r" || featureChunk === "\n" || featureChunk === "c" || featureChunk === "C") {
+                        if ((collaborationTimelineRef.current?.features.length ?? 0) > 0) {
+                            void openCollaborationTimelineRef.current(featureBoardSelectedIndexRef.current);
+                        }
+                        return;
+                    }
+                    if (featureChunk === "\t") {
+                        moveSelectedFeature(1, true);
+                        continue;
+                    }
+                    const selectionDelta = -(rawHistoryDelta(featureChunk)
+                        + rawPageScrollDelta(featureChunk, Math.max(1, outputHeight - 2))
+                        + mouseScrollDelta(featureChunk, 1));
+                    if (selectionDelta !== 0) {
+                        moveSelectedFeature(selectionDelta);
+                    }
+                }
+                return;
+            }
+            if (currentView === "collaboration") {
+                const timelineChunks = tokenizeRawInput(chunk);
+                if (timelineChunks.some((timelineChunk) => isExitShortcut(timelineChunk, {}))) {
+                    activeRunControllerRef.current?.abort();
+                    exitRef.current();
+                    return;
+                }
+                for (const timelineChunk of timelineChunks) {
+                    if (collaborationDetailOpenRef.current && (timelineChunk === "\x1b" || timelineChunk === "\r" || timelineChunk === "\n")) {
+                        collaborationDetailOpenRef.current = false;
+                        setCollaborationDetailOpen(false);
+                        collaborationMaxScrollOffsetRef.current = 0;
+                        setCollaborationMaxScrollOffset(0);
+                        setCollaborationScrollOffset(0);
+                        continue;
+                    }
+                    if (collaborationDetailOpenRef.current) {
+                        const detailDelta = mouseScrollDelta(timelineChunk, 3)
+                            + rawPageScrollDelta(timelineChunk, Math.max(1, outputHeight - 3));
+                        if (detailDelta !== 0) {
+                            setCollaborationScrollOffset((current) => (nextScrollOffset(current, -detailDelta, collaborationMaxScrollOffsetRef.current)));
+                        }
+                        continue;
+                    }
+                    if (timelineChunk === "\x1b" || isWorkerOverviewShortcut(timelineChunk, {})) {
+                        setCollaborationError(null);
+                        viewRef.current = collaborationReturnViewRef.current;
+                        setView(collaborationReturnViewRef.current);
+                        return;
+                    }
+                    const scopedEvents = collaborationTimelineRef.current
+                        ? collaborationTimelineEvents(collaborationTimelineRef.current, collaborationFeatureIndexRef.current, collaborationUnresolvedOnlyRef.current)
+                        : [];
+                    if (timelineChunk === "\r" || timelineChunk === "\n") {
+                        const selectedId = collaborationSelectedEventIdRef.current ?? scopedEvents.at(-1)?.id ?? null;
+                        if (selectedId) {
+                            collaborationSelectedEventIdRef.current = selectedId;
+                            setCollaborationSelectedEventId(selectedId);
+                            collaborationDetailOpenRef.current = true;
+                            setCollaborationDetailOpen(true);
+                            collaborationMaxScrollOffsetRef.current = 0;
+                            setCollaborationMaxScrollOffset(0);
+                            setCollaborationScrollOffset(0);
+                        }
+                        continue;
+                    }
+                    if (timelineChunk === "\t") {
+                        const nextIndex = nextCollaborationFeatureIndex(collaborationFeatureIndexRef.current, 1, collaborationTimelineRef.current?.features.length ?? 0);
+                        collaborationFeatureIndexRef.current = nextIndex;
+                        setCollaborationFeatureIndex(nextIndex);
+                        collaborationSelectedEventIdRef.current = null;
+                        setCollaborationSelectedEventId(null);
+                        collaborationDetailOpenRef.current = false;
+                        setCollaborationDetailOpen(false);
+                        collaborationMaxScrollOffsetRef.current = 0;
+                        setCollaborationMaxScrollOffset(0);
+                        setCollaborationScrollOffset(0);
+                        continue;
+                    }
+                    if (timelineChunk === "u" || timelineChunk === "U") {
+                        const unresolved = !collaborationUnresolvedOnlyRef.current;
+                        collaborationUnresolvedOnlyRef.current = unresolved;
+                        setCollaborationUnresolvedOnly(unresolved);
+                        collaborationSelectedEventIdRef.current = null;
+                        setCollaborationSelectedEventId(null);
+                        collaborationMaxScrollOffsetRef.current = 0;
+                        setCollaborationMaxScrollOffset(0);
+                        setCollaborationScrollOffset(0);
+                        continue;
+                    }
+                    if (timelineChunk === "r" || timelineChunk === "R") {
+                        void refreshCollaborationTimelineRef.current(false);
+                        continue;
+                    }
+                    const eventDelta = rawHistoryDelta(timelineChunk);
+                    if (eventDelta !== 0) {
+                        const nextId = moveCollaborationEventSelection(scopedEvents, collaborationSelectedEventIdRef.current, -eventDelta);
+                        collaborationSelectedEventIdRef.current = nextId;
+                        setCollaborationSelectedEventId(nextId);
+                        const lineHeight = (process.stdout.columns || 120) < 28 ? 1 : 2;
+                        setCollaborationScrollOffset((current) => (nextScrollOffset(current, eventDelta * lineHeight, collaborationMaxScrollOffsetRef.current)));
+                        continue;
+                    }
+                    const timelineDelta = mouseScrollDelta(timelineChunk, 3)
+                        + rawPageScrollDelta(timelineChunk, Math.max(1, outputHeight - 3));
+                    if (timelineDelta !== 0) {
+                        setCollaborationScrollOffset((current) => (nextScrollOffset(current, timelineDelta, collaborationMaxScrollOffsetRef.current)));
+                    }
+                }
+                return;
+            }
+            if (currentView === "workers") {
+                if (isExitShortcut(chunk, {})) {
+                    activeRunControllerRef.current?.abort();
+                    exitRef.current();
+                    return;
+                }
+                if (isWorkerOverviewShortcut(chunk, {}) || chunk === "\x1b") {
+                    setAttachError(null);
+                    viewRef.current = workerOverviewReturnViewRef.current;
+                    setView(workerOverviewReturnViewRef.current);
+                    return;
+                }
+                if (isRouterDiagnosticsShortcut(chunk, {})) {
+                    void openRouterDiagnosticsRef.current();
+                    return;
+                }
+                if (isTaskSessionsShortcut(chunk, {}) && !busyRef.current) {
+                    void openTaskSessionsRef.current();
+                    return;
+                }
+                if (isWorkspaceShortcut(chunk, {}) && !busyRef.current) {
+                    openWorkspacePickerRef.current();
                     return;
                 }
-                const delta = mouseScrollDelta(chunk, 3);
-                if (delta !== 0) {
-                    setWorkerScrollOffset((current) => nextScrollOffset(current, delta, workerMaxScrollOffsetRef.current));
+                if (isNewTaskShortcut(chunk, {}) && !busyRef.current) {
+                    void newTaskRef.current();
+                    return;
+                }
+                if (chunk === "f" || chunk === "F") {
+                    void openFeatureBoardRef.current();
+                    return;
+                }
+                if (chunk === "c" || chunk === "C") {
+                    void openCollaborationTimelineRef.current();
+                    return;
+                }
+                if (isAttachShortcut(chunk, {})) {
+                    const worker = workersRef.current[selectedWorkerIndexRef.current];
+                    if (worker) {
+                        void attachSelectedWorkerRef.current(worker);
+                    }
+                    return;
+                }
+                if (isLogsShortcut(chunk, {}) || chunk === "\r" || chunk === "\n") {
+                    if (workersRef.current.length > 0) {
+                        viewRef.current = "worker";
+                        setView("worker");
+                        setWorkerScrollOffset(0);
+                    }
+                    return;
+                }
+                if (chunk === "\t") {
+                    moveSelectedWorker(1, true);
+                    return;
+                }
+                const selectionDelta = -(rawHistoryDelta(chunk)
+                    + rawPageScrollDelta(chunk, Math.max(1, outputHeight - 2))
+                    + mouseScrollDelta(chunk, 1));
+                if (selectionDelta !== 0) {
+                    moveSelectedWorker(selectionDelta);
+                }
+                return;
+            }
+            if (currentView === "router") {
+                const routerChunks = tokenizeRawInput(chunk);
+                if (routerChunks.some((routerChunk) => isExitShortcut(routerChunk, {}))) {
+                    activeRunControllerRef.current?.abort();
+                    exitRef.current();
+                    return;
+                }
+                for (const routerChunk of routerChunks) {
+                    if (isRouterDiagnosticsShortcut(routerChunk, {})) {
+                        void openRouterDiagnosticsRef.current();
+                        continue;
+                    }
+                    if (isTaskSessionsShortcut(routerChunk, {}) && !busyRef.current) {
+                        void openTaskSessionsRef.current();
+                        return;
+                    }
+                    if (routerChunk === "\t") {
+                        setRouterScope((current) => current === "all" ? "workspace" : "all");
+                        routerMaxScrollOffsetRef.current = 0;
+                        setRouterMaxScrollOffset(0);
+                        setRouterScrollOffset(0);
+                        continue;
+                    }
+                    if (routerChunk === "\x1b") {
+                        setAttachError(null);
+                        viewRef.current = routerReturnViewRef.current;
+                        setView(routerReturnViewRef.current);
+                        return;
+                    }
+                    const routeDelta = mouseScrollDelta(routerChunk, 3)
+                        + rawPageScrollDelta(routerChunk, Math.max(1, outputHeight - 1));
+                    if (routeDelta !== 0) {
+                        setRouterScrollOffset((current) => (nextScrollOffset(current, -routeDelta, routerMaxScrollOffsetRef.current)));
+                    }
+                }
+                return;
+            }
+            if (currentView === "worker") {
+                for (const workerChunk of tokenizeRawInput(chunk)) {
+                    if (isExitShortcut(workerChunk, {})) {
+                        activeRunControllerRef.current?.abort();
+                        exitRef.current();
+                        return;
+                    }
+                    if (workerSearchRef.current.open) {
+                        if (isWorkerSearchShortcut(workerChunk, {}) || workerChunk === "\x1b") {
+                            closeWorkerSearch();
+                            continue;
+                        }
+                        if (workerChunk === "\r" || workerChunk === "\n") {
+                            cycleWorkerSearch(1);
+                            continue;
+                        }
+                        const searchHistoryDelta = rawHistoryDelta(workerChunk);
+                        if (searchHistoryDelta !== 0) {
+                            cycleWorkerSearch(-searchHistoryDelta);
+                            continue;
+                        }
+                        const current = workerSearchRef.current;
+                        const update = applyChatInputChunk(current.query, workerChunk, current.cursor);
+                        const query = update.submit ?? update.value;
+                        const cursor = update.submit === null ? update.cursor : Array.from(query).length;
+                        commitWorkerSearch({
+                            open: true,
+                            query,
+                            cursor,
+                            matchIndex: query === current.query ? current.matchIndex : 0
+                        });
+                        continue;
+                    }
+                    if (isWorkerSearchShortcut(workerChunk, {})) {
+                        commitWorkerSearch({ ...workerSearchRef.current, open: true });
+                        continue;
+                    }
+                    const jumpKind = workerLogJumpKind(workerChunk);
+                    if (jumpKind) {
+                        jumpWorkerLog(jumpKind);
+                        continue;
+                    }
+                    if (isNewTaskShortcut(workerChunk, {}) && !busyRef.current) {
+                        void newTaskRef.current();
+                        return;
+                    }
+                    if (isWorkspaceShortcut(workerChunk, {}) && !busyRef.current) {
+                        openWorkspacePickerRef.current();
+                        return;
+                    }
+                    if (isRouterDiagnosticsShortcut(workerChunk, {})) {
+                        void openRouterDiagnosticsRef.current();
+                        return;
+                    }
+                    if (isTaskSessionsShortcut(workerChunk, {}) && !busyRef.current) {
+                        void openTaskSessionsRef.current();
+                        return;
+                    }
+                    if (isWorkerOverviewShortcut(workerChunk, {})) {
+                        openWorkerOverviewRef.current();
+                        return;
+                    }
+                    if (workerChunk === "\x1b") {
+                        userSelectedWorkerRef.current = true;
+                        setAttachError(null);
+                        setView("chat");
+                        return;
+                    }
+                    const delta = mouseScrollDelta(workerChunk, 3);
+                    if (delta !== 0) {
+                        setWorkerScrollOffset((current) => nextScrollOffset(current, delta, null));
+                    }
                 }
                 return;
             }
             if (currentView === "chat") {
+                if (isWorkspaceShortcut(chunk, {}) && !busyRef.current) {
+                    openWorkspacePickerRef.current();
+                    return;
+                }
+                if (isRouterDiagnosticsShortcut(chunk, {})) {
+                    void openRouterDiagnosticsRef.current();
+                    return;
+                }
+                if (isTaskSessionsShortcut(chunk, {}) && !busyRef.current) {
+                    void openTaskSessionsRef.current();
+                    return;
+                }
+                if (isWorkerOverviewShortcut(chunk, {})) {
+                    openWorkerOverviewRef.current();
+                    return;
+                }
+                if (isTaskResultShortcut(chunk, {})
+                    && activeTaskIdRef.current
+                    && latestTaskResultMessageIndex(messagesRef.current, activeTaskIdRef.current) >= 0) {
+                    const expanded = !taskResultExpandedRef.current;
+                    taskResultExpandedRef.current = expanded;
+                    setTaskResultExpanded(expanded);
+                    chatScrollOffsetRef.current = 0;
+                    setChatScrollOffset(0);
+                    return;
+                }
+                const paste = chatPasteDecoderRef.current.write(chunk);
+                if (paste.intercepted) {
+                    if (busyRef.current) {
+                        return;
+                    }
+                    for (const event of paste.events) {
+                        const previousValue = inputRef.current;
+                        const previousCursor = inputCursorRef.current;
+                        const update = event.kind === "paste"
+                            ? insertChatPaste(previousValue, event.text, previousCursor)
+                            : applyChatInputChunk(previousValue, event.text, previousCursor);
+                        if (!commitChatInputUpdate(update, previousValue, previousCursor)) {
+                            return;
+                        }
+                    }
+                    return;
+                }
+                if (isNewTaskShortcut(chunk, {}) && !busyRef.current) {
+                    void newTaskRef.current();
+                    return;
+                }
                 if (chunk === "\x1b") {
+                    if (busyRef.current) {
+                        activeRunControllerRef.current?.abort();
+                        return;
+                    }
                     userSelectedWorkerRef.current = true;
+                    setAttachError(null);
                     setView("chat");
                     return;
                 }
                 const wheelDelta = mouseScrollDelta(chunk, 3);
-                if (wheelDelta !== 0 && workersRef.current.length > 0) {
+                const pageDelta = rawPageScrollDelta(chunk, Math.max(1, outputHeight - 1));
+                const historyDelta = wheelDelta + pageDelta;
+                if (historyDelta !== 0 && chatMaxScrollOffsetRef.current > 0) {
+                    setChatScrollOffset((current) => {
+                        const next = nextScrollOffset(current, taskResultExpandedRef.current ? -historyDelta : historyDelta, chatMaxScrollOffsetRef.current);
+                        chatScrollOffsetRef.current = next;
+                        return next;
+                    });
+                    return;
+                }
+                if (wheelDelta > 0 && workersRef.current.length > 0 && !taskResultExpandedRef.current) {
+                    setAttachError(null);
+                    viewRef.current = "worker";
                     setView("worker");
-                    setWorkerScrollOffset((current) => nextScrollOffset(current, wheelDelta, workerMaxScrollOffsetRef.current));
+                    setWorkerScrollOffset((current) => nextScrollOffset(current, wheelDelta, null));
                     return;
                 }
                 if (chunk === "\u0017") {
+                    if (workersRef.current.length === 0) {
+                        setAttachError(NO_WORKERS_LOGS_MESSAGE);
+                        return;
+                    }
+                    setAttachError(null);
                     setView("worker");
                     setWorkerScrollOffset(0);
                     return;
@@ -225,7 +1239,7 @@ export function App({ config, orchestrator, cwd, initialTaskId = null, prepareNa
                 if (chunk === "\u000f") {
                     const worker = workersRef.current[selectedWorkerIndexRef.current];
                     if (!worker) {
-                        setAttachError("No worker selected. Run a complex task or wait for workers to load before attaching.");
+                        setAttachError(NO_WORKERS_ATTACH_MESSAGE);
                         return;
                     }
                     void attachSelectedWorkerRef.current(worker);
@@ -235,23 +1249,33 @@ export function App({ config, orchestrator, cwd, initialTaskId = null, prepareNa
                     const nextIndex = (selectedWorkerIndexRef.current + 1) % workersRef.current.length;
                     userSelectedWorkerRef.current = true;
                     selectedWorkerIndexRef.current = nextIndex;
+                    setAttachError(null);
                     setSelectedWorkerIndex(nextIndex);
                     setView("worker");
                     setWorkerScrollOffset(0);
                     return;
                 }
-                const update = applyChatInputChunk(inputRef.current, chunk);
-                inputRef.current = update.value;
-                if (update.exit) {
-                    exitRef.current();
+                if (chunk === "\u0012" && !busyRef.current) {
+                    void retryRef.current();
                     return;
                 }
-                if (!busyRef.current) {
+                const draftHistoryDelta = rawHistoryDelta(chunk);
+                if (draftHistoryDelta !== 0) {
+                    if (busyRef.current) {
+                        return;
+                    }
+                    const update = navigateChatDraftHistory(chatRequestHistory(messagesRef.current), { value: inputRef.current, cursor: inputCursorRef.current }, chatDraftHistoryRef.current, draftHistoryDelta);
+                    chatDraftHistoryRef.current = update.state;
+                    inputRef.current = update.value;
+                    inputCursorRef.current = update.cursor;
                     setInput(update.value);
+                    setInputCursor(update.cursor);
+                    return;
                 }
-                if (update.submit !== null) {
-                    void submitRef.current(update.submit);
-                }
+                const previousValue = inputRef.current;
+                const previousCursor = inputCursorRef.current;
+                const update = applyChatInputChunk(previousValue, chunk, previousCursor);
+                commitChatInputUpdate(update, previousValue, previousCursor);
                 return;
             }
             const nativeWheelDelta = mouseScrollDelta(chunk, Math.max(3, Math.floor(outputHeight / 2)));
@@ -267,6 +1291,7 @@ export function App({ config, orchestrator, cwd, initialTaskId = null, prepareNa
             }
             const update = applyNativeInputChunk(nativeInputRef.current, chunk, outputHeight - 1);
             if (update.exit) {
+                nativeAttachRequestSequenceRef.current += 1;
                 nativeAttachRef.current?.process.kill();
                 nativeAttachRef.current = null;
                 nativeInputRef.current = "";
@@ -292,27 +1317,63 @@ export function App({ config, orchestrator, cwd, initialTaskId = null, prepareNa
             }
         };
         stdinEvents.on("input", handleRawInput);
+        setInputReady(true);
         return () => {
             stdinEvents.removeListener("input", handleRawInput);
             rawInputDecoderRef.current.end();
-            process.stdout.write("\x1b[?1006l\x1b[?1002l\x1b[?1000l");
+            chatPasteDecoderRef.current.reset();
+            process.stdout.write("\x1b[?1006l\x1b[?1002l\x1b[?1000l\x1b[?2004l");
             setRawMode(false);
         };
     }, [outputHeight, setRawMode, stdinEvents]);
+    useEffect(() => {
+        mountedRef.current = true;
+        return () => {
+            mountedRef.current = false;
+            nativeAttachRequestSequenceRef.current += 1;
+            nativeAttachRef.current?.process.kill();
+            nativeAttachRef.current = null;
+            activeRunControllerRef.current?.abort();
+            collaborationLoadSequenceRef.current += 1;
+            routerLoadSequenceRef.current += 1;
+            taskSessionsLoadSequenceRef.current += 1;
+        };
+    }, []);
+    useEffect(() => {
+        if (!shutdownSignal) {
+            return;
+        }
+        const shutdown = () => {
+            activeRunControllerRef.current?.abort();
+            exitRef.current();
+        };
+        if (shutdownSignal.aborted) {
+            shutdown();
+            return;
+        }
+        shutdownSignal.addEventListener("abort", shutdown, { once: true });
+        return () => shutdownSignal.removeEventListener("abort", shutdown);
+    }, [shutdownSignal]);
     useInput((inputKey, key) => {
         if (view === "worker") {
             if (isExitShortcut(inputKey, key)) {
+                activeRunControllerRef.current?.abort();
                 exitRef.current();
                 return;
             }
+            if (isNewTaskShortcut(inputKey, key) && !busy) {
+                void startNewTask();
+                return;
+            }
             const delta = scrollDelta(inputKey, key, outputHeight - 1);
             if (delta !== 0) {
-                setWorkerScrollOffset((current) => nextScrollOffset(current, delta, workerMaxScrollOffset));
+                setWorkerScrollOffset((current) => nextScrollOffset(current, delta, null));
                 return;
             }
         }
         if (key.escape) {
             userSelectedWorkerRef.current = true;
+            setAttachError(null);
             setView("chat");
             return;
         }
@@ -329,13 +1390,16 @@ export function App({ config, orchestrator, cwd, initialTaskId = null, prepareNa
         if (isAttachShortcut(inputKey, key)) {
             const worker = workers[selectedWorkerIndex];
             if (!worker) {
-                setAttachError("No worker selected. Run a complex task or wait for workers to load before attaching.");
+                setAttachError(NO_WORKERS_ATTACH_MESSAGE);
                 return;
             }
             void attachSelectedWorker(worker);
         }
-    }, { isActive: view !== "native" && view !== "chat" });
+    }, { isActive: view === "worker" && !workerSearch.open });
     async function attachSelectedWorker(worker) {
+        const requestSequence = nativeAttachRequestSequenceRef.current + 1;
+        nativeAttachRequestSequenceRef.current = requestSequence;
+        const attachIsCurrent = () => (mountedRef.current && nativeAttachRequestSequenceRef.current === requestSequence);
         setAttachError(null);
         try {
             const launch = await (prepareNativeAttach
@@ -344,9 +1408,12 @@ export function App({ config, orchestrator, cwd, initialTaskId = null, prepareNa
                     config,
                     worker
                 }));
+            if (!attachIsCurrent()) {
+                return;
+            }
             const terminalCols = process.stdout.columns || 120;
             const nativeTerminalCols = nativeAttachTerminalColumns(terminalCols);
-            const terminalRows = Math.max(1, contentHeight - 2);
+            const terminalRows = nativeAttachTerminalRows(process.stdout.rows || 30, Boolean(attachError), config.ui.showStatusBar);
             const screen = new NativeTerminalScreen({
                 cols: nativeTerminalCols,
                 rows: terminalRows
@@ -358,20 +1425,34 @@ export function App({ config, orchestrator, cwd, initialTaskId = null, prepareNa
             };
             const processRef = (startNativeAttach ?? startNativeAttachProcess)(sizedLaunch, {
                 onOutput: (chunk) => {
+                    if (!attachIsCurrent()) {
+                        return;
+                    }
                     void screen.write(chunk).then(() => {
+                        if (!attachIsCurrent()) {
+                            return;
+                        }
                         setNativeAttach((current) => current && current.screen === screen
                             ? {
                                 ...current,
+                                hasOutput: true,
                                 snapshot: screen.snapshot()
                             }
                             : current);
                     });
                 },
                 onClose: (code) => {
-                    void screen.write(`\r\n${nativeAttachExitLine(code, nativeTerminalCols)}\r\n`).then(() => {
+                    if (!attachIsCurrent()) {
+                        return;
+                    }
+                    void screen.write(`\r\n${nativeAttachExitLine(code, screen.dimensions().cols)}\r\n`).then(() => {
+                        if (!attachIsCurrent()) {
+                            return;
+                        }
                         setNativeAttach((current) => current && current.screen === screen
                             ? {
                                 ...current,
+                                hasOutput: true,
                                 closedCode: code,
                                 snapshot: screen.snapshot()
                             }
@@ -379,21 +1460,136 @@ export function App({ config, orchestrator, cwd, initialTaskId = null, prepareNa
                     });
                 },
                 onError: (error) => {
-                    setAttachError(error.message);
+                    if (attachIsCurrent()) {
+                        setAttachError(error.message);
+                    }
                 }
             });
-            setNativeAttach({
+            if (!attachIsCurrent()) {
+                processRef.kill();
+                return;
+            }
+            const nextNativeAttach = {
+                hasOutput: false,
                 launch: sizedLaunch,
                 process: processRef,
                 screen,
                 snapshot: screen.snapshot(),
                 closedCode: null
-            });
+            };
+            nativeAttachRef.current = nextNativeAttach;
+            setNativeAttach(nextNativeAttach);
             setNativeInput("");
             setView("native");
         }
         catch (error) {
-            setAttachError(error instanceof Error ? error.message : String(error));
+            if (attachIsCurrent()) {
+                setAttachError(error instanceof Error ? error.message : String(error));
+            }
+        }
+    }
+    function createRunCallbacks(controller, options = {}) {
+        const announceRoute = options.announceRoute ?? true;
+        return {
+            signal: controller.signal,
+            onRouteStart: (state) => {
+                setRouteElapsedMs(0);
+                setRoutePending({ ...state, startedAtMs: Date.now() });
+            },
+            onRouteProgress: (progress) => {
+                setRoutePending((current) => current ? { ...current, phase: progress.phase } : current);
+            },
+            onRouteFallback: (fallback) => requestRouteFallbackChoice(fallback, controller.signal),
+            onRoute: (route) => {
+                setRoutePending(null);
+                setLastRoute(route);
+                if (announceRoute) {
+                    setRouteAnnouncement({
+                        from: "system",
+                        kind: "route",
+                        text: routeDecisionChatMessage(route),
+                        ...(activeTaskIdRef.current ? { taskId: activeTaskIdRef.current } : {})
+                    });
+                    chatScrollOffsetRef.current = 0;
+                    setChatScrollOffset(0);
+                }
+            },
+            onStatus: (nextStatus) => {
+                setStatus(nextStatus.main
+                    ? { ...nextStatus, mainEngine: config.pairing.main }
+                    : nextStatus);
+                if (nextStatus.taskId !== "main") {
+                    activeTaskIdRef.current = nextStatus.taskId;
+                    setActiveTaskId(nextStatus.taskId);
+                    setActiveMode("complex");
+                }
+            },
+            onWorker: (worker) => {
+                setWorkers((current) => {
+                    const next = upsertWorker(current, worker);
+                    workersRef.current = next;
+                    return next;
+                });
+                if (worker.role === "main" && worker.runtimeStatus) {
+                    setStatus((current) => applyMainRuntimeStatus(current, worker, workerActivityPolicies[worker.engine]));
+                }
+            }
+        };
+    }
+    function requestRouteFallbackChoice(fallback, signal) {
+        routeFallbackResolverRef.current?.("cancel");
+        setRoutePending(null);
+        setLastRoute(fallback.route);
+        routeFallbackPromptRef.current = fallback;
+        setRouteFallbackPrompt(fallback);
+        viewRef.current = "chat";
+        setView("chat");
+        return new Promise((resolve) => {
+            let settled = false;
+            const finish = (choice) => {
+                if (settled) {
+                    return;
+                }
+                settled = true;
+                signal.removeEventListener("abort", onAbort);
+                const current = routeFallbackPromptRef.current;
+                if (current === fallback) {
+                    routeFallbackPromptRef.current = null;
+                    routeFallbackResolverRef.current = null;
+                    setRouteFallbackPrompt(null);
+                    setLastRoute(previewRouteFallbackChoice(fallback.route, choice));
+                }
+                resolve(choice);
+            };
+            const onAbort = () => finish("cancel");
+            routeFallbackResolverRef.current = finish;
+            if (signal.aborted) {
+                finish("cancel");
+            }
+            else {
+                signal.addEventListener("abort", onAbort, { once: true });
+            }
+        });
+    }
+    function settleRouteFallbackChoice(choice) {
+        routeFallbackResolverRef.current?.(choice);
+    }
+    async function appendVisibleMessage(message, taskId) {
+        const visibleMessage = taskId ? { ...message, taskId } : message;
+        setMessages((current) => {
+            const next = [...current, visibleMessage];
+            messagesRef.current = next;
+            return next;
+        });
+        if (!persistChatMessage) {
+            return;
+        }
+        try {
+            await persistChatMessage(message, taskId);
+        }
+        catch (error) {
+            const detail = error instanceof Error ? error.message : String(error);
+            setAttachError(`Chat history write failed · ${detail}`);
         }
     }
     async function submit(value) {
@@ -402,26 +1598,32 @@ export function App({ config, orchestrator, cwd, initialTaskId = null, prepareNa
             return;
         }
         inputRef.current = "";
+        inputCursorRef.current = 0;
+        chatDraftHistoryRef.current = {
+            offset: 0,
+            draft: { value: "", cursor: 0 }
+        };
         setInput("");
+        setInputCursor(0);
+        chatScrollOffsetRef.current = 0;
+        setChatScrollOffset(0);
         busyRef.current = true;
         setBusy(true);
-        setMessages((current) => [...current, { from: "user", text: request }]);
+        setRoutePending(null);
+        setRouteAnnouncement(null);
+        setLastRoute(null);
+        setTaskResultExpanded(false);
+        const controller = new AbortController();
+        activeRunControllerRef.current = controller;
+        const memory = currentSubmitMemoryState(activeTaskIdRef.current, activeMode);
+        await appendVisibleMessage({ from: "user", text: request }, memory.activeTaskId ?? undefined);
         try {
-            const callbacks = {
-                onStatus: setStatus,
-                onWorker: (worker) => {
-                    setWorkers((current) => upsertWorker(current, worker));
-                }
-            };
-            const memory = {
-                activeTaskId,
-                activeMode
-            };
-            const followUpRoute = activeTaskId && activeMode === "complex"
+            const callbacks = createRunCallbacks(controller);
+            const followUpRoute = memory.activeTaskId && memory.activeMode === "complex"
                 ? await orchestrator.routeTaskFollowUp({
                     request,
                     cwd,
-                    taskId: activeTaskId,
+                    taskId: memory.activeTaskId,
                     ...callbacks
                 })
                 : undefined;
@@ -433,13 +1635,13 @@ export function App({ config, orchestrator, cwd, initialTaskId = null, prepareNa
                 userSelectedWorkerRef.current = false;
                 setSelectedWorkerIndex(0);
                 setWorkerScrollOffset(0);
-                setWorkerMaxScrollOffset(0);
             }
             const result = target.kind === "task-turn"
                 ? await orchestrator.handleTaskTurn({
                     request,
                     cwd,
                     taskId: target.taskId,
+                    route: followUpRoute?.route,
                     ...callbacks
                 })
                 : target.kind === "task-question"
@@ -447,6 +1649,7 @@ export function App({ config, orchestrator, cwd, initialTaskId = null, prepareNa
                         request,
                         cwd,
                         taskId: target.taskId,
+                        route: followUpRoute?.route,
                         ...callbacks
                     })
                     : await orchestrator.handleRequest({
@@ -457,72 +1660,1345 @@ export function App({ config, orchestrator, cwd, initialTaskId = null, prepareNa
             const nextMemory = nextSubmitMemoryState(memory, target, result);
             setActiveMode(nextMemory.activeMode);
             setActiveTaskId(nextMemory.activeTaskId);
-            setMessages((current) => [...current, { from: "system", text: result.summary }]);
+            activeTaskIdRef.current = nextMemory.activeTaskId;
+            setCanRetryTask(nextMemory.activeTaskId
+                ? await orchestrator.canRetryTask(nextMemory.activeTaskId)
+                : false);
+            setRouteAnnouncement(null);
+            await appendVisibleMessage({ from: "system", text: result.summary }, nextMemory.activeTaskId ?? undefined);
+            if (result.mode === "complex" && parseTaskResultSummary(result.summary)) {
+                setTaskResultExpanded(true);
+            }
+        }
+        catch (error) {
+            setRouteAnnouncement(null);
+            const retryTaskId = activeTaskIdRef.current;
+            if (retryTaskId) {
+                setCanRetryTask(await orchestrator.canRetryTask(retryTaskId));
+            }
+            await appendVisibleMessage({
+                from: "system",
+                text: isAbortError(error) ? "cancelled · request stopped" : error instanceof Error ? error.message : String(error)
+            }, retryTaskId ?? undefined);
+        }
+        finally {
+            if (activeRunControllerRef.current === controller) {
+                activeRunControllerRef.current = null;
+            }
+            setRoutePending(null);
+            setRouteAnnouncement(null);
+            busyRef.current = false;
+            setBusy(false);
+        }
+    }
+    async function retryActiveTask() {
+        const taskId = activeTaskIdRef.current;
+        if (!taskId || busyRef.current || !canRetryTask) {
+            return;
+        }
+        const controller = new AbortController();
+        activeRunControllerRef.current = controller;
+        busyRef.current = true;
+        setBusy(true);
+        setCanRetryTask(false);
+        setRoutePending(null);
+        setRouteAnnouncement(null);
+        setLastRoute(null);
+        try {
+            const result = await orchestrator.retryTask({
+                taskId,
+                cwd,
+                ...createRunCallbacks(controller, { announceRoute: false })
+            });
+            activeTaskIdRef.current = taskId;
+            setActiveTaskId(taskId);
+            setActiveMode("complex");
+            setCanRetryTask(false);
+            setRouteAnnouncement(null);
+            await appendVisibleMessage({ from: "system", text: result.summary }, taskId);
+            if (parseTaskResultSummary(result.summary)) {
+                setTaskResultExpanded(true);
+            }
+        }
+        catch (error) {
+            setRouteAnnouncement(null);
+            setCanRetryTask(await orchestrator.canRetryTask(taskId));
+            await appendVisibleMessage({
+                from: "system",
+                text: isAbortError(error) ? "cancelled · retry stopped" : error instanceof Error ? error.message : String(error)
+            }, taskId);
+        }
+        finally {
+            if (activeRunControllerRef.current === controller) {
+                activeRunControllerRef.current = null;
+            }
+            setRoutePending(null);
+            setRouteAnnouncement(null);
+            busyRef.current = false;
+            setBusy(false);
+        }
+    }
+    async function startNewTask() {
+        if (busyRef.current || !activeTaskIdRef.current) {
+            return;
+        }
+        try {
+            await activateTaskSession?.(null);
+        }
+        catch (error) {
+            setAttachError(error instanceof Error ? error.message : String(error));
+            return;
+        }
+        const nextMemory = newTaskMemoryState();
+        activeTaskIdRef.current = nextMemory.activeTaskId;
+        setActiveTaskId(nextMemory.activeTaskId);
+        setActiveMode(nextMemory.activeMode);
+        setCanRetryTask(false);
+        setStatus(null);
+        setRoutePending(null);
+        setRouteAnnouncement(null);
+        setLastRoute(null);
+        setTaskResultExpanded(false);
+        setWorkers([]);
+        workersRef.current = [];
+        selectedWorkerIndexRef.current = 0;
+        setSelectedWorkerIndex(0);
+        setWorkerScrollOffset(0);
+        autoSelectedFailedWorkerRef.current = false;
+        userSelectedWorkerRef.current = false;
+        setAttachError(null);
+        viewRef.current = "chat";
+        setView("chat");
+        chatDraftHistoryRef.current = {
+            offset: 0,
+            draft: { value: inputRef.current, cursor: inputCursorRef.current }
+        };
+        await appendVisibleMessage({ from: "system", text: "new task · ready" });
+    }
+    async function openRouterDiagnostics() {
+        const currentView = viewRef.current;
+        if (currentView === "native" || currentView === "workspace") {
+            return;
+        }
+        if (currentView !== "router") {
+            routerReturnViewRef.current = currentView === "worker" || currentView === "workers" || currentView === "sessions"
+                ? currentView
+                : "chat";
+        }
+        viewRef.current = "router";
+        setView("router");
+        setAttachError(null);
+        setRouterError(null);
+        setRouterLoading(true);
+        setRouterScrollOffset(0);
+        routerMaxScrollOffsetRef.current = 0;
+        setRouterMaxScrollOffset(0);
+        const sequence = routerLoadSequenceRef.current + 1;
+        routerLoadSequenceRef.current = sequence;
+        try {
+            if (!loadRouterDiagnostics) {
+                throw new Error("Router diagnostics are unavailable");
+            }
+            const diagnostics = await loadRouterDiagnostics();
+            if (routerLoadSequenceRef.current !== sequence) {
+                return;
+            }
+            setRouterRecords(diagnostics.records);
+            setRouterPolicy(diagnostics.policy);
+        }
+        catch (error) {
+            if (routerLoadSequenceRef.current === sequence) {
+                setRouterError(error instanceof Error ? error.message : String(error));
+            }
+        }
+        finally {
+            if (routerLoadSequenceRef.current === sequence) {
+                setRouterLoading(false);
+            }
+        }
+    }
+    async function openTaskSessions() {
+        const currentView = viewRef.current;
+        if (busyRef.current ||
+            currentView === "native" ||
+            currentView === "workspace" ||
+            currentView === "sessions") {
+            return;
+        }
+        taskSessionsReturnViewRef.current = currentView === "worker" || currentView === "workers" || currentView === "router"
+            ? currentView
+            : "chat";
+        viewRef.current = "sessions";
+        setView("sessions");
+        setAttachError(null);
+        setTaskSessionsError(null);
+        setTaskSessionsNotice(null);
+        updateTaskSessionAction(null);
+        await refreshTaskSessions(activeTaskIdRef.current);
+    }
+    async function refreshTaskSessions(preferredTaskId = null) {
+        taskSessionsLoadingRef.current = true;
+        setTaskSessionsLoading(true);
+        const sequence = taskSessionsLoadSequenceRef.current + 1;
+        taskSessionsLoadSequenceRef.current = sequence;
+        try {
+            if (!loadTaskSessions) {
+                throw new Error("Task sessions are unavailable");
+            }
+            const tasks = await loadTaskSessions({
+                includeArchived: taskSessionsIncludeArchivedRef.current
+            });
+            if (taskSessionsLoadSequenceRef.current !== sequence) {
+                return;
+            }
+            taskSessionsRef.current = tasks;
+            setTaskSessions(tasks);
+            const preferredIndex = preferredTaskId
+                ? tasks.findIndex((task) => task.id === preferredTaskId)
+                : -1;
+            const selectedIndex = preferredIndex >= 0
+                ? preferredIndex
+                : Math.min(Math.max(0, selectedTaskSessionIndexRef.current), Math.max(0, tasks.length - 1));
+            selectedTaskSessionIndexRef.current = selectedIndex;
+            setSelectedTaskSessionIndex(selectedIndex);
+        }
+        catch (error) {
+            if (taskSessionsLoadSequenceRef.current === sequence) {
+                setTaskSessionsError(error instanceof Error ? error.message : String(error));
+            }
+        }
+        finally {
+            if (taskSessionsLoadSequenceRef.current === sequence) {
+                taskSessionsLoadingRef.current = false;
+                setTaskSessionsLoading(false);
+            }
+        }
+    }
+    function updateTaskSessionAction(next) {
+        taskSessionActionRef.current = next;
+        setTaskSessionAction(next);
+    }
+    async function runTaskSessionOperation(run, notice, preferredTaskId) {
+        if (taskSessionsLoadingRef.current) {
+            return;
+        }
+        taskSessionsLoadingRef.current = true;
+        setTaskSessionsLoading(true);
+        setTaskSessionsError(null);
+        setTaskSessionsNotice(null);
+        try {
+            const result = await run();
+            updateTaskSessionAction(null);
+            setTaskSessionsNotice(typeof notice === "function" ? notice(result) : notice);
+            await refreshTaskSessions(preferredTaskId);
+        }
+        catch (error) {
+            setTaskSessionsError(error instanceof Error ? error.message : String(error));
+        }
+        finally {
+            taskSessionsLoadingRef.current = false;
+            setTaskSessionsLoading(false);
+        }
+    }
+    async function renameSelectedTaskSession(action) {
+        await runTaskSessionOperation(async () => {
+            if (!renameTaskSession) {
+                throw new Error("Task session rename is unavailable");
+            }
+            const title = action.value.trim();
+            await renameTaskSession(action.taskId, title);
+            return title;
+        }, (title) => `Renamed · ${title}`, action.taskId);
+    }
+    async function archiveSelectedTaskSession() {
+        const selected = taskSessionsRef.current[selectedTaskSessionIndexRef.current];
+        if (!selected) {
+            return;
+        }
+        const archived = !selected.archived_at;
+        await runTaskSessionOperation(async () => {
+            if (!setTaskSessionArchived) {
+                throw new Error("Task session archive is unavailable");
+            }
+            await setTaskSessionArchived(selected.id, archived);
+        }, archived ? `Archived · ${selected.title}` : `Unarchived · ${selected.title}`, selected.id);
+    }
+    async function deleteSelectedTaskSession(action) {
+        await runTaskSessionOperation(async () => {
+            if (!deleteTaskSession) {
+                throw new Error("Task session deletion is unavailable");
+            }
+            await deleteTaskSession(action.taskId);
+        }, `Deleted · ${action.title}`, null);
+    }
+    async function exportSelectedTaskSession() {
+        const selected = taskSessionsRef.current[selectedTaskSessionIndexRef.current];
+        if (!selected) {
+            return;
+        }
+        await runTaskSessionOperation(async () => {
+            if (!exportTaskSession) {
+                throw new Error("Task session export is unavailable");
+            }
+            return exportTaskSession(selected.id);
+        }, (path) => `Exported · ${path}`, selected.id);
+    }
+    async function activateSelectedTaskSession() {
+        if (busyRef.current || taskSessionsLoadingRef.current) {
+            return;
+        }
+        const selected = taskSessionsRef.current[selectedTaskSessionIndexRef.current];
+        if (!selected) {
+            return;
+        }
+        if (selected.archived_at) {
+            setTaskSessionsError(`Unarchive ${selected.title} before restoring it`);
+            return;
+        }
+        taskSessionsLoadingRef.current = true;
+        setTaskSessionsLoading(true);
+        setTaskSessionsError(null);
+        const sequence = taskSessionsLoadSequenceRef.current + 1;
+        taskSessionsLoadSequenceRef.current = sequence;
+        try {
+            if (!activateTaskSession) {
+                throw new Error("Task session restore is unavailable");
+            }
+            const restored = await activateTaskSession(selected.id);
+            if (taskSessionsLoadSequenceRef.current !== sequence) {
+                return;
+            }
+            if (!restored) {
+                throw new Error(`Task session not found: ${selected.id}`);
+            }
+            activeTaskIdRef.current = restored.taskId;
+            setActiveTaskId(restored.taskId);
+            setActiveMode("complex");
+            setCanRetryTask(restored.canRetry);
+            setStatus(restoredWorkerStatusLine(restored.taskId, restored.workers));
+            setRoutePending(null);
+            setLastRoute(restored.route);
+            setTaskResultExpanded(latestTaskResultMessageIndex(messagesRef.current, restored.taskId) >= 0);
+            workersRef.current = restored.workers;
+            setWorkers(restored.workers);
+            selectedWorkerIndexRef.current = 0;
+            setSelectedWorkerIndex(0);
+            setWorkerScrollOffset(0);
+            autoSelectedFailedWorkerRef.current = false;
+            userSelectedWorkerRef.current = false;
+            setAttachError(null);
+            viewRef.current = "chat";
+            setView("chat");
+        }
+        catch (error) {
+            if (taskSessionsLoadSequenceRef.current === sequence) {
+                setTaskSessionsError(error instanceof Error ? error.message : String(error));
+            }
+        }
+        finally {
+            if (taskSessionsLoadSequenceRef.current === sequence) {
+                taskSessionsLoadingRef.current = false;
+                setTaskSessionsLoading(false);
+            }
+        }
+    }
+    function updateFeatureCancelPrompt(next) {
+        featureCancelPromptRef.current = next;
+        setFeatureCancelPrompt(next);
+    }
+    async function confirmFeatureCancellation(prompt) {
+        updateFeatureCancelPrompt(null);
+        setAttachError(null);
+        try {
+            const result = await orchestrator.cancelFeature(prompt.taskId, prompt.featureId);
+            setFeatureBoardNotice(result.requested
+                ? `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)}`);
+        }
+    }
+    async function openFeatureBoard() {
+        if (viewRef.current !== "workers") {
+            return;
+        }
+        if (!activeTaskIdRef.current) {
+            setAttachError(NO_ACTIVE_FEATURES_MESSAGE);
+            return;
+        }
+        viewRef.current = "features";
+        setView("features");
+        setAttachError(null);
+        setCollaborationError(null);
+        updateFeatureCancelPrompt(null);
+        setFeatureBoardNotice(null);
+        collaborationTimelineRef.current = null;
+        setCollaborationTimeline(null);
+        featureBoardSelectedIndexRef.current = 0;
+        setFeatureBoardSelectedIndex(0);
+        collaborationFeatureIndexRef.current = -1;
+        setCollaborationFeatureIndex(-1);
+        collaborationSelectedEventIdRef.current = null;
+        setCollaborationSelectedEventId(null);
+        collaborationDetailOpenRef.current = false;
+        setCollaborationDetailOpen(false);
+        collaborationUnresolvedOnlyRef.current = false;
+        setCollaborationUnresolvedOnly(false);
+        collaborationMaxScrollOffsetRef.current = 0;
+        setCollaborationMaxScrollOffset(0);
+        setCollaborationScrollOffset(0);
+        await refreshCollaborationTimeline(true);
+    }
+    async function openCollaborationTimeline(featureIndex = -1) {
+        const source = viewRef.current;
+        if (source !== "workers" && source !== "features") {
+            return;
+        }
+        if (!activeTaskIdRef.current) {
+            setAttachError(NO_ACTIVE_COLLABORATION_MESSAGE);
+            return;
+        }
+        collaborationReturnViewRef.current = source;
+        updateFeatureCancelPrompt(null);
+        setFeatureBoardNotice(null);
+        viewRef.current = "collaboration";
+        setView("collaboration");
+        setAttachError(null);
+        setCollaborationError(null);
+        const existingTimeline = source === "features" ? collaborationTimelineRef.current : null;
+        if (!existingTimeline) {
+            collaborationTimelineRef.current = null;
+            setCollaborationTimeline(null);
+        }
+        const nextFeatureIndex = featureIndex >= 0 && featureIndex < (existingTimeline?.features.length ?? 0)
+            ? featureIndex
+            : -1;
+        collaborationFeatureIndexRef.current = nextFeatureIndex;
+        setCollaborationFeatureIndex(nextFeatureIndex);
+        collaborationSelectedEventIdRef.current = null;
+        setCollaborationSelectedEventId(null);
+        collaborationDetailOpenRef.current = false;
+        setCollaborationDetailOpen(false);
+        collaborationUnresolvedOnlyRef.current = false;
+        setCollaborationUnresolvedOnly(false);
+        collaborationMaxScrollOffsetRef.current = 0;
+        setCollaborationMaxScrollOffset(0);
+        setCollaborationScrollOffset(0);
+        await refreshCollaborationTimeline(!existingTimeline);
+    }
+    async function refreshCollaborationTimeline(showLoading = true) {
+        const taskId = activeTaskIdRef.current;
+        if (!taskId) {
+            setCollaborationError(NO_ACTIVE_COLLABORATION_MESSAGE);
+            return;
+        }
+        const sequence = collaborationLoadSequenceRef.current + 1;
+        collaborationLoadSequenceRef.current = sequence;
+        if (showLoading) {
+            setCollaborationLoading(true);
+        }
+        try {
+            if (!loadCollaborationTimeline) {
+                throw new Error("Collaboration timeline is unavailable");
+            }
+            const timeline = await loadCollaborationTimeline(taskId);
+            if (collaborationLoadSequenceRef.current !== sequence) {
+                return;
+            }
+            collaborationTimelineRef.current = timeline;
+            setCollaborationTimeline(timeline);
+            const currentBoardIndex = featureBoardSelectedIndexRef.current;
+            const nextBoardIndex = timeline.features.length > 0
+                ? Math.min(timeline.features.length - 1, Math.max(0, currentBoardIndex))
+                : 0;
+            if (nextBoardIndex !== currentBoardIndex) {
+                featureBoardSelectedIndexRef.current = nextBoardIndex;
+                setFeatureBoardSelectedIndex(nextBoardIndex);
+            }
+            const currentIndex = collaborationFeatureIndexRef.current;
+            const nextIndex = currentIndex >= timeline.features.length ? -1 : currentIndex;
+            if (nextIndex !== currentIndex) {
+                collaborationFeatureIndexRef.current = nextIndex;
+                setCollaborationFeatureIndex(nextIndex);
+                setCollaborationScrollOffset(0);
+            }
+            const scopedEvents = collaborationTimelineEvents(timeline, nextIndex, collaborationUnresolvedOnlyRef.current);
+            const selectedEventId = collaborationSelectedEventIdRef.current;
+            if (selectedEventId && !scopedEvents.some((event) => event.id === selectedEventId)) {
+                collaborationSelectedEventIdRef.current = null;
+                setCollaborationSelectedEventId(null);
+                collaborationDetailOpenRef.current = false;
+                setCollaborationDetailOpen(false);
+                setCollaborationScrollOffset(0);
+            }
+            else if (selectedEventId && !collaborationDetailOpenRef.current) {
+                const minimumOffset = collaborationSelectionScrollOffset(scopedEvents, selectedEventId, process.stdout.columns || 120);
+                setCollaborationScrollOffset((current) => Math.max(current, minimumOffset));
+            }
+            setCollaborationError(null);
         }
         catch (error) {
-            setMessages((current) => [
-                ...current,
-                { from: "system", text: error instanceof Error ? error.message : String(error) }
-            ]);
+            if (collaborationLoadSequenceRef.current === sequence) {
+                setCollaborationError(error instanceof Error ? error.message : String(error));
+            }
         }
         finally {
-            busyRef.current = false;
-            setBusy(false);
+            if (collaborationLoadSequenceRef.current === sequence) {
+                setCollaborationLoading(false);
+            }
+        }
+    }
+    function updateWorkerNavigationTargets(next) {
+        const previous = workerNavigationTargetsRef.current;
+        workerNavigationTargetsRef.current = next;
+        if (!sameNumberArray(previous.errorOffsets, next.errorOffsets)) {
+            workerJumpIndexRef.current.error = -1;
+        }
+        if (!sameNumberArray(previous.diffOffsets, next.diffOffsets)) {
+            workerJumpIndexRef.current.diff = -1;
+        }
+        if (!sameWorkerNavigationTargets(previous, next)) {
+            setWorkerNavigationTargets(next);
+        }
+        const search = workerSearchRef.current;
+        const matchIndex = next.searchOffsets.length > 0
+            ? Math.min(next.searchOffsets.length - 1, Math.max(0, search.matchIndex))
+            : 0;
+        if (matchIndex !== search.matchIndex) {
+            const updated = { ...search, matchIndex };
+            workerSearchRef.current = updated;
+            setWorkerSearch(updated);
+        }
+        if (search.open && search.query.trim() && next.searchOffsets.length > 0) {
+            setWorkerScrollOffset(next.searchOffsets[matchIndex] ?? 0);
+        }
+    }
+    function openWorkerOverview() {
+        const currentView = viewRef.current;
+        if (currentView !== "chat" && currentView !== "worker") {
+            return;
+        }
+        if (workersRef.current.length === 0) {
+            setAttachError(NO_WORKERS_OVERVIEW_MESSAGE);
+            return;
+        }
+        workerOverviewReturnViewRef.current = currentView;
+        viewRef.current = "workers";
+        setAttachError(null);
+        setView("workers");
+    }
+    function openWorkspacePicker() {
+        const currentView = viewRef.current;
+        if (busyRef.current || !switchWorkspace || currentView === "native" || currentView === "workspace") {
+            return;
+        }
+        workspaceReturnViewRef.current = currentView === "worker" || currentView === "workers" || currentView === "sessions"
+            ? currentView
+            : "chat";
+        setAttachError(null);
+        setView("workspace");
+    }
+    function closeWorkspacePicker() {
+        setAttachError(null);
+        setView(workspaceReturnViewRef.current);
+    }
+    async function selectWorkspace(workspace) {
+        if (!switchWorkspace || workspace === cwd) {
+            closeWorkspacePicker();
+            return;
+        }
+        try {
+            await switchWorkspace(workspace);
+        }
+        catch (error) {
+            setAttachError(error instanceof Error ? error.message : String(error));
+            setView(workspaceReturnViewRef.current);
         }
     }
-    return (_jsx(AppShell, { view: view, cwd: cwd, taskId: activeTaskId, statusText: `${formatStatusLine(status)}${visibleWorkerStatus ? ` | ${visibleWorkerStatus}` : ""}`, contentHeight: contentHeight, input: _jsx(InputBar, { mode: view, busy: busy, hasWorkers: workers.length > 0, nativeClosed: view === "native" && nativeAttach?.closedCode !== null, value: view === "native" ? "" : input, terminalWidth: terminalWidth, onChange: view === "native" ? setNativeInput : setInput, onSubmit: view === "native" ? undefined : submit }), error: attachError, children: view === "native" ? (_jsx(NativeAttachView, { attach: nativeAttach })) : view === "chat" ? (_jsx(ChatView, { messages: messages, cwd: cwd, activeTaskId: activeTaskId, terminalWidth: terminalWidth, viewportHeight: contentHeight })) : (_jsx(WorkerOutputView, { title: workerTitle(workers, selectedWorkerIndex), role: workers[selectedWorkerIndex]?.role, logPath: workers[selectedWorkerIndex]?.logPath ?? null, scrollOffset: workerScrollOffset, height: Math.max(1, outputHeight - 1), terminalWidth: terminalWidth, onViewportChange: ({ offset, maxOffset }) => {
-                setWorkerMaxScrollOffset(maxOffset);
+    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"
+                ? { 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"
+                ? workerSearch.query
+                : view === "native" || view === "router" || view === "workers" || view === "features" || view === "sessions" || view === "collaboration" ? "" : 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"
+                ? { 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 }) => {
+                collaborationMaxScrollOffsetRef.current = maxOffset;
+                setCollaborationMaxScrollOffset(maxOffset);
+                if (offset !== collaborationScrollOffset) {
+                    setCollaborationScrollOffset(offset);
+                }
+            } })) : view === "workers" ? (_jsx(WorkerOverviewView, { workers: workers, selectedIndex: selectedWorkerIndex, nowMs: workerClockMs, activityPolicies: workerActivityPolicies, height: contentHeight, terminalWidth: terminalWidth })) : view === "router" ? (_jsx(RouterDiagnosticsView, { records: routerRecords, policy: routerPolicy, currentWorkspace: cwd, scope: routerScope, loading: routerLoading, error: routerError, scrollOffset: routerScrollOffset, height: contentHeight, terminalWidth: terminalWidth, onViewportChange: ({ offset, maxOffset }) => {
+                routerMaxScrollOffsetRef.current = maxOffset;
+                setRouterMaxScrollOffset(maxOffset);
+                if (offset !== routerScrollOffset) {
+                    setRouterScrollOffset(offset);
+                }
+            } })) : view === "chat" ? (_jsx(ChatView, { messages: visibleChatMessages, cwd: cwd, activeTaskId: activeTaskId, terminalWidth: terminalWidth, viewportHeight: contentHeight, scrollOffset: chatScrollOffset, expandedTaskResult: taskResultExpanded, onViewportChange: ({ offset, maxOffset }) => {
+                chatMaxScrollOffsetRef.current = maxOffset;
+                setChatMaxScrollOffset(maxOffset);
+                if (offset !== chatScrollOffsetRef.current) {
+                    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 }) => {
                 if (offset !== workerScrollOffset) {
                     setWorkerScrollOffset(offset);
                 }
             } })) }));
 }
-export function ChatView({ messages, cwd, activeTaskId, terminalWidth = process.stdout.columns || 120, viewportHeight }) {
+function readTerminalSize() {
+    return {
+        columns: Math.max(1, Math.trunc(process.stdout.columns || 120)),
+        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 }) {
     const height = viewportHeight ? Math.max(1, viewportHeight) : undefined;
+    const viewport = useMemo(() => chatMessageViewport(messages, terminalWidth, height ?? 12, scrollOffset, {
+        expandedTaskResult,
+        taskId: activeTaskId
+    }), [activeTaskId, expandedTaskResult, height, messages, scrollOffset, terminalWidth]);
+    useEffect(() => {
+        onViewportChange?.({
+            offset: viewport.clampedOffset,
+            maxOffset: viewport.maxOffset
+        });
+    }, [onViewportChange, viewport.clampedOffset, viewport.maxOffset]);
     if (messages.length === 0) {
-        return (_jsx(Box, { flexDirection: "column", height: height, justifyContent: height ? "flex-end" : undefined, children: _jsx(ChatEmptyState, { cwd: cwd, activeTaskId: activeTaskId, terminalWidth: terminalWidth }) }));
+        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 })] }));
+    }
+    const lines = viewport.lines;
+    const spacerLines = chatViewportSpacerLineCount(lines.length, height);
+    const topAligned = (expandedTaskResult && latestTaskResultMessageIndex(messages, activeTaskId) >= 0) || chatCompletionIsTopAligned(messages);
+    return (_jsxs(Box, { flexDirection: "column", height: height, children: [!topAligned ? _jsx(ChatViewportSpacerLines, { count: spacerLines, terminalWidth: terminalWidth }) : null, lines.map((line, index) => (_jsx(ChatLine, { line: line, terminalWidth: terminalWidth }, `${line.from}-${index}`))), topAligned ? _jsx(ChatViewportSpacerLines, { count: spacerLines, terminalWidth: terminalWidth }) : null] }));
+}
+export function chatLineTheme(line) {
+    const backgroundColor = chatLineBackgroundColor(line.background);
+    if (line.from === "user") {
+        return { backgroundColor, color: TUI_THEME.accent };
+    }
+    if (!line.text.trim()) {
+        return { backgroundColor, color: TUI_THEME.muted };
+    }
+    return { backgroundColor, color: TUI_THEME.text };
+}
+export function chatSpanTheme(from, tone, background = "surface") {
+    const baseColor = from === "user" ? TUI_THEME.accent : TUI_THEME.text;
+    const backgroundColor = chatLineBackgroundColor(background);
+    if (tone === "link") {
+        return {
+            backgroundColor,
+            color: TUI_THEME.accent,
+            underline: true
+        };
+    }
+    if (tone === "code") {
+        return {
+            backgroundColor: TUI_THEME.rail,
+            color: TUI_THEME.warning
+        };
+    }
+    if (tone === "strong") {
+        return {
+            backgroundColor,
+            bold: true,
+            color: baseColor
+        };
+    }
+    if (tone === "success") {
+        return {
+            backgroundColor,
+            bold: true,
+            color: TUI_THEME.success
+        };
+    }
+    if (tone === "warning") {
+        return {
+            backgroundColor,
+            bold: true,
+            color: TUI_THEME.warning
+        };
+    }
+    if (tone === "danger") {
+        return {
+            backgroundColor,
+            bold: true,
+            color: TUI_THEME.danger
+        };
+    }
+    if (tone === "heading") {
+        return {
+            backgroundColor,
+            bold: true,
+            color: TUI_THEME.accent
+        };
+    }
+    if (tone === "emphasis") {
+        return {
+            backgroundColor,
+            color: baseColor,
+            italic: true
+        };
+    }
+    if (tone === "muted" || (tone === "prefix" && from === "system")) {
+        return {
+            backgroundColor,
+            color: TUI_THEME.muted
+        };
+    }
+    return {
+        backgroundColor,
+        color: baseColor
+    };
+}
+function chatLineBackgroundColor(background) {
+    return background === "rail" ? TUI_THEME.rail : TUI_THEME.surface;
+}
+export function chatLineTrailingFillWidth(line, terminalWidth) {
+    return Math.max(0, chatContentWidth(terminalWidth) - displayWidth(chatLineDisplayText(line)));
+}
+export function chatMessageDisplayLines(messages, terminalWidth, maxLines = 12, options = {}) {
+    return chatMessageViewport(messages, terminalWidth, maxLines, 0, options).lines;
+}
+export function chatMessageViewport(messages, terminalWidth, maxLines = 12, offsetFromBottom = 0, options = {}) {
+    const contentWidth = chatContentWidth(terminalWidth);
+    const expandedResultIndex = options.expandedTaskResult
+        ? latestTaskResultMessageIndex(messages, options.taskId)
+        : -1;
+    const renderedByMessage = messages.map((message, index) => (chatSingleMessageDisplayLines(message, contentWidth, index === expandedResultIndex)));
+    const viewportHeight = Math.max(1, maxLines);
+    if (expandedResultIndex >= 0) {
+        const requestIndex = taskResultRequestMessageIndex(messages, expandedResultIndex);
+        const focused = [
+            ...(requestIndex >= 0 ? renderedByMessage[requestIndex] ?? [] : []),
+            ...(renderedByMessage[expandedResultIndex] ?? [])
+        ];
+        const maxOffset = Math.max(0, focused.length - viewportHeight);
+        const clampedOffset = Math.min(Math.max(0, Math.trunc(offsetFromBottom)), maxOffset);
+        return {
+            lines: focused.slice(clampedOffset, clampedOffset + viewportHeight),
+            clampedOffset,
+            maxOffset
+        };
+    }
+    const rendered = renderedByMessage.flat();
+    const maxOffset = Math.max(0, rendered.length - viewportHeight);
+    const clampedOffset = Math.min(Math.max(0, Math.trunc(offsetFromBottom)), maxOffset);
+    const end = rendered.length - clampedOffset;
+    const start = Math.max(0, end - viewportHeight);
+    return {
+        lines: rendered.slice(start, end),
+        clampedOffset,
+        maxOffset
+    };
+}
+function taskResultRequestMessageIndex(messages, resultIndex) {
+    const resultTaskId = messages[resultIndex]?.taskId;
+    for (let index = resultIndex - 1; index >= 0; index -= 1) {
+        const message = messages[index];
+        if (!message || message.from !== "user") {
+            continue;
+        }
+        if (!resultTaskId) {
+            return message.taskId === undefined ? index : -1;
+        }
+        if (message.taskId === resultTaskId || message.taskId === undefined) {
+            return index;
+        }
+        return -1;
     }
-    const lines = chatMessageDisplayLines(messages, terminalWidth, height ?? 12);
-    return (_jsx(Box, { flexDirection: "column", height: height, justifyContent: height ? "flex-end" : undefined, children: lines.map((line, index) => (_jsx(Text, { color: line.from === "user" ? "cyan" : undefined, dimColor: line.from === "system" && !line.text.trim(), children: line.text || " " }, `${line.from}-${index}`))) }));
+    return -1;
+}
+export function chatViewportBlankLineTheme() {
+    return {
+        backgroundColor: TUI_THEME.surface
+    };
+}
+function ChatViewportSpacerLines({ count, terminalWidth }) {
+    return (_jsx(_Fragment, { children: Array.from({ length: count }, (_, index) => (_jsx(Text, { ...chatViewportBlankLineTheme(), children: " ".repeat(chatViewportBlankLineWidth(terminalWidth)) }, `chat-spacer-${index}`))) }));
+}
+function chatViewportSpacerLineCount(contentLines, viewportHeight) {
+    return viewportHeight ? Math.max(0, viewportHeight - contentLines) : 0;
+}
+function chatCompletionIsTopAligned(messages) {
+    const latest = messages.at(-1);
+    return latest?.from === "system" && compactSupervisorSummaryForChat(latest.text) !== null;
+}
+function chatViewportBlankLineWidth(terminalWidth) {
+    return Math.max(1, chatContentWidth(terminalWidth));
+}
+function ChatLine({ line, terminalWidth }) {
+    const theme = chatLineTheme(line);
+    const fillWidth = chatLineTrailingFillWidth(line, terminalWidth);
+    const spans = line.text && line.spans?.length ? line.spans : null;
+    const backgroundColor = chatLineBackgroundColor(line.background);
+    return (_jsxs(Text, { children: [spans
+                ? spans.map((span, index) => (_jsx(Text, { ...chatSpanTheme(line.from, span.tone, line.background), children: span.text }, `${span.tone}-${index}`)))
+                : _jsx(Text, { ...theme, children: chatLineDisplayText(line) }), fillWidth > 0 ? _jsx(Text, { backgroundColor: backgroundColor, children: " ".repeat(fillWidth) }) : null] }));
 }
-export function chatMessageDisplayLines(messages, terminalWidth, maxLines = 12) {
-    const contentWidth = Math.max(8, terminalWidth - 2);
-    const rendered = messages.flatMap((message) => chatSingleMessageDisplayLines(message, contentWidth));
-    return rendered.slice(-maxLines);
+function chatLineDisplayText(line) {
+    return line.text || " ";
 }
-function chatSingleMessageDisplayLines(message, contentWidth) {
-    const rawLines = message.text.split(/\r?\n/);
+function chatContentWidth(terminalWidth) {
+    return Math.max(8, terminalWidth - 2);
+}
+function chatSingleMessageDisplayLines(message, contentWidth, expandedTaskResult = false) {
+    const rawLines = chatMessageMarkdownLines(message, expandedTaskResult, contentWidth);
     const rendered = [];
     rawLines.forEach((rawLine, rawIndex) => {
         const isFirstRawLine = rawIndex === 0;
         const firstPrefix = message.from === "user" && isFirstRawLine ? "> " : message.from === "user" ? "  " : "";
         const wrapWidth = Math.max(1, contentWidth - displayWidth(firstPrefix));
-        const wrapped = wrapByDisplayWidth(rawLine, wrapWidth);
-        wrapped.forEach((chunk, chunkIndex) => {
+        const rawSpans = rawLine.spans;
+        const visibleRawLine = chatSpanText(rawSpans);
+        const wrapped = wrapChatSpans(rawSpans, wrapWidth);
+        wrapped.forEach((chunkSpans, chunkIndex) => {
+            const chunk = chatSpanText(chunkSpans);
             const continuation = !isFirstRawLine || chunkIndex > 0;
-            const prefix = message.from === "user"
-                ? continuation
-                    ? "  "
-                    : "> "
-                : "";
+            const prefix = chatLinePrefix(message.from, visibleRawLine, continuation, chunkIndex > 0, rawLine.continuationPrefix);
             const lineWidth = Math.max(1, contentWidth - displayWidth(prefix));
             const fitted = displayWidth(chunk) > lineWidth
-                ? wrapByDisplayWidth(chunk, lineWidth)
-                : [chunk];
-            fitted.forEach((part, partIndex) => {
+                ? wrapChatSpans(chunkSpans, lineWidth)
+                : [chunkSpans];
+            fitted.forEach((partSpans, partIndex) => {
+                const part = chatSpanText(partSpans);
+                const displaySpans = mergeChatSpans([
+                    ...(prefix ? [{ text: prefix, tone: "prefix" }] : []),
+                    ...partSpans
+                ]);
                 rendered.push({
                     from: message.from,
                     text: `${prefix}${part}`,
-                    continuation: continuation || partIndex > 0
+                    continuation: continuation || partIndex > 0,
+                    spans: displaySpans,
+                    background: rawLine.background
                 });
             });
         });
     });
     return rendered;
 }
+function chatMessageMarkdownLines(message, expandedTaskResult = false, contentWidth = Number.POSITIVE_INFINITY) {
+    if (message.kind === "route") {
+        return routeChatMessageLines(message.text);
+    }
+    if (message.from === "system" && expandedTaskResult) {
+        const expanded = expandedSupervisorSummaryForChat(message.text, contentWidth);
+        if (expanded) {
+            return expanded;
+        }
+    }
+    const compact = message.from === "system" ? compactSupervisorSummaryForChat(message.text) : null;
+    if (compact) {
+        return compact.map((line) => ({
+            spans: compactChatSummarySpans(line),
+            continuationPrefix: isCompactChatSummaryLine(line) ? "  " : undefined
+        }));
+    }
+    return chatMarkdownBlockLines(message.text);
+}
+function routeChatMessageLines(text) {
+    const [header = "route", ...details] = text.split(/\r?\n/);
+    return [
+        {
+            spans: routeChatHeaderSpans(header),
+            background: "rail",
+            continuationPrefix: "  "
+        },
+        ...details.map((detail) => ({
+            spans: mergeChatSpans([
+                { text: "  ", tone: "muted" },
+                ...applyChatSpanTone(chatMarkdownSpans(detail), "muted")
+            ]),
+            background: "rail",
+            continuationPrefix: "  "
+        }))
+    ];
+}
+function routeChatHeaderSpans(header) {
+    const match = header.match(/^route\s*·\s*(simple|complex)\s*·\s*(.+)$/i);
+    if (!match?.[1] || !match[2]) {
+        return applyChatSpanTone(chatMarkdownSpans(header), "heading");
+    }
+    const mode = match[1].toLowerCase();
+    return [
+        { text: "route", tone: "heading" },
+        { text: " · ", tone: "muted" },
+        { text: mode, tone: mode === "simple" ? "success" : "warning" },
+        { text: ` · ${match[2].trim()}`, tone: "muted" }
+    ];
+}
+function chatMarkdownBlockLines(text) {
+    if (!text) {
+        return [{ spans: [] }];
+    }
+    try {
+        const lines = chatBlockTokensToLines(Lexer.lex(text));
+        return lines.length > 0 ? lines : [{ spans: [] }];
+    }
+    catch {
+        return text.split(/\r?\n/).map((line) => ({ spans: chatMarkdownSpans(line) }));
+    }
+}
+function chatBlockTokensToLines(tokens) {
+    return tokens.flatMap((token) => chatBlockTokenToLines(token));
+}
+function chatBlockTokenToLines(token) {
+    if (token.type === "space") {
+        return [{ spans: [] }];
+    }
+    if (token.type === "checkbox") {
+        return [];
+    }
+    if (token.type === "heading") {
+        return chatInlineMarkdownLines(tokenText(token)).map((line) => ({
+            ...line,
+            spans: applyChatSpanTone(line.spans, "heading")
+        }));
+    }
+    if (token.type === "paragraph" || token.type === "text") {
+        return chatInlineMarkdownLines(tokenText(token));
+    }
+    if (isChatListToken(token)) {
+        return chatListTokenToLines(token);
+    }
+    if (token.type === "blockquote") {
+        return chatBlockTokensToLines(tokenTokens(token)).map((line) => (chatMarkdownLineIsBlank(line)
+            ? line
+            : prependChatMarkdownLine(line, "│ ", "muted", "  ")));
+    }
+    if (isChatCodeToken(token)) {
+        return chatCodeTokenToLines(token);
+    }
+    if (token.type === "hr") {
+        return [{ spans: [{ text: "· · ·", tone: "muted" }] }];
+    }
+    if (isChatTableToken(token)) {
+        return chatTableTokenToLines(token);
+    }
+    if (token.type === "html") {
+        return tokenText(token).split(/\r?\n/).map((line) => ({ spans: chatMarkdownSpans(line) }));
+    }
+    if (token.type === "def") {
+        return [];
+    }
+    const nested = tokenTokens(token);
+    if (nested.length > 0) {
+        return chatBlockTokensToLines(nested);
+    }
+    return tokenText(token).split(/\r?\n/).map((line) => ({ spans: chatMarkdownSpans(line) }));
+}
+function chatInlineMarkdownLines(text) {
+    return text.split(/\r?\n/).map((line) => ({ spans: chatMarkdownSpans(line) }));
+}
+function chatListTokenToLines(token) {
+    const rendered = [];
+    const start = typeof token.start === "number" ? token.start : 1;
+    token.items.forEach((item, itemIndex) => {
+        const marker = item.task
+            ? item.checked ? "[x] " : "[ ] "
+            : token.ordered ? `${start + itemIndex}. ` : "• ";
+        const continuationPrefix = " ".repeat(displayWidth(marker));
+        let hasItemContent = false;
+        for (const itemToken of item.tokens) {
+            if (isChatListToken(itemToken)) {
+                const nested = chatListTokenToLines(itemToken);
+                rendered.push(...nested.map((line) => (chatMarkdownLineIsBlank(line)
+                    ? line
+                    : prependChatMarkdownLine(line, continuationPrefix, "muted", continuationPrefix))));
+                continue;
+            }
+            for (const line of chatBlockTokenToLines(itemToken)) {
+                if (chatMarkdownLineIsBlank(line)) {
+                    rendered.push(line);
+                    continue;
+                }
+                if (!hasItemContent) {
+                    rendered.push(prependChatMarkdownLine(line, marker, "muted", continuationPrefix));
+                    hasItemContent = true;
+                }
+                else {
+                    rendered.push(prependChatMarkdownLine(line, continuationPrefix, "muted", continuationPrefix));
+                }
+            }
+        }
+        if (!hasItemContent && !item.tokens.some((itemToken) => itemToken.type === "list")) {
+            rendered.push({ spans: [{ text: marker.trimEnd(), tone: "muted" }] });
+        }
+    });
+    return rendered;
+}
+function chatCodeTokenToLines(token) {
+    const rendered = [];
+    const language = token.lang?.trim().split(/\s+/)[0] ?? "";
+    if (language) {
+        rendered.push({
+            spans: [{ text: language, tone: "muted" }],
+            background: "rail"
+        });
+    }
+    const codeLines = token.text.split(/\r?\n/);
+    for (const line of codeLines) {
+        rendered.push({
+            spans: mergeChatSpans([
+                { text: "| ", tone: "muted" },
+                ...(line ? [{ text: line, tone: "code" }] : [])
+            ]),
+            background: "rail",
+            continuationPrefix: "  "
+        });
+    }
+    return rendered;
+}
+function chatTableTokenToLines(token) {
+    const row = (cells, heading) => ({
+        spans: mergeChatSpans([
+            { text: "| ", tone: "muted" },
+            ...cells.flatMap((cell, index) => [
+                ...applyChatSpanTone(chatSpansFromTokens(cell.tokens, "text"), heading ? "strong" : "text"),
+                { text: index === cells.length - 1 ? " |" : " | ", tone: "muted" }
+            ])
+        ]),
+        background: "rail",
+        continuationPrefix: "  "
+    });
+    return [row(token.header, true), ...token.rows.map((cells) => row(cells, false))];
+}
+function prependChatMarkdownLine(line, prefix, tone, continuationPrefix) {
+    return {
+        ...line,
+        spans: mergeChatSpans([{ text: prefix, tone }, ...line.spans]),
+        continuationPrefix
+    };
+}
+function chatMarkdownLineIsBlank(line) {
+    return !chatSpanText(line.spans).trim();
+}
+function isChatListToken(token) {
+    return token.type === "list" && "items" in token && Array.isArray(token.items);
+}
+function isChatCodeToken(token) {
+    return token.type === "code" && "text" in token && typeof token.text === "string";
+}
+function isChatTableToken(token) {
+    return (token.type === "table" &&
+        "header" in token && Array.isArray(token.header) &&
+        "rows" in token && Array.isArray(token.rows));
+}
+function chatMarkdownSpans(text) {
+    if (!text) {
+        return [];
+    }
+    try {
+        return mergeChatSpans(chatSpansFromTokens(Lexer.lexInline(text), "text"));
+    }
+    catch {
+        return [{ text, tone: "text" }];
+    }
+}
+function chatSpansFromTokens(tokens, inheritedTone) {
+    return tokens.flatMap((token) => chatSpansFromToken(token, inheritedTone));
+}
+function chatSpansFromToken(token, inheritedTone) {
+    const nested = tokenTokens(token);
+    if (token.type === "codespan" || token.type === "code") {
+        return [{ text: tokenText(token), tone: "code" }];
+    }
+    if (token.type === "link" || token.type === "image") {
+        const label = chatSpanText(chatSpansFromTokens(nested, "text")) || tokenText(token);
+        const href = tokenHref(token);
+        return mergeChatSpans([
+            ...(label ? [{ text: label, tone: "link" }] : []),
+            ...(href && isExternalChatLink(href) && href !== label
+                ? [{ text: ` <${href}>`, tone: "muted" }]
+                : [])
+        ]);
+    }
+    if (token.type === "strong") {
+        return applyChatSpanTone(chatSpansFromTokens(nested, inheritedTone), "strong");
+    }
+    if (token.type === "em") {
+        return applyChatSpanTone(chatSpansFromTokens(nested, inheritedTone), "emphasis");
+    }
+    if (token.type === "del") {
+        return applyChatSpanTone(chatSpansFromTokens(nested, inheritedTone), "muted");
+    }
+    if (token.type === "br") {
+        return [{ text: " ", tone: inheritedTone }];
+    }
+    if (nested.length > 0) {
+        return chatSpansFromTokens(nested, inheritedTone);
+    }
+    const text = token.type === "html"
+        ? tokenText(token).replace(/<[^>]*>/g, "")
+        : tokenText(token);
+    return text ? [{ text: decodeHtmlEntities(text), tone: inheritedTone }] : [];
+}
+function tokenTokens(token) {
+    return "tokens" in token && Array.isArray(token.tokens) ? token.tokens : [];
+}
+function tokenText(token) {
+    if ("text" in token && typeof token.text === "string") {
+        return token.text;
+    }
+    return typeof token.raw === "string" ? token.raw : "";
+}
+function tokenHref(token) {
+    return "href" in token && typeof token.href === "string" ? token.href.trim() : "";
+}
+function applyChatSpanTone(spans, tone) {
+    return spans.map((span) => ({
+        ...span,
+        tone: span.tone === "code" || span.tone === "link" ? span.tone : tone
+    }));
+}
+function isExternalChatLink(href) {
+    return /^(?:https?:|mailto:)/i.test(href);
+}
+function chatSpanText(spans) {
+    return spans.map((span) => span.text).join("");
+}
+function mergeChatSpans(spans) {
+    const merged = [];
+    for (const span of spans) {
+        if (!span.text) {
+            continue;
+        }
+        const previous = merged.at(-1);
+        if (previous?.tone === span.tone) {
+            previous.text += span.text;
+        }
+        else {
+            merged.push({ ...span });
+        }
+    }
+    return merged;
+}
+function wrapChatSpans(spans, maxWidth) {
+    const text = chatSpanText(spans);
+    if (!text) {
+        return [[]];
+    }
+    const chunks = wrapByDisplayWidth(text, maxWidth);
+    let cursor = 0;
+    return chunks.map((chunk) => {
+        const found = text.indexOf(chunk, cursor);
+        const start = found >= 0 ? found : cursor;
+        const end = start + chunk.length;
+        cursor = end;
+        return sliceChatSpans(spans, start, end);
+    });
+}
+function sliceChatSpans(spans, start, end) {
+    const sliced = [];
+    let offset = 0;
+    for (const span of spans) {
+        const spanStart = offset;
+        const spanEnd = spanStart + span.text.length;
+        offset = spanEnd;
+        const overlapStart = Math.max(start, spanStart);
+        const overlapEnd = Math.min(end, spanEnd);
+        if (overlapStart < overlapEnd) {
+            sliced.push({
+                text: span.text.slice(overlapStart - spanStart, overlapEnd - spanStart),
+                tone: span.tone
+            });
+        }
+    }
+    return mergeChatSpans(sliced);
+}
+function chatLinePrefix(from, rawLine, continuation, wrappedContinuation, markdownContinuationPrefix) {
+    if (from === "user") {
+        return continuation ? "  " : "> ";
+    }
+    if (from === "system" && wrappedContinuation) {
+        return markdownContinuationPrefix ?? (isCompactChatSummaryLine(rawLine) ? "  " : "");
+    }
+    return "";
+}
+function expandedSupervisorSummaryForChat(text, contentWidth) {
+    const result = parseTaskResultSummary(text);
+    if (!result) {
+        return null;
+    }
+    const outcome = taskResultOutcomeDisplay(result.outcome);
+    const lines = [
+        {
+            spans: taskResultHeaderSpans(outcome, contentWidth),
+            background: "rail",
+            continuationPrefix: "  "
+        }
+    ];
+    const sections = [
+        { key: "requirements", title: "Requirements" },
+        { key: "implementation", title: "Implementation" },
+        { key: "changes", title: "Changes", optional: true },
+        { key: "review", title: "Review" },
+        { key: "verification", title: "Verification", optional: true },
+        { key: "findings", title: "Findings" }
+    ];
+    for (const section of sections) {
+        if (section.optional && !result.sections[section.key].trim()) {
+            continue;
+        }
+        lines.push({
+            spans: [{ text: section.title, tone: "heading" }],
+            background: "rail",
+            continuationPrefix: "  "
+        });
+        lines.push(...taskResultSectionMarkdownLines(result.sections[section.key], section.key, result.outcome));
+    }
+    return lines;
+}
+function taskResultSectionMarkdownLines(content, section, outcome) {
+    if (!content.trim()) {
+        return [{
+                spans: [
+                    { text: "  ", tone: "prefix" },
+                    { text: "none", tone: "muted" }
+                ],
+                continuationPrefix: "  "
+            }];
+    }
+    return chatMarkdownBlockLines(content)
+        .filter((line) => !chatMarkdownLineIsBlank(line))
+        .map((line) => {
+        const text = chatSpanText(line.spans).trim();
+        const decisionSection = section === "review" || section === "verification";
+        const semanticTone = decisionSection && /^(?:Critic decision:\s*)?APPROVED\b/i.test(text)
+            ? "success"
+            : decisionSection && /^(?:Critic decision:\s*)?(?:REVISION_REQUIRED|REJECTED|FAILED)\b/i.test(text)
+                ? "danger"
+                : section === "findings" && outcome === "revision-required"
+                    ? "warning"
+                    : null;
+        const spans = semanticTone ? applyChatSpanTone(line.spans, semanticTone) : line.spans;
+        return prependChatMarkdownLine({ ...line, spans }, "  ", "prefix", "  ");
+    });
+}
+function taskResultOutcomeDisplay(outcome) {
+    if (outcome === "approved") {
+        return { label: "APPROVED", shortLabel: "APPROVED", tone: "success" };
+    }
+    if (outcome === "revision-required") {
+        return { label: "REVISION REQUIRED", shortLabel: "REVISION", tone: "danger" };
+    }
+    return { label: "COMPLETE", shortLabel: "COMPLETE", tone: "warning" };
+}
+function taskResultHeaderSpans(outcome, maxWidth) {
+    const details = ["complex task completed", "complex", null];
+    const titleWith = (detail, label) => (mergeChatSpans([
+        { text: "done", tone: "success" },
+        ...(detail
+            ? [
+                { text: " · ", tone: "muted" },
+                { text: detail, tone: "text" }
+            ]
+            : []),
+        { text: " · ", tone: "muted" },
+        { text: label, tone: outcome.tone }
+    ]));
+    const candidates = [
+        ...details.map((detail) => titleWith(detail, outcome.label)),
+        [{ text: outcome.label, tone: outcome.tone }]
+    ];
+    if (outcome.shortLabel !== outcome.label) {
+        candidates.push(...details.map((detail) => titleWith(detail, outcome.shortLabel)), [{ text: outcome.shortLabel, tone: outcome.tone }]);
+    }
+    const width = Math.max(1, Math.trunc(maxWidth));
+    return candidates.find((candidate) => displayWidth(chatSpanText(candidate)) <= width)
+        ?? [{ text: compactEndByDisplayWidth(outcome.shortLabel, width), tone: outcome.tone }];
+}
+function compactSupervisorSummaryForChat(text) {
+    const result = parseTaskResultSummary(text);
+    if (!result) {
+        return null;
+    }
+    const sections = [
+        { label: "requirements", value: result.sections.requirements },
+        { label: "actor", value: result.sections.implementation },
+        { label: "review", value: result.sections.review },
+        { label: "findings", value: result.sections.findings }
+    ];
+    return [
+        "done · complex task completed",
+        ...sections.map((section) => (`${section.label} · ${chatSummarySectionValue(section.value.split(/\r?\n/))}`))
+    ];
+}
+function chatSummarySectionValue(lines) {
+    for (const line of lines) {
+        const cleaned = cleanChatSummaryLine(line);
+        if (cleaned && !isChatSummaryHeading(cleaned)) {
+            return cleaned;
+        }
+    }
+    return "none";
+}
+function cleanChatSummaryLine(line) {
+    const cleaned = line
+        .trim()
+        .replace(/^#{1,6}\s+/, "")
+        .replace(/^[-*]\s+/, "")
+        .replace(/^\d+\.\s+/, "")
+        .replace(/`([^`]+)`/g, "$1")
+        .replace(/\*\*([^*]+)\*\*/g, "$1")
+        .replace(/__([^_]+)__/g, "$1")
+        .trim();
+    return cleaned === "(empty)" ? "none" : cleaned;
+}
+function isChatSummaryHeading(line) {
+    return /^(?:requirements|actor work|worklog|changed files|critic review|review|verification|critic findings):?$/i.test(line);
+}
+function isCompactChatSummaryLine(line) {
+    return /^(?:done|requirements|actor|review|findings) · /i.test(line.trim());
+}
+function compactChatSummarySpans(line) {
+    const match = line.match(/^([^·]+?)\s+·\s+(.+)$/u);
+    if (!match) {
+        return chatMarkdownSpans(line);
+    }
+    const label = (match[1] ?? "").trim();
+    const value = (match[2] ?? "").trim();
+    const labelTone = label === "done" ? "success" : "muted";
+    const valueSpans = label === "review" && /^APPROVED\b/i.test(value)
+        ? [{ text: value, tone: "success" }]
+        : label === "findings" && /^none$/i.test(value)
+            ? [{ text: value, tone: "muted" }]
+            : chatMarkdownSpans(value);
+    return mergeChatSpans([
+        { text: label, tone: labelTone },
+        { text: " · ", tone: "muted" },
+        ...valueSpans
+    ]);
+}
 function ChatEmptyState({ cwd, activeTaskId, terminalWidth }) {
-    const contentWidth = Math.max(8, terminalWidth - 2);
-    return (_jsx(Box, { flexDirection: "column", children: _jsx(Text, { color: "green", bold: true, children: chatEmptyStateDisplayLine(cwd, activeTaskId, contentWidth) }) }));
+    const contentWidth = chatContentWidth(terminalWidth);
+    const line = chatEmptyStateDisplayLine(cwd, activeTaskId, contentWidth);
+    const fillWidth = Math.max(0, contentWidth - displayWidth(line));
+    return (_jsx(Box, { flexDirection: "column", children: _jsxs(Text, { children: [_jsx(Text, { ...chatEmptyStateTheme(), children: line }), fillWidth > 0 ? _jsx(Text, { backgroundColor: TUI_THEME.surface, children: " ".repeat(fillWidth) }) : null] }) }));
+}
+export function chatEmptyStateTrailingFillWidth(cwd, activeTaskId, terminalWidth) {
+    const contentWidth = chatContentWidth(terminalWidth);
+    const line = chatEmptyStateDisplayLine(cwd, activeTaskId, contentWidth);
+    return Math.max(0, contentWidth - displayWidth(line));
+}
+export function chatEmptyStateTheme() {
+    return {
+        backgroundColor: TUI_THEME.surface,
+        bold: true,
+        color: TUI_THEME.success
+    };
 }
 function chatEmptyStateDisplayLine(cwd, activeTaskId, contentWidth) {
     const project = compactChatWorkspace(cwd);
@@ -530,6 +3006,9 @@ function chatEmptyStateDisplayLine(cwd, activeTaskId, contentWidth) {
     if (contentWidth < 14) {
         return compactChatText(project || task || "ready", contentWidth);
     }
+    if (contentWidth >= 38) {
+        return "ready";
+    }
     const roomyPrefix = task ? `ready · ${project} · ` : "ready · ";
     const roomyValue = task || project;
     const roomy = `${roomyPrefix}${compactChatText(roomyValue, Math.max(1, contentWidth - displayWidth(roomyPrefix)))}`;
@@ -599,6 +3078,54 @@ function upsertWorker(workers, worker) {
     }
     return [...workers, worker];
 }
+function restoredWorkerStatusLine(taskId, workers) {
+    if (!taskId) {
+        return null;
+    }
+    const state = { taskId };
+    const restored = (workers ?? []).map((worker) => {
+        return {
+            role: worker.role,
+            engine: worker.engine,
+            label: worker.label,
+            status: worker.runtimeStatus ? formatWorkerRuntimeStatus(worker.runtimeStatus) : "waiting"
+        };
+    });
+    if (restored.length === 0) {
+        return state;
+    }
+    state.workers = restored.map(({ label, status }) => ({ label, status }));
+    for (const worker of restored) {
+        state[worker.role] = worker.status;
+        if (worker.role === "main") {
+            state.mainEngine = worker.engine;
+        }
+    }
+    return state;
+}
+export function statusLineWithWorkerRefs(status, workers) {
+    if (!status || workers.length === 0) {
+        return status;
+    }
+    const restored = restoredWorkerStatusLine(status.taskId, workers);
+    if (!restored?.workers?.length) {
+        return status;
+    }
+    const next = {
+        ...status,
+        workers: restored.workers
+    };
+    for (const role of ["judge", "actor", "critic"]) {
+        if (restored[role]) {
+            next[role] = restored[role];
+        }
+    }
+    if (restored.main && (!terminalMainStatus(status.main) || terminalMainStatus(restored.main))) {
+        next.main = restored.main;
+        next.mainEngine = restored.mainEngine;
+    }
+    return next;
+}
 function workerTitle(workers, selectedWorkerIndex) {
     const worker = workers[selectedWorkerIndex];
     if (!worker) {
@@ -606,42 +3133,177 @@ function workerTitle(workers, selectedWorkerIndex) {
     }
     return `${worker.label} output (${selectedWorkerIndex + 1}/${workers.length})`;
 }
-export function appContentHeight(rows, hasError = false) {
+function sameWorkerRuntimeStatus(left, right) {
+    if (!left || !right) {
+        return left === right;
+    }
+    return left.worker_id === right.worker_id &&
+        left.feature_id === right.feature_id &&
+        left.feature_title === right.feature_title &&
+        left.role === right.role &&
+        left.engine === right.engine &&
+        left.state === right.state &&
+        left.phase === right.phase &&
+        left.last_event_at === right.last_event_at &&
+        left.summary === right.summary &&
+        left.native_session_id === right.native_session_id;
+}
+function mainWorkerProgress(status, policy, nowMs = Date.now()) {
+    const initialized = status.state === "idle" && status.phase === "initialized";
+    if (!initialized && status.state !== "starting" && status.state !== "running") {
+        return undefined;
+    }
+    const lastEventMs = Date.parse(status.last_event_at);
+    const firstOutputTimeoutMs = effectiveWorkerWatchdog(policy?.firstOutputTimeoutMs, policy?.timeoutMs);
+    const idleTimeoutMs = effectiveWorkerWatchdog(policy?.idleTimeoutMs, policy?.timeoutMs);
+    return {
+        phase: status.phase,
+        elapsedMs: Number.isFinite(lastEventMs) ? Math.max(0, nowMs - lastEventMs) : 0,
+        ...(firstOutputTimeoutMs
+            ? { firstOutputTimeoutMs }
+            : {}),
+        ...(idleTimeoutMs
+            ? { idleTimeoutMs }
+            : {})
+    };
+}
+function applyMainRuntimeStatus(current, worker, policy, nowMs = Date.now()) {
+    const runtimeStatus = worker.runtimeStatus;
+    if (!current || !runtimeStatus) {
+        return current;
+    }
+    if (terminalMainStatus(current.main)
+        && activeWorkerRuntime(runtimeStatus)
+        && !recoveringWorkerRuntime(runtimeStatus)) {
+        return current;
+    }
+    return {
+        ...current,
+        main: formatWorkerRuntimeStatus(runtimeStatus),
+        mainEngine: worker.engine,
+        mainProgress: mainWorkerProgress(runtimeStatus, policy, nowMs)
+    };
+}
+function terminalMainStatus(status) {
+    const state = status?.trim().split(/[\s/:·]/, 1)[0]?.toLowerCase();
+    return state === "done"
+        || state === "fail"
+        || state === "failed"
+        || state === "error"
+        || state === "stop"
+        || state === "cancelled"
+        || state === "canceled";
+}
+function activeWorkerRuntime(status) {
+    return status.state === "idle" || status.state === "starting" || status.state === "running";
+}
+function recoveringWorkerRuntime(status) {
+    return activeWorkerRuntime(status) && status.phase === "native-resume-fallback";
+}
+function newerTerminalRuntime(current, incoming) {
+    if (!current) {
+        return false;
+    }
+    const currentTime = Date.parse(current.last_event_at);
+    const incomingTime = Date.parse(incoming.last_event_at);
+    if (!activeWorkerRuntime(current) && activeWorkerRuntime(incoming)) {
+        if (recoveringWorkerRuntime(incoming)) {
+            return Number.isFinite(currentTime)
+                && Number.isFinite(incomingTime)
+                && currentTime > incomingTime;
+        }
+        return true;
+    }
+    return Number.isFinite(currentTime)
+        && Number.isFinite(incomingTime)
+        && currentTime > incomingTime;
+}
+function sameWorkerNavigationTargets(left, right) {
+    return sameNumberArray(left.searchOffsets, right.searchOffsets) &&
+        sameNumberArray(left.searchLineIndexes, right.searchLineIndexes) &&
+        sameNumberArray(left.errorOffsets, right.errorOffsets) &&
+        sameNumberArray(left.diffOffsets, right.diffOffsets);
+}
+function sameNumberArray(left, right) {
+    return left.length === right.length && left.every((value, index) => value === right[index]);
+}
+function previewRouteFallbackChoice(route, choice) {
+    const mode = choice === "main" ? "simple" : choice === "parallel" ? "complex" : route.mode;
+    return {
+        ...route,
+        mode,
+        suggested_roles: mode === "complex" ? ["judge", "actor", "critic"] : [],
+        router_fallback_resolution: choice === "cancel" ? "cancelled" : choice
+    };
+}
+export function appContentHeight(rows, hasError = false, showStatusBar = true) {
     const headerRows = 1;
     const inputRows = 1;
-    const statusRows = 1;
+    const statusRows = showStatusBar ? 1 : 0;
     const errorRows = hasError ? 1 : 0;
     return Math.max(2, rows - headerRows - inputRows - statusRows - errorRows);
 }
-function NativeAttachView({ attach }) {
+function NativeAttachView({ attach, viewportHeight }) {
     if (!attach) {
-        return _jsx(Text, { children: "Starting native attach..." });
+        return _jsx(Text, { ...nativeAttachStartingTheme(), children: nativeAttachStartingText() });
     }
     const terminalWidth = process.stdout.columns || 120;
     const panelWidth = nativeAttachPanelRailWidth(terminalWidth);
     const scroll = attach.screen.scrollState();
     const scrollLabel = nativeTerminalScrollDisplay(scroll.offset, scroll.maxOffset, terminalWidth);
     const title = nativeAttachTitleDisplay(attach.launch.label, attach.launch.sessionId, attach.closedCode, panelWidth, scrollLabel);
-    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(NativeAttachTitleRail, { title: title, width: panelWidth }), _jsx(TerminalOutput, { lines: attach.screen.styledSnapshotLines({ showCursor: true }) })] }));
+    const outputMinLines = Math.max(1, viewportHeight - 1);
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(NativeAttachTitleRail, { title: title, width: panelWidth }), _jsx(TerminalOutput, { lines: attach.hasOutput ? attach.screen.styledSnapshotLines({ showCursor: true }) : [], minLines: outputMinLines, width: panelWidth })] }));
+}
+export function nativeAttachStartingTheme() {
+    return {
+        backgroundColor: TUI_THEME.surface,
+        color: TUI_THEME.muted
+    };
+}
+export function nativeAttachStartingText() {
+    return "opening native session";
 }
 function NativeAttachTitleRail({ title, width }) {
     const titleText = ` ${title} `;
+    const segments = nativeAttachTitleSegments(title);
     const renderWidth = typeof process.stdout.columns === "number"
         ? width
         : null;
     const trailingWidth = renderWidth === null
         ? 0
         : Math.max(0, renderWidth - displayWidth(titleText));
-    return (_jsxs(Box, { children: [_jsx(Text, { backgroundColor: NATIVE_PANEL_TITLE_BACKGROUND, color: "white", bold: true, children: titleText }), trailingWidth > 0 ? _jsx(Text, { backgroundColor: NATIVE_PANEL_BACKGROUND, children: " ".repeat(trailingWidth) }) : null] }));
+    return (_jsxs(Box, { children: [_jsx(Text, { backgroundColor: TUI_THEME.chrome, children: " " }), segments.map((segment, index) => (_jsx(Text, { backgroundColor: TUI_THEME.chrome, color: segment.tone === "identity" ? TUI_THEME.accent : segment.tone === "danger" ? TUI_THEME.danger : TUI_THEME.muted, bold: segment.tone === "identity", children: segment.text }, `${segment.tone}-${index}`))), _jsx(Text, { backgroundColor: TUI_THEME.chrome, children: " " }), trailingWidth > 0 ? _jsx(Text, { backgroundColor: TUI_THEME.chrome, children: " ".repeat(trailingWidth) }) : null] }));
+}
+function nativeAttachTitleSegments(title) {
+    const parts = title.split(" · ");
+    if (parts.length > 1) {
+        return parts.map((part, index) => ({
+            text: index === 0 ? part : ` · ${part}`,
+            tone: index === 0 ? "identity" : isNativeExitTitlePart(part) ? "danger" : "muted"
+        }));
+    }
+    const exitMatch = title.match(/^(.*?)(\s+(?:exited\s+\d+|exit:\d+))$/);
+    if (exitMatch?.[1]) {
+        return [
+            { text: exitMatch[1], tone: "identity" },
+            { text: exitMatch[2] ?? "", tone: "danger" }
+        ];
+    }
+    return [{ text: title, tone: isNativeExitTitlePart(title) ? "danger" : "identity" }];
+}
+function isNativeExitTitlePart(text) {
+    return /^(?:exited\s+\d+|exit:\d+)$/.test(text.trim());
 }
 function nativeAttachPanelRailWidth(terminalWidth) {
     const renderWidth = typeof process.stdout.columns === "number"
         ? Math.max(1, Math.min(terminalWidth, process.stdout.columns))
         : terminalWidth;
-    return Math.max(1, renderWidth - 4);
+    return Math.max(1, renderWidth - 2);
 }
 export function nativeAttachTitleDisplay(label, sessionId, closedCode, terminalWidth = process.stdout.columns || 120, scrollLabel = null) {
     const exit = closedCode === null ? "" : `exit:${closedCode}`;
+    const exitReadable = closedCode === null ? "" : `exited ${closedCode}`;
     const contentWidth = Math.max(1, terminalWidth - 2);
     if (terminalWidth < 24) {
         return tinyNativeAttachTitle(label, exit ? ` ${exit}` : "", contentWidth);
@@ -650,9 +3312,18 @@ export function nativeAttachTitleDisplay(label, sessionId, closedCode, terminalW
     const roleLabel = compactNativeAttachRole(label);
     if (exit) {
         return firstNativeTitleThatFits(withNativeTitleSuffix([
+            ...(terminalWidth >= 32
+                ? [
+                    `native ${compactLabel} · ${exitReadable}`,
+                    `native ${roleLabel} · ${exitReadable}`,
+                    `${roleLabel} ${exitReadable}`,
+                    exitReadable
+                ]
+                : []),
             `native ${compactLabel} · ${exit}`,
             `native ${roleLabel} · ${exit}`,
-            `${roleLabel} ${exit}`
+            `${roleLabel} ${exit}`,
+            exit
         ], scrollLabel), contentWidth);
     }
     const prefix = `native ${compactLabel}`;
@@ -681,11 +3352,14 @@ export function nativeTerminalScrollDisplay(offset, maxOffset, width) {
 export function nativeAttachTerminalColumns(terminalWidth = process.stdout.columns || 120) {
     return Math.max(1, terminalWidth - 2);
 }
+export function nativeAttachTerminalRows(terminalRows = process.stdout.rows || 30, hasError = false, showStatusBar = true) {
+    return Math.max(1, appContentHeight(terminalRows, hasError, showStatusBar) - 2);
+}
 export function nativeAttachExitLine(code, nativeTerminalCols) {
     const contentWidth = Math.max(1, nativeTerminalCols);
     const candidates = [
-        `[process exited with code ${code}]`,
-        `[exit ${code}]`,
+        `process exited · code ${code}`,
+        `exit code ${code}`,
         `exit:${code}`
     ];
     return firstNativeTitleThatFits(candidates, contentWidth);
@@ -740,3 +3414,6 @@ function compactNativeAttachRole(label) {
 function compactNativeSessionForTitle(sessionId, maxLength) {
     return compactEndByDisplayWidth(sessionId, Math.min(maxLength, 16));
 }
+function isAbortError(error) {
+    return error instanceof Error && error.name === "AbortError";
+}