mindweave 2.5.0 → 3.0.0

package/dist/cli/App.js

@@ -1,4 +1,4 @@
-import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 /**
  * App — the terminal UI shell (the "eyes and hands" of Mindweave).
  *
@@ -24,14 +24,16 @@ import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-run
 import { useCallback, useEffect, useMemo, useReducer, useRef, useState } from "react";
 import { isAbsolute, resolve } from "node:path";
 import { Box, Static, Text, measureElement, useApp, useInput, useStdout } from "ink";
-import { compactNow, contextUsed, respond } from "../dynamo/engine.js";
-import { contextPressure, sharpContextWindow, autoCompactThreshold } from "../dynamo/contextWindow.js";
+import { compactNow, contextUsed, effectiveAutoCompactThreshold, respond } from "../dynamo/engine.js";
+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 { saveSession, listSessions } from "../memory/store.js";
 import { stopChassis } from "../alternator/lane.js";
 import { loadSkillBody, substituteSkillArgs } from "../governor/skills.js";
 import { appendForbidden, appendForbiddenCommand } from "../governor/write.js";
+import { stopUi } from "../tools/ui.js";
 import { addRoot, removeRoot } from "../tools/workspace.js";
 import { discoverRelatedRoots } from "../tools/workspaceDiscover.js";
 import { rootLabel, rootsOf, relativize } from "../tools/paths.js";
@@ -45,8 +47,9 @@ import { providerRows, keyRowsFor, nextSlotFor } from "./keyManager.js";
 import { keysFor } from "./keyStore.js";
 import { TrustGate } from "./components/TrustGate.js";
 import { rootBreadth, breadthWarning, trustPersists, isTrusted, rememberTrust } from "./trust.js";
-import { projectDir } from "../memory/store.js";
+import { checkpointDir, projectDir } from "../memory/store.js";
 import { parseUndoArg, undoNotice } from "../tools/checkpoints.js";
+import { rewindPoints, rewindTo, pasteSlot, reloadAgentState } from "../memory/rewind.js";
 import { DEFAULT_MODEL_CONFIG, thinkLevels, thinkLabel, modelLabel, modelsOfProvider, providerOf, usableFallback, needsKeySetup, withModel, saveModelConfig, refreshModels, DISCOVERY_TTL_MS } from "../dynamo/model.js";
 import { allProviders, manifestForModel, modelsOf } from "../drivers/registry.js";
 import { orderProviders, orderModels } from "./pickerOrder.js";
@@ -61,7 +64,8 @@ import { formatHelp } from "./help.js";
 import { hasApiKey, saveApiKey, removeApiKey, useApiKey, globalEnvPath, reloadConfig } from "./bootstrap.js";
 import { versionLabel, appVersion } from "./version.js";
 import { checkForUpdate } from "./updateCheck.js";
-import { ANALYTICS_EXPLANATION, analyticsEnabled, sendAnalyticsPing, setAnalyticsEnabled, startupStatusLine, } from "./analytics.js";
+import { ANALYTICS_EXPLANATION, sendAnalyticsPing, } from "./analytics.js";
+import { APP_EXPLANATION, APP_PAGE_URL, appAnnouncement, openInBrowser } from "./desktopApp.js";
 import { PromptInput } from "./components/PromptInput.js";
 import { Picker } from "./components/Picker.js";
 import { ApprovalBox } from "./components/ApprovalBox.js";
@@ -73,9 +77,14 @@ import { applyScreenMode } from "./screenShell.js";
 import { saveScreenMode } from "./screenStore.js";
 import { needsMeasure, pruneHeights } from "./blockHeights.js";
 import { BASE_COMMANDS } from "./commands.js";
+import { dismissMarathon } from "../core/turnRunner.js";
+import { describeMarathonEvent, resumeMarathon, startMarathon } from "../dynamo/marathon.js";
+import { MarathonBox } from "./components/MarathonBox.js";
+import { isFinished, isLive, marathonUiReduce } from "./marathonUi.js";
 import { manualCommand, refusalReason } from "./selfUpdate.js";
 import { currentInstall, requestRestart, runUpdate } from "./updateRunner.js";
 import { enableMouse, readMouse, readWheel } from "./mouse.js";
+import { wheelLines, wheelStart } from "./wheelAccel.js";
 import { applySelection, ctrlCShouldCopy, isEmpty, selectionText } from "./selection.js";
 import { latestScreen, repaintOverlay, setFrameOverlay } from "./framebuffer/overlay.js";
 import { requestFullRepaint } from "./framebuffer/writer.js";
@@ -85,36 +94,42 @@ import { growFill, INLINE_LIVE_RESERVE, NO_FILL } from "./startupFill.js";
 import { setRowsBelowCaret } from "./exitCursor.js";
 import { caretCell } from "./caretPark.js";
 import { countNewReplies, hitsPill, pillBounds, scrollPill } from "./scrollPill.js";
-import { virtualWindow } from "./virtualWindow.js";
+import { SCROLLBACK_BLOCKS, virtualWindow } from "./virtualWindow.js";
 import { perf, perfEnabled } from "./perfLog.js";
-import { isGroupMember, groupSettled, planGroupReveal, planStandaloneReveal, resultQueued, STANDALONE_HOLD_MS } from "./groupReveal.js";
+import { newPacer, nextHoldAt, nextMove, takeImmediate, takePaced } from "./revealQueue.js";
 import { drain as drainQueue, popAll as popAllQueued, queueMessage, takeSteerable, visibleQueue } from "./messageQueue.js";
 import { routeCommand, parseCommandLine, unknownCommandMessage } from "./commandRoute.js";
 import { resolveChoice, splitModelArg } from "./commandArgs.js";
 import { carryAcrossFreshSession } from "./sessionCarry.js";
-import { toolDisplay, isGroupable, KIND_COLOR } from "./toolDisplay.js";
+import { fitBanner } from "./bannerFit.js";
+import { neverShown, toolDisplay, isGroupable, narrationShown, noteReads } from "./toolDisplay.js";
 import { workingVerb } from "./workingVerb.js";
+import { PulseDot } from "./components/PulseDot.js";
 import { narrationPending, revealWait } from "./revealPace.js";
 import { summarizeTask, formatTokens } from "../dynamo/pricing.js";
-import { meterReset, meterDelta, meterTick, meterValue } from "../dynamo/liveMeter.js";
+import { meterReset, meterDelta, meterUsage, meterTick, meterValue } from "../dynamo/liveMeter.js";
 import { addServerToConfig, configPathFor, parseAddSpec, removeServerFromConfig, resolveConfigPath, splitArgs } from "../mcp/configWrite.js";
 import { mapPromptArguments, promptCommand, promptUsage } from "../mcp/prompts.js";
 import { DEFAULT_MODE, modeById, modeFromFlags, nextMode } from "./modes.js";
 import { ApprovalChannel } from "./approvalChannel.js";
+import { ACCENT, WARN } from "./theme.js";
 const MINDWEAVE_DOCS_URL = "https://mindweave.dev";
 /** How long each hint under the input box stays up. Long enough to read twice without
  *  hurrying, short enough that a session sees the whole set rather than one of them. */
 const TIP_ROTATE_MS = 12_000;
+/** Two Esc presses this close together, on an empty box, open /rewind. */
+const DOUBLE_ESC_MS = 600;
 /** Commands whose whole job is to open a surface in the box under the input. Written out
  *  in full, because only a bare invocation opens anything: given an argument each of these
  *  acts directly and there is no surface to hold the frame for. */
 const OVERLAY_COMMANDS = new Set([
-    "/analytics",
+    "/app",
     "/continue",
     "/key",
     "/mcp",
     "/model",
     "/provider",
+    "/rewind",
     "/shells",
     "/think",
 ]);
