mindweave 3.2.8 → 3.3.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";
@@ -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);
@@ -371,6 +379,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 +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
@@ -689,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)
@@ -699,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 —" });
@@ -723,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,
@@ -752,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") {
@@ -998,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
@@ -1054,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;
@@ -1064,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.
@@ -1113,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
@@ -1122,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);
@@ -1465,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));
     });
     /**
@@ -1584,11 +1663,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.
@@ -1689,6 +1830,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 +1862,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 +1884,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 +1916,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 +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.
@@ -2239,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 });
@@ -2361,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
@@ -2818,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",
@@ -2831,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.
@@ -3511,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
@@ -3735,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;
@@ -3759,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;
@@ -3872,6 +4129,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
@@ -4009,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
@@ -4511,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
@@ -4544,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,
@@ -4572,6 +4844,8 @@ 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;