mindweave 3.2.8 → 3.4.0

package/dist/cli/App.js

@@ -81,7 +81,9 @@ 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";
@@ -93,13 +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, RowStore } from "./selectionGrow.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, revealScroll } 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";
@@ -107,7 +109,7 @@ import { countNewReplies, hitsPill, pillBounds, scrollPill } from "./scrollPill.
 import { SCROLLBACK_BLOCKS, virtualWindow } from "./virtualWindow.js";
 import { perf, perfEnabled } from "./perfLog.js";
 import { newPacer, nextHoldAt, nextMove, takeImmediate, takePaced } from "./revealQueue.js";
-import { drain as drainQueue, popAll as popAllQueued, queueMessage, takeSteerable, visibleQueue } from "./messageQueue.js";
+import { drain as drainQueue, popAll as popAllQueued, queueMessage, takeSteerable } from "./messageQueue.js";
 import { routeCommand, parseCommandLine, unknownCommandMessage } from "./commandRoute.js";
 import { resolveChoice, splitModelArg } from "./commandArgs.js";
 import { carryAcrossFreshSession } from "./sessionCarry.js";
@@ -239,6 +241,11 @@ export function App({ resumeSessionId, initialScreen }) {
             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.
      *
@@ -256,9 +263,10 @@ export function App({ resumeSessionId, initialScreen }) {
         rowStore.current.clear();
         pointer.current = null;
         stopEdge();
+        dropPendingThird();
         repaintOverlay();
         setFrameOverlay(null);
-    }, [stopEdge]);
+    }, [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);
@@ -351,6 +359,14 @@ export function App({ resumeSessionId, initialScreen }) {
     /** The chip's cells in SCREEN coordinates, for the pointer handler. Null when there is
      *  nothing to click. Published by the render, read between frames. */
     const pillHit = useRef(null);
+    /** The queued line's row within the live region (measured as it is drawn), and its screen row for a click. */
+    const queueRow = useRef(null);
+    // Steered messages that left the queue but have not reached the chat yet (see steerRunningTurn).
+    const [departing, setDeparting] = useState([]);
+    const departingRef = useRef(0);
+    const queueHitRow = useRef(null);
+    /** Pulls the queue back into the input box to edit (installed by the input, as the caret click is). */
+    const pullQueue = useRef(null);
     // Where the layout's first row sits on the screen, published each render for the pointer.
     const frameTopRef = useRef(0);
     // The row the pointer is over, if it can be pressed. State rather than a ref: it is what
@@ -371,6 +387,9 @@ export function App({ resumeSessionId, initialScreen }) {
     // 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
@@ -419,6 +438,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
@@ -689,6 +719,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)
@@ -699,6 +730,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 —" });
@@ -723,7 +771,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,
@@ -752,6 +800,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") {
@@ -998,10 +1052,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
@@ -1054,6 +1112,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;
@@ -1064,6 +1123,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.
@@ -1113,6 +1186,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
@@ -1122,8 +1198,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);
@@ -1465,6 +1543,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));
     });
     /**
@@ -1584,11 +1671,73 @@ export function App({ resumeSessionId, initialScreen }) {
         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);
-        if (grown.text)
+        // 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.
@@ -1682,6 +1831,12 @@ export function App({ resumeSessionId, initialScreen }) {
                 // On PRESS rather than release: the chip is a single row and the view moves out
                 // from under the pointer the instant it is hit, so a release-matched-to-press
                 // would be testing the pointer against a screen that had already changed.
+                // The queued line is a button too: a click on it takes the queue back into the box to edit.
+                if (queueHitRow.current !== null && event.y === queueHitRow.current && pullQueue.current) {
+                    clearSelection();
+                    pullQueue.current();
+                    continue;
+                }
                 const hit = pillHit.current;
                 if (hit && hitsPill(hit, event.x, event.y)) {
                     clearSelection();
@@ -1689,6 +1844,22 @@ 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)) {
@@ -1705,6 +1876,15 @@ export function App({ resumeSessionId, initialScreen }) {
                 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;
@@ -1718,6 +1898,21 @@ 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();
@@ -1735,9 +1930,13 @@ export function App({ resumeSessionId, initialScreen }) {
                         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;
                     }
@@ -1812,8 +2011,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.
@@ -2041,6 +2242,8 @@ export function App({ resumeSessionId, initialScreen }) {
         holdTimer.current = null;
         revealQ.current = [];
         pacer.current = newPacer(revealQ.current);
+        departingRef.current = 0;
+        setDeparting([]);
     }
     function enqueueReveal(a) {
         revealQ.current.push(a);
@@ -2090,6 +2293,13 @@ export function App({ resumeSessionId, initialScreen }) {
         // same de-sync risk a reveal carries, so the banner is healed on the same frame.
         requestFullRepaint();
         applyBatch(actions);
+        // A steered message that has just reached the chat stops showing in the queue line.
+        const arrived = departingRef.current > 0 ? actions.filter((a) => a.type === "user").length : 0;
+        if (arrived > 0) {
+            const n = Math.min(arrived, departingRef.current);
+            departingRef.current -= n;
+            setDeparting((d) => d.slice(n));
+        }
     }
     function pace() {
         return {
@@ -2177,23 +2387,35 @@ export function App({ resumeSessionId, initialScreen }) {
      * rows around it.
      */
     async function steerRunningTurn(s) {
+        // Never into a turn that has been stopped (Esc, ctrl+F, an interrupted command). Handed over at its
+        // last step boundary, a message queued BEFORE the stop was drawn in the chat, put in the transcript
+        // and never answered, because nothing runs after a stopped turn. It stays queued and goes out as
+        // the next turn, which is what the person who typed it expects.
+        if (abortRef.current?.signal.aborted)
+            return [];
         const { send, rest } = takeSteerable(queueRef.current);
         if (send.length === 0)
             return [];
         queueRef.current = rest;
-        setQueued(rest);
         const out = [];
+        const shown = [];
         for (const { text } of send) {
             // No history write here: `onSend` records every message the moment it is typed,
             // queued or not, so ↑ walks them in the order they were written rather than the
             // order they happened to go out. Recording again on the way out appended each one
             // a second time.
             const { content, displayText, notes, images } = await prepareMessage(s, text);
-            enqueueReveal({ type: "user", text: displayText });
-            for (const n of notes)
-                enqueueReveal({ type: "note", text: n });
+            shown.push({ type: "user", text: displayText }, ...notes.map((n) => ({ type: "note", text: n })));
             out.push({ content, ...(images.length > 0 ? { images } : {}) });
         }
+        // The message leaves the queue line in the same paint it reaches the chat, so it is never on
+        // neither. Behind other rows it waits its beat in the chat's order, so the queue line keeps
+        // showing it (`departing`) until then.
+        setDeparting((d) => [...d, ...send]);
+        departingRef.current += send.length;
+        setQueued([...queueRef.current]);
+        for (const a of shown)
+            enqueueReveal(a);
         return out;
     }
     async function streamRespond(s, run) {
@@ -2239,7 +2461,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 });
@@ -2361,6 +2583,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
@@ -2818,7 +3088,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",
@@ -2831,7 +3105,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.
@@ -3511,6 +3789,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
@@ -3633,6 +3925,36 @@ export function App({ resumeSessionId, initialScreen }) {
         }
         void handleSubmit(text);
     }
