mindweave 3.2.7 → 3.2.8

package/dist/cli/App.js

@@ -77,8 +77,9 @@ import { parseScreenArg, screenChoices, screenNotice, startupMode } from "./scre
 import { applyScreenMode } from "./screenShell.js";
 import { saveScreenMode } from "./screenStore.js";
 import { FULL_TAIL_BLOCKS, needsMeasure, pruneHeights, seedHeights } from "./blockHeights.js";
-import { expandableAt, hitBlock, hitItem } from "./expandHits.js";
+import { expandableAt, hitBlock, hitItem, revealNode } from "./expandHits.js";
 import { shellNote } from "./shellNotes.js";
+import { pressBackground } from "./commandBackground.js";
 import { readFileSync, statSync } from "node:fs";
 import { compactUiDetail, rebuildFull, writtenFromDisk } from "../tools/rebuildDetail.js";
 import { shownText } from "../memory/compaction.js";
@@ -92,10 +93,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 { blockSpans, registerBlockBox } from "./blockBoxes.js";
+import { holdFrames, releaseFrames } from "./framebuffer/frameHold.js";
 import { latestScreen, repaintOverlay, setFrameOverlay } from "./framebuffer/overlay.js";
 import { requestFullRepaint } from "./framebuffer/writer.js";
 import { copyToClipboard } from "./clipboard.js";
-import { chatLayout, reflowScroll, growScroll } from "./chatAnchor.js";
+import { chatLayout, reflowScroll, growScroll, revealScroll } from "./chatAnchor.js";
 import { growFill, INLINE_LIVE_RESERVE, NO_FILL } from "./startupFill.js";
 import { setRowsBelowCaret } from "./exitCursor.js";
 import { caretCell } from "./caretPark.js";
@@ -220,6 +224,21 @@ export function App({ resumeSessionId, initialScreen }) {
     // state: it is painted by the framebuffer overlay rather than by React, so changing it
     // must not cost a render (see the pointer effect).
     const selection = useRef(null);
+    // The selection that FOLLOWS THE CONVERSATION, for a drag that begins in the chat (see
+    // selectionGrow.ts): it keeps growing while the view scrolls, and copies all of it. A drag
+    // that begins anywhere else (the input box, the banner) is the screen selection above.
+    const grow = useRef(null);
+    // The rows that passed through the screen while it was alive, which is what gets copied.
+    const rowStore = useRef(new RowStore());
+    // Where the pointer is while the button is down, so scrolling can move the end of the
+    // selection even when the pointer itself does not move.
+    const pointer = useRef(null);
+    const edgeTimer = useRef(null);
+    const stopEdge = useCallback(() => {
+        if (edgeTimer.current)
+            clearInterval(edgeTimer.current);
+        edgeTimer.current = null;
+    }, []);
     /**
      * Drop the highlight, if there is one, and stop tinting frames.
      *
@@ -230,12 +249,16 @@ export function App({ resumeSessionId, initialScreen }) {
      * then uninstall: the repaint is what takes the highlight off the screen.
      */
     const clearSelection = useCallback(() => {
-        if (!selection.current)
+        if (!selection.current && !grow.current)
             return;
         selection.current = null;
+        grow.current = null;
+        rowStore.current.clear();
+        pointer.current = null;
+        stopEdge();
         repaintOverlay();
         setFrameOverlay(null);
-    }, []);
+    }, [stopEdge]);
     // PromptInput installs the handler that turns a click into a caret position; only it
     // knows what its rows currently hold. Null until the input is on screen.
     const caretClick = useRef(null);
