mindweave 3.3.0 → 3.4.1

package/dist/cli/App.js

@@ -28,7 +28,7 @@ import { compactNow, contextUsed, effectiveAutoCompactThreshold, respond } from
 import { contextPressure, sharpContextWindow } from "../dynamo/contextWindow.js";
 import { contextBudget, formatBudget } from "../dynamo/contextBudget.js";
 import { contextView, resetContextOverride, setContextOverride } from "../core/contextSettings.js";
-import { createSession, resumeSession, reloadProjectMemory } from "../memory/session.js";
+import { createSession, resumeSession } from "../memory/session.js";
 import { saveSession, listSessions } from "../memory/store.js";
 import { stopChassis } from "../alternator/lane.js";
 import { loadSkillBody, substituteSkillArgs } from "../governor/skills.js";
@@ -73,15 +73,16 @@ import { approvalAnswer, approvalBlock, workedSeconds } from "./approvalText.js"
 import { BlockView } from "./components/BlockView.js";
 import { initialState, lastExpandable, reduce, trimNarration } from "./transcript.js";
 import { isTight } from "./blockSpacing.js";
-import { parseScreenArg, screenChoices, screenNotice, startupMode } from "./screenMode.js";
+import { INLINE_AVAILABLE, INLINE_UNAVAILABLE, parseScreenArg, screenChoices, screenNotice, startupMode } from "./screenMode.js";
 import { applyScreenMode } from "./screenShell.js";
 import { saveScreenMode } from "./screenStore.js";
 import { FULL_TAIL_BLOCKS, needsMeasure, pruneHeights, seedHeights } from "./blockHeights.js";
-import { expandableAt, hitBlock, hitItem, revealNode } from "./expandHits.js";
+import { expandableAt, hitBlock, hitItem, itemHit, revealNode } from "./expandHits.js";
+import { isGrouped, nameAt } from "./editGroup.js";
 import { shellNote } from "./shellNotes.js";
 import { pressBackground } from "./commandBackground.js";
 import { readFileSync, statSync } from "node:fs";