+    /**
+     * ctrl+F: send NOW, the way the queue sends, at the first moment that loses nothing.
+     *
+     * It is the queue, not a second mechanism: the message goes in the same queue and reaches the agent
+     * by the same road (handed to the running turn when its step ends). What it adds is a way to make
+     * that moment come SOONER, and the only thing that holds a step up for long without anyone's
+     * leave is a command the turn is waiting on. That is moved to the background, as ctrl+X moves it:
+     * it keeps running, the step ends at once, the message arrives, and the agent is told the command
+     * is still going and hears when it ends. Nothing is stopped, killed or thrown away; only Esc, or
+     * the person asking, does that.
+     *
+     * A reply being written, a compaction or a sub-agent has no such handle and is left alone: the
+     * message arrives the moment it ends, exactly as it would have through Enter.
+     */
+    function forceSend(text) {
+        if (!busy && queueRef.current.length === 0) {
+            // Idle: nothing is in the way, so it is Enter.
+            if (text)
+                onSend(text);
+            return;
+        }
+        if (text) {
+            setScrollUp(0);
+            setHistory((h) => (h[h.length - 1] === text ? h : [...h, text]));
+            queueRef.current.push(queueMessage(text, { interrupting: interrupting.current }));
+            setQueued([...queueRef.current]);
+        }
+        if (busy)
+            pressBackground(session.current?.toolContext.foregroundCommands);
+    }
     // Autocomplete entries: the built-in slash commands, this project's skills, and any
     // prompts the connected MCP servers offer (all read from the live session, so a freshly
     // created skill — or a server that just finished connecting — shows up next render).