@@ -336,6 +359,12 @@ export function App({ resumeSessionId, initialScreen }) {
     const [hoverId, setHoverId] = useState(null);
     // Set when a row is opened or folded, read once by the height effect.
     const rowToggled = useRef(false);
+    // Which place was pressed, and where the view stood before it was opened and after the view
+    // moved to show it, so that folding the same row can put the view back where it was.
+    const toggledHit = useRef(null);
+    // Whether the row pressed is the NEWEST one that can be opened, the only kind the view follows.
+    const toggledNewest = useRef(false);
+    const openedFrom = useRef(null);
     const [footerHeight, setFooterHeight] = useState(0);
     // The chat viewport's REAL height. Yoga decides it now (flexGrow beside a
     // flexShrink:0 footer); this is read back purely so the scroll maths knows how
@@ -1062,6 +1091,12 @@ export function App({ resumeSessionId, initialScreen }) {
     useInput((input, key) => {
         if (!key.ctrl || input !== "c")
             return;
+        const g = grow.current;
+        if (g && !isEmptyGrow(g)) {
+            copyGrown(g);
+            clearSelection();
+            return;
+        }
         const sel = selection.current;
         if (ctrlCShouldCopy(sel)) {
             const screen = latestScreen();
@@ -1219,6 +1254,14 @@ export function App({ resumeSessionId, initialScreen }) {
             requestFullRepaint();
             setScrollUp(maxScrollRef.current);
         }
+        // Move what the turn is waiting on to the background, without waiting for the agent
+        // to decide it. Silent when nothing is running (a stray press needs no comment); it
+        // speaks only when something WAS running and could not be moved.
+        else if (key.ctrl && _input === "x") {
+            if (pressBackground(session.current?.toolContext.foregroundCommands) === "stuck") {
+                note("That command could not be moved to the background.");
+            }
+        }
     }, { isActive: ready && overlay === null });
     // Leaving the reading view when it reaches the bottom needs no effect of its own:
     // `reading` is `scrollUp > 0`, so landing on zero — the wheel, the keys, ctrl+End, or
@@ -1322,17 +1365,45 @@ export function App({ resumeSessionId, initialScreen }) {
             // reader's absolute position rather than leave `scrollUp` where it was.
             const prev = prevContentHeight.current;
             let next = growScroll(scrollUp, prev, height);
-            // A row was just opened or folded. The row the reader pressed stays where it is and
-            // the change happens below it: opening from the bottom would otherwise follow the
-            // new end of the output and carry the row's own first line off the top, and folding
-            // would slide the view up by what was taken away.
+            // A row was just opened or folded.
+            //
+            // OPENED, while pinned to the newest: the view moves just far enough to show what opened
+            // (see revealScroll). It used to hold the pressed row in place and let the contents appear
+            // below it, which for the newest row is below the screen: the reader had to scroll to see
+            // what they had asked for. A row opened with the view scrolled back is NOT touched.
+            // FOLDED: the view goes back to where it was before this row was opened, if nothing has
+            // moved it since; otherwise it slides up by what was taken away, so the row stays put.
             if (rowToggled.current && height !== prev) {
-                if (height > prev && scrollUp === 0)
-                    next = height - prev;
-                else if (height < prev)
-                    next = Math.max(0, scrollUp - (prev - height));
+                const hit = toggledHit.current;
+                if (height > prev) {
+                    // Only for the NEWEST row that can be opened, with the reader pinned to the bottom: that
+                    // is the one whose contents would be pushed below the screen. Every other row, even one
+                    // that is on screen at the time, keeps the old rule (held in place, contents below it).
+                    const node = hit !== null && scrollUp === 0 && toggledNewest.current ? revealNode(hit) : undefined;
+                    if (hit !== null && node && contentRef.current) {
+                        const n = measureElement(node);
+                        const c = measureElement(contentRef.current);
+                        next = revealScroll(scrollUp, height, chatRows, n.y - c.y, n.height);
+                        openedFrom.current = { hit, before: scrollUp, after: next };
+                    }
+                    else {
+                        openedFrom.current = null;
+                        if (scrollUp === 0)
+                            next = height - prev;
+                    }
+                }
+                else {
+                    const from = openedFrom.current;
+                    if (from && from.hit === hit && from.after === scrollUp)
+                        next = Math.min(from.before, Math.max(0, height - chatRows));
+                    else
+                        next = Math.max(0, scrollUp - (prev - height));
+                    openedFrom.current = null;
+                }
             }
             rowToggled.current = false;
+            // The view is now placed for the new height; the next frame is the right one.
+            releaseFrames();
             if (next !== scrollUp)
                 setScrollUp(next);
         }
@@ -1448,14 +1519,87 @@ export function App({ resumeSessionId, initialScreen }) {
      * chance to reflow the screen under a user who is only trying to highlight a word.
      * `repaintOverlay` re-tints the frame already on screen instead.
      */
+    // ── the selection that follows the conversation ──────────────────────────────────────────
+    /** The screen rows that show the conversation. */
+    const chatViewRows = useCallback(() => {
+        if (!chatRef.current)
+            return null;
+        const m = measureElement(chatRef.current);
+        return { top: frameTopRef.current + m.y, bottom: frameTopRef.current + m.y + m.height };
+    }, []);
+    /** Runs on every frame while a selection of this kind exists: keep the rows, then paint it. */
+    const growOverlay = useCallback((screen) => {
+        const g = grow.current;
+        const view = chatViewRows();
+        if (!g || !view)
+            return;
+        const spans = blockSpans(frameTopRef.current);
+        if (g.dragging) {
+            // The pointer has not moved but the view has, so what is under it is a different
+            // row: the end of the selection is wherever the pointer is NOW.
+            const p = pointer.current;
+            if (p) {
+                const focus = focusFromPointer(spans, view, p.x, p.y, screen.width);
+                if (focus)
+                    g.focus = focus;
+            }
+            const chip = pillHit.current;
+            rowStore.current.capture(screen, spans, view, chip ? { y: chip.row, x0: chip.left, x1: chip.right + 1 } : null);
+        }
+        applyGrowSelection(screen, g, spans, view);
+    }, [chatViewRows]);
+    /** Begin a selection that follows the conversation, if the press landed on it. */
+    const startGrow = useCallback((x, y) => {
+        const view = chatViewRows();
+        const screen = latestScreen();
+        if (!view || !screen || y < view.top || y >= view.bottom)
+            return false;
+        const focus = focusFromPointer(blockSpans(frameTopRef.current), view, x, y, screen.width);
+        if (!focus)
+            return false;
+        grow.current = { anchor: focus, focus, dragging: true };
+        rowStore.current.clear();
+        pointer.current = { x, y };
+        setFrameOverlay(growOverlay);
+        repaintOverlay();
+        return true;
+    }, [chatViewRows, growOverlay]);
+    /** While the pointer is held past an edge, keep scrolling, so the selection keeps growing. */
+    const keepScrolling = useCallback(() => {
+        if (edgeTimer.current)
+            return;
+        edgeTimer.current = setInterval(() => {
+            const view = chatViewRows();
+            const p = pointer.current;
+            if (!grow.current?.dragging || !view || !p)
+                return stopEdge();
+            const lines = edgeLines(p.y, view, latestScreen()?.height ?? process.stdout.rows ?? 24);
+            if (lines === 0)
+                return stopEdge();
+            scrollBy(lines);
+        }, EDGE_SCROLL_MS);
+    }, [chatViewRows, scrollBy, stopEdge]);
+    /** Copy everything between the two ends, and say so if some of it could not be. */
+    function copyGrown(g) {
+        const s = stateRef.current;
+        const ids = [...s.committed, ...s.tail].map((b) => b.id);
+        const grown = rowStore.current.text(g, ids, (id) => blockHeights.current.get(id)?.height);
+        if (grown.text)
+            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.");
+    }
     // Mouse reporting itself is switched on and off by  — it belongs to
     // the shell, not to this component, because the inline shell must never have it on.
     // What is left here is the highlight, which has to come down when the app unmounts.
     useEffect(() => {
         if (!ready)
             return;
-        return () => setFrameOverlay(null);
-    }, [ready]);
+        return () => {
+            stopEdge();
+            setFrameOverlay(null);
+        };
+    }, [ready, stopEdge]);
     /**
      * Everything the pointer does, read through `useInput`.
      *
@@ -1485,14 +1629,23 @@ export function App({ resumeSessionId, initialScreen }) {
         // This is the same rule the input box already follows for keystrokes — one event
         // in, one render out — applied to the other thing that arrives in bursts.
         if (notches.length > 0) {
-            // Content moves out from under a selection when the view scrolls, so the
-            // highlight would be sitting on text that is no longer the text it copied.
-            clearSelection();
+            // Content moves out from under a SCREEN selection when the view scrolls, so the
+            // highlight would be sitting on text that is no longer the text it copied. One that
+            // follows the conversation stays, and grows if the button is still down.
+            if (!grow.current)
+                clearSelection();
             // Signed notch count, then the distance for it. The same distance for every notch,
             // applied at once (wheelStep.ts): how far the view goes follows how far the wheel
             // was turned, and nothing else.
             const net = notches.reduce((n, dir) => n + (dir === "up" ? 1 : -1), 0);
-            const lines = wheelLines(net);
+            let lines = wheelLines(net);
+            // With a selection alive no row may be scrolled past unseen: a step is never more than
+            // the view is tall, or the rows in between could not be copied.
+            if (grow.current) {
+                const view = chatViewRows();
+                const room = view ? Math.max(1, view.bottom - view.top - 1) : 16;
+                lines = Math.max(-room, Math.min(room, lines));
+            }
             // The wheel is how anyone actually scrolls, so in the inline shell it is what
             // opens the reading view. Turning it UP is the gesture: the reader is going back
             // through the conversation and wants the prompt to stay where they can type into
@@ -1536,12 +1689,28 @@ export function App({ resumeSessionId, initialScreen }) {
                     setScrollUp(0);
                     continue;
                 }
+                // A press on the conversation starts a selection that follows it. Anywhere else (the
+                // input box, the banner) it is the screen selection, which is what edits the input.
+                if (startGrow(event.x, event.y)) {
+                    selection.current = null;
+                    continue;
+                }
+                grow.current = null;
+                rowStore.current.clear();
+                pointer.current = null;
+                stopEdge();
                 selection.current = { anchor: { x: event.x, y: event.y }, focus: { x: event.x, y: event.y } };
                 // Installed here rather than for the life of the session: see clearSelection.
                 setFrameOverlay((screen) => applySelection(screen, selection.current));
                 repaintOverlay();
             }
             else if (event.kind === "drag") {
+                if (grow.current?.dragging) {
+                    pointer.current = { x: event.x, y: event.y };
+                    pendingDrag = true;
+                    keepScrolling();
+                    continue;
+                }
                 if (!selection.current)
                     continue;
                 selection.current = { anchor: selection.current.anchor, focus: { x: event.x, y: event.y } };
@@ -1549,6 +1718,34 @@ export function App({ resumeSessionId, initialScreen }) {
             }
             else {
                 pendingDrag = false;
+                const g = grow.current;
+                if (g) {
+                    stopEdge();
+                    pointer.current = null;
+                    g.dragging = false;
+                    const view = chatViewRows();
+                    const screen = latestScreen();
+                    if (view && screen) {
+                        const focus = focusFromPointer(blockSpans(frameTopRef.current), view, event.x, event.y, screen.width);
+                        if (focus)
+                            g.focus = focus;
+                    }
+                    if (isEmptyGrow(g)) {
+                        // A click, not a drag: take the highlight down, then do what a click does.
+                        clearSelection();
+                        const hitId = expandableAt(event.y, frameTopRef.current, chatRef.current);
+                        if (hitId !== null) {
+                            toggleRow(hitId);
+                            continue;
+                        }
+                        placeCaretAt(event.x, event.y);
+                        continue;
+                    }
+                    // Copied on release, so selecting IS copying; the highlight stays as the receipt.
+                    copyGrown(g);
+                    repaintOverlay();
+                    continue;
+                }
                 const sel = selection.current;
                 if (!sel)
                     continue;
@@ -1602,6 +1799,11 @@ export function App({ resumeSessionId, initialScreen }) {
     /** Open or fold a row, keeping it where the reader pressed it. See the height effect. */
     function toggleRow(hit) {
         rowToggled.current = true;
+        toggledHit.current = hit;
+        toggledNewest.current = lastExpandable(stateRef.current) === hitBlock(hit);
+        // Opening or folding takes two renders, and the first is drawn with the view still placed
+        // for the old height. Keep that one off the screen; the effect below releases it.
+        holdFrames();
         // A hit on one command inside a commands row opens that command; anything else is a row.
         if (hitItem(hit) >= 0)
             dispatch({ type: "toggleItem", id: hitBlock(hit), index: hitItem(hit) });
@@ -3439,7 +3641,7 @@ export function App({ resumeSessionId, initialScreen }) {
     const completions = [
         ...BASE_COMMANDS,
         ...skills.map((s) => ({ name: `/${s.name}`, description: s.description || "project skill" })),
-        ...mcpPrompts.map((p) => ({ name: promptCommand(p), description: p.description || `prompt from ${p.server}` })),
+        ...mcpPrompts.map((p) => ({ name: promptCommand(p), description: p.description || `prompt from ${p.server}`, quiet: true })),
     ];
     // While an overlay is open it renders in the menu slot below the input and owns the
     // keyboard; the input box itself stays visible but inert. `maxRows` is the App's
@@ -3676,7 +3878,7 @@ export function App({ resumeSessionId, initialScreen }) {
     // to `chatAnchor.ts` so the rule is unit-tested rather than eyeballed — see there
     // for why a short transcript now rests ON the input box instead of stranding
     // itself at the top of the screen, and why that cannot disturb a scrolled frame.
-    const { marginTop: chatOffset, restsOnFooter, maxScroll, scrolled } = chatLayout(contentHeight, chatRows, scrollUp);
+    const { marginTop: chatOffset, maxScroll, scrolled } = chatLayout(contentHeight, chatRows, scrollUp);
     // Published for the scroll handlers, which run between frames and cannot compute it.
     maxScrollRef.current = maxScroll;
     // The chip that says the view is not at the bottom. `scrolled` and not `scrollUp`:
@@ -3753,6 +3955,15 @@ export function App({ resumeSessionId, initialScreen }) {
         // carried off by a resize they did not intend as navigation. Applied once the new
         // height has actually been measured — see the effect that consumes this.
         reflowFrom.current = { scrolled: scrollUp, maxScroll: Math.max(0, contentHeight - chatRows) };
+        // A re-wrap changes how many rows every block has, so the rows kept for a selection no
+        // longer line up with what is on screen. Dropped without a repaint (this is a render).
+        if (grow.current) {
+            grow.current = null;
+            rowStore.current.clear();
+            pointer.current = null;
+            stopEdge();
+            setFrameOverlay(null);
+        }
     }
     // Only a MEASURED prefix can be virtualized: a block whose height is unknown cannot
     // be replaced by a spacer, because there is no honest number to give the spacer.
@@ -3815,18 +4026,31 @@ export function App({ resumeSessionId, initialScreen }) {
     // Yoga sizes against a pinned footer, with the transcript offset inside it. Kept as
     // two copies they would drift apart the first time either was touched, and the drift
     // would show as scrolling behaving differently in one shell than in the other.
-    const chatView = (_jsxs(Box, { ref: chatRef, flexDirection: "column", flexGrow: 1, flexShrink: 1, minHeight: 1, overflow: "hidden", children: [restsOnFooter ? _jsx(Box, { flexGrow: 1, flexShrink: 1 }) : null, _jsx(Box, { flexDirection: "column", flexShrink: 0, marginTop: chatOffset, children: _jsxs(Box, { ref: contentRef, flexDirection: "column", flexShrink: 0, children: [win.padTop > 0 ? _jsx(Box, { flexShrink: 0, height: win.padTop }) : null, rendered.slice(win.start, win.end).map((b, i) => {
+    // Pinned to the newest, the transcript is ALIGNED to the bottom of the viewport by the layout
+    // itself (flex-end) instead of being offset by a number. The number comes from measurements
+    // that lag a frame: when the footer grows (a menu opens, the input takes a second line) or a
+    // row lands, the first frame was drawn with the old numbers, so for a moment the view showed
+    // the wrong part of the conversation. Yoga decides alignment in the same pass that sizes the
+    // frame, so there is nothing stale to be wrong about. A short conversation rests on the
+    // footer by the same rule, which is what the spacer that used to be here did.
+    //
+    // Scrolled back, the offset has to be a number again (nothing but a distance from the top
+    // can hold a position while content is appended), and `growScroll` keeps it right.
+    const pinnedView = scrolled === 0;
+    const chatView = (_jsxs(Box, { ref: chatRef, flexDirection: "column", flexGrow: 1, flexShrink: 1, minHeight: 1, overflow: "hidden", justifyContent: pinnedView ? "flex-end" : "flex-start", children: [_jsx(Box, { flexDirection: "column", flexShrink: 0, marginTop: pinnedView ? 0 : chatOffset, children: _jsxs(Box, { ref: contentRef, flexDirection: "column", flexShrink: 0, children: [win.padTop > 0 ? _jsx(Box, { flexShrink: 0, height: win.padTop }) : null, rendered.slice(win.start, win.end).map((b, i) => {
                             const idx = win.start + i;
                             return (
                             // flexShrink:0 is load-bearing — without it Yoga compresses an
                             // overfull column and silently drops rows out of the middle.
                             _jsx(Box, { ref: (node) => {
+                                    registerBlockBox(b.id, node);
                                     if (node && needsMeasure(blockHeights.current.get(b.id), b))
                                         toMeasure.current.set(b, node);
                                 }, flexShrink: 0, flexDirection: "column", children: _jsx(BlockView, { block: b, columns: width, tightTop: isTight(allBlocks, offset + idx), hovered: hoverId !== null && hitBlock(hoverId) === b.id && hitItem(hoverId) < 0, hoveredItem: hoverId !== null && hitBlock(hoverId) === b.id ? hitItem(hoverId) : -1 }) }, b.id));
                         }), padMiddle > 0 ? _jsx(Box, { flexShrink: 0, height: padMiddle }) : null, rendered.slice(known).map((b, i) => {
                             const idx = known + i;
                             return (_jsx(Box, { ref: (node) => {
+                                    registerBlockBox(b.id, node);
                                     if (node && needsMeasure(blockHeights.current.get(b.id), b))
                                         toMeasure.current.set(b, node);
                                 }, flexShrink: 0, flexDirection: "column", children: _jsx(BlockView, { block: b, columns: width, tightTop: isTight(allBlocks, offset + idx), hovered: hoverId !== null && hitBlock(hoverId) === b.id && hitItem(hoverId) < 0, hoveredItem: hoverId !== null && hitBlock(hoverId) === b.id ? hitItem(hoverId) : -1 }) }, b.id));
@@ -4347,6 +4571,8 @@ function StatusLine({ busy, startedAt, lastMs, usage, received, advance, waiting
     // component rendering nothing at all. Two would read as a hole.
     return (_jsxs(Box, { marginBottom: 0, children: [dot, label] }));
 }
+/** How often the view scrolls while a drag is held past the edge of the conversation. */
+const EDGE_SCROLL_MS = 45;
 /** The working line's render clock, in milliseconds. See StatusLine's tick. */
 const LIVE_TICK_MS = 16;
 function fmtElapsed(s) {