mindweave 3.2.7 → 3.3.0

package/dist/cli/App.js

@@ -77,10 +77,13 @@ import { parseScreenArg, screenChoices, screenNotice, startupMode } from "./scre
 import { applyScreenMode } from "./screenShell.js";
 import { saveScreenMode } from "./screenStore.js";
 import { FULL_TAIL_BLOCKS, needsMeasure, pruneHeights, seedHeights } from "./blockHeights.js";
-import { expandableAt, hitBlock, hitItem } from "./expandHits.js";
+import { expandableAt, hitBlock, hitItem, revealNode } from "./expandHits.js";
 import { shellNote } from "./shellNotes.js";
+import { pressBackground } from "./commandBackground.js";
 import { readFileSync, statSync } from "node:fs";
-import { compactUiDetail, rebuildFull, writtenFromDisk } from "../tools/rebuildDetail.js";
+import { compactSearchDetail, compactUiDetail, rebuildFull, writtenFromDisk } from "../tools/rebuildDetail.js";
+import { isUserShell, runUserCommand } from "../tools/userCommand.js";
+import { isUserCommandText, parseUserCommand } from "../memory/localCommand.js";
 import { shownText } from "../memory/compaction.js";
 import { BASE_COMMANDS } from "./commands.js";
 import { attachmentBudget, dismissMarathon } from "../core/turnRunner.js";
@@ -92,10 +95,13 @@ import { currentInstall, requestRestart, runUpdate } from "./updateRunner.js";
 import { enableMouse, readMouse, readWheel } from "./mouse.js";
 import { wheelLines } from "./wheelStep.js";
 import { applySelection, ctrlCShouldCopy, isEmpty, selectionText } from "./selection.js";
+import { applyGrowSelection, edgeLines, focusFromPointer, isEmptyGrow, lineBounds, nextClick, RowStore, rowOfKey, wordBounds } from "./selectionGrow.js";
+import { blockSpans, registerBlockBox } from "./blockBoxes.js";
+import { holdFrames, releaseFrames } from "./framebuffer/frameHold.js";
 import { latestScreen, repaintOverlay, setFrameOverlay } from "./framebuffer/overlay.js";
 import { requestFullRepaint } from "./framebuffer/writer.js";
 import { copyToClipboard } from "./clipboard.js";
-import { chatLayout, reflowScroll, growScroll } from "./chatAnchor.js";
+import { chatLayout, reflowScroll, growScroll, revealScroll, viewportScroll } from "./chatAnchor.js";
 import { growFill, INLINE_LIVE_RESERVE, NO_FILL } from "./startupFill.js";
 import { setRowsBelowCaret } from "./exitCursor.js";
 import { caretCell } from "./caretPark.js";
@@ -220,6 +226,26 @@ export function App({ resumeSessionId, initialScreen }) {
     // state: it is painted by the framebuffer overlay rather than by React, so changing it
     // must not cost a render (see the pointer effect).
     const selection = useRef(null);
+    // The selection that FOLLOWS THE CONVERSATION, for a drag that begins in the chat (see
+    // selectionGrow.ts): it keeps growing while the view scrolls, and copies all of it. A drag
+    // that begins anywhere else (the input box, the banner) is the screen selection above.
+    const grow = useRef(null);
+    // The rows that passed through the screen while it was alive, which is what gets copied.
+    const rowStore = useRef(new RowStore());
+    // Where the pointer is while the button is down, so scrolling can move the end of the
+    // selection even when the pointer itself does not move.
+    const pointer = useRef(null);
+    const edgeTimer = useRef(null);
+    const stopEdge = useCallback(() => {
+        if (edgeTimer.current)
+            clearInterval(edgeTimer.current);
+        edgeTimer.current = null;
+    }, []);
+    /** A press that may be the third click of a row, waiting for its release to say which it was. */
+    const pendingThird = useRef(null);
+    const dropPendingThird = useCallback(() => {
+        pendingThird.current = null;
+    }, []);
     /**
      * Drop the highlight, if there is one, and stop tinting frames.
      *
@@ -230,12 +256,17 @@ export function App({ resumeSessionId, initialScreen }) {
      * then uninstall: the repaint is what takes the highlight off the screen.
      */
     const clearSelection = useCallback(() => {
-        if (!selection.current)
+        if (!selection.current && !grow.current)
             return;
         selection.current = null;
+        grow.current = null;
+        rowStore.current.clear();
+        pointer.current = null;
+        stopEdge();
+        dropPendingThird();
         repaintOverlay();
         setFrameOverlay(null);
-    }, []);
+    }, [stopEdge, dropPendingThird]);
     // PromptInput installs the handler that turns a click into a caret position; only it
     // knows what its rows currently hold. Null until the input is on screen.
     const caretClick = useRef(null);
@@ -336,12 +367,21 @@ export function App({ resumeSessionId, initialScreen }) {
     const [hoverId, setHoverId] = useState(null);
     // Set when a row is opened or folded, read once by the height effect.
     const rowToggled = useRef(false);
+    // Which place was pressed, and where the view stood before it was opened and after the view
+    // moved to show it, so that folding the same row can put the view back where it was.
+    const toggledHit = useRef(null);
+    // Whether the row pressed is the NEWEST one that can be opened, the only kind the view follows.
+    const toggledNewest = useRef(false);
+    const openedFrom = useRef(null);
     const [footerHeight, setFooterHeight] = useState(0);
     // The chat viewport's REAL height. Yoga decides it now (flexGrow beside a
     // flexShrink:0 footer); this is read back purely so the scroll maths knows how
     // much of the content is on screen.
     const chatRef = useRef(null);
     const [chatHeight, setChatHeight] = useState(0);
+    /** The chat viewport's height and the width it had when last measured, so a change of the
+     *  footer's height can move the scroll with it. See viewportScroll. */
+    const chatRowsSeen = useRef(null);
     // Bumped by PromptInput when its suggestion menu changes size. Its only job is
     // to re-render App so the footer measurement below re-runs: the menu is
     // PromptInput's own state, so App is not re-rendered by it and would otherwise
@@ -390,6 +430,17 @@ export function App({ resumeSessionId, initialScreen }) {
     }, []);
     // Aborts the in-flight turn when the user presses Esc (created fresh per turn).
     const abortRef = useRef(null);
+    /** A command the person typed after `!` is running (not an agent turn). Esc stops just that. */
+    const userCommandRunning = useRef(false);
+    /** The turn in progress is the person's own `!` command, not the agent working. */
+    const userTurn = useRef(false);
+    /**
+     * A command the person ran with `!` has just ended and the agent has not answered it yet. The agent
+     * is woken for it the way it is when a command of its own finishes: given the result, it carries on
+     * (that is the point: it can ask the person to run something and go on from what comes back).
+     * Cleared when any turn starts, since that turn reads the result anyway.
+     */
+    const wakeAfterUserCommand = useRef(false);
     // Which provider's key we still need, or null once we have it. Not a bare
     // boolean: with more than one provider, the key we must ask for depends on the
     // model the user is about to run, and switching models can make a different key