@@ -3685,36 +4007,36 @@ export function App({ resumeSessionId, initialScreen }) {
             return null;
         const cur = session.current;
         if (overlay.kind === "app") {
-            return (_jsx(Picker, { title: "Mindweave desktop app", note: APP_EXPLANATION, items: [{ label: "Open the download page", description: "opens your default browser" }], width: width, maxRows: maxRows, initialIndex: 0, onSelect: onOverlaySelect, onCancel: onOverlayCancel }));
+            return (_jsx(Picker, { title: "Mindweave desktop app", note: APP_EXPLANATION, items: [{ label: "Open the download page", description: "opens your default browser" }], width: width, maxRows: maxRows, initialIndex: 0, onSelect: onOverlaySelect, onCancel: onOverlayCancel }, overlay.kind));
         }
         if (overlay.kind === "rewind") {
             const items = overlay.items.map((p) => ({
                 label: p.text,
                 description: [timeAgo(p.at), changeSummary(p)].filter(Boolean).join(" · "),
             }));
-            return (_jsx(Picker, { title: "Rewind to before which message?", items: items, width: width, maxRows: maxRows, rightAlignDescription: true, onSelect: onOverlaySelect, onCancel: onOverlayCancel }));
+            return (_jsx(Picker, { title: "Rewind to before which message?", items: items, width: width, maxRows: maxRows, rightAlignDescription: true, onSelect: onOverlaySelect, onCancel: onOverlayCancel }, overlay.kind));
         }
         if (overlay.kind === "rewindConfirm") {
             const p = overlay.point;
             const quoted = p.text.length > 48 ? `${p.text.slice(0, 47)}…` : p.text;
-            return (_jsx(Picker, { title: `Rewind to before “${quoted}”?`, items: rewindChoices(p).map(({ label, description }) => ({ label, description })), describeSelection: true, width: width, maxRows: maxRows, onSelect: onOverlaySelect, onCancel: onOverlayCancel }));
+            return (_jsx(Picker, { title: `Rewind to before “${quoted}”?`, items: rewindChoices(p).map(({ label, description }) => ({ label, description })), describeSelection: true, width: width, maxRows: maxRows, onSelect: onOverlaySelect, onCancel: onOverlayCancel }, overlay.kind));
         }
         if (overlay.kind === "sessions") {
             const items = overlay.items.map((m) => ({
                 label: sessionTitle(m),
                 description: `${timeAgo(m.updatedAt)} · ${m.entryCount} msg${m.entryCount === 1 ? "" : "s"}`,
             }));
-            return (_jsx(Picker, { title: "Continue which session?", items: items, width: width, maxRows: maxRows, rightAlignDescription: true, onSelect: onOverlaySelect, onCancel: onOverlayCancel }));
+            return (_jsx(Picker, { title: "Continue which session?", items: items, width: width, maxRows: maxRows, rightAlignDescription: true, onSelect: onOverlaySelect, onCancel: onOverlayCancel }, overlay.kind));
         }
         if (overlay.kind === "resumeMode") {
-            return (_jsx(Picker, { title: `Continue “${sessionTitle(overlay.meta)}” — how?`, items: RESUME_MODES, width: width, maxRows: maxRows, onSelect: onOverlaySelect, onCancel: onOverlayCancel }));
+            return (_jsx(Picker, { title: `Continue “${sessionTitle(overlay.meta)}” — how?`, items: RESUME_MODES, width: width, maxRows: maxRows, onSelect: onOverlaySelect, onCancel: onOverlayCancel }, overlay.kind));
         }
         if (overlay.kind === "shells") {
             const items = overlay.items.map((sh) => ({
                 label: `#${sh.id} ${clipCmd(sh.command)}`,
                 description: sh.status === "running" ? `running ${shellElapsed(sh)} — Enter to stop` : sh.status === "killed" ? "killed" : `exited ${sh.exitCode}`,
             }));
-            return (_jsx(Picker, { title: "Background shells", items: items, width: width, maxRows: maxRows, onSelect: onOverlaySelect, onCancel: onOverlayCancel }));
+            return (_jsx(Picker, { title: "Background shells", items: items, width: width, maxRows: maxRows, onSelect: onOverlaySelect, onCancel: onOverlayCancel }, overlay.kind));
         }
         if (overlay.kind === "provider") {
             const activeModel = cur?.modelConfig.model ?? DEFAULT_MODEL_CONFIG.model;
@@ -3735,7 +4057,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 }, overlay.kind));
         }
         if (overlay.kind === "model") {
             const id = cur?.modelConfig.model ?? DEFAULT_MODEL_CONFIG.model;
@@ -3759,14 +4081,14 @@ 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 }, overlay.kind));
         }
         if (overlay.kind === "think") {
             const model = cur?.modelConfig.model ?? DEFAULT_MODEL_CONFIG.model;
             const levels = thinkLevels(model);
             const curLabel = cur ? thinkLabel(cur.modelConfig) : "";
             const items = levels.map((l) => ({ label: l.label + (l.label === curLabel ? "  ✓" : ""), description: l.description }));
-            return (_jsx(Picker, { title: `Reasoning for ${modelLabel(model)}`, items: items, width: width, maxRows: maxRows, initialIndex: Math.max(0, levels.findIndex((l) => l.label === curLabel)), onSelect: onOverlaySelect, onCancel: onOverlayCancel }));
+            return (_jsx(Picker, { title: `Reasoning for ${modelLabel(model)}`, items: items, width: width, maxRows: maxRows, initialIndex: Math.max(0, levels.findIndex((l) => l.label === curLabel)), onSelect: onOverlaySelect, onCancel: onOverlayCancel }, overlay.kind));
         }
         if (overlay.kind === "screen") {
             const choices = screenChoices(shell);
@@ -3776,7 +4098,7 @@ export function App({ resumeSessionId, initialScreen }) {
                 describeSelection: true, 
                 // Opens on the one in use, so Enter alone changes nothing. A chooser that opens
                 // somewhere else turns a glance at the options into an accidental switch.
-                initialIndex: Math.max(0, choices.findIndex((c) => c.mode === shell)), onSelect: onOverlaySelect, onCancel: onOverlayCancel }));
+                initialIndex: Math.max(0, choices.findIndex((c) => c.mode === shell)), onSelect: onOverlaySelect, onCancel: onOverlayCancel }, overlay.kind));
         }
         // approval — a plan, a Sentinel action, a forbidden-path lift. It interrupts the user's
         // work and the answer commits them to something, so it reads as a stop; it renders in
