@aui.io/apollo 0.1.9 → 0.1.10

package/node_modules/@aui.io/apollo-tui/dist/src/opentui-app.js

@@ -1,37 +1,77 @@
-import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "@opentui/react/jsx-runtime";
+import { jsx as _jsx, jsxs as _jsxs } from "@opentui/react/jsx-runtime";
 /**
- * Apollo TUI — OpenTUI engine.
+ * Apollo TUI — OpenTUI engine, two-mode workbench shell.
  *
- * Global slash command desk; tabs are views. Business logic in apollo-core
- * via lib/actions.ts.
+ * Author (program cockpit) and Talk (runtime conversation) are the only
+ * primary modes (TUI_DESIGN §6). Business logic stays in apollo-core via
+ * lib/actions.ts; this file owns composition, input semantics, and focus.
  */
-import { useEffect, useRef, useState } from "react";
-import { createCliRenderer } from "@opentui/core";
-import { createRoot, useKeyboard } from "@opentui/react";
+import { watch } from "node:fs";
+import { useEffect, useMemo, useRef, useState, useSyncExternalStore } from "react";
+import { createCliRenderer, } from "@opentui/core";
+import { createRoot, useKeyboard, useTerminalDimensions } from "@opentui/react";
 import { resolveContext } from "@aui.io/apollo-core/config/index.js";
+import { listVersions } from "@aui.io/apollo-core/services/bundles.js";
 import { createClients } from "@aui.io/apollo-core/services/clients.js";
-import { sendMessage } from "@aui.io/apollo-core/services/messaging.js";
+import { listAgentThreads, listThreads, resolveSendVersion, sendMessage, } from "@aui.io/apollo-core/services/messaging.js";
 import { GlyphController } from "./components/glyph.js";
 import { applyPick, chatOverlay, destructiveSpec, loadPickerCatalog, refreshContext, runDestructive, runSheetAction, runSimpleCommand, } from "./lib/actions.js";
-import { filterCommands, helpLines, PLACE_ONBOARD_COMMAND, resolveCommand, } from "./lib/commands.js";
+import { filterCommands, PLACE_ONBOARD_COMMAND, resolveCommand, SLASH_COMMANDS, } from "./lib/commands.js";
 import { checkConfirm, createConfirm } from "./lib/confirm.js";
-import { clampPickerCursor, effectivePickerFilter, filterPickerItems, pickerColumnWidths, pickerPageSize, resolvePickerAnswer, truncatePickerText, } from "./lib/picker.js";
+import { copyToClipboard } from "./lib/clipboard.js";
+import { matchActivity, matchArrow, matchContext, matchCtrlC, matchEscape, matchHorizontal, matchModeJump, matchModeToggle, matchNewThread, matchPage, matchPalette, matchTalkTarget, matchTurnDebug, matchTurnTrace, } from "./lib/keys.js";
+import { modeByIndex, modeForJumpTab, otherMode } from "./lib/modes.js";
+import { clampPickerCursor, effectivePickerFilter, filterPickerItems, pickerPageSize, resolvePickerAnswer, } from "./lib/picker.js";
 import { hasPlace } from "./lib/place.js";
+import { applyNames, resolveScopeNames, scopeFromContext, } from "./lib/scope.js";
 import { createSheet, moveFocus, setFocusedValue, validateSheet, visibleFields, } from "./lib/sheet.js";
-import { scopeFromContext } from "./lib/scope.js";
-import { TABS, nextTab, prevTab, tabByIndex } from "./lib/tabs.js";
-const TEAL = "#4FB8B0";
-const TEAL_DIM = "#2E6B66";
-const AMBER = "#E6A23C";
-const RED = "#D46A6A";
-const DIM = "#8A8A8A";
-const FAINT = "#5C5C5C";
-const FG = "#D8D8D8";
-const VERSION = process.env.npm_package_version ?? "0.1.7";
+import { actionByAlias, buildActionRegistry, searchActions, } from "./actions/registry.js";
+import { ActionPalettePane } from "./actions/ActionPalette.js";
+import { AuthorHome } from "./author/AuthorHome.js";
+import { agentRootOf, bundleSrcRoot, changeEntries, changesSummary, defaultDiffStyle, fetchRemoteFiles, fileContentDiff, listPlaceFiles, loadAuthorSnapshot, readLocalFiles, readPlaceFile, relativeTime, runValidationRecord, validationSummary, } from "./author/data.js";
+import { ActivityDrawerPane } from "./activity/ActivityDrawer.js";
+import { ActivitySummaryLine } from "./activity/ActivitySummary.js";
+import { isOperationCommand, latestOperation, operationStore, orderedOperations, } from "./activity/operationStore.js";
+import { resolveAuthorBackend, } from "./author/backend/index.js";
+import { loadSessions, saveSession } from "./author/backend/sessions.js";
+import { relativizeEvent, sessionCancel, sessionCreate, sessionEvent, sessionPrompt, sessionRows, unitRowOffset, } from "./author/session.js";
+import { DiffView } from "./author/DiffView.js";
+import { treeRows } from "./author/tree.js";
+import { ValidationViewPane } from "./author/ValidationView.js";
+import { VersionsViewPane } from "./author/VersionsView.js";
+import { CONTEXT_ROWS, ContextSwitcherPane, } from "./context/ContextSwitcher.js";
+import { Breadcrumb } from "./shell/Breadcrumb.js";
+import { FooterHints } from "./shell/FooterHints.js";
+import { ModeNav } from "./shell/ModeNav.js";
+import { Composer } from "./talk/Composer.js";
+import { agentOrdinal, beginSend, cancelSend, composerDisabledReason, hasPendingSend, inspectorMeta, lastAgentTurnIndex, settleSend, talkLayout, talkRows, threadSummaries, turnRowOffset, } from "./talk/data.js";
+import { NEW_THREAD_ROW, threadsRowCount } from "./talk/ThreadsPane.js";
+import { TalkView } from "./talk/TalkView.js";
+import { ConfirmPane } from "./ui/ConfirmPane.js";
+import { PickerPane } from "./ui/PickerPane.js";
+import { SheetPane } from "./ui/SheetPane.js";
+import { AMBER, DIM, FAINT, FG, TEAL, TEAL_DIM } from "./theme/tokens.js";
+const VERSION = process.env.npm_package_version ?? "0.1.10";
+const REGISTRY = buildActionRegistry();
+/** Author-mode single-letter quick actions (typed + Enter). */
+const AUTHOR_QUICK = {
+    v: "validate",
+    d: "diff",
+    p: "push",
+    l: "pull",
+    r: "versions",
+    o: "ide",
+};
+const OLD_NAV_NAMES = new Set(["chat", "bundle", "mockdb", "scope", "overview"]);
+const AUTHOR_VIEW_FOCUS = {
+    diff: "author-diff",
+    validation: "author-validation",
+    versions: "author-versions",
+};
 function App({ context: initialContext, initialScope, glyph, onQuit }) {
     const [context, setContext] = useState(initialContext);
     const [scope, setScope] = useState(initialScope);
-    const [tab, setTab] = useState("overview");
+    const [mode, setMode] = useState("author");
     const [input, setInput] = useState("");
     const [chat, setChat] = useState([]);
     const [threadId, setThreadId] = useState();
@@ -40,53 +80,874 @@ function App({ context: initialContext, initialScope, glyph, onQuit }) {
     const [sheetCommand, setSheetCommand] = useState();
     const [picker, setPicker] = useState();
     const [confirm, setConfirm] = useState();
+    const [paletteCursor, setPaletteCursor] = useState();
+    const [switcherCursor, setSwitcherCursor] = useState();
+    /** Activity drawer cursor; undefined = closed (^J toggles). */
+    const [activityCursor, setActivityCursor] = useState();
     const [paneTitle, setPaneTitle] = useState();
     const [paneLines, setPaneLines] = useState([]);
     const [working, setWorking] = useState(false);
     const [trace, setTrace] = useState(false);
     const [localMode, setLocalMode] = useState(false);
+    /**
+     * Session talk target: undefined = follow the `.apollorc` binding,
+     * "latest" = force the live version, else an explicit tag. Never written
+     * to disk — pinning a tag for a chat must not move the author baseline.
+     */
+    const [talkTag, setTalkTag] = useState(undefined);
     const [vars, setVars] = useState([]);
     const [frame, setFrame] = useState(glyph.frame());
+    // Author workbench state (Phase 3).
+    const [authorView, setAuthorView] = useState("home");
+    const [snapshot, setSnapshot] = useState();
+    const [validation, setValidation] = useState();
+    const [versions, setVersions] = useState();
+    /** Cursor over the visible file-tree rows in the diff/browse sidebar. */
+    const [diffCursor, setDiffCursor] = useState(0);
+    /** Full-width single-file preview (Enter on a file); Esc collapses. */
+    const [fileDiff, setFileDiff] = useState();
+    /** Local+remote contents backing diff content panes (loaded on entry). */
+    const [diffFiles, setDiffFiles] = useState();
+    /** Explicit split/unified override; undefined = auto by terminal width. */
+    const [diffStyle, setDiffStyle] = useState();
+    /** Collapsed dirs in the file tree (keys are compacted dir paths). */
+    const [diffCollapsed, setDiffCollapsed] = useState(() => new Set());
+    /** Last file the tree cursor rested on — what the preview pane shows. */
+    const [previewPath, setPreviewPath] = useState();
+    /** Workspace-level browse listing (no agent: tree shows place files). */
+    const [placeFiles, setPlaceFiles] = useState();
+    /** Async read for browse-mode previews (agent mode is sync from maps). */
+    const [browsePreview, setBrowsePreview] = useState();
+    const browseCacheRef = useRef(new Map());
+    // Author copilot (Phase 5): pluggable backend behind the AuthorBackend seam.
+    const authorBackend = useMemo(() => resolveAuthorBackend(), []);
+    const [backendDetection, setBackendDetection] = useState();
+    /** Multi-turn session transcript (work units); survives across turns. */
+    const [authorSession, setAuthorSession] = useState();
+    /** Cursor over session units; Enter expands action units (input/result). */
+    const [sessionCursor, setSessionCursor] = useState(0);
+    const [sessionExpanded, setSessionExpanded] = useState(() => new Set());
+    /** Messages typed while a turn runs — sent in order when it finishes. */
+    const [queuedPrompts, setQueuedPrompts] = useState([]);
+    // Talk workbench state (Phase 6, TUI_DESIGN §9).
+    /** ←/→ move focus between the threads pane and the conversation. */
+    const [talkFocus, setTalkFocus] = useState("chat");
+    /** Selected turn; the inspector describes it, ^T/^D fetch its payloads. */
+    const [talkCursor, setTalkCursor] = useState(0);
+    const [threads, setThreads] = useState();
+    const [threadsLoading, setThreadsLoading] = useState(false);
+    /** Row 0 is "new thread"; real threads follow. */
+    const [threadCursor, setThreadCursor] = useState(0);
+    /** Trace/debug fetched for one turn; cleared when the selection moves. */
+    const [inspectorFetch, setInspectorFetch] = useState();
+    /** Mirror of the composer textarea (emptiness gates arrow-key semantics). */
+    const [composer, setComposer] = useState("");
+    const composerRef = useRef(null);
+    const inspectorScrollRef = useRef(null);
+    /** Drafts survive thread switches; keyed by thread id ("new" = unstarted). */
+    const draftsRef = useRef(new Map());
+    /**
+     * Send epoch — the messaging API cannot cancel server-side, so cancelling
+     * (or switching threads) bumps this and the stale reply is discarded.
+     */
+    const sendSeqRef = useRef(0);
+    const turnHandleRef = useRef(undefined);
+    /** Operation id of the active turn — also the "is this turn stale" guard. */
+    const turnOpIdRef = useRef(undefined);
+    /** Full feed mirror for the operation drawer's output copy. */
+    const turnFeedRef = useRef([]);
+    /** The one scrollable content pane on screen (diff/validation/versions/talk). */
+    const contentScrollRef = useRef(null);
+    /** Remote bundle contents cached per bound tag (content diffs). */
+    const remoteFilesRef = useRef(undefined);
+    /** Detects agent switches to reset per-agent author state. */
+    const agentKeyRef = useRef(undefined);
     /** Soft place gate offered once per session (pick / skip / already had place). */
     const placeGateOffered = useRef(false);
+    const { width: termWidth } = useTerminalDimensions();
+    /** Effective diff style: explicit toggle wins, else width decides. */
+    const diffStyleEffective = diffStyle ?? defaultDiffStyle(termWidth);
+    // Durable operations (TUI_DESIGN §13): the store outlives view switches;
+    // this subscription only renders what it holds.
+    const operations = useSyncExternalStore(operationStore.subscribe, operationStore.snapshot);
+    const orderedOps = useMemo(() => orderedOperations(operations), [operations]);
+    const latestOp = latestOperation(operations);
+    // Elapsed-time tick while anything runs or the drawer shows ages.
+    const hasRunningOp = operations.some((op) => op.status === "running");
+    const [, setActivityTick] = useState(0);
+    useEffect(() => {
+        if (!hasRunningOp && activityCursor === undefined)
+            return;
+        const id = setInterval(() => setActivityTick((t) => t + 1), 1000);
+        return () => clearInterval(id);
+    }, [hasRunningOp, activityCursor]);
+    const hasAgent = scope.agent !== "—";
+    /** Changed paths → status, from the author snapshot. */
+    const statusByPath = useMemo(() => {
+        const map = new Map();
+        for (const entry of changeEntries(snapshot?.diff)) {
+            map.set(entry.path, entry.status);
+        }
+        return map;
+    }, [snapshot]);
+    /**
+     * What the sidebar tree lists: changed files when an agent has changes,
+     * the whole checkout when clean, the place's files at workspace level.
+     */
+    const treeEntries = useMemo(() => {
+        if (hasAgent) {
+            const changed = changeEntries(snapshot?.diff);
+            if (changed.length > 0)
+                return changed;
+            if (diffFiles?.status === "ready") {
+                return Object.keys(diffFiles.local)
+                    .sort()
+                    .map((path) => ({ path }));
+            }
+            return [];
+        }
+        return (placeFiles ?? []).map((path) => ({ path }));
+    }, [hasAgent, snapshot, diffFiles, placeFiles]);
+    const diffRows = useMemo(() => treeRows(treeEntries, diffCollapsed), [treeEntries, diffCollapsed]);
+    /** Session rows are pre-wrapped to the pane width → exact scroll offsets. */
+    const sessionPaneWidth = Math.max(30, termWidth - 8);
+    const sessionRowsView = useMemo(() => authorSession
+        ? sessionRows(authorSession, sessionExpanded, sessionPaneWidth, queuedPrompts)
+        : [], [authorSession, sessionExpanded, sessionPaneWidth, queuedPrompts]);
+    // Talk workbench derivations: panes by width, pre-wrapped rows, pending.
+    const talkLayoutEffective = useMemo(() => talkLayout(termWidth), [termWidth]);
+    const talkPending = hasPendingSend(chat);
+    /** Ticks the pending row's elapsed time (and header ages) while waiting. */
+    const [talkTick, setTalkTick] = useState(0);
+    useEffect(() => {
+        if (!talkPending)
+            return;
+        const id = setInterval(() => setTalkTick((t) => t + 1), 500);
+        return () => clearInterval(id);
+    }, [talkPending]);
+    const conversationWidth = Math.max(28, termWidth -
+        8 -
+        (talkLayoutEffective.threads ? talkLayoutEffective.threadsWidth : 0) -
+        (talkLayoutEffective.inspector ? talkLayoutEffective.inspectorWidth : 0));
+    const talkRowsView = useMemo(() => talkRows(chat, conversationWidth, Date.now()), 
+    // talkTick re-times the pending row twice a second.
+    [chat, conversationWidth, talkTick]);
+    const talkCursorClamped = clampPickerCursor(talkCursor, chat.length);
+    /** What sends run against, for the composer label and inspector (^B picks). */
+    const talkVersionLabel = talkTag === "latest"
+        ? "live"
+        : (talkTag ?? (scope.version !== "—" ? scope.version : "live"));
+    const inspectorMetaLines = useMemo(() => inspectorMeta(chat, talkCursorClamped, {
+        localMode,
+        remoteTag: talkVersionLabel,
+        env: scope.env,
+        vars,
+    }), [chat, talkCursorClamped, localMode, talkVersionLabel, scope.env, vars]);
+    const composerReason = composerDisabledReason(scope, localMode, scope.agentPath);
     const stateRef = useRef({
-        tab,
+        mode,
         sheet,
         sheetCommand,
         picker,
         confirm,
+        paletteCursor,
+        switcherCursor,
+        activityCursor,
         context,
         input,
+        scope,
+        authorView,
+        snapshot,
+        validation,
+        diffCursor,
+        fileDiff,
+        diffFiles,
+        diffRows,
+        diffStyleEffective,
+        orderedOps,
+        authorSession,
+        sessionCursor,
+        queuedPrompts,
+        backendDetection,
+        chat,
+        threadId,
+        localMode,
+        talkTag,
+        vars,
+        composer,
+        talkFocus,
+        talkCursor,
+        threads,
+        threadCursor,
+        talkPending,
+        inspectorFetch,
+        talkLayout: talkLayoutEffective,
     });
-    stateRef.current = { tab, sheet, sheetCommand, picker, confirm, context, input };
+    stateRef.current = {
+        mode,
+        sheet,
+        sheetCommand,
+        picker,
+        confirm,
+        paletteCursor,
+        switcherCursor,
+        activityCursor,
+        context,
+        input,
+        scope,
+        authorView,
+        snapshot,
+        validation,
+        diffCursor,
+        fileDiff,
+        diffFiles,
+        diffRows,
+        diffStyleEffective,
+        orderedOps,
+        authorSession,
+        sessionCursor,
+        queuedPrompts,
+        backendDetection,
+        chat,
+        threadId,
+        localMode,
+        talkTag,
+        vars,
+        composer,
+        talkFocus,
+        talkCursor,
+        threads,
+        threadCursor,
+        talkPending,
+        inspectorFetch,
+        talkLayout: talkLayoutEffective,
+    };
+    const paletteOpen = paletteCursor !== undefined;
+    const switcherOpen = switcherCursor !== undefined;
+    const activityOpen = activityCursor !== undefined;
+    const authorEmpty = !scope.loggedIn || scope.agent === "—";
+    /** Where the browse tree roots without an agent (workspace level). */
+    const browseRoot = bundleSrcRoot(context) ?? context.workspaceRoot;
+    /** Subviews need an agent — except diff, which browses any place. */
+    const authorViewEffective = authorEmpty && !(authorView === "diff" && browseRoot) ? "home" : authorView;
     useEffect(() => {
-        if (tab !== "overview")
+        if (mode !== "author" || !authorEmpty)
             return;
         const id = setInterval(() => setFrame(glyph.frame()), 33);
         return () => clearInterval(id);
-    }, [tab, glyph]);
+    }, [mode, authorEmpty, glyph]);
     useEffect(() => {
         glyph.setWorking(working);
     }, [working, glyph]);