@@ -318,6 +333,11 @@ export function App({ resumeSessionId, initialScreen }) {
     // PromptInput's own state, so App is not re-rendered by it and would otherwise
     // keep sizing the chat against a footer that no longer exists — leaving the
     // menu clipped off the bottom of the frame with nothing to correct it.
+    // The Marathon panel: null when there is no run and none is armed. It sits in the
+    // measured footer, so it pushes the chat up instead of overlapping it.
+    const [marathonUi, setMarathonUi] = useState(null);
+    const marathonUiRef = useRef(null);
+    marathonUiRef.current = marathonUi;
     const [, bumpFooter] = useState(0);
     const onMenuChange = useCallback(() => bumpFooter((t) => t + 1), []);
     // Turn timing for the status line: when the current turn started, how long the
@@ -341,8 +361,14 @@ export function App({ resumeSessionId, initialScreen }) {
     // reads the current value there.
     const meter = useRef(meterReset());
     const liveTokens = useCallback(() => meterValue(meter.current), []);
+    const lastMeterTick = useRef(0);
     const advanceTokens = useCallback(() => {
-        meter.current = meterTick(meter.current);
+        // By the time actually elapsed since the last tick, not by tick count: the clock runs at the
+        // display's pace and a late tick must move the figure further, not the same distance.
+        const now = performance.now();
+        const dt = lastMeterTick.current ? now - lastMeterTick.current : LIVE_TICK_MS;
+        lastMeterTick.current = now;
+        meter.current = meterTick(meter.current, dt);
     }, []);
     // Aborts the in-flight turn when the user presses Esc (created fresh per turn).
     const abortRef = useRef(null);
@@ -488,7 +514,7 @@ export function App({ resumeSessionId, initialScreen }) {
             // gone whatever we do; reprinting all of it costs about 1.7ms a block, measured, so
             // a long session spent a third of a second on a blank screen printing scrollback
             // nobody asked to see. A couple of screens is all that can be looked at anyway.
-            reprintFrom.current = Math.max(0, committed.length - INLINE_REPRINT_BLOCKS);
+            reprintFrom.current = Math.max(0, stateRef.current.committed.length - INLINE_REPRINT_BLOCKS);
             // Blank rows so the conversation lands at the BOTTOM of the screen rather than the
             // top. A terminal prints from wherever the cursor is, which after leaving the
             // alternate screen is wherever the shell left it — usually near the top, with the
@@ -523,6 +549,8 @@ export function App({ resumeSessionId, initialScreen }) {
     // holds them stays on screen for the gap between the command list closing and the
     // surface appearing. See `OVERLAY_COMMANDS`.
     const [opening, setOpening] = useState(false);
+    /** A message handed back to the input box to edit (a rewind). A new object each time. */
+    const [fill, setFill] = useState(undefined);
     // The approval channel handed to tools: a forbidden-path tool calls this to ask
     // the user Yes/No/other, and we render it as an overlay that resolves the promise.
     // A ref so the function injected into a session's tool context always reaches the
@@ -584,9 +612,14 @@ export function App({ resumeSessionId, initialScreen }) {
     // it WAS a diff did not, so every resumed edit rendered as dim plain lines. Anything
     // added to a row's appearance has to be stored here too, or the claim above quietly
     // stops being true again.
+    // What compaction took out is drawn too (memory/earlier.ts), so a resumed chat is the whole conversation.
+    const withEarlier = (session) => [...(session.earlier ?? []), ...session.transcript];
     function showResumed(transcript) {
+        const readThisTurn = new Set(); // for narrationShown, as live
         for (const e of transcript) {
             if (e.role === "user") {
+                if (!e.synthetic)
+                    readThisTurn.clear();
                 // Engine nudges ride as `user` messages so the model reads them as instruction,
                 // but they are ours, not the person's. Replaying one draws it as a `>` prompt
                 // the user never typed — seen live as "> That was 3 sentences between tool
@@ -602,15 +635,18 @@ export function App({ resumeSessionId, initialScreen }) {
                 // re-announce each tool call exactly as streamRespond does.
                 // Same cut as the live path: prose that precedes tool calls is narration,
                 // and a resumed chat must not print the essays the live one trimmed away.
-                if (e.content.trim()) {
-                    const intermediate = (e.toolCalls?.length ?? 0) > 0;
+                const calls = (e.toolCalls ?? []).map((c) => ({ name: c.name, args: parseToolArgs(c.arguments) }));
+                const shown = calls.length === 0 || narrationShown(calls, readThisTurn);
+                noteReads(calls, readThisTurn);
+                if (shown && e.content.trim()) {
+                    const intermediate = calls.length > 0;
                     dispatch({ type: "say", text: intermediate ? trimNarration(e.content) : e.content });
                 }
                 for (const call of e.toolCalls ?? []) {
                     // The spawn itself is drawn by its sub-agent block live, never as a raw row.
                     // Replaying it as one puts a `● SpawnSubagent(...)` in a resumed transcript
                     // that was not in the live one.
-                    if (call.name === "spawn_subagent")
+                    if (call.name === "spawn_subagent" || neverShown(call.name))
                         continue;
                     const d = toolDisplay(call.name, parseToolArgs(call.arguments));
                     dispatch({
@@ -797,7 +833,7 @@ export function App({ resumeSessionId, initialScreen }) {
         widthBefore.current = width;
         if (shell !== "inline")
             return;
-        reprintFrom.current = Math.max(0, committed.length - INLINE_REPRINT_BLOCKS);
+        reprintFrom.current = Math.max(0, stateRef.current.committed.length - INLINE_REPRINT_BLOCKS);
         startFill.current = Math.max(0, rows - INLINE_LIVE_RESERVE);
         setStaticEpoch((n) => n + 1);
     }, [width, shell]);
@@ -817,7 +853,7 @@ export function App({ resumeSessionId, initialScreen }) {
             session.current = s;
             setReady(true);
             if (resumeSessionId && s.id === resumeSessionId) {
-                showResumed(s.transcript);
+                showResumed(withEarlier(s));
                 note(`— updated to v${appVersion()}, continuing —`);
             }
             // The project may have a model saved from a different provider than the
@@ -826,13 +862,22 @@ export function App({ resumeSessionId, initialScreen }) {
             if (!cur)
                 return;
             const need = missingKeyFor(cur.modelConfig.model);
-            if (!need)
+            if (!need) {
+                // The model the project saved can run. Setup may still be open: it was decided before a local
+                // runtime (Ollama) had been asked whether it runs, and with the saved model already usable the
+                // branch below that closes it never ran, so every launch after the first showed "add a key"
+                // to anyone whose only provider is local.
+                setSetupOpen(false);
                 return;
+            }
             // A saved config can outlive the key that made it usable. Rather than open
             // straight into an inescapable prompt, fall back to a provider we can actually
             // run and say so — the user can always pick again with /provider.
             const fallback = usableFallback(cur.modelConfig.model, hasApiKey);
             if (fallback) {
+                // Setup may already be open: it is decided before a local runtime (Ollama) has been
+                // asked whether it runs. Something runnable was found, so there is nothing to set up.
+                setSetupOpen(false);
                 void switchTo(fallback, providerOf(fallback).label).then(() => note(`no ${need.label} key yet — using ${providerOf(fallback).label} instead. /provider to change.`));
                 return;
             }
@@ -841,10 +886,10 @@ export function App({ resumeSessionId, initialScreen }) {
             setSetupOpen(true);
         });
     }, []);
-    // Anonymous usage ping — on by default. The status line shows every launch, not just
-    // the first one; the full explanation lives in the /analytics box itself.
+    // The usage ping is paused for now (see analytics.ts). What every session starts with instead is
+    // the pointer to the desktop app, shown every launch.
     useEffect(() => {
-        note(startupStatusLine());
+        note(appAnnouncement());
         sendAnalyticsPing(appVersion());
     }, []);
     // A quiet, backgrounded check for a newer release — independent of session startup so a
@@ -896,12 +941,30 @@ export function App({ resumeSessionId, initialScreen }) {
     // and a keypress that both stopped the turn and silently emptied the queue would be
     // two decisions on one key. So mid-turn Esc is declined here and the interrupt
     // handler above has it alone. ↑ has no such conflict and always pops.
+    // Esc twice on an empty box while nothing runs opens /rewind. The first press is
+    // remembered here because this is the one place an idle Esc arrives with the box's text.
+    const lastIdleEsc = useRef(0);
+    const openRewind = useRef(() => { });
+    openRewind.current = () => {
+        setOpening(true);
+        void handleCommand("/rewind").finally(() => setOpening(false));
+    };
     const popQueue = useCallback((input, cursor, via) => {
         if (via === "escape" && busy)
             return undefined;
         const popped = popAllQueued(queueRef.current, input, cursor);
-        if (!popped)
+        if (!popped) {
+            if (via === "escape" && input.trim() === "") {
+                const now = Date.now();
+                if (now - lastIdleEsc.current < DOUBLE_ESC_MS) {
+                    lastIdleEsc.current = 0;
+                    openRewind.current();
+                }
+                else
+                    lastIdleEsc.current = now;
+            }
             return undefined;
+        }
         queueRef.current = [];
         setQueued([]);
         return popped;
@@ -970,6 +1033,9 @@ export function App({ resumeSessionId, initialScreen }) {
             const mgr = session.current?.toolContext.backgroundShells;
             for (const sh of mgr?.running() ?? [])
                 mgr?.kill(sh.id, "user");
+            // And the app it was testing, with its live view and any hidden browser.
+            if (session.current)
+                void stopUi(session.current.toolContext);
             flush.current = true; // drain the rest of the queue immediately
             // A held-but-unsettled group (see pump()) waits for the NEXT enqueued
             // action to notice anything changed — nothing schedules a timer while
@@ -983,6 +1049,12 @@ export function App({ resumeSessionId, initialScreen }) {
             // more line of the app talking about itself.
         }
     }, { isActive: busy && overlay === null });
+    // Esc on an armed Marathon box takes it down again (nothing has started). Once a run is
+    // going, Esc is the ordinary stop above and the run becomes resumable instead.
+    useInput((_input, key) => {
+        if (key.escape)
+            setMarathonUi(null);
+    }, { isActive: !busy && overlay === null && marathonUi?.phase === "armed" });
     // shift-tab cycles the interaction mode (Lightning ⇄ Architect). Active whenever
     // the input owns the keyboard (no overlay); takes effect from the next turn.
     useInput((_input, key) => {
@@ -1014,6 +1086,8 @@ export function App({ resumeSessionId, initialScreen }) {
     // counter kept climbing — and every one of those phantom lines then had to be
     // scrolled back down before the view moved at all. A flick or two past the top bought
     // a second of a wheel that did nothing, which reads as the app having frozen.
+    /** The wheel gesture in progress, for scroll acceleration (wheelAccel.ts). */
+    const wheelRef = useRef(wheelStart());
     const scrollBy = useCallback((lines) => {
         // Repaint the whole next frame. A scroll can move a row out from under the
         // framebuffer's model (see requestFullRepaint), which is what left a transcript row
@@ -1338,7 +1412,12 @@ export function App({ resumeSessionId, initialScreen }) {
             // 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();
-            const lines = notches.reduce((n, dir) => n + (dir === "up" ? WHEEL_LINES : -WHEEL_LINES), 0);
+            // Signed notch count, then the distance for it: the faster the wheel is turning,
+            // the further each notch goes (wheelAccel.ts). A slow notch is still three lines.
+            const net = notches.reduce((n, dir) => n + (dir === "up" ? 1 : -1), 0);
+            const step = wheelLines(wheelRef.current, net, performance.now());
+            wheelRef.current = step.state;
+            const lines = step.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
@@ -1422,6 +1501,7 @@ export function App({ resumeSessionId, initialScreen }) {
             clearSelection();
     }, { isActive: true });
     function endTurn() {
+        releaseLiveGates();
         if (turnStart.current != null)
             setLastMs(Date.now() - turnStart.current);
         // Settle every tool row this turn produced into its past-tense verb. The single
@@ -1626,52 +1706,39 @@ export function App({ resumeSessionId, initialScreen }) {
     const pumpTimer = useRef(null);
     const streamDone = useRef(false);
     const flush = useRef(false); // Esc → drain the rest with no pacing
-    // Whether a "tools" group is currently visible (already revealed and still
-    // open). Tracked at this layer — not read from transcript state — because the
-    // decision it drives (does the NEXT grouped toolStart need to be held) has to
-    // be made before that action is even dispatched.
-    const groupOpen = useRef(false);
-    // When the row currently at the front of the queue began waiting for its own result,
-    // and the timer that gives up on it. See the hold in pump().
-    const heldStart = useRef(null);
+    // What is waiting, which rows on screen are still working, and whether a read row is open.
+    // The rules live in revealQueue.ts, which the tests replay; this only drives them.
+    const pacer = useRef(newPacer(revealQ.current));
+    // Commands wait for their own row (RespondOptions.beforeLiveTool): call id -> the engine's
+    // "go". Released when the row reaches the screen, and ALWAYS released on Esc, at the end of
+    // the queue and at the end of a turn, because a gate nobody opens is a turn that never ends.
+    const liveGates = useRef(new Map());
+    // Every tool row that has reached the screen this turn, so a gate asked for after its row
+    // is already up opens at once.
+    const shownRows = useRef(new Set());
     const holdTimer = useRef(null);
-    // A new block appears (paced); a token (silent), a tool resolution (in place), a
-    // discovery call folding into an ALREADY-OPEN group, or a sub-agent's nested
-    // activity (folds into / resolves its rail in place) is not.
-    //
-    // Both kinds of tool start are paced AND held: pump() waits for the matching
-    // toolEnd so the row arrives complete, then reveals the pair on the beat. (It used
-    // to show instantly as a bare header and then patch in place; that was the
-    // two-stage reveal the hold mechanism exists to remove.) Holding and pacing are
-    // separate questions — one is about the block being whole, the other about when a
-    // whole block is allowed on screen — and a standalone row used to answer only the
-    // first, which is why a burst of edits landed together however calm the rest of
-    // the turn was.
-    const isPaced = (a) => {
-        if (a.type === "toolStart")
-            return a.group ? !groupOpen.current : true;
-        return (a.type !== "token" &&
-            a.type !== "toolEnd" &&
-            a.type !== "toolProgress" &&
-            a.type !== "subToolStart" &&
-            a.type !== "subToolEnd" &&
-            a.type !== "subagentEnd");
-    };
+    function releaseLiveGates() {
+        for (const go of liveGates.current.values())
+            go();
+        liveGates.current.clear();
+    }
+    /** Start a fresh pacer over an empty queue (a new turn, a cleared conversation). */
+    function resetPacer() {
+        releaseLiveGates();
+        shownRows.current.clear();
+        if (holdTimer.current)
+            clearTimeout(holdTimer.current);
+        holdTimer.current = null;
+        revealQ.current = [];
+        pacer.current = newPacer(revealQ.current);
+    }
     function enqueueReveal(a) {
         revealQ.current.push(a);
-        // A result arriving is exactly what the hold below is waiting for, so its deadline is
-        // cancelled rather than waited out — otherwise every quick tool would sit out the
-        // full grace before its pair could be shown.
-        if (holdTimer.current) {
-            clearTimeout(holdTimer.current);
-            holdTimer.current = null;
-        }
         if (!pumpTimer.current)
             pump();
     }
-    // Reveal the next block on the beat (a minimum since the last reveal, not an added
-    // delay), then stamp the clock and carry on draining. Every paced path in pump()
-    // goes through here, so the tempo is decided in exactly one place.
+    // Reveal the next block on the beat, then stamp the clock and carry on draining. Every
+    // paced path in pump() goes through here, so the tempo is decided in exactly one place.
     function schedulePaced(reveal) {
         const wait = revealWait({ flush: flush.current });
         pumpTimer.current = setTimeout(() => {
@@ -1686,150 +1753,78 @@ export function App({ resumeSessionId, initialScreen }) {
             pump();
         }, wait);
     }
-    function pump() {
-        // Apply immediate actions at once: silent tokens, in-place resolves, and a
-        // discovery call folding into a group that's already on screen.
-        while (revealQ.current.length > 0 && !isPaced(revealQ.current[0])) {
-            const a = revealQ.current.shift();
-            if (a.type === "token")
-                applySilent(a);
-            else {
-                // An in-place resolve grows a row into its result, shifting everything below it —
-                // the same de-sync risk a reveal carries, so heal the banner on the same frame.
-                requestFullRepaint();
-                dispatch(a);
-            }
-            // A group stays open once shown; anything that isn't part of it (a
-            // standalone tool, narration, a sub-agent) closes it, mirroring exactly
-            // what the transcript reducer's own closeToolGroup does on the same actions.
-            if (a.type === "toolStart" && a.group)
-                groupOpen.current = true;
-            else if (a.type !== "toolEnd")
-                groupOpen.current = false;
-        }
-        if (revealQ.current.length === 0) {
-            if (streamDone.current) {
-                streamDone.current = false;
-                endTurn();
-            }
+    /** Apply a run of actions as one paint; streamed text alone is applied without one. */
+    function applyNow(actions) {
+        if (actions.length === 0)
             return;
-        }
-        const front = revealQ.current[0];
-        // Narration waiting in front of a tool call gets the beat to itself. `toolStart`
-        // seals the open assistant block as part of its own action, so without this the
-        // sentence and the row it introduces reach the terminal in the SAME paint and
-        // land as one clump — the pacer's blind spot, since nothing was ever queued for
-        // the text. Sealing it first lets the sentence be read before the row appears
-        // under it. Only when a block will actually result (see narrationPending): the
-        // narration budget is one line per turn, and pausing for a sentence that seals
-        // to nothing would be an empty beat, which is a stall rather than a rhythm.
-        if (front.type === "toolStart" && narrationPending(stateRef.current)) {
-            schedulePaced(() => {
-                dispatch({ type: "sealNarration" });
-                groupOpen.current = false;
-            });
+        if (actions.every((a) => a.type === "token")) {
+            for (const a of actions)
+                applySilent(a);
             return;
         }
-        // A tool's opening call is HELD — not dispatched, not scheduled, nothing shown —
-        // until its result is queued behind it, so the row never appears bare and then
-        // sprouts a body a second later. Holding costs nothing that was worth having:
-        // the header alone names a call whose result is the entire point of showing it,
-        // and the footer's live timer is what says work is happening. There is no
-        // time-based fallback (see groupReveal.ts): every later enqueueReveal re-enters
-        // pump, which re-checks. Esc sets `flush`, and `streamDone` releases the hold
-        // unconditionally — once the stream is over no further event can arrive, so a
-        // call whose end never came (an abort mid-flight) must still be shown rather
-        // than stranding the queue and the turn with it.
-        //
-        // Then the whole held burst reveals in ONE paint, on the beat. Painting per
-        // action would show the block assembling itself (header, then a running row,
-        // then the resolved row): Ink's root is a legacy React root, so every dispatch
-        // flushes synchronously and each one is a frame the terminal actually shows.
-        if (front.type === "toolStart") {
-            const isNewGroup = front.group && !groupOpen.current;
-            if (isNewGroup) {
-                if (planGroupReveal(groupSettled(revealQ.current.slice(1)), flush.current) === "hold")
-                    return;
+        // A command's row going on screen is its "go": it starts now, so its timer starts now, and
+        // it stays visibly running for at least a moment even if it ends in a blink.
+        const now = Date.now();
+        for (const a of actions) {
+            if (a.type !== "toolStart")
+                continue;
+            shownRows.current.add(a.toolId);
+            const go = liveGates.current.get(a.toolId);
+            if (go) {
+                liveGates.current.delete(a.toolId);
+                a.at = now;
+                go();
             }
-            else {
-                // A standalone row is held for its own result, but only for so long.
-                //
-                // Held with no limit, a  row was invisible for the ten
-                // minutes the build took: the last thing on screen stayed the tool before it, and
-                // an agent working steadily was indistinguishable from one that had hung. It was
-                // reported as a hang. It was not one — the command ran, the timeout fired, the
-                // shell was backgrounded, all of it correct and none of it visible.
-                if (heldStart.current?.toolId !== front.toolId) {
-                    heldStart.current = { toolId: front.toolId, at: Date.now() };
-                }
-                const heldForMs = Date.now() - heldStart.current.at;
-                const plan = planStandaloneReveal({
-                    resultQueued: resultQueued(front.toolId, revealQ.current),
-                    flushing: flush.current,
-                    streamDone: streamDone.current,
-                    heldForMs,
-                });
-                if (plan === "hold") {
-                    // Re-enter when the deadline passes. Its OWN timer, not the pacing one: the
-                    // result arriving must be able to cancel this and reveal the pair at once, and
-                    // clearing the pacing timer instead would drop the beat.
-                    if (!holdTimer.current) {
-                        holdTimer.current = setTimeout(() => {
-                            holdTimer.current = null;
-                            pump();
-                        }, Math.max(0, STANDALONE_HOLD_MS - heldForMs));
-                    }
-                    return;
-                }
+        }
+        // A row resolving in place grows into its result and shifts everything below it — the
+        // same de-sync risk a reveal carries, so the banner is healed on the same frame.
+        requestFullRepaint();
+        applyBatch(actions);
+    }
+    function pace() {
+        return {
+            flushing: flush.current,
+            streamDone: streamDone.current,
+            narrationPending: narrationPending(stateRef.current),
+            now: Date.now(),
+        };
+    }
+    function pump() {
+        // A beat already scheduled keeps its time, unless Esc asked for everything now.
+        if (pumpTimer.current) {
+            if (!flush.current)
+                return;
+            clearTimeout(pumpTimer.current);
+            pumpTimer.current = null;
+        }
+        if (flush.current)
+            releaseLiveGates();
+        applyNow(takeImmediate(pacer.current, pace()));
+        const move = nextMove(pacer.current);
+        // A row on screen is still working: its result, when it comes, re-enters here through
+        // enqueueReveal. The beat for the next block starts only after that. A result that is
+        // already here but held (a command shorter than its minimum running time) needs a timer,
+        // because nothing else will arrive to wake the pump.
+        if (move === "wait") {
+            const at = nextHoldAt(pacer.current);
+            if (at !== null && !holdTimer.current) {
+                holdTimer.current = setTimeout(() => {
+                    holdTimer.current = null;
+                    pump();
+                }, Math.max(0, at - Date.now()));
             }
-            schedulePaced(() => {
-                // Measured HERE, not when the beat was scheduled: the queue keeps growing
-                // while we wait, and a group's burst can gain members in that window. A span
-                // measured early would leave the stragglers behind to open a second group,
-                // splitting one burst across two blocks.
-                if (isNewGroup) {
-                    // A group folds into ONE row ("Read 8 files"), so its whole burst is a single
-                    // block and reveals together by design.
-                    let take = 0;
-                    while (take < revealQ.current.length && isGroupMember(revealQ.current[take]))
-                        take++;
-                    applyBatch(revealQ.current.splice(0, take));
-                }
-                else {
-                    // This call and its OWN result — never the span between them. The engine emits
-                    // every toolStart of a batch before running any of it, so when those calls run
-                    // concurrently the matching end sits behind the other calls' starts. Taking a
-                    // contiguous span from the front swallowed all of them into this one paint:
-                    // eight rows appearing at once, however calm the beat before it was. Each of
-                    // those calls is its own block and waits its own beat; only the pair is atomic,
-                    // so a row still arrives carrying its result rather than sprouting one later.
-                    const endIdx = revealQ.current.findIndex((x) => x.type === "toolEnd" && x.toolId === front.toolId);
-                    if (endIdx === -1) {
-                        applyBatch(revealQ.current.splice(0, 1));
-                    }
-                    else {
-                        // The end first: it sits at the higher index, so removing it cannot shift
-                        // the start out from under the shift() that follows.
-                        const endAction = revealQ.current.splice(endIdx, 1)[0];
-                        const startAction = revealQ.current.shift();
-                        applyBatch([startAction, endAction]);
-                    }
-                }
-                // Resolved either way — the action that closes the block follows next.
-                groupOpen.current = false;
-            });
             return;
         }
-        // Every remaining paced block (a sealed reply, a sub-agent start, notes) reveals
-        // on the same beat.
-        schedulePaced(() => {
-            const a = revealQ.current.shift();
-            if (a) {
-                dispatch(a);
-                if (a.type !== "toolEnd")
-                    groupOpen.current = a.type === "toolStart" && !!a.group;
+        if (move === "idle") {
+            // Nothing is queued, so a command still waiting for its row has no row coming: let it run.
+            releaseLiveGates();
+            if (streamDone.current) {
+                streamDone.current = false;
+                endTurn();
             }
-        });
+            return;
+        }
+        schedulePaced(() => applyNow(takePaced(pacer.current, pace())));
     }
     /**
      * Run one streaming turn against the session. Engine events are QUEUED onto the
@@ -1891,26 +1886,19 @@ export function App({ resumeSessionId, initialScreen }) {
         }
         return out;
     }
-    async function streamRespond(s) {
+    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(() => { });
-        revealQ.current = [];
+        resetPacer();
         lastRevealAt.current = 0;
         streamDone.current = false;
         flush.current = false;
-        // A hold belongs to one turn. Left standing, its deadline fires into the next one and
-        // pumps a queue that has nothing to do with it.
-        heldStart.current = null;
-        if (holdTimer.current) {
-            clearTimeout(holdTimer.current);
-            holdTimer.current = null;
-        }
         try {
-            await respond(s, {
+            const turnOptions = {
                 // Messages typed while this turn runs reach it here, at each step boundary,
                 // rather than waiting for it to end and starting another one.
                 steer: () => steerRunningTurn(s),
@@ -1931,9 +1919,15 @@ export function App({ resumeSessionId, initialScreen }) {
                     else if (e.type === "replyReset") {
                         enqueueReveal({ type: "resetReply" });
                     }
+                    else if (e.type === "narration") {
+                        // Words that led only to unseen tools (searches, re-reads) are not shown at all.
+                        if (!e.shown)
+                            enqueueReveal({ type: "resetReply" });
+                    }
                     else if (e.type === "tool" && e.phase === "start") {
-                        // The spawn call itself is rendered by its sub-agent block, not a raw row.
-                        if (e.name === "spawn_subagent")
+                        // The spawn call itself is rendered by its sub-agent block, not a raw row;
+                        // loading a tool is never shown at all (see mcpSearch.ts).
+                        if (e.name === "spawn_subagent" || neverShown(e.name))
                             return;
                         const d = toolDisplay(e.name, e.args);
                         if (e.agent) {
@@ -1941,7 +1935,7 @@ export function App({ resumeSessionId, initialScreen }) {
                             enqueueReveal({ type: "subToolStart", agentId: e.agent, toolId: e.id, name: d.name, arg: d.arg, action: d.kind });
                         }
                         else {
-                            enqueueReveal({ type: "toolStart", toolId: e.id, name: d.name, arg: d.arg, meta: d.meta, action: d.kind, group: isGroupable(e.name), ...(d.covers ? { covers: d.covers } : {}) });
+                            enqueueReveal({ type: "toolStart", toolId: e.id, name: d.name, arg: d.arg, meta: d.meta, action: d.kind, group: isGroupable(e.name), at: Date.now(), ...(d.covers ? { covers: d.covers } : {}) });
                         }
                     }
                     else if (e.type === "tool" && e.phase === "progress") {
@@ -1950,7 +1944,7 @@ export function App({ resumeSessionId, initialScreen }) {
                             enqueueReveal({ type: "toolProgress", toolId: e.id, text: e.text });
                     }
                     else if (e.type === "tool" && e.phase === "end") {
-                        if (e.name === "spawn_subagent")
+                        if (e.name === "spawn_subagent" || neverShown(e.name))
                             return;
                         if (e.agent) {
                             enqueueReveal({ type: "subToolEnd", agentId: e.agent, toolId: e.id, ok: !e.error, summary: e.summary });
@@ -1986,7 +1980,13 @@ export function App({ resumeSessionId, initialScreen }) {
                     else if (e.type === "subagent" && e.phase === "end") {
                         enqueueReveal({ type: "subagentEnd", agentId: e.id, ok: !e.error, summary: e.summary });
                     }
+                    else if (e.type === "todos") {
+                        setMarathonUi((ui) => marathonUiReduce(ui, { type: "todos", items: e.items }));
+                    }
                     else if (e.type === "usage") {
+                        // The live figure swaps this call's streamed estimate for its real output size
+                        // (tool arguments never stream as text, so the estimate alone runs far behind).
+                        meter.current = meterUsage(meter.current, e.completionTokens);
                         // Keep each call's real usage; fold into the context+cost summary shown
                         // once the turn ends. The model id drives cache-aware pricing.
                         usageSamples.current.push({
@@ -2004,11 +2004,26 @@ export function App({ resumeSessionId, initialScreen }) {
                     }
                 },
                 signal: abortRef.current?.signal,
+                // A command starts only once its row is on screen, so the row's running state is the
+                // real work, one thing at a time, instead of a replay of something long finished.
+                beforeLiveTool: (id) => new Promise((resolve) => {
+                    if (flush.current || abortRef.current?.signal.aborted || shownRows.current.has(id))
+                        return resolve();
+                    liveGates.current.set(id, resolve);
+                    if (!pumpTimer.current)
+                        pump();
+                }),
                 // Persist after every step so a hard crash / PC shutdown mid-turn loses at
                 // most the current in-flight step — not the whole turn. (The finally below
                 // still saves on clean/aborted exits.)
                 persist: () => saveSession(s),
-            });
+            };
+            // A Marathon run drives the very same turns, so every event above draws identically
+            // whether one turn or a hundred of them produced it.
+            if (run)
+                await run(turnOptions);
+            else
+                await respond(s, turnOptions);
             enqueueReveal({ type: "finishReply" });
         }
         catch (error) {
@@ -2035,6 +2050,34 @@ export function App({ resumeSessionId, initialScreen }) {
                 pump(); // ensure we drain to endTurn even if idle now
         }
     }
+    /**
+     * Run a Marathon through this screen's own turn pipeline. It is the same `respond` loop
+     * as any message, driven by `startMarathon`/`resumeMarathon`, so every tool row, token and
+     * question draws exactly as it does in a normal turn. The box is fed by its events.
+     */
+    async function driveMarathon(s, go) {
+        const onMarathon = (event) => {
+            setMarathonUi((ui) => marathonUiReduce(ui, { type: "event", event }));
+            // The outcome is worth one line in the conversation; the box carries the rest.
+            if (event.type === "finished")
+                enqueueReveal({ type: "note", text: describeMarathonEvent(event) });
+        };
+        try {
+            await streamRespond(s, (options) => go({ ...options, onMarathon }));
+        }
+        finally {
+            // However it ended (an error included), the box must not keep spinning for a run that is gone.
+            setMarathonUi((ui) => (ui && isLive(ui) ? { ...ui, phase: "paused", line: "Stopped" } : ui));
+        }
+    }
+    /** The armed box's next message: it becomes the goal. */
+    async function beginMarathon(s, text) {
+        const { content, displayText, notes, images } = await prepareMessage(s, text);
+        dispatch({ type: "user", text: displayText });
+        for (const n of notes)
+            note(n);
+        await driveMarathon(s, (options) => startMarathon(s, content, { ...options, ...(images.length > 0 ? { goalImages: images } : {}) }));
+    }
     // When a background shell finishes while Mindweave is idle, kick a turn so the model
     // reports the result (and proposes a fix on failure). respond() drains the
     // completion event; the guard stops overlapping reactions.
@@ -2083,7 +2126,7 @@ export function App({ resumeSessionId, initialScreen }) {
             }
         }
         note(`— continuing${compactFirst ? " (compacted)" : ""}: ${sessionTitle(meta)} —`);
-        showResumed(resumed.transcript);
+        showResumed(withEarlier(resumed));
     }
     /**
      * Drop the current chat and start a clean session in the same project.
@@ -2126,29 +2169,128 @@ export function App({ resumeSessionId, initialScreen }) {
         // The files the old conversation edited are still edited, and its checkpoints are
         // the only record of what they were before.
         carryAcrossFreshSession(s.toolContext, fresh.toolContext);
+        // The history moves with it on disk too, so it still works after a restart and the
+        // 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) {
-            // The chips are keyed per conversation; a stale one would expand into a message
-            // the new session never saw.
-            pasteStore.current.clear();
-            setScrollUp(0);
-            // Anything the pacer is still holding belongs to the conversation being cleared.
-            // Left in place it would paint into the empty screen a moment later, which looks
-            // exactly like the clear having failed.
-            revealQ.current = [];
-            lastRevealAt.current = 0;
-            streamDone.current = false;
-            flush.current = false;
-            // The status line still reads "Cooked for 1m 23s" from a turn that is no longer
-            // on screen or in the model's context.
-            setTaskUsage(null);
-            setLastMs(null);
-            dispatch({ type: "clear" });
-        }
+        if (wipeScreen)
+            wipeChat();
         note(killed > 0
             ? `— started a fresh session (stopped ${killed} background command${killed === 1 ? "" : "s"}) —`
             : "— started a fresh session —");
     }
+    /** Clear the chat off the screen, and everything that would paint into it afterwards. */
+    function wipeChat() {
+        // The chips are keyed per conversation; a stale one would expand into a message
+        // the new session never saw.
+        pasteStore.current.clear();
+        setScrollUp(0);
+        // Anything the pacer is still holding belongs to the conversation being cleared.
+        // Left in place it would paint into the empty screen a moment later, which looks
+        // exactly like the clear having failed.
+        resetPacer();
+        lastRevealAt.current = 0;
+        streamDone.current = false;
+        flush.current = false;
+        // The status line still reads "Cooked for 1m 23s" from a turn that is no longer
+        // on screen or in the model's context.
+        setTaskUsage(null);
+        setLastMs(null);
+        dispatch({ type: "clear" });
+    }
+    /** "2 files +12 −3 · 1 rule": what the turns since this message changed. */
+    function changeSummary(p) {
+        const parts = [];
+        if (p.files > 0)
+            parts.push(`${p.files} file${p.files === 1 ? "" : "s"} +${p.added} −${p.removed}`);
+        const state = stateSummary(p.state);
+        if (state)
+            parts.push(state);
+        return parts.join(" · ");
+    }
+    function stateSummary(state) {
+        const noun = {
+            memory: ["memory", "memories"], rule: ["rule", "rules"], skill: ["skill", "skills"],
+            permission: ["permission list", "permission lists"], mcp: ["MCP config", "MCP configs"],
+        };
+        return Object.entries(state)
+            .filter(([, n]) => (n ?? 0) > 0)
+            .map(([k, n]) => `${n} ${noun[k][n === 1 ? 0 : 1]}`)
+            .join(", ");
+    }
+    /** The choices a rewind offers, each saying exactly what it does and what it cannot. */
+    function rewindChoices(p) {
+        const hasFiles = p.files > 0 || Object.keys(p.state).length > 0;
+        const what = changeSummary(p);
+        const caveat = [
+            p.ranShell ? "Commands the agent ran are not undone." : "",
+            !hasFiles && session.current?.toolContext.checkpoints?.wasResumed() ? "Changes from before this session was reopened stay." : "",
+        ].filter(Boolean).join(" ");
+        const choices = [];
+        if (hasFiles) {
+            choices.push({ label: "Conversation and files", description: `The chat goes back to before this message, which returns to the input box. Puts back ${what}. ${caveat}`.trim(), mode: "both" });
+        }
+        choices.push({ label: "Conversation only", description: `The chat goes back to before this message, which returns to the input box.${hasFiles ? " Files stay as they are now." : ""} ${caveat}`.trim(), mode: "conversation" });
+        if (hasFiles) {
+            choices.push({ label: "Files only", description: `Puts back ${what}. The conversation stays, and the agent is told. ${caveat}`.trim(), mode: "files" });
+        }
+        choices.push({ label: "Cancel", description: "Keep everything as it is.", mode: null });
+        return choices;
+    }
+    async function applyRewind(point, mode) {
+        const s = session.current;
+        if (!s)
+            return;
+        const r = await rewindTo(s, point.at, mode);
+        if (!r) {
+            say("That message isn't in the conversation any more.");
+            return;
+        }
+        // Files only: the conversation stays on screen as it is; only the report is new.
+        if (mode !== "files") {
+            wipeChat();
+            showResumed(withEarlier(s));
+        }
+        reportRewind(s, r);
+        if (mode !== "files")
+            setFill({ text: refillText(r) });
+    }
+    function reportRewind(s, r) {
+        const rel = (p) => relativize(s.toolContext, p);
+        const list = (ps) => ps.map(rel).join(", ");
+        const took = [];
+        if (r.restored.length)
+            took.push(`put back ${r.restored.length} file${r.restored.length === 1 ? "" : "s"}`);
+        const state = {};
+        for (const { kind } of r.restoredState)
+            state[kind] = (state[kind] ?? 0) + 1;
+        const stateLine = stateSummary(state);
+        if (stateLine)
+            took.push(`took back ${stateLine}`);
+        const head = r.mode === "files" ? "— files rolled back to before your message" : "— rewound to before your message";
+        note(`${head}${took.length ? `; ${took.join("; ")}` : ""} —`);
+        if (r.conflicts.length)
+            note(`left alone, changed since: ${list(r.conflicts)}`, { error: true });
+        if (r.failed.length)
+            note(`could not be put back: ${list(r.failed)}`, { error: true });
+        if (r.skipped.length)
+            note(`too large to have been kept, still changed: ${list(r.skipped)}`, { error: true });
+        if (r.notRestored.length)
+            note(`changed before this session was reopened, so still changed: ${list(r.notRestored)}`, { error: true });
+        if (r.ranShell)
+            note("commands the agent ran are not undone");
+    }
+    /** The message as the input box holds one: pastes as their chips, attachments as handles. */
+    function refillText(r) {
+        let text = r.message.template;
+        r.message.pastes.forEach((paste, i) => {
+            text = text.split(pasteSlot(i)).join(registerPaste(paste));
+        });
+        const attached = [...r.message.files, ...r.message.images].map((p) => `"${p}"`).join(" ");
+        if (attached)
+            text = `${text}${text ? " " : ""}${dropHandles.current.register(attached)}`;
+        return text;
+    }
     // Apply the resume-mode pick for a chosen session: compact & continue / as-is / fresh.
     async function applyResume(meta, mode) {
         if (mode === 2)
@@ -2199,6 +2341,11 @@ export function App({ resumeSessionId, initialScreen }) {
             note(`already on ${provider.label} · ${modelLabel(s.modelConfig.model)}`);
             return;
         }
+        // A local runtime (Ollama) has no key to ask for: it has to be running, with a model pulled.
+        if (provider.local && !hasApiKey(provider.apiKeyEnv)) {
+            note(`${provider.label} isn't running here, or has no models yet. Start it and pull a model, then pick it again. ${provider.keysUrl}`);
+            return;
+        }
         const target = modelsOf(provider)[0];
         if (!target)
             return;
@@ -2272,10 +2419,19 @@ export function App({ resumeSessionId, initialScreen }) {
             setOverlay({ kind: "resumeMode", meta: o.items[index] });
             return;
         }
+        if (o.kind === "rewind") {
+            setOverlay({ kind: "rewindConfirm", point: o.items[index] });
+            return;
+        }
         setOverlay(null);
-        if (o.kind === "analytics") {
-            setAnalyticsEnabled(index === 0);
-            note(`Analytics turned ${index === 0 ? "on" : "off"}.`);
+        if (o.kind === "rewindConfirm") {
+            const mode = rewindChoices(o.point)[index]?.mode;
+            if (mode)
+                void applyRewind(o.point, mode);
+            return;
+        }
+        if (o.kind === "app") {
+            note(openInBrowser(APP_PAGE_URL) ? "Opened the download page in your browser." : `Could not open a browser. The page is ${APP_PAGE_URL}`);
         }
         else if (o.kind === "resumeMode")
             void applyResume(o.meta, index);
@@ -2421,8 +2577,7 @@ export function App({ resumeSessionId, initialScreen }) {
             exit();
             return;
         }
-        // /analytics — the anonymous usage ping. Bare opens the on/off switch, the same
-        // fixed box every other setting uses; an argument acts directly, same as /model.
+        // /analytics — the usage count, paused for now: it explains why and offers no switch.
         // /feedback — a message to the maintainer, from inside the app. No account, no issue
         // tracker, no mail client: the whole point is that it costs the sender nothing. What
         // leaves the machine is decided in cli/feedback.ts and shown here before it goes.
@@ -2459,16 +2614,9 @@ export function App({ resumeSessionId, initialScreen }) {
             }
         }
         if (name === "/analytics") {
-            const verb = arg.trim().toLowerCase();
-            if (verb === "on" || verb === "off") {
-                setAnalyticsEnabled(verb === "on");
-                note(`Analytics turned ${verb}.`);
-                return;
-            }
-            if (verb) {
-                return say("/analytics on|off, or bare to open the switch.");
-            }
-            setOverlay({ kind: "analytics" });
+            // Counting is paused (see analytics.ts), so there is nothing to choose: the command only
+            // explains why. Whatever follows it on the line gets the same answer.
+            note(ANALYTICS_EXPLANATION);
             return;
         }
         // /clear — a fresh conversation without leaving the folder. Until now the only
@@ -2534,6 +2682,41 @@ export function App({ resumeSessionId, initialScreen }) {
                 say(text);
                 return;
             }
+            // /context limit [<tokens>|reset] [global] — the same override Settings > Usage >
+            // Context sets in mwcode; see core/contextSettings.ts for the shared logic.
+            if (/^limit\b/.test(arg.trim())) {
+                const rest = arg.trim().slice("limit".length).trim();
+                const global = /(^|\s)global(\s|$)/i.test(rest);
+                const cleaned = rest.replace(/(^|\s)global(\s|$)/i, " ").trim();
+                const scope = global ? "global" : "project";
+                if (/^reset$/i.test(cleaned)) {
+                    await resetContextOverride(s, scope, s.governance.forbidden.root);
+                    note(`cleared the ${global ? "all-projects" : "project"} context limit.`);
+                }
+                else if (cleaned) {
+                    const n = Number(cleaned.replace(/[,_]/g, ""));
+                    if (!Number.isFinite(n) || n <= 0) {
+                        say("Give a token count, e.g. /context limit 200000, or /context limit 200000 global.");
+                        return;
+                    }
+                    const result = await setContextOverride(s, scope, n, s.governance.forbidden.root);
+                    if (!result.ok) {
+                        say(result.error);
+                        return;
+                    }
+                }
+                const view = await contextView(s, s.governance.forbidden.root);
+                const sourceLabel = view.effective.source === "project"
+                    ? "this project's own limit"
+                    : view.effective.source === "global"
+                        ? "your all-projects limit"
+                        : `Mindweave's default for ${view.model}`;
+                say(`Compacts at ${formatTokens(view.effective.tokens)} — ${sourceLabel}.\n\n` +
+                    `  ${view.recommendation.note}\n\n` +
+                    `  /context limit <tokens> sets it for this project, add "global" for every project.\n` +
+                    `  /context limit reset clears it back to the default (add "global" to clear that scope).`);
+                return;
+            }
             // Only a measurement taken against the CURRENT model is passed through; a figure
             // carried over from another provider's tool serialisation would be the largest
             // single error in the table, and the table is meant to settle arguments.
@@ -2541,9 +2724,51 @@ 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), autoCompactThreshold(s.modelConfig.model))}
+            say(`${formatBudget(budget, sharpContextWindow(s.modelConfig.model), effectiveAutoCompactThreshold(s))}
 
-  /context project shows what Mindweave read about this directory at startup.`);
+  /context project shows what Mindweave read about this directory at startup.
+  /context limit shows or sets your own compaction limit.`);
+            return;
+        }
+        // /app — the desktop app. One screen with one choice: Enter opens the download page in the
+        // user's browser. It is a screen rather than a bare link so nothing opens by surprise.
+        if (name === "/app") {
+            setOverlay({ kind: "app" });
+            return;
+        }
+        // /rewind — go back to before one of your messages: the conversation AND the files
+        // its turns changed, with the message handed back to edit. See memory/rewind.ts.
+        if (name === "/rewind") {
+            const items = rewindPoints(s);
+            if (items.length === 0) {
+                say("Nothing to rewind to yet. Send a message first.");
+                return;
+            }
+            setOverlay({ kind: "rewind", items });
+            return;
+        }
+        // /marathon — hand over a goal and let it run on its own. Bare arms the box (the next
+        // message is the goal) or carries on a run that was stopped; `clear` takes a run down;
+        // with text it starts straight away. Questions are asked at the start only.
+        if (name === "/marathon") {
+            const rest = arg.trim();
+            if (rest === "clear") {
+                await dismissMarathon(s); // saved too, so it stays closed when the session is reopened
+                setMarathonUi(null);
+                note("marathon cleared.");
+                return;
+            }
+            if (rest) {
+                await beginMarathon(s, rest);
+                return;
+            }
+            if (s.marathon?.status === "running") {
+                const state = s.marathon;
+                setMarathonUi((ui) => marathonUiReduce(ui, { type: "restore", goal: state.goal, turn: state.turnsSpent, todos: state.todos ?? [] }));
+                await driveMarathon(s, (options) => resumeMarathon(s, options));
+                return;
+            }
+            setMarathonUi((ui) => marathonUiReduce(ui, { type: "arm" }));
             return;
         }
         // /undo — roll back file changes. Bare undoes the last turn; `list` shows what's
@@ -2559,7 +2784,7 @@ export function App({ resumeSessionId, initialScreen }) {
                 // A resumed session genuinely has no history to undo, which is NOT the same
                 // as nothing having happened — say which.
                 say(cp?.wasResumed()
-                    ? "Nothing to undo here — undo history isn't carried across restarts. Changes from the earlier run are still on disk."
+                    ? "Nothing to undo here. This session has no saved undo history, so changes from its earlier runs stay as they are."
                     : "Nothing to undo — no file changes have been made yet this session.");
                 return;
             }
@@ -2591,6 +2816,9 @@ export function App({ resumeSessionId, initialScreen }) {
             // separate note/say text lines — same restored/conflict/failed/skipped facts,
             // rendered the same way an edit's diff or a command's output is.
             if (restored.length > 0) {
+                // A memory, rule, skill or MCP server can be among them; the live session has to
+                // match what is on disk again.
+                await reloadAgentState(s, restored);
                 // The files on disk are back to their pre-turn state; drop them from the read
                 // ledger so the model must re-read before it can edit them again.
                 for (const p of restored)
@@ -2987,6 +3215,14 @@ export function App({ resumeSessionId, initialScreen }) {
         const s = session.current;
         if (!s)
             return;
+        // /marathon armed the box: this message is the goal.
+        if (marathonUiRef.current?.phase === "armed") {
+            await beginMarathon(s, trimmed);
+            return;
+        }
+        // A finished run's box has said its piece; the next ordinary message takes it down.
+        if (marathonUiRef.current && isFinished(marathonUiRef.current))
+            setMarathonUi(null);
         // The chat shows the typed line — `@mentions` stay visible, a dragged/dropped
         // file path collapses to just its name — never the file dump. The model gets
         // the full content via resolved <attached_file> blocks, and each attachment
@@ -3035,7 +3271,7 @@ export function App({ resumeSessionId, initialScreen }) {
         return (_jsx(TrustGate, { rows: rows, cwd: startCwd.current, breadth: trustBreadth, warning: breadthWarning(trustBreadth, startCwd.current), persists: trustPersists(trustBreadth), version: versionLabel(), docsUrl: MINDWEAVE_DOCS_URL, onTrust: () => {
                 rememberTrust(projectDir(startCwd.current), trustBreadth);
                 setTrustOpen(false);
-            }, onQuit: () => exit() }));
+            }, onQuit: () => process.exit(0) }));
     }
     // FIRST RUN: nothing can run yet, so offer every provider rather than one. The user
     // adds as many keys as they like and continues when they are ready. See KeySetup.
@@ -3068,7 +3304,10 @@ export function App({ resumeSessionId, initialScreen }) {
         // above where you are scrolled to, reads as the app having ignored you.
         setScrollUp(0);
         setHistory((h) => (h[h.length - 1] === text ? h : [...h, text]));
-        if (busy) {
+        // Also when something is already queued, busy or not: a turn ends, the next queued message is
+        // about to be sent, and for one render `busy` reads false. A message typed in that moment used to
+        // go straight out and arrive BEFORE the ones that had been waiting.
+        if (busy || queueRef.current.length > 0) {
             queueRef.current.push(queueMessage(text, { interrupting: interrupting.current }));
             setQueued([...queueRef.current]);
             return;
@@ -3126,13 +3365,20 @@ export function App({ resumeSessionId, initialScreen }) {
         if (!overlay)
             return null;
         const cur = session.current;
-        if (overlay.kind === "analytics") {
-            const enabled = analyticsEnabled();
-            const items = [
-                { label: "On" + (enabled ? "  ✓" : ""), description: "sends the ping" },
-                { label: "Off" + (!enabled ? "  ✓" : ""), description: "sends nothing" },
-            ];
-            return (_jsx(Picker, { title: "Anonymous usage analytics", note: ANALYTICS_EXPLANATION, items: items, width: width, maxRows: maxRows, initialIndex: enabled ? 0 : 1, onSelect: onOverlaySelect, onCancel: onOverlayCancel }));
+        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 }));
+        }
+        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 }));
+        }
+        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 }));
         }
         if (overlay.kind === "sessions") {
             const items = overlay.items.map((m) => ({
@@ -3163,8 +3409,10 @@ export function App({ resumeSessionId, initialScreen }) {
                 const n = modelsOf(p).length;
                 const models = `${n} model${n === 1 ? "" : "s"}`;
                 // Say up front which ones you can actually run — finding out at the next
-                // request is the worse place to learn it.
-                const key = hasApiKey(p.apiKeyEnv) ? "key set" : `needs ${p.apiKeyEnv}`;
+                // request is the worse place to learn it. A local runtime has no key: it runs or not.
+                const key = p.local
+                    ? hasApiKey(p.apiKeyEnv) ? "running on this machine" : n > 0 ? "not running" : "not running, or no models pulled"
+                    : hasApiKey(p.apiKeyEnv) ? "key set" : `needs ${p.apiKeyEnv}`;
                 const here = p.id === active ? ` · on ${activeLabel}` : "";
                 return { label: p.label + (p.id === active ? "  ✓" : ""), description: `${models} · ${key}${here}` };
             });
@@ -3248,6 +3496,10 @@ export function App({ resumeSessionId, initialScreen }) {
     // authority for the frame: no min or max against the polled state, which can lag a
     // resize, and a live syscall never can.
     const liveRows = liveTerminalSize(stdout).rows;
+    // The header is fitted to the width RIGHT NOW as well. Fitted to the debounced width, for the
+    // moment after a narrowing resize it was laid out for the old, wider window and wrapped its
+    // words over two rows.
+    const liveCols = liveTerminalSize(stdout).columns;
     // The FULL height, so the footer sits on the very last row with nothing below it.
     //
     // This was `liveRows - 1` for a real reason that no longer applies. Ink's own renderer
@@ -3335,10 +3587,9 @@ export function App({ resumeSessionId, initialScreen }) {
      */
     const frameTop = readingInline ? Math.max(0, rows - frameHeight) : 0;
     pillHit.current = pill !== null && pillRow.current !== null ? pillBounds(pill, width, frameTop + pillRow.current) : null;
-    // Only the blocks that can still be reached are worth laying out. Yoga lays
-    // out every child on every render — including one caused by a keystroke — so
-    // an unbounded transcript makes typing slower the longer you have been
-    // talking. This is generous enough to scroll through comfortably.
+    // 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.
     const rendered = allBlocks.length > SCROLLBACK_BLOCKS ? allBlocks.slice(-SCROLLBACK_BLOCKS) : allBlocks;
     const offset = allBlocks.length - rendered.length;
     // Which of those actually reach Yoga. Everything else becomes a spacer of exactly
@@ -3416,16 +3667,16 @@ export function App({ resumeSessionId, initialScreen }) {
     // The status line, the queued bar, the input and whatever sits under it. Built once
     // and rendered by BOTH shells: the only thing that differs between them is where it
     // ends up — pinned to the bottom of a frame we own, or simply the last thing printed.
-    const footerView = (_jsxs(Box, { ref: footerRef, flexDirection: "column", flexShrink: 0, children: [_jsx(Box, { flexShrink: 0, children: _jsx(Text, { children: " " }) }), _jsx(Box, { flexShrink: 0, children: _jsx(StatusLine, { busy: busy, startedAt: turnStart.current, lastMs: lastMs, usage: taskUsage, received: liveTokens, advance: advanceTokens }) }), _jsx(Box, { flexShrink: 0, children: _jsx(QueuedBar, { queued: queued }) }), _jsx(Box, { flexShrink: 0, flexDirection: "column", children: ready ? (_jsx(PromptInput, { onSubmit: onSend, opening: opening, disabled: false, placeholder: busy ? "type to queue a message…" : "say something…", width: width, history: history, completions: completions, pathComplete: pathComplete.current, onLargePaste: registerPaste, onDroppedPaths: (text) => dropHandles.current.register(text), registerCaretClick: (place) => {
+    const footerView = (_jsxs(Box, { ref: footerRef, flexDirection: "column", flexShrink: 0, children: [_jsx(Box, { flexShrink: 0, children: _jsx(Text, { children: " " }) }), _jsx(Box, { flexShrink: 0, children: _jsx(StatusLine, { busy: busy, startedAt: turnStart.current, lastMs: lastMs, usage: taskUsage, received: liveTokens, advance: advanceTokens }) }), _jsx(Box, { flexShrink: 0, children: _jsx(QueuedBar, { queued: queued }) }), marathonUi ? (_jsx(Box, { flexShrink: 0, children: _jsx(MarathonBox, { ui: marathonUi, width: width, cap: shell === "inline" ? 4 : 7 }) })) : null, _jsx(Box, { flexShrink: 0, flexDirection: "column", children: ready ? (_jsx(PromptInput, { onSubmit: onSend, opening: opening, disabled: false, placeholder: marathonUi?.phase === "armed" ? "describe the goal…" : busy ? "type to queue a message…" : "say something…", width: width, history: history, completions: completions, pathComplete: pathComplete.current, onLargePaste: registerPaste, onDroppedPaths: (text) => dropHandles.current.register(text), registerCaretClick: (place) => {
                         caretClick.current = place;
                     }, registerTextSelect: (select) => {
                         textSelect.current = select;
-                    }, maxMenuRows: maxMenuItems, menuAbove: shell === "inline", settleKey: committed.length, onMenuChange: onMenuChange, placeCursor: shell === "inline", onQueuePop: popQueue, overlay: overlayView })) : (_jsx(Box, { paddingX: 1, children: _jsx(Text, { dimColor: true, children: "starting\u2026" }) })) }), ctxWarn ? (
+                    }, maxMenuRows: maxMenuItems, menuAbove: shell === "inline", settleKey: committed.length, onMenuChange: onMenuChange, placeCursor: shell === "inline", onQueuePop: popQueue, overlay: overlayView, fill: fill })) : (_jsx(Box, { paddingX: 1, children: _jsx(Text, { dimColor: true, children: "starting\u2026" }) })) }), ctxWarn ? (
             // A compaction is near. This takes the line over the tip and the background bar:
             // it is the one thing here the user needs BEFORE it happens, since the summarizing
             // pass rewrites the conversation. Dim as it approaches, then a plain warning colour
             // with the manual way out once it is about to fire on its own.
-            _jsx(Box, { flexShrink: 0, children: ctxWarn.percentLeft <= 5 ? (_jsx(Text, { color: "yellow", children: "  context low · /compact to summarize now" })) : (_jsx(Text, { dimColor: true, children: `  ${ctxWarn.percentLeft}% until auto-compact` })) })) : !overlayView && runningShells.length > 0 ? (_jsx(Box, { flexShrink: 0, children: _jsx(BackgroundBar, { shells: runningShells }) })) : (_jsx(TipLine, { tip: TIPS[tipIdx % TIPS.length] }))] }));
+            _jsx(Box, { flexShrink: 0, children: ctxWarn.percentLeft <= 5 ? (_jsx(Text, { color: WARN, children: "  context low · /compact to summarize now" })) : (_jsx(Text, { dimColor: true, children: `  ${ctxWarn.percentLeft}% until auto-compact` })) })) : !overlayView && runningShells.length > 0 ? (_jsx(Box, { flexShrink: 0, children: _jsx(BackgroundBar, { shells: runningShells }) })) : (_jsx(TipLine, { tip: TIPS[tipIdx % TIPS.length] }))] }));
     // The transcript viewport: the scrolled window, its measurements, and the chip.
     //
     // Built once and rendered by BOTH shells — the full-screen frame, and the inline
@@ -3618,7 +3869,7 @@ export function App({ resumeSessionId, initialScreen }) {
                         // reprint the whole conversation underneath this frame.
                         chatView) : (tail.map((b, i) => (_jsx(BlockView, { block: b, columns: width, tightTop: isTight(allBlocks, committed.length + i) }, b.id)))), footerView] })] }));
     }
-    return (_jsxs(Box, { flexDirection: "column", height: frameHeight, overflow: "hidden", children: [_jsx(Box, { flexShrink: 0, children: _jsx(Banner, { width: width, mode: mode, modelConfig: session.current?.modelConfig, busy: busy }) }), chatView, footerView] }));
+    return (_jsxs(Box, { flexDirection: "column", height: frameHeight, overflow: "hidden", children: [_jsx(Box, { flexShrink: 0, children: _jsx(Banner, { width: liveCols, mode: mode, modelConfig: session.current?.modelConfig, busy: busy }) }), chatView, footerView] }));
 }
 /**
  * The inline shell's header, printed once at the top of the conversation.
@@ -3630,7 +3881,7 @@ export function App({ resumeSessionId, initialScreen }) {
  * header. What belongs in scrollback is the part that cannot go stale.
  */
 function InlineHeader() {
-    return (_jsxs(Box, { marginBottom: 1, children: [_jsx(Text, { bold: true, color: "yellow", children: "Mindweave" }), _jsxs(Text, { dimColor: true, children: [" ", versionLabel()] })] }));
+    return (_jsxs(Box, { marginBottom: 1, children: [_jsx(Text, { bold: true, color: ACCENT, children: "Mindweave" }), _jsxs(Text, { dimColor: true, children: [" ", versionLabel()] })] }));
 }
 /** A sentinel <Static> item: the one-time header, printed with the transcript so it
  *  scrolls away rather than being redrawn above every frame. */
@@ -3655,20 +3906,15 @@ const MENU_CHROME_ROWS = 4;
 const INLINE_MENU_ROWS = 3;
 /** Lines PageUp/PageDown move per press. */
 const PAGE_LINES = 10;
-/** Lines one wheel notch moves. Three is the usual terminal step, and a flick
- *  sends several reports, so it accumulates into a natural glide. */
-const WHEEL_LINES = 3;
-/** How much of the transcript stays scrollable. Every rendered block is laid out
- *  on every render, so this bounds what typing costs in a long conversation. */
-const SCROLLBACK_BLOCKS = 150;
 /** Blocks reprinted when the inline shell is entered. Two screens or so: enough to look
  *  back over, few enough that the reprint is not a visible pause. */
 /** How long the INLINE shell waits for a drag to settle before re-reading the size.
  *  The full-screen shell does not wait — see useTerminalSize. */
 const RESIZE_SETTLE_MS = 150;
 /** How often the size is polled, for Windows consoles where the resize event may never
- *  fire at all (nodejs/node#13197). Two integer reads; an unchanged size costs nothing. */
-const RESIZE_POLL_MS = 250;
+ *  fire at all (nodejs/node#13197). Two integer reads; an unchanged size costs nothing. 80ms keeps
+ *  the frame laid out for the old width (a header wrapping over two rows) to a single blink. */
+const RESIZE_POLL_MS = 80;
 const INLINE_REPRINT_BLOCKS = 40;
 /**
  * The loom shuttle that runs beside the name while a turn is working.
@@ -3707,7 +3953,7 @@ function Shuttle({ busy }) {
         return () => clearInterval(id);
     }, [busy, stops]);
     if (!busy)
-        return _jsx(Text, { dimColor: true, children: "─".repeat(SHUTTLE_CELLS) });
+        return _jsx(Text, { dimColor: true, wrap: "truncate-end", children: "─".repeat(SHUTTLE_CELLS) });
     // Fold the counter back on itself so the shuttle returns instead of wrapping.
     const pos = step < stops ? step : stops * 2 - 2 - step;
     let track = "";
@@ -3716,10 +3962,24 @@ function Shuttle({ busy }) {
         const right = cell * 2 + 1 >= pos && cell * 2 + 1 < pos + SHUTTLE_SPAN;
         track += left && right ? "━" : left ? "╾" : right ? "╼" : "─";
     }
-    return _jsx(Text, { color: "yellow", children: track });
+    return _jsx(Text, { color: ACCENT, dimColor: true, wrap: "truncate-end", children: track });
 }
-export function Banner({ width, mode, modelConfig, busy }) {
+export function Banner({ width: given, mode, modelConfig, busy }) {
     const m = modeById(mode);
+    // Re-fitted the moment the window changes. On a resize Ink lays the existing frame out again at
+    // the new width before anything re-renders, so a header fitted to the old width wrapped for that
+    // first frame. Listening here re-renders it straight away, and `wrap="truncate-end"` below keeps
+    // even that first frame on one row.
+    const { stdout } = useStdout();
+    const [liveWidth, setLiveWidth] = useState(given);
+    useEffect(() => {
+        const on = () => setLiveWidth(liveTerminalSize(stdout).columns);
+        stdout.on("resize", on);
+        return () => {
+            stdout.off("resize", on);
+        };
+    }, [stdout]);
+    const width = Math.min(given, liveWidth);
     // The release name, not the raw semver — the version stays available through
     // --help and the update-check note; this bar is read constantly during a working
     // turn and has no room to spare for a number nobody is reading it for.
@@ -3730,17 +3990,17 @@ export function Banner({ width, mode, modelConfig, busy }) {
     // (it is the same one the mode uses everywhere else); the model gets the teal of the
     // "reaching outside the machine" family; and the effort level is plain white, the
     // brightest thing in the row, because it is what changes most often.
-    const modeText = `${m.name.toUpperCase()} MODE ON`;
-    const modelText = modelConfig ? modelLabel(modelConfig.model) : "";
-    const effortText = modelConfig ? thinkLabel(modelConfig).toUpperCase() : "";
-    const right = modelConfig ? `${modeText} | ${modelText} | ${effortText}` : modeText;
-    // The title row gets a 1-col inset (same idea as the box's own paddingX),
-    // but the rule spans the FULL width, edge to edge — same as the box's
-    // border below it, so the two anchor the screen the same way instead of
-    // the header floating in from the sides while the box touches both edges.
-    const innerWidth = Math.max(1, width - 2);
-    const gap = Math.max(1, innerWidth - left.length - 1 - SHUTTLE_CELLS - right.length);
-    return (_jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [_jsxs(Box, { paddingX: 1, children: [_jsx(Text, { bold: true, color: "yellow", children: left }), _jsx(Text, { children: " " }), _jsx(Shuttle, { busy: busy }), _jsx(Text, { children: " ".repeat(gap) }), _jsx(Text, { dimColor: true, color: m.color, children: modeText }), modelConfig ? (_jsxs(_Fragment, { children: [_jsx(Text, { dimColor: true, children: " | " }), _jsx(Text, { color: KIND_COLOR.websearch, children: modelText }), _jsx(Text, { dimColor: true, children: " | " }), _jsx(Text, { children: effortText })] })) : null] }), _jsx(Text, { dimColor: true, children: "─".repeat(width) })] }));
+    // Fitted to ONE row whatever the width, model or mode (see bannerFit.ts): left to the layout,
+    // a header too long for the window broke its words over two rows.
+    const fit = fitBanner(Math.max(1, width - 2), {
+        title: left,
+        mode: m.name.toUpperCase(),
+        model: modelConfig ? modelLabel(modelConfig.model) : "",
+        effort: modelConfig ? thinkLabel(modelConfig).toUpperCase() : "",
+        shuttle: SHUTTLE_CELLS,
+    });
+    const status = [fit.model, fit.effort].filter(Boolean);
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { paddingX: 1, children: [fit.title ? _jsx(Text, { bold: true, color: ACCENT, wrap: "truncate-end", children: fit.title }) : null, fit.title && fit.showShuttle ? _jsx(Text, { children: " " }) : null, fit.showShuttle ? _jsx(Shuttle, { busy: busy }) : null, _jsx(Text, { wrap: "truncate-end", children: " ".repeat(fit.gap) }), _jsx(Text, { dimColor: true, color: m.color, wrap: "truncate-end", children: fit.mode }), status.map((part, i) => (_jsxs(Text, { wrap: "truncate-end", children: [_jsx(Text, { dimColor: true, children: " | " }), _jsx(Text, { children: part })] }, i)))] }), _jsx(Text, { dimColor: true, wrap: "truncate-end", children: "─".repeat(width) })] }));
 }
 /**
  * Terminal size that updates on resize — DEBOUNCED. A drag-resize fires a flood
@@ -3823,13 +4083,24 @@ export function useTerminalSize(defer) {
                 read();
                 return;
             }
-            debounce = setTimeout(read, RESIZE_SETTLE_MS);
+            debounce = setTimeout(() => {
+                debounce = undefined;
+                read();
+            }, RESIZE_SETTLE_MS);
         };
         stdout.on("resize", onResize);
+        // The poll must never restart a settle wait already running: it fires more often than the
+        // inline shell's settle delay, so restarting it would postpone the read for ever.
+        const onPoll = () => {
+            if (!deferRef.current)
+                read();
+            else if (!debounce)
+                onResize();
+        };
         // The poll exists for Windows, where the event cannot be relied on at all. It goes
         // through the same handler, so it inherits whichever policy the shell is using, and
         // the identical-size check above makes a poll that finds nothing free.
-        const poll = setInterval(onResize, RESIZE_POLL_MS);
+        const poll = setInterval(onPoll, RESIZE_POLL_MS);
         // The size read at THIS exact instant can be stale too: entering alt-screen
         // (a raw escape code written before Ink even mounts, see altScreen.ts) makes
         // the terminal reconfigure its buffer, and querying dimensions mid-reconfigure
@@ -3887,9 +4158,12 @@ function timeAgo(ms) {
  */
 function StatusLine({ busy, startedAt, lastMs, usage, received, advance, }) {
     // The render clock while busy: it advances the elapsed timer AND steps the eased token
-    // counter one frame. 50ms, which is what makes the number read as counting rather than
-    // as jumping — at 1Hz it moved once a second in whatever lump had arrived, which is a
-    // stutter, not an animation. Nothing else re-renders with it: the tick is this
+    // counter one frame. It runs at about the display's pace (16ms): the number reads as counting
+    // rather than as jumping, and the working dot moves smoothly. It was 50ms (20 frames a
+    // second), which was the slowest-looking thing on a screen that could draw three times as
+    // often, and at 1Hz before that it moved once a second in whatever lump had arrived, which
+    // is a stutter, not an animation. A tick costs about a millisecond now that unchanged rows
+    // are not rebuilt (see inkOutputPatch.ts). Nothing else re-renders with it: the tick is this
     // component's own state and the figure is read through a getter, so the cost is one
     // small subtree per frame.
     const [, tick] = useState(0);
@@ -3906,7 +4180,7 @@ function StatusLine({ busy, startedAt, lastMs, usage, received, advance, }) {
     if (busy && startedAt != null) {
         // `< Scampering… < 45s · ↓ 1.8k tokens >` — the reference shape. The angle brackets
         // are what make it read as a live gauge rather than a sentence, and the verb is
-        // held for the whole turn (see workingVerb) so the line does not flicker between
+        // swapped every few seconds (see workingVerb) and steady inside each, so the line does not flicker between
         // words while the seconds tick.
         const secs = Math.floor((Date.now() - startedAt) / 1000);
         // OUTPUT tokens for THIS task, estimated from what has streamed back. It is the task's
@@ -3915,7 +4189,7 @@ function StatusLine({ busy, startedAt, lastMs, usage, received, advance, }) {
         // did. Output is
         // also the only thing that grows continuously while a turn runs, so it animates cleanly.
         const got = received();
-        label = (_jsxs(Text, { children: [" ", workingVerb(startedAt), "\u2026", "  ", _jsxs(Text, { dimColor: true, children: ["< ", fmtElapsed(secs), got > 0 ? ` · ↓ ${formatTokens(got)} tokens` : "", " >"] })] }));
+        label = (_jsxs(Text, { children: [" ", workingVerb(startedAt, Date.now() - startedAt), "\u2026", "  ", _jsxs(Text, { dimColor: true, children: ["< ", fmtElapsed(secs), got > 0 ? ` · ↓ ${formatTokens(got)} tokens` : "", " >"] })] }));
     }
     else if (lastMs != null) {
         // Settled receipt: elapsed time and the turn's real token cost, shown at once,
@@ -3936,13 +4210,14 @@ function StatusLine({ busy, startedAt, lastMs, usage, received, advance, }) {
     // no line at all, rather than a marker floating with nothing beside it.
     if (!busy && label === null)
         return null;
-    const dot = busy ? _jsx(Text, { color: "cyan", children: "\u25CF" }) : _jsx(Text, { dimColor: true, children: "\u25CF" });
+    // Working: the accent green breathing on the same clock as the tool rows' dots. Done: still and dim.
+    const dot = busy ? _jsx(PulseDot, { tone: "green" }) : _jsx(Text, { dimColor: true, children: "\u25CF" });
     // No marginTop: the footer owns the gap above itself now, so that it survives this
     // component rendering nothing at all. Two would read as a hole.
     return (_jsxs(Box, { marginBottom: 0, children: [dot, label] }));
 }
-/** The working line's render clock. See StatusLine's tick. */
-const LIVE_TICK_MS = 50;
+/** The working line's render clock, in milliseconds. See StatusLine's tick. */
+const LIVE_TICK_MS = 16;
 function fmtElapsed(s) {
     return s < 60 ? `${s}s` : `${Math.floor(s / 60)}m ${s % 60}s`;
 }
@@ -3980,7 +4255,7 @@ function BackgroundBar({ shells }) {
     const cmds = shells
         .map((s) => `$ ${clipCmd(s.command)}${s.port ? ` (${s.port})` : ""} ${bgClock(now - s.startedAt)}`)
         .join(" • ");
-    return (_jsxs(Box, { children: [_jsx(Text, { color: "yellow", children: "[BG] " }), _jsx(Text, { dimColor: true, wrap: "truncate-end", children: `${shells.length} running: ${cmds}` })] }));
+    return (_jsxs(Box, { children: [_jsx(Text, { color: WARN, children: "[BG] " }), _jsx(Text, { dimColor: true, wrap: "truncate-end", children: `${shells.length} running: ${cmds}` })] }));
 }
 /** Elapsed for the background bar: whole seconds under a minute, `1m 20s` past it. */
 function bgClock(ms) {