@@ -3872,6 +4194,21 @@ 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
@@ -3908,6 +4245,7 @@ export function App({ resumeSessionId, initialScreen }) {
     const frameTop = readingInline ? Math.max(0, rows - frameHeight) : 0;
     frameTopRef.current = frameTop;
     pillHit.current = pill !== null && pillRow.current !== null ? pillBounds(pill, width, frameTop + pillRow.current) : null;
+    queueHitRow.current = queueRow.current !== null ? frameTop + queueRow.current : null;
     // The whole conversation stays reachable: the cap is only a safety valve (see
     // SCROLLBACK_BLOCKS). Blocks outside the window cost one number each here and nothing
     // in Yoga, which only ever sees the window and its spacers.
@@ -4009,11 +4347,15 @@ 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, marginBottom: queued.length + departing.length > 0 ? 1 : 0, ref: (node) => {
+                    queueRow.current = node && queued.length + departing.length > 0 ? measureElement(node).y : null;
+                }, children: _jsx(QueuedBar, { queued: [...departing, ...queued] }) }), _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) }) }), 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, onForceSend: forceSend, 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 ? (
+                    }, registerQueuePull: (pull) => {
+                        pullQueue.current = pull;
+                    }, 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
@@ -4511,22 +4853,33 @@ 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
     // second), which was the slowest-looking thing on a screen that could draw three times as
     // often, and at 1Hz before that it moved once a second in whatever lump had arrived, which