-    const paletteOpen = !sheet && !picker && !confirm && input.startsWith("/");
+    // Human names for the strip (workspace manifest, project/org APIs) —
+    // ids render immediately, names overlay when resolved; stale results
+    // (context changed meanwhile) are dropped.
+    useEffect(() => {
+        let live = true;
+        void resolveScopeNames(context).then((names) => {
+            if (live)
+                setScope((s) => applyNames(s, names));
+        });
+        return () => {
+            live = false;
+        };
+    }, [context]);
+    // Author snapshot follows the context; switching agent (or account — the
+    // profile/env pair scopes threads and baselines too) resets per-agent state.
+    useEffect(() => {
+        const key = `${context.profile}:${context.environment}:${context.agentId ?? ""}:${context.agentRoot ?? ""}`;
+        if (agentKeyRef.current !== key) {
+            agentKeyRef.current = key;
+            setValidation(undefined);
+            setVersions(undefined);
+            setFileDiff(undefined);
+            setDiffFiles(undefined);
+            setDiffCursor(0);
+            setDiffCollapsed(new Set());
+            setPreviewPath(undefined);
+            setPlaceFiles(undefined);
+            setBrowsePreview(undefined);
+            browseCacheRef.current.clear();
+            setAuthorView("home");
+            remoteFilesRef.current = undefined;
+            // The session belongs to the previous checkout — stop and clear it.
+            turnHandleRef.current?.cancel();
+            turnHandleRef.current = undefined;
+            setAuthorSession(undefined);
+            setSessionCursor(0);
+            setSessionExpanded(new Set());
+            setQueuedPrompts([]);
+            // The conversation was with the previous agent/account — a reply
+            // arriving now would be misattributed. Discard and start clean.
+            sendSeqRef.current += 1;
+            setChat([]);
+            setThreadId(undefined);
+            setThreads(undefined);
+            setTalkCursor(0);
+            setThreadCursor(0);
+            setTalkFocus("chat");
+            setInspectorFetch(undefined);
+            // Local mode targets one checkout and a pinned tag targets one agent —
+            // carrying either to the next target would silently run something the
+            // user never chose.
+            setLocalMode(false);
+            setTalkTag(undefined);
+        }
+        let cancelled = false;
+        void loadAuthorSnapshot(context).then((snap) => {
+            if (!cancelled)
+                setSnapshot(snap);
+        });
+        return () => {
+            cancelled = true;
+        };
+    }, [context]);
+    // Author backend detection — once per session; failures render an honest
+    // "not detected" card, never a broken input.
+    useEffect(() => {
+        let cancelled = false;
+        void authorBackend.detect().then((detection) => {
+            if (!cancelled)
+                setBackendDetection(detection);
+        });
+        return () => {
+            cancelled = true;
+        };
+    }, [authorBackend]);
+    // Filesystem watcher: saves in the IDE refresh the changes list and mark
+    // validation results stale (TUI_DESIGN §8.6 — filesystem is truth).
+    useEffect(() => {
+        const root = bundleSrcRoot(context);
+        if (!root)
+            return;
+        let timer;
+        let watcher;
+        try {
+            watcher = watch(root, { recursive: true }, () => {
+                if (timer)
+                    clearTimeout(timer);
+                timer = setTimeout(() => {
+                    setValidation((v) => (v && !v.stale ? { ...v, stale: true } : v));
+                    void loadAuthorSnapshot(stateRef.current.context).then(setSnapshot);
+                    // Keep open diff panes honest: refresh the local side on save.
+                    if (stateRef.current.diffFiles?.status === "ready") {
+                        void readLocalFiles(stateRef.current.context).then((local) => setDiffFiles((s) => (s?.status === "ready" ? { ...s, local } : s)));
+                    }
+                }, 400);
+            });
+        }
+        catch {
+            // Recursive watch unsupported — snapshot still refreshes after actions.
+        }
+        return () => {
+            if (timer)
+                clearTimeout(timer);
+            watcher?.close();
+        };
+    }, [context]);
+    // The preview pane follows the tree cursor: resting on a file selects it
+    // (dirs keep the last file up, so browsing feels stable, not flashy).
+    useEffect(() => {
+        const row = diffRows[clampPickerCursor(diffCursor, diffRows.length)];
+        if (row?.kind === "file")
+            setPreviewPath(row.path);
+    }, [diffCursor, diffRows]);
+    // Session follow: new units keep the cursor pinned to the newest unit —
+    // unless the user walked it up to read history.
+    const sessionLenRef = useRef(0);
+    const sessionCursorRef = useRef(0);
+    sessionCursorRef.current = sessionCursor;
+    useEffect(() => {
+        const len = authorSession?.units.length ?? 0;
+        const prev = sessionLenRef.current;
+        sessionLenRef.current = len;
+        if (len === 0 || len === prev)
+            return;
+        if (prev === 0 || sessionCursorRef.current >= prev - 1) {
+            setSessionCursor(len - 1);
+        }
+    }, [authorSession]);
+    // Keep the transcript visible: cursor on the newest unit pins the pane to
+    // the bottom (streaming rows grow below the unit's label — bottom-pinning
+    // keeps live text on screen); browsing history centers the selected unit.
+    useEffect(() => {
+        if (mode !== "author" || authorViewEffective !== "home")
+            return;
+        if (!authorSession || authorSession.units.length === 0)
+            return;
+        const box = contentScrollRef.current;
+        if (!box)
+            return;
+        const count = authorSession.units.length;
+        const cursor = clampPickerCursor(sessionCursor, count);
+        const viewport = Math.max(4, box.height || 10);
+        if (cursor >= count - 1) {
+            box.scrollTo({
+                x: 0,
+                y: Math.max(0, sessionRowsView.length - viewport + 1),
+            });
+            return;
+        }
+        const offset = unitRowOffset(sessionRowsView, cursor);
+        box.scrollTo({ x: 0, y: Math.max(0, offset - Math.floor(viewport / 2)) });
+    }, [sessionCursor, sessionRowsView, authorSession, mode, authorViewEffective]);
+    // Queued prompts drain in order once the running turn settles. (Effect,
+    // not inline in onEvent: stateRef sees the settled session only after the
+    // next render — the running guard in startAuthorTurn needs it fresh.)
+    useEffect(() => {
+        if (!authorSession || authorSession.running)
+            return;
+        if (queuedPrompts.length === 0)
+            return;
+        const [next, ...rest] = queuedPrompts;
+        setQueuedPrompts(rest);
+        if (next)
+            void startAuthorTurn(next);
+    }, [authorSession, queuedPrompts]);
+    // Talk cursor follow: new turns pull the selection to the newest one —
+    // unless the user walked up to read history.
+    const chatLenRef = useRef(0);
+    const talkCursorRef = useRef(0);
+    talkCursorRef.current = talkCursor;
+    useEffect(() => {
+        const len = chat.length;
+        const prev = chatLenRef.current;
+        chatLenRef.current = len;
+        if (len === 0 || len === prev)
+            return;
+        if (prev === 0 || talkCursorRef.current >= prev - 1) {
+            setTalkCursor(len - 1);
+        }
+    }, [chat]);
+    // Conversation scroll follows the selection: newest turn pins the pane to
+    // the bottom (the pending row grows there); history centers the selection.
+    useEffect(() => {
+        if (mode !== "talk" || chat.length === 0)
+            return;
+        const box = contentScrollRef.current;
+        if (!box)
+            return;
+        const cursor = clampPickerCursor(talkCursor, chat.length);
+        const viewport = Math.max(4, box.height || 10);
+        if (cursor >= chat.length - 1) {
+            box.scrollTo({ x: 0, y: Math.max(0, talkRowsView.length - viewport + 1) });
+            return;
+        }
+        const offset = turnRowOffset(talkRowsView, cursor);
+        box.scrollTo({ x: 0, y: Math.max(0, offset - Math.floor(viewport / 2)) });
+    }, [talkCursor, talkRowsView, chat, mode]);
+    // Threads pane data: lazy, once per context (invalidated on new threads).
+    // Scoped to the selected agent when one is bound — a per-user listing
+    // mixes every agent's conversations; without an agent it is the fallback.
+    // Staleness rides a sequence ref, NOT an effect cleanup: `setThreadsLoading`
+    // re-runs this effect, and a cleanup-based cancel flag would cancel the
+    // fetch it just started — the pane then spins forever.
+    const threadsLoadSeq = useRef(0);
+    useEffect(() => {
+        if (mode !== "talk" || !scope.loggedIn)
+            return;
+        if (threads !== undefined)
+            return;
+        const seq = ++threadsLoadSeq.current;
+        setThreadsLoading(true);
+        const clients = createClients(context);
+        const load = context.agentId
+            ? listAgentThreads(context, clients.runtime)
+            : listThreads(context, clients.runtime);
+        void load
+            .then((list) => {
+            if (seq === threadsLoadSeq.current)
+                setThreads(threadSummaries(list));
+        })
+            .catch(() => {
+            if (seq === threadsLoadSeq.current)
+                setThreads([]); // "no threads yet"
+        })
+            .finally(() => {
+            if (seq === threadsLoadSeq.current)
+                setThreadsLoading(false);
+        });
+    }, [mode, scope.loggedIn, threads, context]);
+    // The fetched trace/debug payload belongs to one turn — moving the
+    // selection retires it (meta always re-derives).
+    useEffect(() => {
+        setInspectorFetch((f) => (f && f.turn !== talkCursor ? undefined : f));
+    }, [talkCursor]);
+    // A shrinking terminal can hide the threads pane while it holds focus.
+    useEffect(() => {
+        if (!talkLayoutEffective.threads && talkFocus === "threads") {
+            setTalkFocus("chat");
+        }
+    }, [talkLayoutEffective.threads, talkFocus]);
+    const previewTarget = fileDiff?.path ?? previewPath;
+    // Workspace-level browse listing follows the place (covers entering the
+    // view and switching workspaces while it is open).
+    useEffect(() => {
+        if (authorView !== "diff" || hasAgent || !browseRoot)
+            return;
+        let cancelled = false;
+        void listPlaceFiles(browseRoot).then((files) => {
+            if (!cancelled)
+                setPlaceFiles(files);
+        });
+        return () => {
+            cancelled = true;
+        };
+    }, [authorView, hasAgent, browseRoot]);
+    // Browse mode (no agent): read files on demand, cached per root+path.
+    useEffect(() => {
+        if (hasAgent || !previewTarget || !browseRoot)
+            return;
+        const cacheKey = `${browseRoot}:${previewTarget}`;
+        const cached = browseCacheRef.current.get(cacheKey);
+        if (cached) {
+            setBrowsePreview({ path: previewTarget, lines: cached });
+            return;
+        }
+        let cancelled = false;
+        setBrowsePreview({ path: previewTarget });
+        void readPlaceFile(browseRoot, previewTarget)
+            .then((lines) => {
+            browseCacheRef.current.set(cacheKey, lines);
+            if (!cancelled)
+                setBrowsePreview({ path: previewTarget, lines });
+        })
+            .catch((error) => {
+            if (!cancelled) {
+                setBrowsePreview({
+                    path: previewTarget,
+                    error: error instanceof Error ? error.message : String(error),
+                });
+            }
+        });
+        return () => {
+            cancelled = true;
+        };
+    }, [previewTarget, hasAgent, browseRoot]);
+    /** Content diff for the selected changed file (agent mode, remote known). */
+    const previewDiffLines = useMemo(() => {
+        if (!previewTarget || !hasAgent)
+            return undefined;
+        if (diffFiles?.status !== "ready" || diffFiles.remoteError)
+            return undefined;
+        if (!statusByPath.has(previewTarget))
+            return undefined;
+        return fileContentDiff(previewTarget, diffFiles.local, diffFiles.remote);
+    }, [previewTarget, hasAgent, diffFiles, statusByPath]);
+    /** What the preview pane renders — memoized so pane memoization holds. */
+    const preview = useMemo(() => {
+        if (!previewTarget)
+            return { kind: "none" };
+        if (!hasAgent) {
+            if (browsePreview?.path !== previewTarget) {
+                return { kind: "loading", path: previewTarget };
+            }
+            if (browsePreview.error) {
+                return { kind: "error", path: previewTarget, message: browsePreview.error };
+            }
+            return browsePreview.lines
+                ? { kind: "file", path: previewTarget, lines: browsePreview.lines }
+                : { kind: "loading", path: previewTarget };
+        }
+        if (!diffFiles || diffFiles.status === "loading") {
+            return { kind: "loading", path: previewTarget };
+        }
+        if (diffFiles.status === "error") {
+            return { kind: "error", path: previewTarget, message: diffFiles.message };
+        }
+        if (previewDiffLines) {
+            return { kind: "diff", path: previewTarget, lines: previewDiffLines };
+        }
+        const content = diffFiles.local[previewTarget];
+        if (content === undefined) {
+            return {
+                kind: "error",
+                path: previewTarget,
+                message: diffFiles.remoteError
+                    ? `deleted locally · remote unavailable — ${diffFiles.remoteError}`
+                    : "file missing locally",
+            };
+        }
+        const note = diffFiles.remoteError && statusByPath.has(previewTarget)
+            ? `remote unavailable — showing local file (${diffFiles.remoteError})`
+            : undefined;
+        return {
+            kind: "file",
+            path: previewTarget,
+            lines: content.split("\n"),
+            ...(note ? { note } : {}),
+        };
+    }, [previewTarget, hasAgent, browsePreview, diffFiles, previewDiffLines, statusByPath]);
     const paletteMatches = paletteOpen