-import { compactSearchDetail, compactUiDetail, rebuildFull, writtenFromDisk } from "../tools/rebuildDetail.js";
+import { compactSearchDetail, compactUiDetail, rebuildFull, recoverReadText, recoverSavedText, searchDetailFromContent, 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";
@@ -109,7 +110,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";
@@ -174,11 +175,10 @@ function orderedModelsOf(providerId) {
     const provider = allProviders().find((p) => p.id === providerId);
     return provider ? orderModels(modelsOf(provider)) : [];
 }
-// After you pick a session in /continue, the three ways to resume it.
+// After you pick a session in /continue, the two ways to resume it.
 const RESUME_MODES = [
     { label: "Compact & continue", description: "summarize the old chat first so it won't eat your context, then pick up where you left off" },
     { label: "Continue as-is", description: "resume the full conversation unchanged" },
-    { label: "Fresh start", description: "leave it and start a new empty session here instead" },
 ];
 export function App({ resumeSessionId, initialScreen }) {
     // The transcript state machine lives in a ref and is advanced by the reducer as
@@ -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
@@ -798,6 +806,12 @@ export function App({ resumeSessionId, initialScreen }) {
                             if (compact)
                                 return { detail: compact.detail, ...(compact.detailFull ? { detailFull: compact.detailFull } : {}) };
                         }
+                        // A search saved before it had a row has no block of its own: what it printed is what the model was given.
+                        if (call?.name === "search" && !e.detail) {
+                            const printed = searchDetailFromContent(e.content) ?? recoverSavedText(e.content);
+                            if (printed)
+                                return { detail: printed, detailKind: "text" };
+                        }
                         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") {
@@ -813,7 +827,7 @@ export function App({ resumeSessionId, initialScreen }) {
                         return full ? { detailFull: full } : {};
                     })(),
                     ...(e.detailKind ? { detailKind: e.detailKind } : {}),
-                    ...(e.quiet ? { quiet: true } : {}),
+                    ...(e.quiet && !(!e.isError && !e.content.startsWith("Error:") && callsById.get(e.toolCallId)?.name === "search") ? { quiet: true } : {}),
                     ...(e.displayName ? { name: e.displayName } : {}),
                     ...(e.displayKind ? { action: e.displayKind } : {}),
                     ...(e.awaitsModel ? { awaitsModel: true } : {}),
@@ -1823,6 +1837,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();
@@ -1917,7 +1937,7 @@ export function App({ resumeSessionId, initialScreen }) {
                         const hitId = expandableAt(event.y, frameTopRef.current, chatRef.current);
                         if (hitId !== null) {
                             lastClick.current = null;
-                            toggleRow(hitId);
+                            toggleRow(clickTarget(hitId, event.x));
                             continue;
                         }
                         // Plain text: two clicks in a row take the word, three take the line.
@@ -1946,7 +1966,7 @@ export function App({ resumeSessionId, initialScreen }) {
                     // the input anyway, and a click that does nothing is the worse outcome.
                     const hitId = expandableAt(event.y, frameTopRef.current, chatRef.current);
                     if (hitId !== null) {
-                        toggleRow(hitId);
+                        toggleRow(clickTarget(hitId, event.x));
                         continue;
                     }
                     placeCaretAt(event.x, event.y);
@@ -1970,7 +1990,9 @@ export function App({ resumeSessionId, initialScreen }) {
         // the light out when it leaves. A press or a wheel turn clears it too, below, because
         // the content moves out from under a pointer that did not.
         if (lastMove) {
-            const over = expandableAt(lastMove.y, frameTopRef.current, chatRef.current);
+            // On the closed header of a row of edits the pointer can be over one file's name: that name is what is pointed at.
+            const row = expandableAt(lastMove.y, frameTopRef.current, chatRef.current);
+            const over = row === null ? null : clickTarget(row, lastMove.x);
             setHoverId((h) => (h === over ? h : over));
         }
         else if (notches.length > 0 || events.some((e) => e.kind === "press")) {
@@ -1981,6 +2003,56 @@ export function App({ resumeSessionId, initialScreen }) {
         if (events.length === 0 && notches.length === 0)
             clearSelection();
     }, { isActive: true });
+    /**
+     * A read keeps no text of its own in the row: what it took is in the conversation, under the call's id.
+     * It is fetched when the line is opened, so nothing is stored twice and an old chat opens as well as a new one.
+     */
+    function fetchReadText(blockId, index) {
+        const st = stateRef.current;
+        const block = [...st.committed, ...st.tail].find((b) => b.id === blockId);
+        const item = block && block.kind === "work" && block.items.length > 0 ? block.items[block.items.length === 1 ? 0 : index] : undefined;
+        if (item && !item.open)
+            fetchRead(item);
+    }
+    function fetchRead(item) {
+        if (item.kind !== "read" || item.detail)
+            return;
+        const entry = session.current?.transcript.find((t) => t.role === "tool" && t.toolCallId === item.toolId);
+        // Not recorded yet (the call is still finishing): nothing to fetch, and nothing to claim.
+        if (!entry)
+            return;
+        // Clearing context empties what the MODEL carries; the screen keeps what was read: the copy clearing saved, or the file.
+        const call = [...(session.current?.transcript ?? [])].reverse().flatMap((t) => (t.role === "assistant" ? t.toolCalls ?? [] : [])).find((c) => c.id === item.toolId);
+        let args;
+        try {
+            args = call ? JSON.parse(call.arguments) : undefined;
+        }
+        catch {
+            args = undefined;
+        }
+        const text = searchDetailFromContent(entry.content) ??
+            recoverReadText(entry.content, { args }, session.current?.cwd ?? process.cwd(), (p) => { try {
+                return statSync(p).size < 4_000_000 ? readFileSync(p, "utf8") : undefined;
+            }
+            catch {
+                return undefined;
+            } }, (cwd, p) => resolve(cwd, p));
+        dispatch({ type: "itemDetail", toolId: item.toolId, detail: text ?? "(this file is not on disk any more, and the copy saved when the chat was cleared is gone too)" });
+    }
+    /**
+     * A click on the closed header of a row of several edits can land on one file's name: then it is that file's change that opens.
+     * The header is drawn from the same layout that answers here (editGroup.ts), so the two cannot disagree.
+     */
+    function clickTarget(hit, x) {
+        if (hit < 0)
+            return hit;
+        const st = stateRef.current;
+        const block = [...st.committed, ...st.tail].find((b) => b.id === hit);
+        if (!block || block.kind !== "edits" || block.open || !isGrouped(block.items))
+            return hit;
+        const at = nameAt(block.items, width, x, block.live);
+        return at >= 0 ? itemHit(hit, at) : hit;
+    }
     /** Open or fold a row, keeping it where the reader pressed it. See the height effect. */
     function toggleRow(hit) {
         rowToggled.current = true;
@@ -1990,8 +2062,18 @@ export function App({ resumeSessionId, initialScreen }) {
         // 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)
+        if (hitItem(hit) < 0) {
+            // A row of one read shows its text as soon as it opens, so the text is fetched with the click that opens it.
+            const st = stateRef.current;
+            const block = [...st.committed, ...st.tail].find((b) => b.id === hit);
+            if (block && block.kind === "work" && !block.open && block.items.length === 1)
+                fetchRead(block.items[0]);
+        }
+        if (hitItem(hit) >= 0) {
+            // Before the toggle: the state is updated the moment it is dispatched, and a read already open is not fetched for.
+            fetchReadText(hitBlock(hit), hitItem(hit));
             dispatch({ type: "toggleItem", id: hitBlock(hit), index: hitItem(hit) });
+        }
         else
             dispatch({ type: "toggleExpand", id: hit });
     }
@@ -2228,6 +2310,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 +2361,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,32 +2455,41 @@ 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) {
         startTurn();
-        // Pick up an edit the model made to MINDWEAVE.md, but only if one actually happened
-        // — this is a no-op otherwise. Re-reading unconditionally used to look free and was
-        // not: it rewrites the system prompt string, which discards the entire cached prefix
-        // (base prompt, tool schemas, project snapshot) at 1.25x rewrite cost.
-        await reloadProjectMemory(s).catch(() => { });
+        // No MINDWEAVE.md re-read here: an edit the model made waits for the next compaction, because
+        // re-reading rewrites the system prompt and discards the whole cached prefix (see runTurn).
         resetPacer();
         lastRevealAt.current = 0;
         streamDone.current = false;
@@ -2455,7 +2555,8 @@ export function App({ resumeSessionId, initialScreen }) {
                                 detail: e.detail,
                                 detailKind: e.detailKind,
                                 detailFull: e.detailFull,
-                                quiet: e.quiet,
+                                // A search that worked is a line in the work row; one that failed stays out of sight.
+                                quiet: e.quiet && !(e.name === "search" && !e.error),
                                 action: e.displayKind,
                                 name: e.displayName,
                             });
@@ -2654,6 +2755,10 @@ export function App({ resumeSessionId, initialScreen }) {
         await stopCurrentLanes();
         attachApproval(resumed);
         session.current = resumed;
+        // The model now sees only the picked session. Leaving the conversation it replaced above the
+        // replayed one made each further /continue stack another on top, with the old one still
+        // reachable by scrolling up and reading as part of this one.
+        wipeChat();
         if (compactFirst) {
             startTurn();
             note("compacting the old conversation so it fits…");
@@ -2677,11 +2782,8 @@ export function App({ resumeSessionId, initialScreen }) {
     /**
      * Drop the current chat and start a clean session in the same project.
      *
-     * `wipeScreen` is the difference between the two ways in. Reached through
-     * `/continue`, the old conversation is still worth seeing — you went looking for
-     * sessions, so the history above is context for the choice you just made. Reached
-     * through `/clear`, you asked for it to be gone, and leaving it on screen while the
-     * model can no longer see it is the worst of both: it reads as still being there.
+     * The screen is wiped with it: leaving the old conversation visible while the model
+     * can no longer see it is the worst of both, it reads as still being there.
      *
      * What SURVIVES is as deliberate as what goes, and none of it is automatic — a fresh
      * session starts genuinely empty, so anything that outlives the conversation has to
@@ -2698,7 +2800,7 @@ export function App({ resumeSessionId, initialScreen }) {
      * So they are killed, and `/clear` SAYS how many, because silently stopping someone's
      * dev server is exactly the kind of surprise a one-word command should not spring.
      */
-    async function startFresh(wipeScreen = false) {
+    async function startFresh() {
         const s = session.current;
         if (!s)
             return;
@@ -2719,8 +2821,7 @@ export function App({ resumeSessionId, initialScreen }) {
         // old session no longer claims turns the new one can undo.
         fresh.toolContext.checkpoints?.persistTo(checkpointDir(fresh.cwd, fresh.id));
         session.current = fresh;
-        if (wipeScreen)
-            wipeChat();
+        wipeChat();
         note(killed > 0
             ? `— started a fresh session (stopped ${killed} background command${killed === 1 ? "" : "s"}) —`
             : "— started a fresh session —");
@@ -2837,10 +2938,8 @@ export function App({ resumeSessionId, initialScreen }) {
             text = `${text}${text ? " " : ""}${dropHandles.current.register(attached)}`;
         return text;
     }
-    // Apply the resume-mode pick for a chosen session: compact & continue / as-is / fresh.
+    // Apply the resume-mode pick for a chosen session: compact & continue / as-is.
     async function applyResume(meta, mode) {
-        if (mode === 2)
-            return startFresh();
         return resumePicked(meta, mode === 0);
     }
     // Apply a /model pick: switch model (clamping reasoning to a valid level), persist
@@ -2944,6 +3043,10 @@ export function App({ resumeSessionId, initialScreen }) {
      * watches `shell`. Two copies is how one of them ends up switching without remembering.
      */
     function applyScreen(next) {
+        if (next === "inline" && !INLINE_AVAILABLE) {
+            note(`inline is ${INLINE_UNAVAILABLE}`);
+            return;
+        }
         if (next === shell) {
             note(`already ${screenNotice(next)}`);
             return;
@@ -3181,11 +3284,9 @@ export function App({ resumeSessionId, initialScreen }) {
             note(ANALYTICS_EXPLANATION);
             return;
         }
-        // /clear — a fresh conversation without leaving the folder. Until now the only
-        // way to start over was to quit and relaunch, or to go through /continue and pick
-        // its third option, which is not somewhere anyone looks for "start over".
+        // /clear — a fresh conversation without leaving the folder, and the one place to start over.
         if (name === "/clear") {
-            await startFresh(true);
+            await startFresh();
             return;
         }
         // /init — have the model write MINDWEAVE.md. The file is read into the cached
@@ -3286,9 +3387,9 @@ export function App({ resumeSessionId, initialScreen }) {
             const overhead = measured && measured.model === s.modelConfig.model ? measured.tokens : undefined;
             const budget = contextBudget(s.transcript, overhead);
             note("context breakdown:");
-            say(`${formatBudget(budget, sharpContextWindow(s.modelConfig.model), effectiveAutoCompactThreshold(s))}
-
-  /context project shows what Mindweave read about this directory at startup.
+            say(`${formatBudget(budget, sharpContextWindow(s.modelConfig.model), effectiveAutoCompactThreshold(s))}
+
+  /context project shows what Mindweave read about this directory at startup.
   /context limit shows or sets your own compaction limit.`);
             return;
         }
@@ -3890,6 +3991,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 +4073,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 +4123,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 +4147,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 +4164,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 +4311,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 +4413,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 +4925,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 +4996,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 +5071,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