mindweave 3.3.0 → 3.4.0

package/dist/cli/App.js

@@ -109,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";
@@ -359,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
@@ -1823,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();
@@ -2228,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);
@@ -2277,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 {
@@ -2364,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) {
@@ -3890,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).
@@ -3942,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;
@@ -3992,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, searchBox: providerSearch, 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;
@@ -4016,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, searchBox: modelSearch, 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);
@@ -4033,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
@@ -4180,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.
@@ -4281,10 +4347,14 @@ 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, 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) => {
+    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;
+                    }, 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
@@ -4789,16 +4859,27 @@ function StatusLine({ busy, userCommand, startedAt, lastMs, usage, received, adv
     // 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);
@@ -4849,6 +4930,16 @@ 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`;
 }
@@ -4914,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