-    // is a stutter, not an animation. A tick costs about a millisecond now that unchanged rows
-    // are not rebuilt (see inkOutputPatch.ts). Nothing else re-renders with it: the tick is this
-    // component's own state and the figure is read through a getter, so the cost is one
-    // small subtree per frame.
+    // is a stutter, not an animation. Only the easing advances on every tick; a render is asked for
+    // only when the line's text would change (see below), because a tick that draws the same text
+    // still costs a whole pass through layout and the terminal writer, about a millisecond each,
+    // sixty times a second, for the whole time the agent works.
     const [, tick] = useState(0);
+    // The line as the last render drew it, and the line as it would be drawn now. The clock below runs
+    // at the display's pace to keep the counter easing smoothly, but a render that would draw the same
+    // text is a whole pass through layout and the terminal writer for nothing, and most ticks are that:
+    // the seconds change once a second and the count only when the eased figure moves a whole step.
+    // Read through a ref so the interval never has to be torn down when the props change.
+    const drawn = useRef("");
+    const nowKey = useRef(() => "");
+    nowKey.current = () => (busy && startedAt != null ? statusKey(userCommand, waiting, startedAt, waited(), received()) : "");
+    drawn.current = nowKey.current();
     useEffect(() => {
         if (!busy)
             return;
         const id = setInterval(() => {
             advance();
+            if (nowKey.current() === drawn.current)
+                return;
             tick((t) => t + 1);
         }, LIVE_TICK_MS);
         return () => clearInterval(id);
@@ -4544,7 +4897,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,
@@ -4572,9 +4925,21 @@ function StatusLine({ busy, startedAt, lastMs, usage, received, advance, waiting
     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;
+/**
+ * Everything the working line's text is made of, as one string (pure). Two equal keys draw the same
+ * line, so a render for an unchanged key can be skipped. Built from the same calls the line uses.
+ */
+export function statusKey(userCommand, waiting, startedAt, waitedMs, got) {
+    const secs = workedSeconds(Date.now(), startedAt, waitedMs);
+    if (userCommand)
+        return `u|${fmtElapsed(secs)}`;
+    return `${waiting ? "w" : workingVerb(startedAt, Date.now() - startedAt - waitedMs)}|${fmtElapsed(secs)}|${got > 0 ? formatTokens(got) : ""}`;
+}
 function fmtElapsed(s) {
     return s < 60 ? `${s}s` : `${Math.floor(s / 60)}m ${s % 60}s`;
 }
@@ -4640,11 +5005,18 @@ function bgClock(ms) {
  * you cannot see the handle on — ↑ is not a thing anyone guesses, and the cost of not
  * guessing it is a message you no longer wanted being sent anyway.
  */
+/**
+ * What is waiting to be sent, on ONE line shaped like a work row: the marker, what it is, a dot
+ * between the parts, the key that sends it, and the arrow that opens it (a click pulls the queue back
+ * into the box to edit, as the up key does). Long text is cut so the key and the arrow always stay
+ * on the line.
+ */
 function QueuedBar({ queued }) {
     if (queued.length === 0)
         return null;
-    const { rows, hidden } = visibleQueue(queued);
-    return (_jsxs(Box, { flexDirection: "column", children: [rows.map((q, i) => (_jsxs(Text, { dimColor: true, wrap: "truncate-end", children: ["⏎ queued: ", q.text] }, i))), hidden > 0 ? (_jsx(Text, { dimColor: true, children: `  …and ${hidden} more` })) : null, _jsx(Text, { dimColor: true, children: `  ↑ to edit ${queued.length === 1 ? "it" : "them"}` })] }));
+    const first = queued[0].text.replace(/\s+/g, " ").trim();
+    const more = queued.length - 1;
+    return (_jsxs(Box, { flexShrink: 0, children: [_jsx(Text, { dimColor: true, children: "● " }), _jsx(Box, { flexShrink: 1, children: _jsxs(Text, { dimColor: true, wrap: "truncate-end", children: ["queued: ", first] }) }), _jsx(Box, { flexShrink: 0, children: _jsxs(Text, { dimColor: true, children: [more > 0 ? `  ·  ${more} more` : "", "  ·  ctrl+F to send now  ", "▸"] }) })] }));
 }
 /**
  * Whether some OTHER installed provider has a key, so `/provider` is worth