-        ? filterCommands(input, tab === "overview" ? undefined : tab).slice(0, 10)
+        ? searchActions(REGISTRY, input, mode)
         : [];
+    const paletteHighlight = paletteOpen
+        ? clampPickerCursor(paletteCursor ?? 0, paletteMatches.length)
+        : 0;
+    // Legacy inline `/` suggestions — kept as a power affordance, not taught.
+    const slashOpen = !sheet && !picker && !confirm && !paletteOpen && !switcherOpen && input.startsWith("/");
+    const slashMatches = slashOpen ? filterCommands(input).slice(0, 8) : [];
     useKeyboard((key) => {
         if (key.eventType === "release")
             return;
         const current = stateRef.current;
-        if (current.picker && (key.name === "up" || key.name === "down")) {
+        const arrow = matchArrow(key);
+        // Ctrl+C, Claude Code semantics: cancel the running turn (author) or the
+        // in-flight send (talk); otherwise clear typed input; on an idle empty
+        // prompt, quit. (exitOnCtrlC is off — the app owns this key.)
+        if (matchCtrlC(key)) {
+            key.preventDefault();
+            if (current.mode === "talk" && current.talkPending) {
+                cancelTalkSend();
+                return;
+            }
+            if (current.authorSession?.running) {
+                cancelAuthorTurn();
+                return;
+            }
+            if (current.mode === "talk" && current.composer) {
+                clearComposer();
+                setToast("Composer cleared — ^C again to quit");
+                return;
+            }
+            if (current.input) {
+                setInput("");
+                setToast("Input cleared — ^C again to quit");
+                return;
+            }
+            onQuit(0);
+            return;
+        }
+        if (arrow && current.picker) {
             const visible = filterPickerItems(current.picker.items, effectivePickerFilter(current.input));
             if (visible.length === 0)
                 return;
-            const delta = key.name === "down" ? 1 : -1;
+            const delta = arrow === "down" ? 1 : -1;
             setPicker({
                 ...current.picker,
                 cursor: clampPickerCursor(current.picker.cursor + delta, visible.length),
             });
             return;
         }
+        if (arrow && current.paletteCursor !== undefined) {
+            const matches = searchActions(REGISTRY, current.input, current.mode);
+            if (matches.length === 0)
+                return;
+            const delta = arrow === "down" ? 1 : -1;
+            setPaletteCursor(clampPickerCursor(current.paletteCursor + delta, matches.length));
+            return;
+        }
+        if (arrow && current.switcherCursor !== undefined) {
+            const delta = arrow === "down" ? 1 : -1;
+            setSwitcherCursor(clampPickerCursor(current.switcherCursor + delta, CONTEXT_ROWS.length));
+            return;
+        }
+        if (arrow && current.activityCursor !== undefined) {
+            const count = current.orderedOps.length;
+            if (count === 0)
+                return;
+            const delta = arrow === "down" ? 1 : -1;
+            setActivityCursor((c) => clampPickerCursor((c ?? 0) + delta, count));
+            return;
+        }
+        // Activity drawer quick actions — intercepted before the input sees them.
+        if (current.activityCursor !== undefined &&
+            !key.ctrl &&
+            !key.meta &&
+            (key.name === "r" || key.name === "c")) {
+            key.preventDefault();
+            const op = current.orderedOps[clampPickerCursor(current.activityCursor, current.orderedOps.length)];
+            if (!op)
+                return;
+            if (key.name === "r")
+                retryOperation(op);
+            else
+                copyOperationOutput(op);
+            return;
+        }
+        // Talk workbench keys (no modal open). Chords first — they work no matter
+        // what the composer holds; plain arrows belong to the textarea caret as
+        // soon as there is a draft.
+        const talkActive = current.mode === "talk" &&
+            !current.sheet &&
+            !current.confirm &&
+            !current.picker &&
+            current.paletteCursor === undefined &&
+            current.switcherCursor === undefined &&
+            current.activityCursor === undefined;
+        if (talkActive) {
+            if (matchNewThread(key)) {
+                key.preventDefault();
+                const cmd = SLASH_COMMANDS.find((c) => c.name === "new");
+                if (cmd)
+                    void runCommand(cmd, "");
+                return;
+            }
+            if (matchTalkTarget(key)) {
+                // The textarea's default ctrl+b is cursor-back — the target picker
+                // wins here (arrow keys cover cursor movement).
+                key.preventDefault();
+                const cmd = SLASH_COMMANDS.find((c) => c.name === "target");
+                if (cmd)
+                    void runCommand(cmd, "");
+                return;
+            }
+            if (matchTurnTrace(key)) {
+                key.preventDefault();
+                void inspectTurn("trace");
+                return;
+            }
+            if (matchTurnDebug(key)) {
+                // The textarea's default ctrl+d is delete-forward — ours wins.
+                key.preventDefault();
+                void inspectTurn("debug");
+                return;
+            }
+            if (current.composer.length === 0) {
+                const horizontal = matchHorizontal(key);
+                if (horizontal && current.talkLayout.threads) {
+                    key.preventDefault();
+                    setTalkFocus(horizontal === "left" ? "threads" : "chat");
+                    return;
+                }
+                if (arrow) {
+                    key.preventDefault();
+                    const delta = arrow === "down" ? 1 : -1;
+                    if (current.talkFocus === "threads") {
+                        const count = threadsRowCount(current.threads);
+                        setThreadCursor((c) => clampPickerCursor(c + delta, count));
+                    }
+                    else {
+                        if (current.chat.length === 0)
+                            return;
+                        setTalkCursor((c) => clampPickerCursor(c + delta, current.chat.length));
+                    }
+                    return;
+                }
+            }
+        }
+        // File-tree navigation in the diff/browse sidebar (no modal open).
+        if (arrow &&
+            !current.sheet &&
+            !current.confirm &&
+            current.mode === "author" &&
+            current.authorView === "diff" &&
+            !current.fileDiff) {
+            const rows = current.diffRows;
+            if (rows.length === 0)
+                return;
+            const delta = arrow === "down" ? 1 : -1;
+            setDiffCursor((c) => clampPickerCursor(c + delta, rows.length));
+            return;
+        }
+        // Session unit cursor (Author home): ↑↓ walk the work units; the pane
+        // follows the cursor. Enter (empty input) expands the selected unit.
+        if (arrow &&
+            !current.sheet &&
+            !current.confirm &&
+            !current.picker &&
+            current.paletteCursor === undefined &&
+            current.switcherCursor === undefined &&
+            current.activityCursor === undefined &&
+            current.mode === "author" &&
+            current.authorView === "home" &&
+            current.authorSession &&
+            current.authorSession.units.length > 0) {
+            const count = current.authorSession.units.length;
+            const delta = arrow === "down" ? 1 : -1;
+            setSessionCursor((c) => clampPickerCursor(c + delta, count));
+            return;
+        }
+        // Arrow-scroll the active content pane (expanded file diff, validation,
+        // versions) — the global input keeps focus, so we drive the scrollbox
+        // programmatically. Talk arrows select turns instead (handled above).
+        if (arrow &&
+            !current.sheet &&
+            !current.confirm &&
+            !current.picker &&
+            current.paletteCursor === undefined &&
+            current.switcherCursor === undefined &&
+            current.activityCursor === undefined &&
+            current.mode === "author" &&
+            ((current.authorView === "diff" && current.fileDiff) ||
+                current.authorView === "validation" ||
+                current.authorView === "versions")) {
+            contentScrollRef.current?.scrollBy({ x: 0, y: arrow === "down" ? 1 : -1 });
+            return;
+        }
+        // PgUp/PgDn page-scrolls whatever content pane is on screen (including
+        // the sidebar diff preview while arrows drive the file cursor).
+        const page = matchPage(key);
+        if (page &&
+            !current.sheet &&
+            !current.confirm &&
+            !current.picker &&
+            current.paletteCursor === undefined &&
+            current.switcherCursor === undefined &&
+            current.activityCursor === undefined) {
+            contentScrollRef.current?.scrollBy({ x: 0, y: page === "down" ? 10 : -10 });
+            return;
+        }
+        const jump = matchModeJump(key);
+        if (jump) {
+            const def = modeByIndex(jump);
+            if (def && !current.confirm) {
+                setMode(def.id);
+                setInput("");
+            }
+            return;
+        }
+        if (matchPalette(key)) {
+            if (current.confirm)
+                return;
+            if (current.paletteCursor !== undefined) {
+                setPaletteCursor(undefined);
+                setInput("");
+                return;
+            }
+            // Palette replaces any open picker/sheet (same as Esc first).
+            setPicker(undefined);
+            setSheet(undefined);
+            setSheetCommand(undefined);
+            setSwitcherCursor(undefined);
+            setActivityCursor(undefined);
+            setPaletteCursor(0);
+            setInput("");
+            return;
+        }
+        if (matchContext(key)) {
+            if (current.confirm)
+                return;
+            if (current.switcherCursor !== undefined) {
+                setSwitcherCursor(undefined);
+                return;
+            }
+            setPicker(undefined);
+            setSheet(undefined);
+            setSheetCommand(undefined);
+            setPaletteCursor(undefined);
+            setActivityCursor(undefined);
+            setSwitcherCursor(0);
+            setInput("");
+            return;
+        }
+        // ^J (or raw linefeed in legacy terminals) toggles the activity drawer.
+        // preventDefault keeps the input's linefeed-submit binding from firing —
+        // global handlers run before renderable handlers (InternalKeyHandler).
+        if (matchActivity(key)) {
+            key.preventDefault();
+            if (current.confirm || current.picker || current.sheet)
+                return;
+            if (current.activityCursor !== undefined) {
+                setActivityCursor(undefined);
+                return;
+            }
+            setPaletteCursor(undefined);
+            setSwitcherCursor(undefined);
+            setActivityCursor(0);
+            setInput("");
+            return;
+        }
         if (key.name === "tab") {
             if (current.picker) {
                 const visible = filterPickerItems(current.picker.items, effectivePickerFilter(current.input));
@@ -100,14 +961,28 @@ function App({ context: initialContext, initialScope, glyph, onQuit }) {
             }
             if (current.sheet) {
                 setSheet(moveFocus(current.sheet, key.shift ? -1 : 1));
+                return;
+            }
+            if (current.paletteCursor !== undefined) {
+                const matches = searchActions(REGISTRY, current.input, current.mode);
+                if (matches.length === 0)
+                    return;
+                setPaletteCursor(clampPickerCursor(current.paletteCursor + (key.shift ? -1 : 1), matches.length));
+                return;
+            }
+            if (current.switcherCursor !== undefined) {
+                setSwitcherCursor(clampPickerCursor(current.switcherCursor + (key.shift ? -1 : 1), CONTEXT_ROWS.length));
+                return;
             }
-            else if (!current.confirm) {
-                setTab((t) => (key.shift ? prevTab(t) : nextTab(t)));
+            if (current.activityCursor !== undefined)
+                return;
+            if (!current.confirm && matchModeToggle(key)) {
+                setMode((m) => otherMode(m));
                 setInput("");
             }
             return;
         }
-        if (key.name === "escape") {
+        if (matchEscape(key)) {
             if (current.confirm) {
                 setConfirm(undefined);
                 setToast("Cancelled");
@@ -120,7 +995,7 @@ function App({ context: initialContext, initialScope, glyph, onQuit }) {
                     setSheetCommand(current.picker.command);
                 }
                 setToast(wasPlaceOnboard
-                    ? "Continuing without a workspace — /workspace when ready"
+                    ? "Continuing without a workspace — pick one anytime (^G)"
                     : "Cancelled");
             }
             else if (current.sheet) {
@@ -128,17 +1003,42 @@ function App({ context: initialContext, initialScope, glyph, onQuit }) {
                 setSheetCommand(undefined);
                 setToast("Cancelled");
             }
-            else {
+            else if (current.paletteCursor !== undefined) {
+                setPaletteCursor(undefined);
                 setInput("");
             }
-            return;
-        }
-        if ((key.ctrl || key.meta) && /^[1-5]$/.test(key.name)) {
-            const def = tabByIndex(Number(key.name));
-            if (def) {
-                setTab(def.id);
+            else if (current.switcherCursor !== undefined) {
+                setSwitcherCursor(undefined);
+            }
+            else if (current.activityCursor !== undefined) {
+                setActivityCursor(undefined);
+            }
+            else if (current.mode === "author" && current.authorView !== "home") {
+                // Subview back-stack: file diff → file list → home.
+                if (current.fileDiff)
+                    setFileDiff(undefined);
+                else
+                    setAuthorView("home");
+            }
+            else if (current.mode === "author" && current.authorSession?.running) {
+                cancelAuthorTurn();
+            }
+            else if (current.mode === "talk" && current.inspectorFetch) {
+                setInspectorFetch(undefined);
+            }
+            else if (current.mode === "talk" && current.talkPending) {
+                cancelTalkSend();
+            }
+            else if (current.mode === "talk" && current.composer) {
+                clearComposer();
+            }
+            else if (current.mode === "talk" && current.talkFocus === "threads") {
+                setTalkFocus("chat");
+            }
+            else {
                 setInput("");
             }
+            return;
         }
     });
     async function applyResult(result) {
@@ -158,12 +1058,57 @@ function App({ context: initialContext, initialScope, glyph, onQuit }) {
         }
         if (result.toast)
             setToast(result.toast);
-        if (result.jumpTab)
-            setTab(result.jumpTab);
-        if (result.chat)
+        const jumpMode = modeForJumpTab(result.jumpTab);
+        if (jumpMode)
+            setMode(jumpMode);
+        if (result.chat) {
+            // Thread switch: park the old draft, restore the destination's, and
+            // discard whatever reply was still in flight for the old thread.
+            const previous = stateRef.current;
+            sendSeqRef.current += 1;
+            draftsRef.current.set(previous.threadId ?? "new", previous.composer);
+            const nextKey = result.threadId ?? (result.clearThread ? "new" : previous.threadId ?? "new");
+            const draft = draftsRef.current.get(nextKey) ?? "";
+            composerRef.current?.setText(draft);
+            setComposer(draft);
             setChat(result.chat);
-        if (result.threadId)
+            setTalkCursor(Math.max(0, result.chat.length - 1));
+            setTalkFocus("chat");
+            setInspectorFetch(undefined);
+            // An inline trace/debug overlay belongs to the previous conversation.
+            setPaneTitle((title) => {
+                if (title && /^(trace|debug)/i.test(title)) {
+                    setPaneLines([]);
+                    return undefined;
+                }
+                return title;
+            });
+            setWorking(false);
+        }
+        if (result.clearThread)
+            setThreadId(undefined);
+        if (result.talkTarget) {
+            const target = result.talkTarget;
+            if (target.kind === "local") {
+                setLocalMode(true);
+                setTalkTag(undefined);
+            }
+            else {
+                setLocalMode(false);
+                setTalkTag(target.kind === "bound"
+                    ? undefined
+                    : target.kind === "live"
+                        ? "latest"
+                        : target.tag);
+            }
+        }
+        if (result.threadId) {
             setThreadId(result.threadId);
+            // A thread the pane doesn't know yet → refresh the list lazily.
+            if (!stateRef.current.threads?.some((t) => t.id === result.threadId)) {
+                setThreads(undefined);
+            }
+        }
         if (result.paneLines) {
             setPaneLines(result.paneLines);
             setPaneTitle(result.paneTitle ?? "result");
@@ -175,11 +1120,19 @@ function App({ context: initialContext, initialScope, glyph, onQuit }) {
             const next = await refreshContext();
             setContext(next);
             setScope(scopeFromContext(next));
-            await maybeOfferPlace(next);
+            if (result.offerPlace) {
+                // Account switched somewhere without a workspace — offer the gate
+                // now regardless of whether one was offered at startup.
+                placeGateOffered.current = true;
+                await openPlaceOnboarding(next);
+            }
+            else {
+                await maybeOfferPlace(next);
+            }
         }
     }
-    async function openPlaceOnboarding() {
-        await openPick(PLACE_ONBOARD_COMMAND, "place-onboard");
+    async function openPlaceOnboarding(ctx) {
+        await openPick(PLACE_ONBOARD_COMMAND, "place-onboard", undefined, undefined, ctx);
     }
     async function maybeOfferPlace(ctx) {
         if (placeGateOffered.current)
@@ -188,11 +1141,11 @@ function App({ context: initialContext, initialScope, glyph, onQuit }) {
             placeGateOffered.current = true;
             return;
         }
-        // Logged-out: wait for /login (mount toast covers the hint).
+        // Logged-out: wait for login (mount toast covers the hint).
         if (!ctx.token)
             return;
         placeGateOffered.current = true;
-        await openPlaceOnboarding();
+        await openPlaceOnboarding(ctx);
     }
     useEffect(() => {
         if (hasPlace(initialContext)) {
@@ -200,24 +1153,323 @@ function App({ context: initialContext, initialScope, glyph, onQuit }) {
             return;
         }
         if (!initialContext.token) {
-            setToast("Not in a workspace · /login, then pick a place — Esc skips");
+            setToast("Not in a workspace · log in, then pick a place — Esc skips");
             return;
         }
         placeGateOffered.current = true;
         void openPlaceOnboarding();
         // Once on mount — placeGateOffered guards re-entry.
     }, []);
+    async function refreshSnapshot() {
+        setSnapshot(await loadAuthorSnapshot(stateRef.current.context));
+    }
+    /** Context lines for push/pull sheets — state the operation will act on. */
+    function sheetInfoFor(name) {
+        const { scope: s, snapshot: snap, validation: v } = stateRef.current;
+        if (name !== "push" && name !== "pull")
+            return undefined;
+        const target = `target   ${s.agent}${s.version !== "—" ? ` @ ${s.version}` : ""} · ${s.env}`;
+        if (name === "pull") {
+            const total = changeEntries(snap?.diff).length;
+            return [
+                target,
+                total === 0
+                    ? "local    clean — safe to pull"
+                    : `! local    ${changesSummary(snap?.diff)} uncommitted — pull will refuse without force`,
+            ];
+        }
+        const lines = [
+            target,
+            `changes  ${changesSummary(snap?.diff)}${snap?.baselineTag ? ` vs baseline ${snap.baselineTag}` : ""}`,
+        ];
+        if (!v) {
+            lines.push("! validation not run — push validates before upload");
+        }
+        else {
+            const errors = v.result.findings.filter((f) => f.level !== "warning").length;
+            if (errors > 0 || !v.result.valid) {
+                lines.push(`! validation ✕ ${errors} error(s) — push will fail until fixed`);
+            }
+            else if (v.stale) {
+                lines.push(`! validation ✓ but stale — files changed since ${relativeTime(v.at)}`);
+            }
+            else {
+                lines.push(`validation ✓ ${relativeTime(v.at)}`);
+            }
+        }
+        return lines;
+    }
+    /** Fetch local + remote contents backing the diff content panes. */
+    async function loadDiffFiles() {
+        const ctx = stateRef.current.context;
+        const tag = ctx.versionTag ?? "";
+        setDiffFiles({ status: "loading" });
+        try {
+            const local = await readLocalFiles(ctx);
+            let remote = remoteFilesRef.current;
+            if (remote?.tag !== tag) {
+                try {
+                    const files = await fetchRemoteFiles(ctx, createClients(ctx).management);
+                    remote = { tag, files };
+                    remoteFilesRef.current = remote;
+                }
+                catch (error) {
+                    // Local side is still useful (tree + plain previews) — degrade.
+                    setDiffFiles({
+                        status: "ready",
+                        local,
+                        remote: {},
+                        tag,
+                        remoteError: error instanceof Error ? error.message : String(error),
+                    });
+                    return;
+                }
+            }
+            setDiffFiles({ status: "ready", local, remote: remote.files, tag });
+        }
+        catch (error) {
+            setDiffFiles({
+                status: "error",
+                message: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+    function openDiffView() {
+        const current = stateRef.current;
+        const agentHere = current.scope.agent !== "—";
+        const root = bundleSrcRoot(current.context) ?? current.context.workspaceRoot;
+        if (!agentHere && !root) {
+            setToast("Nothing to browse — enter a workspace or pick an agent (^G)");
+            return false;
+        }
+        setFileDiff(undefined);
+        setDiffCursor(0);
+        setPreviewPath(undefined);
+        setMode("author");
+        setAuthorView("diff");
+        if (agentHere) {
+            void refreshSnapshot();
+            void loadDiffFiles();
+        }
+        // Workspace level: the browse-listing effect walks the place's files.
+        return true;
+    }
+    function toggleDiffStyle() {
+        const next = stateRef.current.diffStyleEffective === "split" ? "unified" : "split";
+        setDiffStyle(next);
+        setToast(`diff style: ${next}`);
+    }
+    // --- Operation tracking (TUI_DESIGN §13): real work lands in the store ---
+    /** Start a tracked operation for whitelisted commands; else undefined. */
+    function trackOperation(name, retry) {
+        if (!isOperationCommand(name))
+            return undefined;
+        const agent = stateRef.current.scope.agent;
+        return operationStore.start(name, agent !== "—" ? `${name} · ${agent}` : name, retry);
+    }
+    function finishOperation(id, result) {
+        if (id === undefined)
+            return;
+        const output = result.paneLines ?? (result.toast ? [result.toast] : []);
+        if (result.error)
+            operationStore.fail(id, result.error, output);
+        else {
+            operationStore.succeed(id, result.toast ?? result.paneLines?.[0], output);
+        }
+    }
+    function failOperation(id, error) {
+        if (id === undefined)
+            return;
+        operationStore.fail(id, error instanceof Error ? error.message : String(error));
+    }
+    function retryOperation(op) {
+        if (op.status !== "failed") {
+            setToast("Only failed operations retry — re-run via ^K");
+            return;
+        }
+        const retry = op.retry;
+        if (!retry) {
+            setToast("This operation can't be retried (needs confirmation)");
+            return;
+        }
+        setActivityCursor(undefined);
+        if (retry.mode === "validate") {
+            void runStructuredValidate();
+            return;
+        }
+        const command = SLASH_COMMANDS.find((c) => c.name === retry.name);
+        if (!command) {
+            setToast(`Unknown command: ${retry.name}`);
+            return;
+        }
+        if (retry.mode === "simple") {
+            void runCommand(command, retry.args);
+            return;
+        }
+        runSheetOp(command, retry.values);
+    }
+    function copyOperationOutput(op) {
+        const text = [op.title, op.detail ?? "", ...op.output]
+            .filter(Boolean)
+            .join("\n");
+        void copyToClipboard(text).then(() => setToast("Output copied to clipboard"), (error) => setToast(error instanceof Error ? error.message : String(error)));
+    }
+    async function runStructuredValidate() {
+        setWorking(true);
+        const opId = trackOperation("validate", { mode: "validate" });
+        try {
+            const ctx = stateRef.current.context;
+            const record = await runValidationRecord(ctx, createClients(ctx).runtime);
+            setValidation(record);
+            if (opId !== undefined) {
+                const errors = record.result.findings.filter((f) => f.level !== "warning").length;
+                const lines = record.result.findings.map((f) => `${(f.level ?? "error").toUpperCase()} ${f.file ?? f.code ?? f.path ?? ""} ${f.message}`);
+                // CI semantics: findings-with-errors is a red operation.
+                if (record.result.valid && errors === 0) {
+                    operationStore.succeed(opId, validationSummary(record), lines);
+                }
+                else {
+                    operationStore.fail(opId, validationSummary(record), lines);
+                }
+            }
+            setMode("author");
+            setAuthorView("validation");
+        }
+        catch (error) {
+            failOperation(opId, error);
+            setToast(error instanceof Error ? error.message : String(error));
+        }
+        finally {
+            setWorking(false);
+        }
+    }
+    async function openVersionsView() {
+        setWorking(true);
+        try {
+            const ctx = stateRef.current.context;
+            const page = await listVersions(ctx, createClients(ctx).management);
+            setVersions(page.results);
+            setMode("author");
+            setAuthorView("versions");
+        }
+        catch (error) {
+            setToast(error instanceof Error ? error.message : String(error));
+        }
+        finally {
+            setWorking(false);
+        }
+    }
+    /**
+     * Author copilot turn (Phase 5): free text on the Author home becomes a
+     * backend turn against the current checkout. The turn is a durable
+     * operation; file truth stays with the watcher (changes card updates as
+     * the backend saves), never with backend-reported edits.
+     */
+    async function startAuthorTurn(text) {
+        const current = stateRef.current;
+        if (current.authorSession?.running) {
+            // Never eat a message: queue it, visible in the transcript, sent
+            // in order when this turn finishes.
+            setQueuedPrompts((q) => [...q, text]);
+            setToast("Queued — sends when this turn finishes (Esc drops it)");
+            return;
+        }
+        const detection = current.backendDetection;
+        if (!detection?.available) {
+            setToast(detection?.reason ?? `${authorBackend.label} not detected — checking…`);
+            return;
+        }
+        const checkoutDir = agentRootOf(current.context);
+        if (!checkoutDir) {
+            setToast("No agent checkout — ^G to pick an agent");
+            return;
+        }
+        const agent = current.scope.agent;
+        const opId = operationStore.start("author-turn", `author · ${authorBackend.label}${agent !== "—" ? ` · ${agent}` : ""}`);
+        turnOpIdRef.current = opId;
+        turnFeedRef.current = [`you: ${text}`];
+        // Append the prompt to the running transcript (multi-turn session).
+        setAuthorSession((s) => sessionPrompt(s ?? sessionCreate(authorBackend.label), text));
+        const sessions = await loadSessions();
+        const handle = authorBackend.startTurn({
+            checkoutDir,
+            text,
+            ...(sessions[checkoutDir] ? { sessionId: sessions[checkoutDir] } : {}),
+            onEvent: (raw) => {
+                // Stale guard: cancelled/superseded turns stop touching state.
+                if (turnOpIdRef.current !== opId)
+                    return;
+                // Checkout-relative paths in tool lines — shorter, wrap-proof.
+                const event = relativizeEvent(raw, checkoutDir);
+                setAuthorSession((s) => (s ? sessionEvent(s, event) : s));
+                switch (event.type) {
+                    case "text":
+                        turnFeedRef.current.push(...event.text.split("\n"));
+                        break;
+                    case "action": {
+                        const label = `${event.label}${event.detail ? ` — ${event.detail}` : ""}`;
+                        turnFeedRef.current.push(`⚙ ${label}`);
+                        operationStore.progress(opId, label);
+                        break;
+                    }
+                    case "text-delta":
+                    case "thinking-delta":
+                    case "action-start":
+                    case "action-result":
+                        break; // rendered via the session; the feed keeps complete blocks
+                    case "done":
+                        turnHandleRef.current = undefined;
+                        turnOpIdRef.current = undefined;
+                        operationStore.succeed(opId, event.summary ?? "turn complete", [
+                            ...turnFeedRef.current,
+                        ]);
+                        if (event.sessionId)
+                            void saveSession(checkoutDir, event.sessionId);
+                        void loadAuthorSnapshot(stateRef.current.context).then(setSnapshot);
+                        break;
+                    case "error":
+                        turnHandleRef.current = undefined;
+                        turnOpIdRef.current = undefined;
+                        turnFeedRef.current.push(`✕ ${event.message}`);
+                        operationStore.fail(opId, event.message, [...turnFeedRef.current]);
+                        break;
+                }
+            },
+        });
+        turnHandleRef.current = handle;
+    }
+    /** Esc while a turn runs: SIGTERM the backend, mark everything cancelled. */
+    function cancelAuthorTurn() {
+        const opId = turnOpIdRef.current;
+        turnOpIdRef.current = undefined; // stale-guard: adapter's exit event is ignored
+        turnHandleRef.current?.cancel();
+        turnHandleRef.current = undefined;
+        setAuthorSession((s) => (s ? sessionCancel(s) : s));
+        if (opId !== undefined) {
+            operationStore.fail(opId, "Cancelled", [...turnFeedRef.current]);
+        }
+        // Cancelling bails on the whole intent — queued follow-ups go with it.
+        const queued = stateRef.current.queuedPrompts.length;
+        setQueuedPrompts([]);
+        setToast(queued > 0
+            ? `Turn cancelled — ${queued} queued message(s) dropped`
+            : "Turn cancelled");
+    }
     function ensureAuth(command) {
-        if (!command.requiresAuth || scope.loggedIn)
+        if (!command.requiresAuth || stateRef.current.scope.loggedIn)
             return true;
-        setToast("Login required — run /login");
-        setInput("/login");
+        const login = SLASH_COMMANDS.find((c) => c.name === "login");
+        if (login?.fields) {
+            setSheet(createSheet(login.name, login.fields));
+            setSheetCommand(login);
+        }
+        setToast("Log in first");
         return false;
     }
-    async function openPick(command, kind, sheetModel, sheetField) {
+    async function openPick(command, kind, sheetModel, sheetField, contextOverride) {
         setWorking(true);
         try {
-            const items = await loadPickerCatalog(kind, stateRef.current.context);
+            const items = await loadPickerCatalog(kind, contextOverride ?? stateRef.current.context);
             if (items.length === 0) {
                 setToast(`No ${kind} options`);
                 return;
@@ -227,6 +1479,8 @@ function App({ context: initialContext, initialScope, glyph, onQuit }) {
                 return;
             }
             setSheet(undefined);
+            setPaletteCursor(undefined);
+            setSwitcherCursor(undefined);
             setPicker({
                 command,
                 items,
@@ -255,7 +1509,8 @@ function App({ context: initialContext, initialScope, glyph, onQuit }) {
             setToast(`Selected ${id}`);
             return;
         }
-        if (command.destructive && (command.name === "version-publish" || command.name === "version-archive")) {
+        if (command.destructive &&
+            (command.name === "version-publish" || command.name === "version-archive")) {
             setConfirm(createConfirm(command.name, "yes", command.name, { id }));
             return;
         }
@@ -271,24 +1526,42 @@ function App({ context: initialContext, initialScope, glyph, onQuit }) {
         }
     }
     async function runCommand(command, args) {
-        if (command.jumpTab) {
-            setTab(command.jumpTab);
-            setToast(`Opened ${command.jumpTab}`);
-            return;
-        }
         if (command.name === "help") {
-            setPaneTitle("help");
-            setPaneLines(helpLines());
-            setTab("overview");
-            setToast("Help — see pane");
+            setPaletteCursor(0);
+            setInput("");
             return;
         }
         if (command.name === "quit") {
             onQuit(0);
             return;
         }
+        if (command.name === "activity") {
+            setActivityCursor((c) => (c === undefined ? 0 : undefined));
+            return;
+        }
+        // Structured diff view is local-first; works logged out (content diff
+        // fetches will surface their own auth errors).
+        if (command.name === "diff" && !args.trim()) {
+            openDiffView();
+            return;
+        }
+        if (command.name === "diff-style") {
+            const current = stateRef.current;
+            const inDiffView = current.mode === "author" && current.authorView === "diff";
+            if (inDiffView || openDiffView())
+                toggleDiffStyle();
+            return;
+        }
         if (!ensureAuth(command))
             return;
+        if (command.name === "validate") {
+            await runStructuredValidate();
+            return;
+        }
+        if (command.name === "versions") {
+            await openVersionsView();
+            return;
+        }
         if (command.name === "trace") {
             setTrace((v) => {
                 setToast(`trace ${v ? "off" : "on"}`);
@@ -298,11 +1571,19 @@ function App({ context: initialContext, initialScope, glyph, onQuit }) {
         }
         if (command.name === "local") {
             setLocalMode((v) => {
-                setToast(`local mode ${v ? "off" : "on"}`);
+                setToast(v
+                    ? "local bundle off — replies run the published version"
+                    : "local bundle on — replies run this checkout");
                 return !v;
             });
             return;
         }
+        // Turn diagnostics land in the inspector (^T/^D reach here too).
+        if (command.name === "turn-trace" || command.name === "turn-debug") {
+            setMode("talk");
+            await inspectTurn(command.name === "turn-trace" ? "trace" : "debug");
+            return;
+        }
         const confirmSpec = destructiveSpec(command.name, stateRef.current.context);
         if (confirmSpec && !command.pick) {
             setConfirm(createConfirm(confirmSpec.title, confirmSpec.phrase, confirmSpec.action, confirmSpec.args));
@@ -326,7 +1607,7 @@ function App({ context: initialContext, initialScope, glyph, onQuit }) {
             return;
         }
         if (command.fields?.length) {
-            let model = createSheet(command.name, command.fields);
+            let model = createSheet(command.name, command.fields, sheetInfoFor(command.name));
             if (args)
                 model = setFocusedValue(model, args);
             setSheet(model);
@@ -338,16 +1619,50 @@ function App({ context: initialContext, initialScope, glyph, onQuit }) {
             return;
         }
         setWorking(true);
+        const opId = trackOperation(command.name, {
+            mode: "simple",
+            name: command.name,
+            args,
+        });
         try {
-            await applyResult(await runSimpleCommand(command.name, stateRef.current.context, args));
+            const result = await runSimpleCommand(command.name, 
+            // Chat commands (`new` creates threads) run under the talk target so
+            // a pinned tag or forced live applies to them too.
+            command.group === "chat" ? talkContext() : stateRef.current.context, args);
+            finishOperation(opId, result);
+            await applyResult(result);
         }
         catch (error) {
+            failOperation(opId, error);
             setToast(error instanceof Error ? error.message : String(error));
         }
         finally {
             setWorking(false);
         }
     }
+    /** Sheet-backed action run — used by sheet submit and drawer retry. */
+    function runSheetOp(command, values) {
+        void (async () => {
+            setWorking(true);
+            const opId = trackOperation(command.name, {
+                mode: "sheet",
+                name: command.name,
+                values,
+            });
+            try {
+                const result = await runSheetAction(command.name, values, stateRef.current.context);
+                finishOperation(opId, result);
+                await applyResult(result);
+            }
+            catch (err) {
+                failOperation(opId, err);
+                setToast(err instanceof Error ? err.message : String(err));
+            }
+            finally {
+                setWorking(false);
+            }
+        })();
+    }
     function submitSheet(model, command) {
         const error = validateSheet(model);
         if (error) {
@@ -364,18 +1679,7 @@ function App({ context: initialContext, initialScope, glyph, onQuit }) {
             }
             return;
         }
-        void (async () => {
-            setWorking(true);
-            try {
-                await applyResult(await runSheetAction(command.name, model.values, stateRef.current.context));
-            }
-            catch (err) {
-                setToast(err instanceof Error ? err.message : String(err));
-            }
-            finally {
-                setWorking(false);
-            }
-        })();
+        runSheetOp(command, model.values);
     }
     async function handleSheetLine(model, command, line) {
         if (line === "+" || line.toLowerCase() === "advanced") {
@@ -437,53 +1741,219 @@ function App({ context: initialContext, initialScope, glyph, onQuit }) {
             }
         }
     }
-    async function sendChat(text) {
-        setChat((c) => [...c, { role: "you", text }]);
-        if (!scope.loggedIn) {
-            setChat((c) => [...c, { role: "system", text: "Not logged in · Run /login" }]);
+    function clearComposer() {
+        composerRef.current?.setText("");
+        setComposer("");
+    }
+    /**
+     * The context sends actually run under: the session talk target overrides
+     * the bound tag ("latest" forces live resolution by dropping the pin).
+     */
+    function talkContext() {
+        const { context: ctx, talkTag: tag } = stateRef.current;
+        if (!tag)
+            return ctx;
+        if (tag === "latest") {
+            // No pin → version resolution falls to the live version.
+            return { ...ctx, versionTag: undefined };
+        }
+        return { ...ctx, versionTag: tag };
+    }
+    /** Client-side cancel: the API has no abort, so the reply is discarded. */
+    function cancelTalkSend() {
+        sendSeqRef.current += 1;
+        setChat((c) => cancelSend(c, Date.now()));
+        setWorking(false);
+        setToast("Cancelled — the reply is discarded when it arrives");
+    }
+    /**
+     * Honest pending: optimistic user turn + a waiting placeholder that shows
+     * real elapsed time — the messaging API is request/response, so there is
+     * no token streaming to fake (TUI_DESIGN §9.5).
+     */
+    async function sendTalkMessage(text) {
+        const current = stateRef.current;
+        const reason = composerDisabledReason(current.scope, current.localMode, current.scope.agentPath);
+        if (reason) {
+            setToast(`Can’t send — ${reason}`);
+            return;
+        }
+        if (current.talkPending) {
+            setToast("Waiting for the reply — Esc cancels it first");
             return;
         }
+        const seq = ++sendSeqRef.current;
+        const startedAt = Date.now();
+        setChat((c) => beginSend(c, text, startedAt));
+        setTalkFocus("chat");
         setWorking(true);
         try {
-            const clients = createClients(stateRef.current.context);
-            const result = await sendMessage(stateRef.current.context, clients.runtime, {
+            // Session talk target applied: pinned tag or forced live.
+            const ctx = talkContext();
+            const clients = createClients(ctx);
+            const local = Boolean(current.localMode && ctx.agentRoot);
+            // The runtime needs an explicit version id (bound tag, else the live
+            // version) — it does not resolve tags itself. Local mode skips this:
+            // the inline bundle carries the program.
+            const versionId = local
+                ? undefined
+                : await resolveSendVersion(ctx, clients.management);
+            const result = await sendMessage(ctx, clients.runtime, {
                 text,
-                ...(threadId ? { threadId } : {}),
+                ...(versionId ? { versionId } : {}),
+                ...(current.threadId ? { threadId: current.threadId } : {}),
                 includeTrace: true,
-                ...(localMode && stateRef.current.context.agentRoot
-                    ? { localDir: stateRef.current.context.agentRoot }
-                    : {}),
-                variables: vars,
+                ...(local && ctx.agentRoot ? { localDir: ctx.agentRoot } : {}),
+                variables: current.vars,
             });
-            if (result.thread_id)
+            if (seq !== sendSeqRef.current)
+                return; // cancelled or superseded
+            if (result.thread_id) {
                 setThreadId(result.thread_id);
-            const reply = result.message.text ?? JSON.stringify(result);
-            setChat((c) => [
-                ...c,
-                {
-                    role: "agent",
-                    text: reply,
-                    messageId: result.message.id,
-                    interactionId: result.message.id,
-                    ...(result.message.trace_info
-                        ? { trace: result.message.trace_info }
+                if (!current.threads?.some((t) => t.id === result.thread_id)) {
+                    setThreads(undefined); // pane learns the new thread lazily
+                }
+            }
+            const message = result.message;
+            const tokens = message.input_tokens !== undefined || message.output_tokens !== undefined
+                ? {
+                    ...(message.input_tokens !== undefined
+                        ? { input: message.input_tokens }
+                        : {}),
+                    ...(message.output_tokens !== undefined
+                        ? { output: message.output_tokens }
                         : {}),
-                },
-            ]);
+                }
+                : undefined;
+            setChat((c) => settleSend(c, {
+                role: "agent",
+                text: message.text ?? JSON.stringify(result),
+                messageId: message.id,
+                interactionId: message.id,
+                ...(message.trace_info ? { trace: message.trace_info } : {}),
+                at: Date.now(),
+                durationMs: Date.now() - startedAt,
+                ...(tokens ? { tokens } : {}),
+            }));
         }
         catch (error) {
-            setChat((c) => [
-                ...c,
-                {
-                    role: "system",
-                    text: error instanceof Error ? error.message : String(error),
-                },
-            ]);
+            if (seq !== sendSeqRef.current)
+                return;
+            setChat((c) => settleSend(c, {
+                role: "system",
+                text: error instanceof Error ? error.message : String(error),
+                at: Date.now(),
+            }));
+            // Failed sends keep the message for a retry (unless a new draft began).
+            if (!stateRef.current.composer) {
+                composerRef.current?.setText(text);
+                setComposer(text);
+            }
+            setToast("Send failed — message kept in the composer");
+        }
+        finally {
+            if (seq === sendSeqRef.current)
+                setWorking(false);
+        }
+    }
+    /**
+     * ^T/^D — diagnostics for the selected turn, attached where they belong:
+     * the inspector pane when it fits, the inline overlay otherwise. A
+     * non-agent selection falls back to the newest reply (and moves to it).
+     */
+    async function inspectTurn(kind) {
+        const current = stateRef.current;
+        const cursor = clampPickerCursor(current.talkCursor, current.chat.length);
+        let target = cursor;
+        let ordinal = agentOrdinal(current.chat, cursor);
+        if (ordinal === undefined) {
+            target = lastAgentTurnIndex(current.chat);
+            if (target < 0) {
+                setToast("No agent replies yet — send a message first");
+                return;
+            }
+            ordinal = agentOrdinal(current.chat, target);
+        }
+        setWorking(true);
+        try {
+            const result = await chatOverlay(kind, current.chat, current.threadId, current.context, ordinal !== undefined ? String(ordinal) : undefined);
+            if (result.error) {
+                setToast(result.error);
+                return;
+            }
+            if (current.talkLayout.inspector) {
+                setMode("talk");
+                if (target !== cursor)
+                    setTalkCursor(target);
+                setInspectorFetch({ turn: target, kind, lines: result.paneLines ?? [] });
+                setToast(`${kind} · reply #${ordinal ?? "?"} → inspector`);
+            }
+            else {
+                await applyResult(result); // narrow terminals: inline overlay
+            }
+        }
+        catch (error) {
+            setToast(error instanceof Error ? error.message : String(error));
         }
         finally {
             setWorking(false);
         }
     }
+    /** Enter in the composer: threads focus opens; otherwise send the draft. */
+    function handleComposerSend() {
+        const current = stateRef.current;
+        if (current.talkFocus === "threads") {
+            const count = threadsRowCount(current.threads);
+            const row = clampPickerCursor(current.threadCursor, count);
+            if (row === NEW_THREAD_ROW) {
+                const cmd = SLASH_COMMANDS.find((c) => c.name === "new");
+                if (cmd)
+                    void runCommand(cmd, "");
+                return;
+            }
+            const picked = current.threads?.[row - 1];
+            if (picked)
+                void openThread(picked.id);
+            return;
+        }
+        const text = (composerRef.current?.plainText ?? "").trim();
+        if (!text)
+            return;
+        clearComposer();
+        void sendTalkMessage(text);
+    }
+    async function openThread(id) {
+        setWorking(true);
+        try {
+            await applyResult(await applyPick("thread", id, stateRef.current.context));
+        }
+        catch (error) {
+            setToast(error instanceof Error ? error.message : String(error));
+        }
+        finally {
+            setWorking(false);
+        }
+    }
+    function runLine(line) {
+        const named = line.slice(1);
+        const { command, args } = resolveCommand(line);
+        if (command) {
+            void runCommand(command, args);
+            return;
+        }
+        const aliasName = named.split(/\s+/)[0] ?? "";
+        if (OLD_NAV_NAMES.has(aliasName.toLowerCase())) {
+            setToast("Navigation: Tab or ^1 Author / ^2 Talk");
+            return;
+        }
+        const action = actionByAlias(REGISTRY, aliasName);
+        if (action) {
+            const rest = named.slice(aliasName.length).trim();
+            void runCommand(action.command, rest);
+            return;
+        }
+        setToast("Unknown command — ^K to browse actions");
+    }
     function handleSubmit(raw) {
         const line = raw.trim();
         setInput("");
@@ -496,10 +1966,16 @@ function App({ context: initialContext, initialScope, glyph, onQuit }) {
                 setConfirm(undefined);
                 void (async () => {
                     setWorking(true);
+                    // Destructive ops are tracked but never offered a retry — a rerun
+                    // must go back through the typed confirmation.
+                    const opId = trackOperation(spec.action);
                     try {
-                        await applyResult(await runDestructive(spec.action, current.context, spec.args ?? {}));
+                        const result = await runDestructive(spec.action, current.context, spec.args ?? {});
+                        finishOperation(opId, result);
+                        await applyResult(result);
                     }
                     catch (error) {
+                        failOperation(opId, error);
                         setToast(error instanceof Error ? error.message : String(error));
                     }
                     finally {
@@ -548,50 +2024,179 @@ function App({ context: initialContext, initialScope, glyph, onQuit }) {
             void handleSheetLine(current.sheet, current.sheetCommand, line);
             return;
         }
-        if (line.startsWith("/")) {
-            const { command, args } = resolveCommand(line);
-            if (!command) {
-                setToast("Unknown command — try /help");
-                setInput("/");
+        if (current.paletteCursor !== undefined) {
+            const matches = searchActions(REGISTRY, line, current.mode);
+            if (matches.length === 0) {
+                setToast("No matching actions");
                 return;
             }
-            void runCommand(command, args);
+            const highlight = clampPickerCursor(current.paletteCursor, matches.length);
+            const action = matches[highlight];
+            const reason = action.disabledReason?.(current.context);
+            setPaletteCursor(undefined);
+            if (reason && !action.command.requiresAuth) {
+                // Auth gaps route to login via ensureAuth; other gaps just explain.
+                setToast(`${action.title} — ${reason}`);
+                return;
+            }
+            void runCommand(action.command, "");
             return;
         }
-        if (line === "")
-            return;
-        if (current.tab === "chat") {
-            const overlay = /^[td](?:\s+(\d+))?$/i.exec(line);
-            if (overlay) {
-                const kind = line[0].toLowerCase() === "d" ? "debug" : "trace";
-                void (async () => {
-                    setWorking(true);
-                    try {
-                        await applyResult(await chatOverlay(kind, chat, threadId, current.context, overlay[1]));
-                    }
-                    catch (error) {
-                        setToast(error instanceof Error ? error.message : String(error));
-                    }
-                    finally {
-                        setWorking(false);
-                    }
-                })();
+        if (current.switcherCursor !== undefined) {
+            const row = CONTEXT_ROWS[clampPickerCursor(current.switcherCursor, CONTEXT_ROWS.length)];
+            setSwitcherCursor(undefined);
+            if (!row)
                 return;
+            const command = SLASH_COMMANDS.find((c) => c.name === row.id);
+            if (command)
+                void runCommand(command, "");
+            return;
+        }
+        // Activity drawer: Enter retries the highlighted failed operation.
+        if (current.activityCursor !== undefined) {
+            const op = current.orderedOps[clampPickerCursor(current.activityCursor, current.orderedOps.length)];
+            if (op && line === "") {
+                if (op.status === "failed" && op.retry)
+                    retryOperation(op);
+                else
+                    setToast("r retry (failed) · c copy output · Esc close");
+            }
+            return;
+        }
+        if (line.startsWith("/")) {
+            runLine(line);
+            return;
+        }
+        // Enter in the file tree: toggle a dir, or expand a file full-width.
+        if (line === "" &&
+            current.mode === "author" &&
+            current.authorView === "diff" &&
+            !current.fileDiff) {
+            const rows = current.diffRows;
+            const row = rows[clampPickerCursor(current.diffCursor, rows.length)];
+            if (row?.kind === "dir") {
+                setDiffCollapsed((prev) => {
+                    const next = new Set(prev);
+                    if (next.has(row.path))
+                        next.delete(row.path);
+                    else
+                        next.add(row.path);
+                    return next;
+                });
+            }
+            else if (row) {
+                setPreviewPath(row.path);
+                setFileDiff({ path: row.path });
+            }
+            return;
+        }
+        // Enter on a session unit: expand/collapse its body (tool input/result).
+        if (line === "" &&
+            current.mode === "author" &&
+            current.authorView === "home" &&
+            current.authorSession) {
+            const units = current.authorSession.units;
+            const unit = units[clampPickerCursor(current.sessionCursor, units.length)];
+            if (unit &&
+                unit.body.length > 0 &&
+                (unit.kind === "action" || unit.kind === "thinking")) {
+                setSessionExpanded((prev) => {
+                    const next = new Set(prev);
+                    if (next.has(unit.id))
+                        next.delete(unit.id);
+                    else
+                        next.add(unit.id);
+                    return next;
+                });
             }
-            void sendChat(line);
             return;
         }
-        setToast("Type / for commands, or use the Chat tab to message the agent");
+        if (line === "")
+            return;
+        // `s` toggles the diff style (split ↔ unified) while in the diff view.
+        if (current.mode === "author" &&
+            current.authorView === "diff" &&
+            line.toLowerCase() === "s") {
+            toggleDiffStyle();
+            return;
+        }
+        // Talk mode never reaches here without an overlay — the composer owns
+        // sending, and ^T/^D/^N replaced the old typed t/d lines.
+        // Author mode: single-letter quick actions; free text on the home
+        // screen is a copilot turn (Phase 5); elsewhere it points at ^K.
+        const quick = AUTHOR_QUICK[line.toLowerCase()];
+        if (quick) {
+            const command = SLASH_COMMANDS.find((c) => c.name === quick);
+            if (command)
+                void runCommand(command, "");
+            return;
+        }
+        if (line === "?" || line.toLowerCase() === "h") {
+            setPaletteCursor(0);
+            return;
+        }
+        if (current.authorView === "home" &&
+            current.scope.loggedIn &&
+            current.scope.agent !== "—") {
+            void startAuthorTurn(line);
+            return;
+        }
+        setToast("^K actions · v/d/p/l/r/o quick · Tab to Talk");
     }
+    /** Talk owns the bottom surface unless an overlay borrows the line input. */
+    const talkComposerActive = mode === "talk" &&
+        !confirm &&
+        !picker &&
+        !sheet &&
+        !paletteOpen &&
+        !switcherOpen &&
+        !activityOpen;
+    const focus = confirm
+        ? "confirm"
+        : picker
+            ? "picker"
+            : sheet
+                ? "sheet"
+                : paletteOpen
+                    ? "palette"
+                    : switcherOpen
+                        ? "context"
+                        : activityOpen
+                            ? "activity"
+                            : mode === "author" && authorViewEffective !== "home"
+                                ? AUTHOR_VIEW_FOCUS[authorViewEffective]
+                                : mode === "talk" && talkFocus === "threads"
+                                    ? "talk-threads"
+                                    : mode;
     const placeholder = confirm
         ? `type "${confirm.phrase}" to confirm · Esc cancel`
         : picker
             ? "filter · ↑↓ move · Enter select · Esc cancel"
-            : tab === "chat"
-                ? "message · t/d trace/debug last reply · / commands"
-                : sheet
-                    ? "value · Enter next · + advanced · Esc cancel"
-                    : "/ for commands · Tab switches tabs";
+            : sheet
+                ? "value · Enter next · + advanced · Esc cancel"
+                : paletteOpen
+                    ? "search actions…"
+                    : switcherOpen
+                        ? "↑↓ rows · Enter change · Esc close"
+                        : activityOpen
+                            ? "↑↓ move · r retry failed · c copy output · Esc close"
+                            : authorViewEffective === "diff"
+                                ? fileDiff
+                                    ? "↑↓/PgUp/PgDn scroll · Esc back to tree"
+                                    : "↑↓ tree · Enter open/toggle · s split/unified · PgUp/PgDn scroll · Esc"
+                                : authorViewEffective === "validation"
+                                    ? "v re-run · ↑↓ scroll · p push · Esc back"
+                                    : authorViewEffective === "versions"
+                                        ? "↑↓ scroll · publish/archive via ^K · Esc back"
+                                        : authorSession?.running
+                                            ? "type to queue a follow-up · ↑↓ units · Esc/^C cancel"
+                                            : authorSession
+                                                ? "describe the next change · ↑↓ units · Enter expand"
+                                                : backendDetection?.available &&
+                                                    scope.loggedIn &&
+                                                    hasAgent
+                                                    ? `describe a change for ${authorBackend.label} · v d p l r o quick · ^K`
+                                                    : "v d p l r o quick actions · ^K all actions";
     const pickerFilter = picker ? effectivePickerFilter(input) : undefined;
     const pickerVisible = picker
         ? filterPickerItems(picker.items, pickerFilter)
@@ -605,15 +2210,36 @@ function App({ context: initialContext, initialScope, glyph, onQuit }) {
         ? 0
         : Math.max(0, Math.min(pickerCursor - Math.floor(PICKER_PAGE / 3), pickerVisible.length - PICKER_PAGE));
     const pickerWindow = pickerVisible.slice(pickerWindowStart, pickerWindowStart + PICKER_PAGE);
-    const modalOpen = Boolean(picker || confirm || sheet);
-    return (_jsxs("box", { style: { flexDirection: "column", flexGrow: 1, paddingLeft: 1, paddingRight: 1 }, children: [_jsx(TabBar, { active: tab }), _jsx("box", { style: { flexDirection: "column", flexGrow: 1, paddingTop: 1 }, children: picker ? (_jsx(PickerPane, { items: pickerWindow, cursor: pickerCursor, windowStart: pickerWindowStart, total: pickerVisible.length, title: picker.command.name, filter: pickerFilter, dismissHint: picker.command.name === "place-onboard"
+    return (_jsxs("box", { style: { flexDirection: "column", flexGrow: 1, paddingLeft: 1, paddingRight: 1 }, children: [_jsx(Breadcrumb, { scope: scope, working: working }), _jsx(ModeNav, { active: mode }), _jsx("box", { style: {
+                    flexDirection: "column",
+                    flexGrow: 1,
+                    flexShrink: 1,
+                    flexBasis: 0,
+                    minHeight: 3,
+                    width: "100%",
+                    overflow: "hidden",
+                    paddingTop: 1,
+                }, children: picker ? (_jsx(PickerPane, { items: pickerWindow, cursor: pickerCursor, windowStart: pickerWindowStart, total: pickerVisible.length, title: picker.command.name, filter: pickerFilter, dismissHint: picker.command.name === "place-onboard"
                         ? "Esc continue without place"
-                        : undefined })) : confirm ? (_jsx(ConfirmPane, { confirm: confirm })) : sheet && sheetCommand ? (_jsx(SheetPane, { sheet: sheet })) : (_jsxs(_Fragment, { children: [tab === "overview" && (_jsx(Overview, { frame: frame, working: working, agentPath: scope.agentPath, paneTitle: paneTitle, paneLines: paneLines })), tab === "chat" && (_jsx(ChatPane, { chat: chat, trace: trace, localMode: localMode, vars: vars, threadId: threadId, paneTitle: paneTitle, paneLines: paneLines })), tab === "bundle" && (_jsx(BundlePane, { paneTitle: paneTitle, paneLines: paneLines })), tab === "mockdb" && (_jsx(MockDbPane, { paneTitle: paneTitle, paneLines: paneLines })), tab === "scope" && _jsx(ScopePane, { scope: scope })] })) }), paletteOpen && !modalOpen && paletteMatches.length > 0 && (_jsx(Palette, { matches: paletteMatches })), toast && (_jsxs("text", { fg: DIM, style: { paddingLeft: 1 }, children: ["\u21B3 ", toast] })), !scope.loggedIn && (_jsx("box", { style: { flexDirection: "row", justifyContent: "flex-end" }, children: _jsx("text", { fg: AMBER, children: "Not logged in \u00B7 Run /login " }) })), _jsx("box", { style: {
+                        : undefined })) : confirm ? (_jsx(ConfirmPane, { confirm: confirm })) : sheet && sheetCommand ? (_jsx(SheetPane, { sheet: sheet })) : paletteOpen ? (_jsx(ActionPalettePane, { actions: paletteMatches, cursor: paletteHighlight, query: input, context: context, pageSize: pickerPageSize() })) : switcherOpen ? (_jsx(ContextSwitcherPane, { scope: scope, cursor: clampPickerCursor(switcherCursor ?? 0, CONTEXT_ROWS.length) })) : activityOpen ? (_jsx(ActivityDrawerPane, { operations: orderedOps, cursor: clampPickerCursor(activityCursor ?? 0, orderedOps.length), pageSize: pickerPageSize(), now: Date.now() })) : mode === "author" ? (authorViewEffective === "home" ? (_jsx(AuthorHome, { scope: scope, snapshot: snapshot, validation: validation, frame: frame, working: working, version: VERSION, paneTitle: paneTitle, paneLines: paneLines, session: authorSession, sessionRows: sessionRowsView, sessionCursor: clampPickerCursor(sessionCursor, authorSession?.units.length ?? 0), sessionScrollRef: contentScrollRef, backendLabel: authorBackend.label, backendDetection: backendDetection })) : authorViewEffective === "diff" ? (_jsx(DiffView, { rows: diffRows, cursor: clampPickerCursor(diffCursor, diffRows.length), treeTitle: hasAgent
+                        ? statusByPath.size > 0
+                            ? `changes (${changesSummary(snapshot?.diff)})`
+                            : "files (clean)"
+                        : "files", preview: preview, style: diffStyleEffective, remoteTag: scope.version, expanded: Boolean(fileDiff), sidebarWidth: Math.max(24, Math.min(36, Math.floor(termWidth / 4))), pageSize: pickerPageSize(), scrollRef: contentScrollRef })) : authorViewEffective === "validation" ? (_jsx(ValidationViewPane, { record: validation, scrollRef: contentScrollRef })) : (_jsx(VersionsViewPane, { versions: versions ?? [], currentTag: scope.version, scrollRef: contentScrollRef }))) : (_jsx(TalkView, { chat: chat, rows: talkRowsView, cursor: talkCursorClamped, focusPane: talkFocus, layout: talkLayoutEffective, threads: threads, threadsLoading: threadsLoading, threadCursor: clampPickerCursor(threadCursor, threadsRowCount(threads)), threadId: threadId, localMode: localMode, trace: trace, vars: vars, inspectorMetaLines: inspectorMetaLines, inspectorFetch: inspectorFetch, paneTitle: paneTitle, paneLines: paneLines, pageSize: pickerPageSize(), scrollRef: contentScrollRef, inspectorScrollRef: inspectorScrollRef })) }), slashOpen && slashMatches.length > 0 && (_jsx("box", { title: " commands ", style: {
+                    border: true,
+                    borderStyle: "rounded",
+                    borderColor: TEAL_DIM,
+                    flexDirection: "column",
+                    flexShrink: 0,
+                    paddingLeft: 1,
+                    paddingRight: 1,
+                }, children: slashMatches.map((cmd) => (_jsxs("text", { children: [_jsxs("span", { fg: TEAL, children: ["/", cmd.name.padEnd(16)] }), _jsx("span", { fg: DIM, children: cmd.summary })] }, cmd.name))) })), latestOp && !activityOpen && (_jsx(ActivitySummaryLine, { operation: latestOp, now: Date.now() })), toast && (_jsxs("text", { fg: DIM, style: { paddingLeft: 1, flexShrink: 0 }, children: ["\u21B3 ", toast] })), talkComposerActive ? (_jsx(Composer, { targetLabel: `${scope.agent !== "—" ? scope.agent : "agent"} on ${localMode ? "local bundle" : `${scope.env} · ${talkVersionLabel}`}`, draft: composer, disabledReason: composerReason, pending: talkPending, taRef: composerRef, onDraftChange: setComposer, onSend: handleComposerSend })) : (_jsx("box", { style: {
                     border: true,
                     borderStyle: "rounded",
                     borderColor: working ? AMBER : TEAL_DIM,
                     focusedBorderColor: TEAL,
                     height: 3,
+                    flexShrink: 0,
                     paddingLeft: 1,
                     paddingRight: 1,
                 }, children: _jsx("input", { focused: true, value: input, placeholder: placeholder, placeholderColor: FAINT, textColor: FG, focusedTextColor: FG, cursorColor: TEAL, backgroundColor: "transparent", focusedBackgroundColor: "transparent", onInput: (value) => {
@@ -625,102 +2251,10 @@ function App({ context: initialContext, initialScope, glyph, onQuit }) {
                                 setPicker({ ...picker, cursor: 0 });
                             }
                         }
-                    }, onSubmit: (value) => handleSubmit(typeof value === "string" ? value : input) }) }), _jsxs("box", { style: { flexDirection: "row", justifyContent: "space-between" }, children: [_jsx("text", { fg: FAINT, children: " Tab tabs \u00B7 / commands \u00B7 Enter send \u00B7 Ctrl+C quit" }), _jsxs("text", { fg: FAINT, children: [scope.profile, "/", scope.env, " \u00B7 ", scope.workspace, " \u00B7 ", scope.agent, " "] })] })] }));
-}
-function TabBar({ active }) {
-    return (_jsx("box", { style: { flexDirection: "row", paddingTop: 1 }, children: TABS.map((t) => t.id === active ? (_jsx("text", { fg: TEAL, children: _jsx("b", { children: ` ${t.label} ` }) }, t.id)) : (_jsx("text", { fg: DIM, children: ` ${t.label} ` }, t.id))) }));
-}
-function Overview({ frame, working, agentPath, paneTitle, paneLines, }) {
-    return (_jsxs("box", { style: { flexDirection: "column", alignItems: "center", flexGrow: 1 }, children: [_jsxs("box", { style: {
-                    border: true,
-                    borderStyle: "rounded",
-                    borderColor: TEAL_DIM,
-                    flexDirection: "column",
-                    alignItems: "center",
-                    width: 44,
-                    paddingTop: 1,
-                    paddingBottom: 1,
-                }, children: [frame.map((line, i) => (_jsx("text", { fg: working ? AMBER : TEAL, children: line }, i))), _jsxs("text", { fg: FG, children: [_jsx("b", { children: "apollo" }), " ", _jsxs("span", { fg: DIM, children: ["v", VERSION] })] }), _jsx("text", { fg: DIM, children: "Manage and operate Apollo agents" }), agentPath && _jsx("text", { fg: FAINT, children: agentPath })] }), _jsx("text", { children: " " }), _jsx("text", { fg: DIM, children: "/status /login /env /agent /push /help" }), paneTitle === "help" && paneLines.length > 0 && (_jsx("scrollbox", { style: { flexGrow: 1, width: "100%", marginTop: 1 }, children: paneLines.map((line, i) => (_jsx("text", { fg: FAINT, children: line }, i))) }))] }));
-}
-function ChatPane({ chat, trace, localMode, vars, threadId, paneTitle, paneLines, }) {
-    const agentCount = chat.filter((t) => t.role === "agent").length;
-    return (_jsxs("box", { style: { flexDirection: "column", flexGrow: 1 }, children: [_jsxs("text", { fg: FAINT, children: ["thread=", threadId?.slice(0, 12) ?? "new", " \u00B7 local=", localMode ? "on" : "off", " \u00B7 trace=", trace ? "on" : "off", " \u00B7 replies=", agentCount, vars.length > 0 ? ` · vars: ${vars.join(", ")}` : ""] }), _jsx("text", { fg: FAINT, children: " t / d = trace / debug last agent reply \u00B7 t 2 = 2nd reply" }), _jsx("text", { children: " " }), _jsxs("scrollbox", { style: { flexGrow: 1, flexDirection: "column" }, stickyScroll: true, children: [chat.length === 0 ? (_jsx("text", { fg: FAINT, children: " (empty \u2014 type a message, /thread, or /new)" })) : (chat.map((turn, i) => (_jsx("text", { fg: turn.role === "you" ? FG : turn.role === "agent" ? TEAL : AMBER, children: ` ${turn.role.padEnd(6)} ${turn.text}` }, i)))), paneLines.length > 0 &&
-                        paneTitle &&
-                        /^(trace|debug)/i.test(paneTitle) ? (_jsxs(_Fragment, { children: [_jsx("text", { children: " " }), _jsxs("text", { fg: AMBER, children: ["\u2014 ", paneTitle, " \u2014"] }), paneLines.map((line, i) => (_jsx("text", { fg: FAINT, children: line }, `p-${i}`)))] })) : null] })] }));
-}
-function ResultPane({ title, hints, paneTitle, paneLines, }) {
-    return (_jsxs("box", { style: { flexDirection: "column", flexGrow: 1 }, children: [_jsx("text", { fg: FG, children: _jsxs("b", { children: [" ", title] }) }), hints.map((h, i) => (_jsxs("text", { fg: DIM, children: [" ", h] }, i))), _jsx("text", { children: " " }), paneLines.length > 0 ? (_jsxs("scrollbox", { style: { flexGrow: 1 }, children: [paneTitle && (_jsxs("text", { fg: TEAL, children: ["\u2014 ", paneTitle, " \u2014"] })), paneLines.map((line, i) => (_jsx("text", { fg: FAINT, children: line }, i)))] })) : (_jsx("text", { fg: FAINT, children: " Use / commands from any tab" }))] }));
-}
-function BundlePane({ paneTitle, paneLines, }) {
-    return (_jsx(ResultPane, { title: "Bundle", hints: ["/validate /diff /pull /push /versions /version-publish"], paneTitle: paneTitle, paneLines: paneLines }));
-}
-function MockDbPane({ paneTitle, paneLines, }) {
-    return (_jsx(ResultPane, { title: "Mock DB", hints: ["/provision /wire /seed /mdb-collection-* /mdb-endpoint-* /mdb-status"], paneTitle: paneTitle, paneLines: paneLines }));
-}
-function ScopePane({ scope }) {
-    return (_jsxs("box", { style: { flexDirection: "column" }, children: [_jsx("text", { fg: FG, children: _jsx("b", { children: " Scope" }) }), _jsxs("text", { fg: DIM, children: [" profile: ", scope.profile] }), _jsxs("text", { fg: DIM, children: [" env: ", scope.env, " (account \u2014 no cd)"] }), _jsxs("text", { fg: DIM, children: [" workspace: ", scope.workspace] }), _jsxs("text", { fg: DIM, children: [" org: ", scope.org] }), _jsxs("text", { fg: DIM, children: [" project: ", scope.project] }), _jsxs("text", { fg: DIM, children: [" agent: ", scope.agent] }), _jsxs("text", { fg: DIM, children: [" version: ", scope.version] }), _jsxs("text", { fg: scope.loggedIn ? DIM : AMBER, children: [" ", "auth: ", scope.loggedIn ? "logged in" : "not logged in"] }), _jsx("text", { children: " " }), _jsxs("text", { fg: FAINT, children: [" ", "/env /profile /workspace /org /project /agent /agent-import /login"] })] }));
-}
-function SheetPane({ sheet }) {
-    const fields = visibleFields(sheet);
-    return (_jsxs("box", { title: ` /${sheet.title} `, style: {
-            border: true,
-            borderStyle: "rounded",
-            borderColor: TEAL_DIM,
-            flexDirection: "column",
-            flexGrow: 1,
-            paddingLeft: 1,
-            paddingRight: 1,
-        }, children: [fields.map((field, i) => {
-                const raw = sheet.values[field.name];
-                const display = field.control === "toggle" ? (raw ? "[x]" : "[ ]") : String(raw ?? "");
-                const active = i === sheet.focused;
-                return (_jsxs("text", { fg: active ? FG : DIM, children: [active ? "› " : "  ", field.label.padEnd(18), " ", display, field.control === "picker" ? _jsx("span", { fg: FAINT, children: " (picker)" }) : null, field.required && !display ? _jsx("span", { fg: FAINT, children: " (required)" }) : null] }, field.name));
-            }), sheet.fields.some((f) => f.advanced) && (_jsxs("text", { fg: FAINT, children: [" ", sheet.advancedOpen ? "▾" : "▸", " advanced (+ to toggle)"] })), sheet.error && _jsxs("text", { fg: RED, children: ["! ", sheet.error] }), _jsx("text", { fg: FAINT, children: "type value + Enter \u00B7 Enter skip \u00B7 Tab move \u00B7 Esc cancel" })] }));
-}
-function PickerPane({ items, cursor, windowStart, total, title, filter, dismissHint, }) {
-    const { nameWidth, idWidth } = pickerColumnWidths();
-    return (_jsxs("box", { title: ` pick ${title}${filter ? ` · “${filter}”` : ""} `, style: {
-            border: true,
-            borderStyle: "rounded",
-            borderColor: TEAL_DIM,
-            flexDirection: "column",
-            flexGrow: 1,
-            paddingLeft: 1,
-            paddingRight: 1,
-        }, children: [items.length === 0 ? (_jsx("text", { fg: AMBER, children: " No matches" })) : (items.map((item, offset) => {
-                const index = windowStart + offset;
-                const active = index === cursor;
-                const marker = active ? "›" : " ";
-                const number = String(index + 1).padStart(2);
-                const name = truncatePickerText(item.label, nameWidth).padEnd(nameWidth);
-                const secondary = item.detail && item.detail !== item.label
-                    ? truncatePickerText(item.detail, idWidth)
-                    : "";
-                return (_jsxs("text", { fg: active ? TEAL : FG, children: [`${marker} ${number}  ${name}`, secondary ? (_jsx("span", { fg: FAINT, children: `  ${secondary}` })) : null] }, `${item.id}-${index}`));
-            })), _jsxs("text", { fg: FAINT, children: [total > items.length
-                        ? ` ${cursor + 1}/${total} · ↑↓ move · type to filter · Enter`
-                        : ` ↑↓ move · type to filter · Enter select`, dismissHint ? ` · ${dismissHint}` : ""] })] }));
-}
-function ConfirmPane({ confirm }) {
-    return (_jsxs("box", { title: ` confirm ${confirm.title} `, style: {
-            border: true,
-            borderStyle: "rounded",
-            borderColor: AMBER,
-            flexDirection: "column",
-            flexGrow: 1,
-            paddingLeft: 1,
-            paddingRight: 1,
-        }, children: [_jsxs("text", { fg: AMBER, children: ["Type ", _jsx("b", { children: confirm.phrase }), " to confirm"] }), confirm.error && _jsxs("text", { fg: RED, children: ["! ", confirm.error] })] }));
-}
-function Palette({ matches }) {
-    return (_jsx("box", { title: " commands ", style: {
-            border: true,
-            borderStyle: "rounded",
-            borderColor: TEAL_DIM,
-            flexDirection: "column",
-            paddingLeft: 1,
-            paddingRight: 1,
-        }, children: matches.map((cmd) => (_jsxs("text", { children: [_jsxs("span", { fg: TEAL, children: ["/", cmd.name.padEnd(16)] }), _jsx("span", { fg: DIM, children: cmd.summary })] }, cmd.name))) }));
+                        if (paletteCursor !== undefined && value !== input) {
+                            setPaletteCursor(0);
+                        }
+                    }, onSubmit: (value) => handleSubmit(typeof value === "string" ? value : input) }) })), _jsx(FooterHints, { focus: focus, version: VERSION, copilot: Boolean(backendDetection?.available && scope.loggedIn && hasAgent) })] }));
 }
 export async function runOpenTui() {
     const context = await resolveContext({});
@@ -731,8 +2265,11 @@ export async function runOpenTui() {
         compact: true,
     });
     const renderer = await createCliRenderer({
-        exitOnCtrlC: true,
+        // Ctrl+C is an app key (cancel turn / clear input / quit) — see matchCtrlC.
+        exitOnCtrlC: false,
         targetFps: 30,
+        // Wheel-scrolling of content panes; keyboard scroll is driven centrally.
+        useMouse: true,
     });
     const root = createRoot(renderer);
     const code = await new Promise((resolve) => {