@aui.io/apollo 0.1.7 → 0.1.10

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

@@ -1,192 +1,1668 @@
 import { jsx as _jsx, jsxs as _jsxs } from "@opentui/react/jsx-runtime";
 /**
- * Apollo TUI — OpenTUI engine (the real one, per the plan).
+ * Apollo TUI — OpenTUI engine, two-mode workbench shell.
  *
- * Renders the five-tab operator app with the animated brand glyph, slash
- * command palette, and command sheets on top of @opentui/react. Business
- * logic stays in @aui.io/apollo-core; presentation-only state lives here.
+ * 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 { localDiff, pullBundle, pushBundle, remoteDiff, validateLocalBundle, } from "@aui.io/apollo-core/services/bundles.js";
+import { listVersions } from "@aui.io/apollo-core/services/bundles.js";
 import { createClients } from "@aui.io/apollo-core/services/clients.js";
-import { provisionMockDb, wireMockDbConnection, } from "@aui.io/apollo-core/services/mockdb.js";
-import { getStatus } from "@aui.io/apollo-core/services/status.service.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 { filterCommands, resolveCommand, } from "./lib/commands.js";
+import { applyPick, chatOverlay, destructiveSpec, loadPickerCatalog, refreshContext, runDestructive, runSheetAction, runSimpleCommand, } from "./lib/actions.js";
+import { filterCommands, PLACE_ONBOARD_COMMAND, resolveCommand, SLASH_COMMANDS, } from "./lib/commands.js";
+import { checkConfirm, createConfirm } from "./lib/confirm.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.2";
-function diffSummary(diff) {
-    const total = diff.added.length + diff.changed.length + diff.removed.length;
-    if (total === 0)
-        return "no changes";
-    return `+${diff.added.length} ~${diff.changed.length} -${diff.removed.length}`;
-}
-function App({ context, initialScope, glyph, onQuit }) {
-    const [tab, setTab] = useState("overview");
+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 [mode, setMode] = useState("author");
     const [input, setInput] = useState("");
     const [chat, setChat] = useState([]);
-    const [toast, setToast] = useState(undefined);
-    const [sheet, setSheet] = useState(undefined);
-    const [sheetCommand, setSheetCommand] = useState(undefined);
+    const [threadId, setThreadId] = useState();
+    const [toast, setToast] = useState();
+    const [sheet, setSheet] = useState();
+    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());
-    const scope = initialScope;
-    // Keep chat state accessible from async handlers without stale closures.
-    const stateRef = useRef({ tab, sheet, sheetCommand });
-    stateRef.current = { tab, sheet, sheetCommand };
-    // Animated glyph on the Overview tab (energized while working).
+    // 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({
+        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 = {
+        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 && input.startsWith("/");
-    const paletteMatches = paletteOpen ? filterCommands(input).slice(0, 8) : [];
+    // 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
+        ? 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;
+        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 = 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));
+                if (visible.length === 0)
+                    return;
+                setPicker({
+                    ...current.picker,
+                    cursor: clampPickerCursor(current.picker.cursor + (key.shift ? -1 : 1), visible.length),
+                });
+                return;
+            }
             if (current.sheet) {
                 setSheet(moveFocus(current.sheet, key.shift ? -1 : 1));
+                return;
             }
-            else {
-                setTab((t) => (key.shift ? prevTab(t) : nextTab(t)));
+            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;
+            }
+            if (current.activityCursor !== undefined)
+                return;
+            if (!current.confirm && matchModeToggle(key)) {
+                setMode((m) => otherMode(m));
                 setInput("");
             }
             return;
         }
-        if (key.name === "escape") {
-            if (current.sheet) {
+        if (matchEscape(key)) {
+            if (current.confirm) {
+                setConfirm(undefined);
+                setToast("Cancelled");
+            }
+            else if (current.picker) {
+                const wasPlaceOnboard = current.picker.command.name === "place-onboard";
+                setPicker(undefined);
+                if (current.picker.sheet && current.picker.command) {
+                    setSheet(current.picker.sheet);
+                    setSheetCommand(current.picker.command);
+                }
+                setToast(wasPlaceOnboard
+                    ? "Continuing without a workspace — pick one anytime (^G)"
+                    : "Cancelled");
+            }
+            else if (current.sheet) {
                 setSheet(undefined);
                 setSheetCommand(undefined);
                 setToast("Cancelled");
             }
+            else if (current.paletteCursor !== undefined) {
+                setPaletteCursor(undefined);
+                setInput("");
+            }
+            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;
         }
-        if ((key.ctrl || key.meta) && /^[1-5]$/.test(key.name)) {
-            const def = tabByIndex(Number(key.name));
-            if (def) {
-                setTab(def.id);
-                setInput("");
+    });
+    async function applyResult(result) {
+        if (result.error) {
+            setToast(result.error);
+            return;
+        }
+        if (result.openWorkspaceCreate) {
+            const createCmd = resolveCommand("/workspace-create").command;
+            if (createCmd?.fields) {
+                const model = createSheet(createCmd.name, createCmd.fields);
+                setSheet(model);
+                setSheetCommand(createCmd);
+                setToast("Create a workspace — enter a path");
             }
+            return;
         }
-    });
+        if (result.toast)
+            setToast(result.toast);
+        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);
+            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");
+        }
+        if (result.needConfirm) {
+            setConfirm(createConfirm(result.needConfirm.title, result.needConfirm.phrase, result.needConfirm.action, result.needConfirm.args));
+        }
+        if (result.refreshScope) {
+            const next = await refreshContext();
+            setContext(next);
+            setScope(scopeFromContext(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(ctx) {
+        await openPick(PLACE_ONBOARD_COMMAND, "place-onboard", undefined, undefined, ctx);
+    }
+    async function maybeOfferPlace(ctx) {
+        if (placeGateOffered.current)
+            return;
+        if (hasPlace(ctx)) {
+            placeGateOffered.current = true;
+            return;
+        }
+        // Logged-out: wait for login (mount toast covers the hint).
+        if (!ctx.token)
+            return;
+        placeGateOffered.current = true;
+        await openPlaceOnboarding(ctx);
+    }
+    useEffect(() => {
+        if (hasPlace(initialContext)) {
+            placeGateOffered.current = true;
+            return;
+        }
+        if (!initialContext.token) {
+            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 runCommand(command, args) {
-        if (command.jumpTab) {
-            setTab(command.jumpTab);
-            setToast(`Opened ${command.jumpTab}`);
+    async function openPick(command, kind, sheetModel, sheetField, contextOverride) {
+        setWorking(true);
+        try {
+            const items = await loadPickerCatalog(kind, contextOverride ?? stateRef.current.context);
+            if (items.length === 0) {
+                setToast(`No ${kind} options`);
+                return;
+            }
+            if (items.length === 1 && !sheetField && command.name !== "place-onboard") {
+                await finishPick(command, items[0].id, sheetModel, sheetField);
+                return;
+            }
+            setSheet(undefined);
+            setPaletteCursor(undefined);
+            setSwitcherCursor(undefined);
+            setPicker({
+                command,
+                items,
+                cursor: 0,
+                ...(sheetField ? { sheetField } : {}),
+                ...(sheetModel ? { sheet: sheetModel } : {}),
+            });
+            setInput("");
+        }
+        catch (error) {
+            setToast(error instanceof Error ? error.message : String(error));
+        }
+        finally {
+            setWorking(false);
+        }
+    }
+    async function finishPick(command, id, sheetModel, sheetField) {
+        setPicker(undefined);
+        if (sheetModel && sheetField) {
+            const next = {
+                ...sheetModel,
+                values: { ...sheetModel.values, [sheetField]: id },
+            };
+            setSheet(next);
+            setSheetCommand(command);
+            setToast(`Selected ${id}`);
             return;
         }
-        if (!ensureAuth(command))
+        if (command.destructive &&
+            (command.name === "version-publish" || command.name === "version-archive")) {
+            setConfirm(createConfirm(command.name, "yes", command.name, { id }));
             return;
+        }
+        setWorking(true);
+        try {
+            await applyResult(await applyPick(command.name, id, stateRef.current.context));
+        }
+        catch (error) {
+            setToast(error instanceof Error ? error.message : String(error));
+        }
+        finally {
+            setWorking(false);
+        }
+    }
+    async function runCommand(command, args) {
         if (command.name === "help") {
-            setInput("/");
+            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"}`);
+                return !v;
+            });
+            return;
+        }
+        if (command.name === "local") {
+            setLocalMode((v) => {
+                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));
+            return;
+        }
+        if (command.pick) {
+            if (args.trim()) {
+                setWorking(true);
+                try {
+                    await applyResult(await applyPick(command.name, args.trim(), stateRef.current.context));
+                }
+                catch (error) {
+                    setToast(error instanceof Error ? error.message : String(error));
+                }
+                finally {
+                    setWorking(false);
+                }
+                return;
+            }
+            await openPick(command, command.pick);
+            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);
             setSheetCommand(command);
+            const focused = visibleFields(model)[model.focused];
+            if (focused?.control === "picker" && focused.picker) {
+                await openPick(command, focused.picker, model, focused.name);
+            }
             return;
         }
         setWorking(true);
+        const opId = trackOperation(command.name, {
+            mode: "simple",
+            name: command.name,
+            args,
+        });
         try {
-            if (command.name === "status") {
-                const status = await getStatus(context, { check: true });
-                setToast(`status · env=${status.environment} · agent=${status.agentId ?? "—"}`);
-            }
-            else if (command.name === "validate") {
-                setTab("bundle");
-                const result = await validateLocalBundle(context, createClients(context).runtime);
-                if (result.valid) {
-                    setToast(result.program?.id
-                        ? `Valid — ${result.program.id}@${result.program.version ?? "?"}`
-                        : "Program is valid");
-                }
-                else {
-                    const errors = result.findings.filter((f) => f.level !== "warning");
-                    const first = errors[0]?.message ?? "validation failed";
-                    setToast(`Invalid: ${first}${errors.length > 1 ? ` (+${errors.length - 1} more)` : ""}`);
-                }
-            }
-            else if (command.name === "diff") {
-                setTab("bundle");
-                const remote = args.trim().toLowerCase() === "remote";
-                const diff = remote
-                    ? await remoteDiff(context, createClients(context).management)
-                    : await localDiff(context);
-                setToast(`diff vs ${remote ? "remote" : "baseline"} · ${diffSummary(diff)}`);
-            }
-            else if (command.name === "trace") {
-                setTrace((v) => {
-                    setToast(`trace ${v ? "off" : "on"}`);
-                    return !v;
-                });
-            }
-            else if (command.name === "local") {
-                setLocalMode((v) => {
-                    setToast(`local mode ${v ? "off" : "on"}`);
-                    return !v;
-                });
-            }
-            else if (command.name === "new") {
-                setChat([]);
-                setToast("New thread");
-            }
-            else if (command.name === "logout") {
-                setToast("Use apollo logout in the CLI (confirm modal coming soon)");
-            }
-            else if (command.name === "upgrade") {
-                setToast("Run apollo upgrade from the CLI");
-            }
-            else {
-                setToast(`/${command.name} queued`);
-            }
+            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) {
@@ -203,86 +1679,48 @@ function App({ context, initialScope, glyph, onQuit }) {
             }
             return;
         }
-        if (command.name === "login") {
-            setTab("scope");
-            setToast("Browser login isn't in the TUI yet — run apollo login from the CLI");
-            return;
-        }
-        void executeSheet(command, model.values);
+        runSheetOp(command, model.values);
     }
-    /** Run the service call behind a submitted command sheet. */
-    async function executeSheet(command, values) {
-        const text = (name) => {
-            const value = values[name];
-            return typeof value === "string" ? value.trim() : "";
-        };
-        setWorking(true);
-        try {
-            const clients = createClients(context);
-            if (command.name === "pull") {
-                setTab("bundle");
-                const tag = text("tag");
-                const dir = text("dir");
-                const result = await pullBundle(context, clients.management, {
-                    // "latest" is the sheet default; omitting the tag pulls the
-                    // selected/live version, matching the CLI's bare `apollo pull`.
-                    ...(tag && tag !== "latest" ? { tag } : {}),
-                    ...(dir ? { destination: dir } : {}),
-                    force: false,
-                });
-                const removed = result.removed.length ? ` · removed ${result.removed.length}` : "";
-                setToast(`Pulled ${Object.keys(result.files).length} file(s)${removed}`);
-            }
-            else if (command.name === "push") {
-                setTab("bundle");
-                const message = text("message");
-                const dryRun = values.dryRun === true;
-                const result = await pushBundle(context, clients.management, clients.runtime, {
-                    ...(message ? { commitMessage: message } : {}),
-                    dryRun,
-                });
-                setToast(result.push
-                    ? `Pushed ${result.push.new_version_tag} · ${diffSummary(result.diff)}`
-                    : `Dry run · ${diffSummary(result.diff)}`);
-            }
-            else if (command.name === "provision") {
-                setTab("mockdb");
-                const provisioned = await provisionMockDb(context);
-                let note = `Provisioned mock DB for ${provisioned.agentId ?? "agent"}`;
-                if (values.wire === true) {
-                    const wired = await wireMockDbConnection(context);
-                    note += ` · wired ${wired.connectionId}`;
-                }
-                setToast(note);
-            }
-            else if (command.name === "thread") {
-                setChat([]);
-                setToast(`Thread ${text("thread") || "new"} (per-thread history coming soon)`);
-            }
-            else {
-                setToast(`/${command.name} isn't wired in the TUI yet — use apollo ${command.name}`);
-            }
-        }
-        catch (error) {
-            setToast(error instanceof Error ? error.message : String(error));
-        }
-        finally {
-            setWorking(false);
+    async function handleSheetLine(model, command, line) {
+        if (line === "+" || line.toLowerCase() === "advanced") {
+            setSheet({ ...model, advancedOpen: !model.advancedOpen });
+            return;
         }
-    }
-    function handleSheetLine(model, command, line) {
         const fields = visibleFields(model);
         const focused = fields[model.focused];
         if (line === "") {
-            // Empty entry advances; on the last field it submits.
             if (model.focused >= fields.length - 1) {
                 submitSheet(model, command);
             }
             else {
-                setSheet(moveFocus(model, 1));
+                const next = moveFocus(model, 1);
+                setSheet(next);
+                const nextField = visibleFields(next)[next.focused];
+                if (nextField?.control === "picker" && nextField.picker) {
+                    await openPick(command, nextField.picker, next, nextField.name);
+                }
             }
             return;
         }
+        if (focused?.control === "picker" && focused.picker) {
+            await openPick(command, focused.picker, model, focused.name);
+            // Also try resolving against a fresh catalog if user typed a filter as the line
+            setWorking(true);
+            try {
+                const items = await loadPickerCatalog(focused.picker, stateRef.current.context);
+                const hit = resolvePickerAnswer(filterPickerItems(items, line), line);
+                if (hit) {
+                    await finishPick(command, hit.id, model, focused.name);
+                    return;
+                }
+            }
+            catch {
+                /* fall through */
+            }
+            finally {
+                setWorking(false);
+            }
+        }
         let next = model;
         if (focused?.control === "toggle") {
             const truthy = ["y", "yes", "true", "on", "x"].includes(line.toLowerCase());
@@ -295,134 +1733,528 @@ function App({ context, initialScope, glyph, onQuit }) {
             submitSheet(next, command);
         }
         else {
-            setSheet(moveFocus(next, 1));
+            const moved = moveFocus(next, 1);
+            setSheet(moved);
+            const nextField = visibleFields(moved)[moved.focused];
+            if (nextField?.control === "picker" && nextField.picker) {
+                await openPick(command, nextField.picker, moved, nextField.name);
+            }
+        }
+    }
+    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 };
     }
-    async function sendChat(text) {
-        setChat((c) => [...c, { role: "you", text }]);
-        if (!scope.loggedIn) {
-            setChat((c) => [...c, { role: "system", text: "Not logged in · Run /login" }]);
+    /** 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(context);
-            const result = await sendMessage(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,
-                ...(trace ? { includeTrace: true } : {}),
-                ...(localMode && context.agentRoot ? { localDir: context.agentRoot } : {}),
-                variables: vars,
+                ...(versionId ? { versionId } : {}),
+                ...(current.threadId ? { threadId: current.threadId } : {}),
+                includeTrace: true,
+                ...(local && ctx.agentRoot ? { localDir: ctx.agentRoot } : {}),
+                variables: current.vars,
             });
-            const reply = result.message.text ?? JSON.stringify(result);
-            setChat((c) => [...c, { role: "agent", text: reply }]);
+            if (seq !== sendSeqRef.current)
+                return; // cancelled or superseded
+            if (result.thread_id) {
+                setThreadId(result.thread_id);
+                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("");
         setToast(undefined);
         const current = stateRef.current;
+        if (current.confirm) {
+            const checked = checkConfirm(current.confirm, line);
+            if (checked === "ok") {
+                const spec = current.confirm;
+                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 {
+                        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 {
+                        setWorking(false);
+                    }
+                })();
+            }
+            else {
+                setConfirm(checked);
+            }
+            return;
+        }
+        if (current.picker) {
+            const visible = filterPickerItems(current.picker.items, effectivePickerFilter(line));
+            if (visible.length === 0) {
+                setToast(line ? `No match for "${line}"` : "No options");
+                setInput(line);
+                return;
+            }
+            // Empty Enter → highlighted row. Digits → index. Text → unique match only.
+            const trimmed = line.trim();
+            let hit;
+            if (!trimmed) {
+                hit = visible[clampPickerCursor(current.picker.cursor, visible.length)];
+            }
+            else if (/^\d+$/.test(trimmed)) {
+                hit = resolvePickerAnswer(visible, trimmed);
+            }
+            else {
+                hit = resolvePickerAnswer(visible, trimmed);
+                if (!hit && visible.length > 1) {
+                    setToast("↑↓ to choose, Enter to select (or narrow the filter)");
+                    setInput(line);
+                    return;
+                }
+            }
+            if (!hit) {
+                setToast(line ? `No match for "${line}"` : "↑↓ to choose, Enter to select");
+                setInput(line);
+                return;
+            }
+            void finishPick(current.picker.command, hit.id, current.picker.sheet, current.picker.sheetField);
+            return;
+        }
         if (current.sheet && current.sheetCommand) {
-            handleSheetLine(current.sheet, current.sheetCommand, line);
+            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 (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;
+                });
+            }
             return;
         }
         if (line === "")
             return;
-        if (current.tab === "chat") {
-            void sendChat(line);
+        // `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("Type / for commands, or use the Chat tab to message the agent");
+        setToast("^K actions · v/d/p/l/r/o quick · Tab to Talk");
     }
-    const placeholder = tab === "chat"
-        ? "message the agent, or / for commands"
-        : sheet
-            ? "type a value · Enter next · Esc cancel"
-            : "/ for commands · Tab switches tabs";
-    return (_jsxs("box", { style: { flexDirection: "column", flexGrow: 1, paddingLeft: 1, paddingRight: 1 }, children: [_jsx(TabBar, { active: tab }), _jsxs("box", { style: { flexDirection: "column", flexGrow: 1, paddingTop: 1 }, children: [tab === "overview" && (_jsx(Overview, { frame: frame, working: working, agentPath: scope.agentPath })), tab === "chat" && (_jsx(ChatPane, { chat: chat, trace: trace, localMode: localMode, vars: vars })), tab === "bundle" && _jsx(BundlePane, {}), tab === "mockdb" && _jsx(MockDbPane, {}), tab === "scope" && _jsx(ScopePane, { scope: scope })] }), sheet && sheetCommand && _jsx(SheetPane, { sheet: sheet }), paletteOpen && 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: {
+    /** 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"
+            : 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)
+        : [];
+    const pickerCursor = picker
+        ? clampPickerCursor(picker.cursor, pickerVisible.length)
+        : 0;
+    // Keep the highlighted row on screen when the list is long.
+    const PICKER_PAGE = pickerPageSize();
+    const pickerWindowStart = pickerVisible.length <= PICKER_PAGE
+        ? 0
+        : Math.max(0, Math.min(pickerCursor - Math.floor(PICKER_PAGE / 3), pickerVisible.length - PICKER_PAGE));
+    const pickerWindow = pickerVisible.slice(pickerWindowStart, pickerWindowStart + PICKER_PAGE);
+    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 })) : 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) => setInput(value), 
-                    // ENTER emits the current widget value; using React state here would
-                    // be stale when typing and Enter arrive in the same input batch.
-                    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.env, " \u00B7 ", scope.agent, " \u00B7 ", scope.version, " "] })] })] }));
-}
-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, }) {
-    return (_jsxs("box", { style: { flexDirection: "column", alignItems: "center" }, 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 /push /chat /mockdb /help" })] }));
-}
-function ChatPane({ chat, trace, localMode, vars, }) {
-    return (_jsxs("box", { style: { flexDirection: "column", flexGrow: 1 }, children: [_jsxs("text", { fg: FAINT, children: ["thread \u00B7 user=cli \u00B7 local=", localMode ? "on" : "off", " \u00B7 trace=", trace ? "on" : "off", vars.length > 0 ? ` · vars: ${vars.join(", ")}` : ""] }), _jsx("text", { children: " " }), _jsx("scrollbox", { style: { flexGrow: 1, flexDirection: "column" }, stickyScroll: true, children: chat.length === 0 ? (_jsx("text", { fg: FAINT, children: " (empty thread \u2014 type a message 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)))) })] }));
-}
-function BundlePane() {
-    return (_jsxs("box", { style: { flexDirection: "column" }, children: [_jsx("text", { fg: FG, children: _jsx("b", { children: " Bundle" }) }), _jsx("text", { fg: DIM, children: " Validate \u00B7 Diff vs baseline \u00B7 Diff vs remote" }), _jsx("text", { fg: DIM, children: " Pull\u2026 \u00B7 Push\u2026 \u00B7 Versions" }), _jsx("text", { children: " " }), _jsx("text", { fg: FAINT, children: " Open a command sheet with /push, /pull, /validate, /diff" })] }));
-}
-function MockDbPane() {
-    return (_jsxs("box", { style: { flexDirection: "column" }, children: [_jsx("text", { fg: FG, children: _jsx("b", { children: " Mock DB" }) }), _jsx("text", { fg: DIM, children: " Status \u00B7 Collections \u00B7 Endpoints \u00B7 Sessions" }), _jsx("text", { children: " " }), _jsx("text", { fg: FAINT, children: " /provision /wire /seed \u2014 or use the Scope agent context" })] }));
-}
-function ScopePane({ scope }) {
-    return (_jsxs("box", { style: { flexDirection: "column" }, children: [_jsx("text", { fg: FG, children: _jsx("b", { children: " Scope" }) }), _jsxs("text", { fg: DIM, children: [" env: ", scope.env] }), _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: " " }), _jsx("text", { fg: FAINT, children: " /login /logout \u2014 pickers for env/org/project/agent live here" })] }));
-}
-function SheetPane({ sheet }) {
-    const fields = visibleFields(sheet);
-    return (_jsxs("box", { title: ` /${sheet.title} `, style: {
-            border: true,
-            borderStyle: "rounded",
-            borderColor: TEAL_DIM,
-            flexDirection: "column",
-            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.required && !display ? _jsx("span", { fg: FAINT, children: " (required)" }) : null] }, field.name));
-            }), 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 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(12)] }), _jsx("span", { fg: DIM, children: cmd.summary })] }, cmd.name))) }));
+                }, children: _jsx("input", { focused: true, value: input, placeholder: placeholder, placeholderColor: FAINT, textColor: FG, focusedTextColor: FG, cursorColor: TEAL, backgroundColor: "transparent", focusedBackgroundColor: "transparent", onInput: (value) => {
+                        setInput(value);
+                        if (picker) {
+                            const nextFilter = effectivePickerFilter(value);
+                            const prevFilter = effectivePickerFilter(input);
+                            if (nextFilter !== prevFilter) {
+                                setPicker({ ...picker, cursor: 0 });
+                            }
+                        }
+                        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({});
@@ -433,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) => {
@@ -442,8 +2277,6 @@ export async function runOpenTui() {
     });
     root.unmount();
     renderer.destroy();
-    // The raw-mode stdin handle keeps the event loop alive after destroy;
-    // exit explicitly so /quit actually returns to the shell.
     process.exit(code);
 }
 //# sourceMappingURL=opentui-app.js.map