@@ -660,6 +711,7 @@ export function App({ resumeSessionId, initialScreen }) {
         // Each call's name and arguments by id, so a result from a session saved before the uncut
         // text was kept can have it put back together (see rebuildDetail.ts).
         const callsById = new Map();
+        let userRows = 0; // commands the person ran with `!`, to give each replayed row its own id
         for (const e of transcript) {
             if (e.role === "user") {
                 if (!e.synthetic)
@@ -670,6 +722,23 @@ export function App({ resumeSessionId, initialScreen }) {
                 // calls…" sitting in their own chat history.
                 if (!e.synthetic)
                     dispatch({ type: "user", text: collapsePastes(stripAttachments(e.content)) });
+                // A command the person ran with `!` comes back as the row it was: what they ran, how it ended,
+                // and the output behind the click. The screen's record is kept whole even when the model's copy
+                // of the output was cleared to save context.
+                else if (e.localCommand) {
+                    const rec = e.localCommand;
+                    const toolId = `user-replay-${userRows++}`;
+                    dispatch({ type: "toolStart", toolId, name: "Run", arg: rec.command, action: "run", group: true, byUser: true });
+                    dispatch({
+                        type: "toolEnd",
+                        toolId,
+                        ok: rec.ok,
+                        summary: rec.summary,
+                        detail: rec.detail,
+                        detailKind: "shell",
+                        ...(rec.detailFull ? { detailFull: rec.detailFull } : {}),
+                    });
+                }
             }
             else if (e.role === "summary") {
                 dispatch({ type: "note", text: "— resumed; earlier context summarized —" });
@@ -694,7 +763,7 @@ export function App({ resumeSessionId, initialScreen }) {
                     // that was not in the live one.
                     if (call.name === "spawn_subagent" || neverShown(call.name))
                         continue;
-                    const d = toolDisplay(call.name, parseToolArgs(call.arguments));
+                    const d = toolDisplay(call.name, parseToolArgs(call.arguments), session.current?.cwd ?? process.cwd());
                     dispatch({
                         type: "toolStart",
                         toolId: call.id,
@@ -723,6 +792,12 @@ export function App({ resumeSessionId, initialScreen }) {
                             if (compact)
                                 return { detail: compact.detail, ...(compact.detailFull ? { detailFull: compact.detailFull } : {}) };
                         }
+                        // A web search saved before it became a short row that opens on a click comes back as one.
+                        if ((call?.name === "web_search" || call?.name === "web") && !e.detailFull) {
+                            const compact = compactSearchDetail(e.detail);
+                            if (compact)
+                                return { detail: compact.detail, ...(compact.detailFull ? { detailFull: compact.detailFull } : {}) };
+                        }
                         let full = e.detailFull ?? rebuildFull(call?.name, call?.args, e);
                         // A write whose text was cleared to save context has only the file left to open.
                         if (!full && call?.name === "write_file" && typeof call.args?.path === "string") {
@@ -969,10 +1044,14 @@ export function App({ resumeSessionId, initialScreen }) {
             needsKey,
             reacting: reactingRef.current,
             modalOpen,
-            pending: mgr?.pendingCount() ?? 0,
+            // A command the person ran counts as one event worth waking for, unless something they typed
+            // is already queued: that message's turn reads the command's result too.
+            pending: (mgr?.pendingCount() ?? 0) + (wakeAfterUserCommand.current && queueRef.current.length === 0 ? 1 : 0),
         });
-        if (wake)
+        if (wake) {
+            wakeAfterUserCommand.current = false;
             void reactToBackground();
+        }
     }, [bgTick, busy, ready, needsKey, modalOpen]);
     // When the turn ends, send what's queued — CONSECUTIVE plain messages together, as
     // one turn (see messageQueue.ts for why), a slash command on its own. Chains: each
@@ -1025,6 +1104,7 @@ export function App({ resumeSessionId, initialScreen }) {
     }, [busy]);
     // Start/stop a turn's timer (drives the persistent status line).
     function startTurn() {
+        wakeAfterUserCommand.current = false;
         turnStart.current = Date.now();
         waitedMs.current = 0;
         waitSince.current = null;
@@ -1035,6 +1115,20 @@ export function App({ resumeSessionId, initialScreen }) {
         abortRef.current = new AbortController();
         setBusy(true);
     }
+    /**
+     * The start of a `!` command's time on screen. Like `startTurn` for what the box needs (busy, a way
+     * to stop it, anything typed meanwhile queued) and nothing of the agent's: the task's usage and
+     * its "Worked for" receipt belong to the last time the agent worked, and are left as they were.
+     */
+    function startUserTurn() {
+        turnStart.current = Date.now();
+        waitedMs.current = 0;
+        waitSince.current = null;
+        interrupting.current = false;
+        abortRef.current = new AbortController();
+        userTurn.current = true;
+        setBusy(true);
+    }
     // Esc interrupts the current turn: it aborts the model call AND kills a running
     // command — run_command listens to this same signal (see runShell), so a hung
     // command (e.g. an installer waiting on a GUI) can no longer freeze the agent.
@@ -1062,6 +1156,12 @@ export function App({ resumeSessionId, initialScreen }) {
     useInput((input, key) => {
         if (!key.ctrl || input !== "c")
             return;
+        const g = grow.current;
+        if (g && !isEmptyGrow(g)) {
+            copyGrown(g);
+            clearSelection();
+            return;
+        }
         const sel = selection.current;
         if (ctrlCShouldCopy(sel)) {
             const screen = latestScreen();
@@ -1078,6 +1178,9 @@ export function App({ resumeSessionId, initialScreen }) {
     useInput((_input, key) => {
         if (key.escape) {
             abortRef.current?.abort();
+            // The person's own `!` command: Esc stops just that (no turn was cut off, no shells below).
+            if (userCommandRunning.current)
+                return;
             // From here until the next turn starts, anything typed is for the NEXT turn.
             interrupting.current = true;
             // Anything still waiting to be asked is answered as declined. A queued approval
@@ -1087,8 +1190,10 @@ export function App({ resumeSessionId, initialScreen }) {
             // Esc means STOP — including anything running in the background (a starting app,
             // a dev server). Aborting the turn alone left those alive, so the app still opened.
             const mgr = session.current?.toolContext.backgroundShells;
+            // Not an app the person started themselves with `!`: that one is theirs, and stops from its own window or /shells.
             for (const sh of mgr?.running() ?? [])
-                mgr?.kill(sh.id, "user");
+                if (!isUserShell(mgr, sh.id))
+                    mgr?.kill(sh.id, "user");
             // And the app it was testing, with its live view and any hidden browser.
             if (session.current)
                 void stopUi(session.current.toolContext);
@@ -1219,6 +1324,14 @@ export function App({ resumeSessionId, initialScreen }) {
             requestFullRepaint();
             setScrollUp(maxScrollRef.current);
         }
+        // Move what the turn is waiting on to the background, without waiting for the agent
+        // to decide it. Silent when nothing is running (a stray press needs no comment); it
+        // speaks only when something WAS running and could not be moved.
+        else if (key.ctrl && _input === "x") {
+            if (pressBackground(session.current?.toolContext.foregroundCommands) === "stuck") {
+                note("That command could not be moved to the background.");
+            }
+        }
     }, { isActive: ready && overlay === null });
     // Leaving the reading view when it reaches the bottom needs no effect of its own:
     // `reading` is `scrollUp > 0`, so landing on zero — the wheel, the keys, ctrl+End, or
@@ -1322,17 +1435,45 @@ export function App({ resumeSessionId, initialScreen }) {
             // reader's absolute position rather than leave `scrollUp` where it was.
             const prev = prevContentHeight.current;
             let next = growScroll(scrollUp, prev, height);
-            // A row was just opened or folded. The row the reader pressed stays where it is and
-            // the change happens below it: opening from the bottom would otherwise follow the
-            // new end of the output and carry the row's own first line off the top, and folding
-            // would slide the view up by what was taken away.
+            // A row was just opened or folded.
+            //
+            // OPENED, while pinned to the newest: the view moves just far enough to show what opened
+            // (see revealScroll). It used to hold the pressed row in place and let the contents appear
+            // below it, which for the newest row is below the screen: the reader had to scroll to see
+            // what they had asked for. A row opened with the view scrolled back is NOT touched.
+            // FOLDED: the view goes back to where it was before this row was opened, if nothing has
+            // moved it since; otherwise it slides up by what was taken away, so the row stays put.
             if (rowToggled.current && height !== prev) {
-                if (height > prev && scrollUp === 0)
-                    next = height - prev;
-                else if (height < prev)
-                    next = Math.max(0, scrollUp - (prev - height));
+                const hit = toggledHit.current;
+                if (height > prev) {
+                    // Only for the NEWEST row that can be opened, with the reader pinned to the bottom: that
+                    // is the one whose contents would be pushed below the screen. Every other row, even one
+                    // that is on screen at the time, keeps the old rule (held in place, contents below it).
+                    const node = hit !== null && scrollUp === 0 && toggledNewest.current ? revealNode(hit) : undefined;
+                    if (hit !== null && node && contentRef.current) {
+                        const n = measureElement(node);
+                        const c = measureElement(contentRef.current);
+                        next = revealScroll(scrollUp, height, chatRows, n.y - c.y, n.height);
+                        openedFrom.current = { hit, before: scrollUp, after: next };
+                    }
+                    else {
+                        openedFrom.current = null;
+                        if (scrollUp === 0)
+                            next = height - prev;
+                    }
+                }
+                else {
+                    const from = openedFrom.current;
+                    if (from && from.hit === hit && from.after === scrollUp)
+                        next = Math.min(from.before, Math.max(0, height - chatRows));
+                    else
+                        next = Math.max(0, scrollUp - (prev - height));
+                    openedFrom.current = null;
+                }
             }
             rowToggled.current = false;
+            // The view is now placed for the new height; the next frame is the right one.
+            releaseFrames();
             if (next !== scrollUp)
                 setScrollUp(next);
         }
@@ -1394,6 +1535,15 @@ export function App({ resumeSessionId, initialScreen }) {
         if (!chatRef.current)
             return;
         const { height } = measureElement(chatRef.current);
+        // The footer grew or shrank. The frame already drawn kept the top of the window where it
+        // was; the numbers for the next one hold the bottom. Moving the scroll by the same
+        // amount in this update makes both show the same rows (see viewportScroll). A change of
+        // WIDTH is the reflow's to handle, not this.
+        const prev = chatRowsSeen.current;
+        if (prev !== null && prev.width === width && prev.rows !== height) {
+            setScrollUp((s) => viewportScroll(s, prev.rows, height));
+        }
+        chatRowsSeen.current = { rows: height, width };
         setChatHeight((h) => (h === height ? h : height));
     });
     /**
@@ -1448,14 +1598,149 @@ export function App({ resumeSessionId, initialScreen }) {
      * chance to reflow the screen under a user who is only trying to highlight a word.
      * `repaintOverlay` re-tints the frame already on screen instead.
      */
+    // ── the selection that follows the conversation ──────────────────────────────────────────
+    /** The screen rows that show the conversation. */
+    const chatViewRows = useCallback(() => {
+        if (!chatRef.current)
+            return null;
+        const m = measureElement(chatRef.current);
+        return { top: frameTopRef.current + m.y, bottom: frameTopRef.current + m.y + m.height };
+    }, []);
+    /** Runs on every frame while a selection of this kind exists: keep the rows, then paint it. */
+    const growOverlay = useCallback((screen) => {
+        const g = grow.current;
+        const view = chatViewRows();
+        if (!g || !view)
+            return;
+        const spans = blockSpans(frameTopRef.current);
+        if (g.dragging) {
+            // The pointer has not moved but the view has, so what is under it is a different
+            // row: the end of the selection is wherever the pointer is NOW.
+            const p = pointer.current;
+            if (p) {
+                const focus = focusFromPointer(spans, view, p.x, p.y, screen.width);
+                if (focus)
+                    g.focus = focus;
+            }
+            const chip = pillHit.current;
+            rowStore.current.capture(screen, spans, view, chip ? { y: chip.row, x0: chip.left, x1: chip.right + 1 } : null);
+        }
+        applyGrowSelection(screen, g, spans, view);
+    }, [chatViewRows]);
+    /** Begin a selection that follows the conversation, if the press landed on it. */
+    const startGrow = useCallback((x, y) => {
+        const view = chatViewRows();
+        const screen = latestScreen();
+        if (!view || !screen || y < view.top || y >= view.bottom)
+            return false;
+        const focus = focusFromPointer(blockSpans(frameTopRef.current), view, x, y, screen.width);
+        if (!focus)
+            return false;
+        grow.current = { anchor: focus, focus, dragging: true };
+        rowStore.current.clear();
+        pointer.current = { x, y };
+        setFrameOverlay(growOverlay);
+        repaintOverlay();
+        return true;
+    }, [chatViewRows, growOverlay]);
+    /** While the pointer is held past an edge, keep scrolling, so the selection keeps growing. */
+    const keepScrolling = useCallback(() => {
+        if (edgeTimer.current)
+            return;
+        edgeTimer.current = setInterval(() => {
+            const view = chatViewRows();
+            const p = pointer.current;
+            if (!grow.current?.dragging || !view || !p)
+                return stopEdge();
+            const lines = edgeLines(p.y, view, latestScreen()?.height ?? process.stdout.rows ?? 24);
+            if (lines === 0)
+                return stopEdge();
+            scrollBy(lines);
+        }, EDGE_SCROLL_MS);
+    }, [chatViewRows, scrollBy, stopEdge]);
+    /** Copy everything between the two ends, and say so if some of it could not be. */
+    function copyGrown(g) {
+        const s = stateRef.current;
+        const ids = [...s.committed, ...s.tail].map((b) => b.id);
+        const grown = rowStore.current.text(g, ids, (id) => blockHeights.current.get(id)?.height);
+        // Only real text: a drag over empty space gathers nothing but line breaks, and copies nothing.
+        if (grown.text.trim())
+            copyToClipboard(grown.text);
+        if (!grown.complete)
+            note("Part of what you selected scrolled past too fast to be copied. Select it again, scrolling more slowly.");
+    }
+    /**
+     * The third click: the selected word becomes the whole line, in one step. The word stayed
+     * highlighted until now (the press did not take it down), so there is no moment with nothing
+     * selected between the two. What is copied is the line.
+     */
+    function selectLineOfWord() {
+        const g = grow.current;
+        const view = chatViewRows();
+        const screen = latestScreen();
+        if (!g || !view || !screen)
+            return;
+        const spans = blockSpans(frameTopRef.current);
+        const y = rowOfKey(spans, { id: g.anchor.id, off: g.anchor.off });
+        const line = y === null ? null : lineBounds(Array.from({ length: screen.width }, (_, cx) => screen.chars[screen.index(cx, y)]));
+        if (line) {
+            g.anchor = { ...g.anchor, x: line.from };
+            g.focus = { ...g.focus, x: line.to };
+        }
+        rowStore.current.clear();
+        const chip = pillHit.current;
+        rowStore.current.capture(screen, spans, view, chip ? { y: chip.row, x0: chip.left, x1: chip.right + 1 } : null);
+        repaintOverlay();
+        copyGrown(g);
+    }
+    /** The last click on the conversation, to tell clicks in a row from separate ones. */
+    const lastClick = useRef(null);
+    /**
+     * Clicking text selects it, and copies it, as a drag does. One click does nothing, so a stray
+     * click never takes anything; two clicks in a row, each soon after the last, take the word under
+     * the pointer; three take the whole line. A click that comes too late starts the count again.
+     * Returns false when nothing was taken (a first click, or a blank), so the click can do what it
+     * did before.
+     */
+    function selectClicked(x, y) {
+        const click = nextClick(lastClick.current, Date.now(), x, y, DOUBLE_CLICK_MS);
+        // Three is the most there is: the next click begins again.
+        lastClick.current = click.count >= 3 ? null : click;
+        if (click.count < 2)
+            return false;
+        const view = chatViewRows();
+        const screen = latestScreen();
+        if (!view || !screen || y < view.top || y >= view.bottom)
+            return false;
+        const spans = blockSpans(frameTopRef.current);
+        const at = focusFromPointer(spans, view, x, y, screen.width);
+        if (!at)
+            return false;
+        const cells = Array.from({ length: screen.width }, (_, cx) => screen.chars[screen.index(cx, y)]);
+        const range = click.count >= 3 ? lineBounds(cells) : wordBounds(cells, x);
+        if (!range)
+            return false;
+        const g = { anchor: { id: at.id, off: at.off, x: range.from }, focus: { id: at.id, off: at.off, x: range.to }, dragging: false };
+        grow.current = g;
+        rowStore.current.clear();
+        const chip = pillHit.current;
+        rowStore.current.capture(screen, spans, view, chip ? { y: chip.row, x0: chip.left, x1: chip.right + 1 } : null);
+        setFrameOverlay(growOverlay);
+        repaintOverlay();
+        copyGrown(g);
+        return true;
+    }
     // Mouse reporting itself is switched on and off by  — it belongs to
     // the shell, not to this component, because the inline shell must never have it on.
     // What is left here is the highlight, which has to come down when the app unmounts.
     useEffect(() => {
         if (!ready)
             return;
-        return () => setFrameOverlay(null);
-    }, [ready]);
+        return () => {
+            stopEdge();
+            setFrameOverlay(null);
+        };
+    }, [ready, stopEdge]);
     /**
      * Everything the pointer does, read through `useInput`.
      *
@@ -1485,14 +1770,23 @@ export function App({ resumeSessionId, initialScreen }) {
         // This is the same rule the input box already follows for keystrokes — one event
         // in, one render out — applied to the other thing that arrives in bursts.
         if (notches.length > 0) {
-            // Content moves out from under a selection when the view scrolls, so the
-            // highlight would be sitting on text that is no longer the text it copied.
-            clearSelection();
+            // Content moves out from under a SCREEN selection when the view scrolls, so the
+            // highlight would be sitting on text that is no longer the text it copied. One that
+            // follows the conversation stays, and grows if the button is still down.
+            if (!grow.current)
+                clearSelection();
             // Signed notch count, then the distance for it. The same distance for every notch,
             // applied at once (wheelStep.ts): how far the view goes follows how far the wheel
             // was turned, and nothing else.
             const net = notches.reduce((n, dir) => n + (dir === "up" ? 1 : -1), 0);
-            const lines = wheelLines(net);
+            let lines = wheelLines(net);
+            // With a selection alive no row may be scrolled past unseen: a step is never more than
+            // the view is tall, or the rows in between could not be copied.
+            if (grow.current) {
+                const view = chatViewRows();
+                const room = view ? Math.max(1, view.bottom - view.top - 1) : 16;
+                lines = Math.max(-room, Math.min(room, lines));
+            }
             // The wheel is how anyone actually scrolls, so in the inline shell it is what
             // opens the reading view. Turning it UP is the gesture: the reader is going back
             // through the conversation and wants the prompt to stay where they can type into
@@ -1536,12 +1830,53 @@ export function App({ resumeSessionId, initialScreen }) {
                     setScrollUp(0);
                     continue;
                 }
+                // The press that may be the THIRD click: a word is selected from the second, and this
+                // lands where it did, soon enough. The word is left up (a new selection would take
+                // it down) and the release decides: a click grows it to the line, a drag starts over.
+                const before = lastClick.current;
+                const word = grow.current;
+                if (before &&
+                    before.count === 2 &&
+                    Date.now() - before.at <= DOUBLE_CLICK_MS &&
+                    before.y === event.y &&
+                    Math.abs(before.x - event.x) <= 2 &&
+                    word &&
+                    !word.dragging &&
+                    !isEmptyGrow(word)) {
+                    pendingThird.current = { x: event.x, y: event.y };
+                    continue;
+                }
+                // A press on the conversation starts a selection that follows it. Anywhere else (the
+                // input box, the banner) it is the screen selection, which is what edits the input.
+                if (startGrow(event.x, event.y)) {
+                    selection.current = null;
+                    continue;
+                }
+                grow.current = null;
+                rowStore.current.clear();
+                pointer.current = null;
+                stopEdge();
                 selection.current = { anchor: { x: event.x, y: event.y }, focus: { x: event.x, y: event.y } };
                 // Installed here rather than for the life of the session: see clearSelection.
                 setFrameOverlay((screen) => applySelection(screen, selection.current));
                 repaintOverlay();
             }
             else if (event.kind === "drag") {
+                // The press that might have been a third click was the start of a drag: begin the
+                // selection it was always going to be, from where it was pressed.
+                if (pendingThird.current) {
+                    const at = pendingThird.current;
+                    pendingThird.current = null;
+                    lastClick.current = null;
+                    if (startGrow(at.x, at.y))
+                        selection.current = null;
+                }
+                if (grow.current?.dragging) {
+                    pointer.current = { x: event.x, y: event.y };
+                    pendingDrag = true;
+                    keepScrolling();
+                    continue;
+                }
                 if (!selection.current)
                     continue;
                 selection.current = { anchor: selection.current.anchor, focus: { x: event.x, y: event.y } };
@@ -1549,6 +1884,53 @@ export function App({ resumeSessionId, initialScreen }) {
             }
             else {
                 pendingDrag = false;
+                // The release of a press that kept the word up: a third click in time takes the line;
+                // anything else is an ordinary first click.
+                if (pendingThird.current) {
+                    pendingThird.current = null;
+                    const click = nextClick(lastClick.current, Date.now(), event.x, event.y, DOUBLE_CLICK_MS);
+                    if (click.count === 3) {
+                        lastClick.current = null;
+                        selectLineOfWord();
+                    }
+                    else {
+                        lastClick.current = click;
+                        clearSelection();
+                    }
+                    continue;
+                }
+                const g = grow.current;
+                if (g) {
+                    stopEdge();
+                    pointer.current = null;
+                    g.dragging = false;
+                    const view = chatViewRows();
+                    const screen = latestScreen();
+                    if (view && screen) {
+                        const focus = focusFromPointer(blockSpans(frameTopRef.current), view, event.x, event.y, screen.width);
+                        if (focus)
+                            g.focus = focus;
+                    }
+                    if (isEmptyGrow(g)) {
+                        // A click, not a drag: take the highlight down, then do what a click does.
+                        clearSelection();
+                        const hitId = expandableAt(event.y, frameTopRef.current, chatRef.current);
+                        if (hitId !== null) {
+                            lastClick.current = null;
+                            toggleRow(hitId);
+                            continue;
+                        }
+                        // Plain text: two clicks in a row take the word, three take the line.
+                        if (selectClicked(event.x, event.y))
+                            continue;
+                        placeCaretAt(event.x, event.y);
+                        continue;
+                    }
+                    // Copied on release, so selecting IS copying; the highlight stays as the receipt.
+                    copyGrown(g);
+                    repaintOverlay();
+                    continue;
+                }
                 const sel = selection.current;
                 if (!sel)
                     continue;
@@ -1602,6 +1984,11 @@ export function App({ resumeSessionId, initialScreen }) {
     /** Open or fold a row, keeping it where the reader pressed it. See the height effect. */
     function toggleRow(hit) {
         rowToggled.current = true;
+        toggledHit.current = hit;
+        toggledNewest.current = lastExpandable(stateRef.current) === hitBlock(hit);
+        // Opening or folding takes two renders, and the first is drawn with the view still placed
+        // for the old height. Keep that one off the screen; the effect below releases it.
+        holdFrames();
         // A hit on one command inside a commands row opens that command; anything else is a row.
         if (hitItem(hit) >= 0)
             dispatch({ type: "toggleItem", id: hitBlock(hit), index: hitItem(hit) });
@@ -1610,8 +1997,10 @@ export function App({ resumeSessionId, initialScreen }) {
     }
     function endTurn() {
         releaseLiveGates();
-        if (turnStart.current != null)
+        // A `!` command is not the agent working: no "Worked for" receipt for it.
+        if (turnStart.current != null && !userTurn.current)
             setLastMs(Date.now() - turnStart.current);
+        userTurn.current = false;
         // Settle every tool row this turn produced into its past-tense verb. The single
         // funnel for a turn ending (normal completion, error, interrupt), so no row is
         // left reading "Reading" once nothing is being read.
@@ -2037,7 +2426,7 @@ export function App({ resumeSessionId, initialScreen }) {
                         // loading a tool is never shown at all (see mcpSearch.ts).
                         if (e.name === "spawn_subagent" || neverShown(e.name))
                             return;
-                        const d = toolDisplay(e.name, e.args);
+                        const d = toolDisplay(e.name, e.args, session.current?.cwd ?? process.cwd());
                         if (e.agent) {
                             // A sub-agent's own tool call — fold it into that worker's nested rail.
                             enqueueReveal({ type: "subToolStart", agentId: e.agent, toolId: e.id, name: d.name, arg: d.arg, action: d.kind });
@@ -2159,6 +2548,54 @@ export function App({ resumeSessionId, initialScreen }) {
                 pump(); // ensure we drain to endTurn even if idle now
         }
     }
+    /**
+     * A command the person typed after `!`: run it now, in the project's shell, as THEIRS.
+     *
+     * It is drawn as a row of its own, `You ran 1 command`, that opens on the command and its output
+     * exactly as a command the agent ran does. It goes through the same pipeline as a turn only as far
+     * as the screen is concerned: the box is busy while it runs (so Esc stops it, and anything typed
+     * meanwhile is queued), and the row is revealed in order. No turn starts and the model is not
+     * called: the agent reads the command and its output on its next turn, from the entry
+     * `runUserCommand` adds to the conversation.
+     */
+    async function runShellForUser(s, command) {
+        startUserTurn();
+        userCommandRunning.current = true;
+        resetPacer();
+        lastRevealAt.current = 0;
+        streamDone.current = false;
+        flush.current = false;
+        const toolId = `user-${crypto.randomUUID()}`;
+        enqueueReveal({ type: "toolStart", toolId, name: "Run", arg: command, action: "run", group: true, at: Date.now(), byUser: true });
+        try {
+            const { result } = await runUserCommand(s, command, {
+                signal: abortRef.current?.signal,
+                onProgress: (text) => enqueueReveal({ type: "toolProgress", toolId, text }),
+            });
+            enqueueReveal({
+                type: "toolEnd",
+                toolId,
+                ok: !result.isError,
+                summary: result.summary,
+                detail: result.detail,
+                detailKind: result.detailKind,
+                detailFull: result.detailFull,
+            });
+        }
+        catch (error) {
+            enqueueReveal({ type: "toolEnd", toolId, ok: false, summary: `could not run: ${errText(error)}` });
+        }
+        finally {
+            userCommandRunning.current = false;
+            // The agent answers it, unless the person stopped it themselves with Esc (they ended it on purpose).
+            if (!abortRef.current?.signal.aborted)
+                wakeAfterUserCommand.current = true;
+            await saveSession(s);
+            streamDone.current = true;
+            if (!pumpTimer.current)
+                pump(); // drain to endTurn even if the row is already shown
+        }
+    }
     /**
      * Run a Marathon through this screen's own turn pipeline. It is the same `respond` loop
      * as any message, driven by `startMarathon`/`resumeMarathon`, so every tool row, token and
@@ -2616,7 +3053,11 @@ export function App({ resumeSessionId, initialScreen }) {
         if (name === "/help") {
             const skills = s.governance.skills ?? [];
             const mcpPrompts = s.toolContext.mcp?.promptCatalog() ?? [];
-            say(formatHelp([
+            // In the full-screen shell the list is set apart from the conversation (a click takes it
+            // away) instead of said into it: a list this long, drawn like the agent's own words, was
+            // hard to tell from what the agent said. The inline shell prints into the terminal's own
+            // scrollback, where nothing can be taken back, so it keeps saying it.
+            const helpText = formatHelp([
                 { title: "Commands", commands: BASE_COMMANDS },
                 {
                     title: "Project skills",
@@ -2629,7 +3070,11 @@ export function App({ resumeSessionId, initialScreen }) {
                         description: p.description || `prompt from ${p.server}`,
                     })),
                 },
-            ]));
+            ]);
+            if (shell === "inline")
+                say(helpText);
+            else
+                dispatch({ type: "help", text: helpText });
             return;
         }
         // /update — take the newer version and come back to this same conversation.
@@ -3309,6 +3754,20 @@ export function App({ resumeSessionId, initialScreen }) {
         const trimmed = value.trim();
         if (trimmed.length === 0 || busy || !ready)
             return;
+        // `!` runs what follows in the project's shell, as the person's own command: no question, no
+        // turn, nothing said to the model. See runShellForUser.
+        if (isUserCommandText(trimmed)) {
+            const s = session.current;
+            if (!s)
+                return;
+            const command = parseUserCommand(trimmed);
+            if (!command) {
+                note("Type the command after the !, for example: ! git status");
+                return;
+            }
+            await runShellForUser(s, command);
+            return;
+        }
         if (trimmed.startsWith("/")) {
             // Submitting clears the input, which closes the command list; the surface the command
             // opens can only arrive after the work it does first (reading sessions, refreshing
@@ -3439,7 +3898,7 @@ export function App({ resumeSessionId, initialScreen }) {
     const completions = [
         ...BASE_COMMANDS,
         ...skills.map((s) => ({ name: `/${s.name}`, description: s.description || "project skill" })),
-        ...mcpPrompts.map((p) => ({ name: promptCommand(p), description: p.description || `prompt from ${p.server}` })),
+        ...mcpPrompts.map((p) => ({ name: promptCommand(p), description: p.description || `prompt from ${p.server}`, quiet: true })),
     ];
     // While an overlay is open it renders in the menu slot below the input and owns the
     // keyboard; the input box itself stays visible but inert. `maxRows` is the App's
@@ -3533,7 +3992,7 @@ export function App({ resumeSessionId, initialScreen }) {
                 const here = p.id === active ? ` · on ${activeLabel}` : "";
                 return { label: p.label + (p.id === active ? "  ✓" : ""), description: `${models} · ${key}${here}` };
             });
-            return (_jsx(Picker, { title: "Choose a provider", items: items, width: width, maxRows: maxRows, initialIndex: Math.max(0, providers.findIndex((p) => p.id === active)), onSelect: onOverlaySelect, onCancel: onOverlayCancel }));
+            return (_jsx(Picker, { title: "Choose a provider", items: items, width: width, maxRows: maxRows, searchBox: providerSearch, initialIndex: Math.max(0, providers.findIndex((p) => p.id === active)), onSelect: onOverlaySelect, onCancel: onOverlayCancel }));
         }
         if (overlay.kind === "model") {
             const id = cur?.modelConfig.model ?? DEFAULT_MODEL_CONFIG.model;
@@ -3557,7 +4016,7 @@ export function App({ resumeSessionId, initialScreen }) {
                     keywords: m.id,
                 };
             });
-            return (_jsx(Picker, { title: `Choose ${/^[aeiou]/i.test(pickerProvider) ? "an" : "a"} ${pickerProvider} model`, items: items, width: width, maxRows: maxRows, initialIndex: Math.max(0, models.findIndex((m) => m.id === id)), initialFilter: overlay.filter, onSelect: onOverlaySelect, onCancel: onOverlayCancel }));
+            return (_jsx(Picker, { title: `Choose ${/^[aeiou]/i.test(pickerProvider) ? "an" : "a"} ${pickerProvider} model`, items: items, width: width, maxRows: maxRows, initialIndex: Math.max(0, models.findIndex((m) => m.id === id)), initialFilter: overlay.filter, searchBox: modelSearch, onSelect: onOverlaySelect, onCancel: onOverlayCancel }));
         }
         if (overlay.kind === "think") {
             const model = cur?.modelConfig.model ?? DEFAULT_MODEL_CONFIG.model;
@@ -3670,13 +4129,28 @@ export function App({ resumeSessionId, initialScreen }) {
     // surface — the pickers, the key manager, and the approval prompt — is content-only and
     // renders inside the input's one menu box below the input line. There is no separate
     // "boxed" overlay any more; the box is always the same, only its contents change.
+    // A list of models is searched, not scrolled (OpenRouter's catalogue is nearly three hundred),
+    // and the words are typed in the input box, which becomes the search field for as long as the
+    // list is open (see pickerSearch.ts). The same for every provider, so typing never lands on
+    // the picker's own bottom line while the chat box sits empty.
+    const modelSearchLabel = overlay?.kind === "model"
+        ? (overlay.providerId ? allProviders().find((p) => p.id === overlay.providerId)?.label : undefined) ??
+            providerOf(session.current?.modelConfig.model ?? DEFAULT_MODEL_CONFIG.model).label
+        : undefined;
+    const modelSearch = modelSearchLabel !== undefined;
+    // The provider list is searched the same way.
+    const providerSearch = overlay?.kind === "provider";
+    // The keys manager opens on its provider list, which is searched the same way, unless it was
+    // reached by picking a provider that has no key (it opens on that provider's key field).
+    const keysSearch = keysOpen && !pendingSwitch.current;
+    const searchPlaceholder = modelSearch ? `Search ${modelSearchLabel} models…` : providerSearch || keysSearch ? "Search providers…" : undefined;
     const overlayView = buildOverlayView(maxMenuItems);
     const runningShells = session.current?.toolContext.backgroundShells?.running() ?? [];
     // Where the transcript sits in the viewport, and how far it can travel. Extracted
     // to `chatAnchor.ts` so the rule is unit-tested rather than eyeballed — see there
     // for why a short transcript now rests ON the input box instead of stranding
     // itself at the top of the screen, and why that cannot disturb a scrolled frame.
-    const { marginTop: chatOffset, restsOnFooter, maxScroll, scrolled } = chatLayout(contentHeight, chatRows, scrollUp);
+    const { marginTop: chatOffset, maxScroll, scrolled } = chatLayout(contentHeight, chatRows, scrollUp);
     // Published for the scroll handlers, which run between frames and cannot compute it.
     maxScrollRef.current = maxScroll;
     // The chip that says the view is not at the bottom. `scrolled` and not `scrollUp`:
@@ -3753,6 +4227,15 @@ export function App({ resumeSessionId, initialScreen }) {
         // carried off by a resize they did not intend as navigation. Applied once the new
         // height has actually been measured — see the effect that consumes this.
         reflowFrom.current = { scrolled: scrollUp, maxScroll: Math.max(0, contentHeight - chatRows) };
+        // A re-wrap changes how many rows every block has, so the rows kept for a selection no
+        // longer line up with what is on screen. Dropped without a repaint (this is a render).
+        if (grow.current) {
+            grow.current = null;
+            rowStore.current.clear();
+            pointer.current = null;
+            stopEdge();
+            setFrameOverlay(null);
+        }
     }
     // Only a MEASURED prefix can be virtualized: a block whose height is unknown cannot
     // be replaced by a spacer, because there is no honest number to give the spacer.
@@ -3798,11 +4281,11 @@ export function App({ resumeSessionId, initialScreen }) {
     // The status line, the queued bar, the input and whatever sits under it. Built once
     // and rendered by BOTH shells: the only thing that differs between them is where it
     // ends up — pinned to the bottom of a frame we own, or simply the last thing printed.
-    const footerView = (_jsxs(Box, { ref: footerRef, flexDirection: "column", flexShrink: 0, children: [_jsx(Box, { flexShrink: 0, children: _jsx(Text, { children: " " }) }), _jsx(Box, { flexShrink: 0, children: _jsx(StatusLine, { busy: busy, startedAt: turnStart.current, lastMs: lastMs, usage: taskUsage, received: liveTokens, advance: advanceTokens, waiting: overlay?.kind === "approval", waited: () => waitedMs.current + (waitSince.current != null ? Date.now() - waitSince.current : 0) }) }), _jsx(Box, { flexShrink: 0, children: _jsx(QueuedBar, { queued: queued }) }), marathonUi ? (_jsx(Box, { flexShrink: 0, children: _jsx(MarathonBox, { ui: marathonUi, width: width, cap: shell === "inline" ? 4 : 7 }) })) : null, _jsx(Box, { flexShrink: 0, flexDirection: "column", children: ready ? (_jsx(PromptInput, { onSubmit: onSend, opening: opening, disabled: false, placeholder: marathonUi?.phase === "armed" ? "describe the goal…" : busy ? "type to queue a message…" : "say something…", width: width, history: history, completions: completions, pathComplete: pathComplete.current, onLargePaste: registerPaste, onDroppedPaths: (text) => dropHandles.current.register(text), registerCaretClick: (place) => {
+    const footerView = (_jsxs(Box, { ref: footerRef, flexDirection: "column", flexShrink: 0, children: [_jsx(Box, { flexShrink: 0, children: _jsx(Text, { children: " " }) }), _jsx(Box, { flexShrink: 0, children: _jsx(StatusLine, { busy: busy, userCommand: busy && userTurn.current, startedAt: turnStart.current, lastMs: lastMs, usage: taskUsage, received: liveTokens, advance: advanceTokens, waiting: overlay?.kind === "approval", waited: () => waitedMs.current + (waitSince.current != null ? Date.now() - waitSince.current : 0) }) }), _jsx(Box, { flexShrink: 0, children: _jsx(QueuedBar, { queued: queued }) }), marathonUi ? (_jsx(Box, { flexShrink: 0, children: _jsx(MarathonBox, { ui: marathonUi, width: width, cap: shell === "inline" ? 4 : 7 }) })) : null, _jsx(Box, { flexShrink: 0, flexDirection: "column", children: ready ? (_jsx(PromptInput, { onSubmit: onSend, opening: opening, disabled: false, placeholder: marathonUi?.phase === "armed" ? "describe the goal…" : busy ? "type to queue a message…" : "say something…", width: width, history: history, completions: completions, pathComplete: pathComplete.current, onLargePaste: registerPaste, onDroppedPaths: (text) => dropHandles.current.register(text), registerCaretClick: (place) => {
                         caretClick.current = place;
                     }, registerTextSelect: (select) => {
                         textSelect.current = select;
-                    }, maxMenuRows: maxMenuItems, menuAbove: shell === "inline", settleKey: committed.length, onMenuChange: onMenuChange, placeCursor: shell === "inline", onQueuePop: popQueue, overlay: overlayView, fill: fill })) : (_jsx(Box, { paddingX: 1, children: _jsx(Text, { dimColor: true, children: "starting\u2026" }) })) }), ctxWarn ? (
+                    }, maxMenuRows: maxMenuItems, menuAbove: shell === "inline", settleKey: committed.length, onMenuChange: onMenuChange, placeCursor: shell === "inline", onQueuePop: popQueue, overlay: overlayView, ...(searchPlaceholder ? { searchPlaceholder } : {}), fill: fill })) : (_jsx(Box, { paddingX: 1, children: _jsx(Text, { dimColor: true, children: "starting\u2026" }) })) }), ctxWarn ? (
             // A compaction is near. This takes the line over the tip and the background bar:
             // it is the one thing here the user needs BEFORE it happens, since the summarizing
             // pass rewrites the conversation. Dim as it approaches, then a plain warning colour
@@ -3815,18 +4298,31 @@ export function App({ resumeSessionId, initialScreen }) {
     // Yoga sizes against a pinned footer, with the transcript offset inside it. Kept as
     // two copies they would drift apart the first time either was touched, and the drift
     // would show as scrolling behaving differently in one shell than in the other.
-    const chatView = (_jsxs(Box, { ref: chatRef, flexDirection: "column", flexGrow: 1, flexShrink: 1, minHeight: 1, overflow: "hidden", children: [restsOnFooter ? _jsx(Box, { flexGrow: 1, flexShrink: 1 }) : null, _jsx(Box, { flexDirection: "column", flexShrink: 0, marginTop: chatOffset, children: _jsxs(Box, { ref: contentRef, flexDirection: "column", flexShrink: 0, children: [win.padTop > 0 ? _jsx(Box, { flexShrink: 0, height: win.padTop }) : null, rendered.slice(win.start, win.end).map((b, i) => {
+    // Pinned to the newest, the transcript is ALIGNED to the bottom of the viewport by the layout
+    // itself (flex-end) instead of being offset by a number. The number comes from measurements
+    // that lag a frame: when the footer grows (a menu opens, the input takes a second line) or a
+    // row lands, the first frame was drawn with the old numbers, so for a moment the view showed
+    // the wrong part of the conversation. Yoga decides alignment in the same pass that sizes the
+    // frame, so there is nothing stale to be wrong about. A short conversation rests on the
+    // footer by the same rule, which is what the spacer that used to be here did.
+    //
+    // Scrolled back, the offset has to be a number again (nothing but a distance from the top
+    // can hold a position while content is appended), and `growScroll` keeps it right.
+    const pinnedView = scrolled === 0;
+    const chatView = (_jsxs(Box, { ref: chatRef, flexDirection: "column", flexGrow: 1, flexShrink: 1, minHeight: 1, overflow: "hidden", justifyContent: pinnedView ? "flex-end" : "flex-start", children: [_jsx(Box, { flexDirection: "column", flexShrink: 0, marginTop: pinnedView ? 0 : chatOffset, children: _jsxs(Box, { ref: contentRef, flexDirection: "column", flexShrink: 0, children: [win.padTop > 0 ? _jsx(Box, { flexShrink: 0, height: win.padTop }) : null, rendered.slice(win.start, win.end).map((b, i) => {
                             const idx = win.start + i;
                             return (
                             // flexShrink:0 is load-bearing — without it Yoga compresses an
                             // overfull column and silently drops rows out of the middle.
                             _jsx(Box, { ref: (node) => {
+                                    registerBlockBox(b.id, node);
                                     if (node && needsMeasure(blockHeights.current.get(b.id), b))
                                         toMeasure.current.set(b, node);
                                 }, flexShrink: 0, flexDirection: "column", children: _jsx(BlockView, { block: b, columns: width, tightTop: isTight(allBlocks, offset + idx), hovered: hoverId !== null && hitBlock(hoverId) === b.id && hitItem(hoverId) < 0, hoveredItem: hoverId !== null && hitBlock(hoverId) === b.id ? hitItem(hoverId) : -1 }) }, b.id));
                         }), padMiddle > 0 ? _jsx(Box, { flexShrink: 0, height: padMiddle }) : null, rendered.slice(known).map((b, i) => {
                             const idx = known + i;
                             return (_jsx(Box, { ref: (node) => {
+                                    registerBlockBox(b.id, node);
                                     if (node && needsMeasure(blockHeights.current.get(b.id), b))
                                         toMeasure.current.set(b, node);
                                 }, flexShrink: 0, flexDirection: "column", children: _jsx(BlockView, { block: b, columns: width, tightTop: isTight(allBlocks, offset + idx), hovered: hoverId !== null && hitBlock(hoverId) === b.id && hitItem(hoverId) < 0, hoveredItem: hoverId !== null && hitBlock(hoverId) === b.id ? hitItem(hoverId) : -1 }) }, b.id));
@@ -4287,7 +4783,7 @@ function timeAgo(ms) {
  * line above separating it from the conversation, where the
  * receipt belongs to the prompt area, not glued to the last reply.
  */
-function StatusLine({ busy, startedAt, lastMs, usage, received, advance, waiting, waited, }) {
+function StatusLine({ busy, userCommand, startedAt, lastMs, usage, received, advance, waiting, waited, }) {
     // The render clock while busy: it advances the elapsed timer AND steps the eased token
     // counter one frame. It runs at about the display's pace (16ms): the number reads as counting
     // rather than as jumping, and the working dot moves smoothly. It was 50ms (20 frames a
@@ -4320,7 +4816,7 @@ function StatusLine({ busy, startedAt, lastMs, usage, received, advance, waiting
         // did. Output is
         // also the only thing that grows continuously while a turn runs, so it animates cleanly.
         const got = received();
-        label = (_jsxs(Text, { children: [" ", waiting ? "Waiting for your answer" : workingVerb(startedAt, Date.now() - startedAt - waited()), "\u2026", "  ", _jsxs(Text, { dimColor: true, children: ["< ", fmtElapsed(secs), got > 0 ? ` · ↓ ${formatTokens(got)} tokens` : "", " >"] })] }));
+        label = userCommand ? (_jsxs(Text, { children: [" ", "Running your command\u2026", "  ", _jsxs(Text, { dimColor: true, children: ["< ", fmtElapsed(secs), " >"] })] })) : (_jsxs(Text, { children: [" ", waiting ? "Waiting for your answer" : workingVerb(startedAt, Date.now() - startedAt - waited()), "\u2026", "  ", _jsxs(Text, { dimColor: true, children: ["< ", fmtElapsed(secs), got > 0 ? ` · ↓ ${formatTokens(got)} tokens` : "", " >"] })] }));
     }
     else if (lastMs != null) {
         // Settled receipt: elapsed time and the turn's real token cost, shown at once,
@@ -4347,6 +4843,10 @@ function StatusLine({ busy, startedAt, lastMs, usage, received, advance, waiting
     // component rendering nothing at all. Two would read as a hole.
     return (_jsxs(Box, { marginBottom: 0, children: [dot, label] }));
 }
+/** How often the view scrolls while a drag is held past the edge of the conversation. */
+/** The longest wait between two clicks for them to count as a double (or triple) click. */
+const DOUBLE_CLICK_MS = 500;
+const EDGE_SCROLL_MS = 45;
 /** The working line's render clock, in milliseconds. See StatusLine's tick. */
 const LIVE_TICK_MS = 16;
 function fmtElapsed(s) {