@aragon-agent/cli 0.5.8 → 0.5.10

package/dist/ui/App.js

@@ -28,10 +28,21 @@ import { Transcript, TranscriptList } from './Transcript.js';
 import { PromptInput } from './PromptInput.js';
 import { Composer } from './Composer.js';
 import { StatusBar } from './StatusBar.js';
+import { secondsLeft } from '../agent/retry-view.js';
 import { TeamPanel } from './TeamPanel.js';
 import { TodoPanel } from './TodoPanel.js';
 import { TodoStrip } from './TodoStrip.js';
-import { ToastStack } from './ToastStack.js';
+import { ActivityLine } from './ActivityLine.js';
+import { BottomStatusRow } from './BottomStatusRow.js';
+import { UpdateLine } from './UpdateLine.js';
+// The updater's two PURE modules. `shouldRenderUpdateLine` decides the row's
+// presence AT THE CALL SITE (C-15), and `UPDATE_LIMITS` owns the width
+// threshold - both are values, and both are resolved here rather than inside
+// `UpdateLine` so that component's only edge into `update/` stays erasable by
+// tsc (cli-auto-update section 3.1 rule 1 / IF-1). Neither module opens a
+// socket, spawns a process or creates a timer.
+import { shouldRenderUpdateLine } from '../update/types.js';
+import { UPDATE_LIMITS } from '../update/limits.js';
 import { AppShell } from './layout/AppShell.js';
 import { ScrollViewport } from './layout/ScrollViewport.js';
 import { todoRailRows, todoRailWidth } from './layout/rail.js';
@@ -43,14 +54,13 @@ import { useRenderGovernor } from './use-render-governor.js';
 import { setPerfResetHook, setPerfSnapshotProvider } from '../commands/perf.js';
 import { frameHeight, MIN_FULLSCREEN_ROWS } from './layout/frame.js';
 import { HINT_MIN_ROWS, viewportRows as computeViewportRows } from './layout/budget.js';
-import { UNMEASURED_GEOMETRY } from './layout/regions.js';
 import { OVERLAY_PAGE, useWheelRouting } from './use-wheel-routing.js';
 import { installConsoleBridge } from './console-bridge.js';
 import { publishExitSnapshot } from './exit-snapshot.js';
 import { OverlayFrame } from './layout/OverlayFrame.js';
 import { helpRows } from './overlays/HelpOverlay.js';
 import { ModelPicker } from './overlays/ModelPicker.js';
-import { SettingsScreen } from './overlays/SettingsScreen.js';
+import { SettingsScreen, fastSettingsFrom, readFastSettings, } from './overlays/SettingsScreen.js';
 import { ConfirmDialog } from './overlays/ConfirmDialog.js';
 import { QuestionOverlay } from './overlays/QuestionOverlay.js';
 import { PlanReviewOverlay } from './overlays/PlanReviewOverlay.js';
@@ -93,7 +103,14 @@ export function resolveSettingsMaxTokens(raw, previous) {
         toast: ['warn', 'Max tokens must be a number or "auto".'],
     };
 }
-export function App({ controller, version, mode, initialOverlay, initialPrompt, confirmBridge, humanInputBridge, mouseSource, geometryOverride, }) {
+/**
+ * The lazy `useReducer` initializer. Module scope, so the reference is stable
+ * across renders and React never re-runs it.
+ */
+function seedViewState(thinkingVisible) {
+    return initialViewState({ thinkingVisible });
+}
+export function App({ controller, version, mode, initialOverlay, initialPrompt, confirmBridge, humanInputBridge, mouseSource, updateBridge, }) {
     const { exit } = useApp();
     const { stdout } = useStdout();
     const fullscreen = mode === 'fullscreen';
@@ -110,9 +127,21 @@ export function App({ controller, version, mode, initialOverlay, initialPrompt,
     });
     /** The transcript height cache, owned here and read by `TranscriptList` (L3). */
     const heights = useHeightStore();
-    const [state, dispatch] = useReducer(viewReducer, undefined, initialViewState);
+    // SEEDED FROM CONFIG, not dispatched after mount (§3.1.1): a post-mount
+    // `toggleThinking` would let `/resume` flash a restored thinking block on
+    // frame 1. `seedViewState` is module-scope so the lazy initializer is a stable
+    // function reference.
+    const [state, dispatch] = useReducer(viewReducer, cfg.showThinking, seedViewState);
     const [elapsedMs, setElapsedMs] = useState(0);
     const [confirmState, setConfirmState] = useState(null);
+    /**
+     * The updater's latest snapshot, or `null` while there is no service
+     * (cli-auto-update section 6.1).
+     *
+     * `UpdateSnapshot` is a VALUE OBJECT the service replaces wholesale on every
+     * transition, so this state can use referential equality and never diff fields.
+     */
+    const [updateSnapshot, setUpdateSnapshot] = useState(null);
     /** The request the question / plan overlay is currently rendering. */
     const [humanRequest, setHumanRequest] = useState(null);
     // Seeded from the history file, not from `CliConfig`: the list is no longer
@@ -121,8 +150,6 @@ export function App({ controller, version, mode, initialOverlay, initialPrompt,
     const [promptHistory, setPromptHistory] = useState(() => loadPromptHistory());
     // Scroll plumbing: intent goes down, one derived display number comes back.
     const [scrollIntent, setScrollIntent] = useState();
-    /** One prompt-history step per wheel notch over the composer band (§4.7). */
-    const [historyIntent, setHistoryIntent] = useState();
     const [pinToBottomNonce, setPinToBottomNonce] = useState(0);
     const [scrolledLines, setScrolledLines] = useState(0);
     // I-5 (§4.13): Ctrl+L cannot repaint by writing escapes — Ink dedupes
@@ -155,12 +182,21 @@ export function App({ controller, version, mode, initialOverlay, initialPrompt,
     const ctrlCArmed = useRef(false);
     const ctrlCTimer = useRef(null);
     const runBaselineOut = useRef(0);
+    /**
+     * Epoch ms the current run began — the activity phrase's seed.
+     *
+     * ASSIGNED IN RENDER SCOPE, NOT IN THE ELAPSED EFFECT (P1-7). That effect runs
+     * AFTER the render that first sees `status === 'running'`, so a ref it wrote
+     * would be one frame late — and the first frame of a run is exactly when the
+     * phrase is chosen. `Transcript.tsx` updates `highWater` / `prevLen` during
+     * render for the same reason: a value derived from a transition is needed by
+     * the very render that observes the transition.
+     */
+    const runStartedAt = useRef(0);
     const toastTimers = useRef(new Map());
     /** Every outstanding `gate.request()`. Held in a ref, never in state: it is
      *  bookkeeping for promises, and re-rendering on it would be noise. */
     const pendingHuman = useRef(new Set());
-    /** Written by `AppShell`'s layout effect, read at wheel-event time (§4.5). */
-    const geometryRef = useRef(UNMEASURED_GEOMETRY);
     /**
      * What `/perf` reports. Assigned during render, exactly like `stateRef` above,
      * because a slash command runs outside the render pass and a value captured in
@@ -181,6 +217,15 @@ export function App({ controller, version, mode, initialOverlay, initialPrompt,
     // `ViewState` is a field `restoreEntries`, `/clear`, `/reset` and the session
     // round-trip each have to have an opinion about, and none of them has an
     // opinion about a 3-second timer.
+    /**
+     * Whether the one `installing -> ready` toast has already been pushed
+     * (cli-auto-update section 6.3).
+     *
+     * A REF AND NOT STATE: this must survive every re-render without causing one,
+     * and it is the whole of AC-19 - ten re-renders while the phase sits at
+     * `ready` must still produce exactly one toast.
+     */
+    const updateToastPushed = useRef(false);
     const budgetRef = useRef(emptyBudget());
     const followTimer = useRef(null);
     /** True while the run in flight was started by the grace timer, not the user. */
@@ -289,10 +334,16 @@ export function App({ controller, version, mode, initialOverlay, initialPrompt,
         for (const action of merged)
             dispatch(action);
     }, []);
+    /**
+     * The CLI-local diff side channel (§3.3.7). Memoized once, beside the `cost`
+     * lookup below, because `reduceEvent` TAKES a patch rather than reading one:
+     * the store is consume-once, so this object must not be rebuilt per event.
+     */
+    const patchSource = useMemo(() => ({ take: (id) => controller.takeFilePatch(id) }), [controller]);
     useEffect(() => {
         const unsubscribe = controller.subscribe((event) => {
             const cost = controller.getModelInfo().cost;
-            for (const action of reduceEvent(event, cost)) {
+            for (const action of reduceEvent(event, cost, patchSource)) {
                 // MUTATED HERE, ONE INSTANT BEFORE THE ACTION THAT SETS
                 // `ViewState.errorNoticed`, rather than read back from the reducer one
                 // commit later (C-11). This is the whole of the batching-independence
@@ -406,7 +457,7 @@ export function App({ controller, version, mode, initialOverlay, initialPrompt,
             cancelFollowThrough();
             unsubscribe();
         };
-    }, [controller, flushPending, cancelPendingHuman, cancelFollowThrough]);
+    }, [controller, patchSource, flushPending, cancelPendingHuman, cancelFollowThrough]);
     // --- Team-mode event stream (team-subagents §5.2 / §3.9). --------------
     //
     // A SEPARATE SUBSCRIPTION, not a branch in the one above: `TeamEvent` is
@@ -440,16 +491,32 @@ export function App({ controller, version, mode, initialOverlay, initialPrompt,
                         dispatch({ type: 'teamUpdate', snapshot });
                     break;
                 }
-                case 'usage':
+                case 'usage': {
                     // Child spend is REAL SPEND and must reach the status bar, or the
                     // session cost readout under-reports by however much the team consumed
                     // — the single most misleading possible failure of this feature (R-5).
-                    dispatch({
-                        type: 'teamUsage',
-                        usage: event.usage,
-                        costDelta: computeCost(event.usage, controller.getModelInfo().cost),
-                    });
+                    //
+                    // THE COST TABLE IS SELECTED BY TIER (fast-model-tier §3.6 / R-7).
+                    // Always using the lead's would over-report a Haiku child under a
+                    // Sonnet lead by roughly an order of magnitude, which is a different
+                    // way of being wrong about the same number.
+                    // FROM THE CONTROLLER, NOT FROM `cfg` (the rule the `agent_end`
+                    // handler above records): this effect's dependency list never changes,
+                    // so it closes over the `cfg` object of the render it mounted in, and
+                    // `setModel` builds a NEW one.
+                    const live = controller.getConfig();
+                    const fastTier = event.tier === 'fast' ? controller.getFastStatus().tier : null;
+                    const ref = fastTier && fastTier.ok
+                        ? fastTier.ref
+                        : { providerId: live.provider, modelId: live.model };
+                    // Unknown pricing contributes ZERO rather than a fabricated figure
+                    // (C-11 / RV-4); `/fast status` and the dispatch report say `unknown`.
+                    const costDelta = controller.isPricedModel(ref)
+                        ? computeCost(event.usage, controller.getModelInfoFor(ref).cost)
+                        : 0;
+                    dispatch({ type: 'teamUsage', usage: event.usage, costDelta });
                     break;
+                }
                 case 'dispatch_end':
                     dispatch({ type: 'teamEnd', outcome: event.outcome });
                     break;
@@ -491,6 +558,83 @@ export function App({ controller, version, mode, initialOverlay, initialPrompt,
             }
         });
     }, [controller]);
+    // --- Fast-tier event stream (fast-model-tier §5.3). --------------------
+    //
+    // A FOURTH SUBSCRIPTION, for the reason the team and todo ones record:
+    // `FastEvent` is deliberately not a member of core's `AgentEvent` union
+    // (D-10), so it cannot arrive through `controller.subscribe`.
+    //
+    // `subscribeFast` returns a no-op unsubscribe when the tier was off at
+    // construction, so this can subscribe unconditionally and an ordinary session
+    // pays one closure for the whole run.
+    useEffect(() => {
+        // Seed the chip from the tier resolved at construction, so a fast-enabled
+        // session shows it on the first frame rather than after the first review.
+        const initial = controller.getFastStatus();
+        if (initial.registered)
+            dispatch({ type: 'fastTier', snapshot: initial.snapshot });
+        return controller.subscribeFast((event) => {
+            switch (event.type) {
+                case 'review_start':
+                    dispatch({
+                        type: 'fastStart',
+                        index: event.index,
+                        turn: event.turn,
+                        model: controller.getFastStatus().snapshot.model,
+                    });
+                    break;
+                case 'review_end':
+                    dispatch({ type: 'fastEnd', review: event.review });
+                    // The card settled, so the chip's `inFlight` and the session totals
+                    // both moved. One dispatch rather than two: `fastTier` carries them.
+                    dispatch({ type: 'fastTier', snapshot: controller.getFastStatus().snapshot });
+                    break;
+                case 'usage': {
+                    // Review spend is REAL SPEND at the FAST model's price (§3.6 / AC-18).
+                    const ref = controller.getFastStatus().tier;
+                    const costDelta = ref.ok && controller.isPricedModel(ref.ref)
+                        ? computeCost(event.usage, controller.getModelInfoFor(ref.ref).cost)
+                        : 0;
+                    dispatch({ type: 'fastUsage', usage: event.usage, costDelta });
+                    break;
+                }
+                case 'tier_changed':
+                    dispatch({ type: 'fastTier', snapshot: event.snapshot });
+                    break;
+            }
+        });
+    }, [controller]);
+    // --- Live tool output (agent-activity-presentation-live §3.3.2). --------
+    //
+    // A FIFTH SUBSCRIPTION, and THE ONE THAT DOES GO THROUGH THE STREAMING
+    // COALESCER (D-34 / P0-2). The three above each carry a discrete act at human
+    // frequency — a roster change, a `todo_write`, a review verdict — and each has
+    // a comment refusing the buffer for that reason. This one carries a STREAM at
+    // pipe speed: the producer is a child process's stdout, so dispatching per
+    // chunk would be one React commit per `read()`.
+    //
+    // THE EFFECT PUSHES INTO `pending.current` AND ARMS `flushTimer` ITSELF.
+    // There is no "buffered path for every other action" to fall into —
+    // `App.tsx:436-447` buffers exactly `textDelta` / `thinkingDelta` and
+    // dispatches everything else immediately — so writing this the way its three
+    // siblings are written leaves `mergeDeltas`'s new clause dead code and R-1
+    // with one bound instead of two. AC-38 is the pin, mutation-checked against
+    // the direct-dispatch form.
+    //
+    // `Date.now()` IS READ HERE, in the listener, not in the reducer, which is
+    // what keeps `viewReducer` pure.
+    useEffect(() => {
+        return controller.subscribeToolOutput(({ toolCallId, rows }) => {
+            pending.current.push({ type: 'toolOutputDelta', toolCallId, rows, at: Date.now() });
+            if (!flushTimer.current) {
+                // READ FROM THE REF AT ARM TIME, for the reason `App.tsx:439-441`
+                // records: this effect's dependency list never changes, so a captured
+                // number would be pinned to the mount render and the governor's ladder
+                // would move nothing.
+                flushTimer.current = setTimeout(() => flushPending(), governorInterval.current);
+            }
+        });
+    }, [controller, flushPending, governorInterval]);
     // --- Elapsed timer + tokens/sec baseline while running. ----------------
     useEffect(() => {
         if (state.status !== 'running') {
@@ -503,6 +647,19 @@ export function App({ controller, version, mode, initialOverlay, initialPrompt,
         const id = setInterval(() => setElapsedMs(Date.now() - startedAt), 200);
         return () => clearInterval(id);
     }, [state.status]);
+    // --- Retry countdown tick (llm-api-retry-backoff §6.5). ----------------
+    //
+    // ONLY WHILE A BACKOFF IS ACTUALLY WAITING, and the effect's teardown clears it —
+    // so an idle session, and even a session that is retrying but has already fired
+    // its next attempt, has NO timer at all. 1 Hz rather than the elapsed timer's
+    // 200 ms because the card shows whole seconds and a five-times-finer tick would
+    // buy four identical frames.
+    useEffect(() => {
+        if (state.retry?.phase !== 'waiting')
+            return undefined;
+        const id = setInterval(() => dispatch({ type: 'retryTick' }), 1000);
+        return () => clearInterval(id);
+    }, [state.retry?.phase]);
     // --- Toast auto-dismiss (single effect keyed on the toast list). -------
     useEffect(() => {
         for (const t of state.toasts) {
@@ -670,6 +827,48 @@ export function App({ controller, version, mode, initialOverlay, initialPrompt,
     // --- Helpers -----------------------------------------------------------
     const notify = (level, text) => dispatch({ type: 'notice', level, text });
     const toast = (level, text) => dispatch({ type: 'pushToast', level, text });
+    // --- Auto-update bridge (cli-auto-update section 3.8 / 6.3). ------------
+    //
+    // TWO ARRIVAL ORDERS, AND BOTH HAPPEN. The service is built by a dynamic
+    // `import()` fired after `render()`, so on a warm module cache it can be
+    // attached BEFORE this effect runs, and on a cold one long after. Reading
+    // `bridge.service` first and installing `onAttach` second covers both without
+    // a race - the same shape `confirmBridge` uses one screen up.
+    useEffect(() => {
+        if (!updateBridge)
+            return undefined;
+        const bridge = updateBridge;
+        let unsubscribe = null;
+        const attach = (service) => {
+            setUpdateSnapshot(service.snapshot());
+            unsubscribe = service.subscribe(setUpdateSnapshot);
+        };
+        if (bridge.service)
+            attach(bridge.service);
+        else
+            bridge.onAttach = attach;
+        return () => {
+            bridge.onAttach = null;
+            unsubscribe?.();
+        };
+    }, [updateBridge]);
+    // ONE TOAST, ON THE `installing -> ready` EDGE ONLY (section 6.3 / AC-19).
+    //
+    // It exists because the moment of completion may arrive while the user is
+    // reading the transcript with the row occupied by a run: the toast wins the row
+    // for its TTL and then hands it back to the persistent line. The ref is what
+    // makes ten re-renders at `ready` push exactly one.
+    useEffect(() => {
+        if (updateSnapshot?.phase !== 'ready')
+            return;
+        if (updateToastPushed.current)
+            return;
+        updateToastPushed.current = true;
+        toast('info', `${updateSnapshot.latestVersion ?? 'Update'} installed - restart aragon to apply.`);
+        // `toast` is a stable dispatch wrapper; depending on it would re-run this on
+        // every render and defeat the ref guard's purpose rather than its mechanism.
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [updateSnapshot?.phase, updateSnapshot?.latestVersion]);
     const persistConfig = (patch) => {
         try {
             updatePersistedConfig(patch);
@@ -727,6 +926,12 @@ export function App({ controller, version, mode, initialOverlay, initialPrompt,
         // Read at command time, so `/todo status` reports the live count rather than
         // whatever it was when this context was built.
         followBudget: budgetRef.current,
+        // Read at command time for the same reason, and additionally because the
+        // service ATTACHES LATE (section 3.8): a value captured when this closure was
+        // first created would be `undefined` for the whole session on a cold module
+        // cache, and `/update` would report "disabled" on a session where it is on.
+        // `?? undefined` because the bridge holds `null` and the port is optional.
+        update: updateBridge?.service ?? undefined,
     });
     /**
      * Submitting a prompt no longer touches `config.json` at all — it appends one
@@ -803,6 +1008,14 @@ export function App({ controller, version, mode, initialOverlay, initialPrompt,
         controller.setModel(values.provider, values.model, values.baseUrl || undefined);
         controller.setThinkingLevel(values.thinkingLevel);
         controller.setMaxTokens(cap.applied);
+        // THE SETTER AND THE PERSIST ARE BOTH REQUIRED, the pair `/todo panel`
+        // documents: persisting alone reports success and changes nothing until the
+        // next launch. `thinkingVisible` lives in `ViewState`, not in the config the
+        // controller holds, so the live half is a dispatch rather than a setter —
+        // and it is a no-op when the row already agrees with the current state.
+        if ((values.showThinking === 'on') !== stateRef.current.thinkingVisible) {
+            dispatch({ type: 'toggleThinking' });
+        }
         const key = values.apiKey.trim();
         if (key.length > 0) {
             // Registration site 4 (§4.4.3), and the one that matters most: this is how
@@ -817,6 +1030,12 @@ export function App({ controller, version, mode, initialOverlay, initialPrompt,
             model: values.model,
             baseUrl: values.baseUrl.trim() ? values.baseUrl.trim() : null,
             thinkingLevel: values.thinkingLevel,
+            showThinking: values.showThinking === 'on',
+            // PERSIST ONLY, with no paired live setter — the store is allocated in
+            // `AgentController`'s constructor, so this row takes effect on the next
+            // launch. That is what manual row 8 asks for, and it is why the seed above
+            // reads `cfg` rather than `ViewState`.
+            liveToolOutput: values.liveToolOutput === 'on',
             // Omitted entirely when the field was unusable, so the previous value
             // survives instead of being overwritten with a guess.
             ...(cap.persist !== 'skip' ? { maxTokens: cap.persist } : {}),
@@ -827,6 +1046,20 @@ export function App({ controller, version, mode, initialOverlay, initialPrompt,
         // merges it — a shallow merge here would reset `redactSecrets` every time
         // someone touched the level.
         patch.log = { level: values.logLevel };
+        // --- Fast tier (fast-model-tier §4.5) ---------------------------------
+        //
+        // THE SETTER AND THE PERSIST ARE BOTH REQUIRED, and this is the pair `/todo
+        // panel` documents (P1-2): `App` reads `controller.getConfig()` at render
+        // time, so persisting alone reports success and changes nothing until the
+        // next launch, while the setter alone forgets by morning.
+        //
+        // `setFastConfig` also re-resolves the tier, which matters HERE more than
+        // anywhere: this same Enter press may have changed the main provider, the
+        // main model or the API key, and `fast.provider: ''` inherits from all
+        // three (§3.2 rule 8 / RV-3).
+        const fastPatch = readFastSettings(values);
+        controller.setFastConfig(fastPatch);
+        patch.fast = fastPatch;
         persistConfig(patch);
         getLogger().reconfigure({ ...controller.getConfig().log, level: values.logLevel });
         dispatch({ type: 'setOverlay', overlay: null });
@@ -864,26 +1097,24 @@ export function App({ controller, version, mode, initialOverlay, initialPrompt,
         }
         resolveHuman({ kind: 'planDecision', decision: verdict.decision, feedback: verdict.feedback });
     };
-    // --- Mouse wheel region routing (§4.6). Table and coalescer live in the
-    // hook (D-13); only the wiring it cannot own stays here. Inline arrows are
-    // fine — the hook re-reads its options through a ref every render. The
-    // `Math.max(0, …)` mirrors the keyboard branch below, and for the same
-    // reason: `OverlayFrame` only ever reports a clamp DOWNWARD.
+    // --- Mouse wheel routing (wheel-scrolls-transcript-only §4.1). Table and
+    // coalescer live in the hook (D-13); only the wiring it cannot own stays here.
+    // Inline arrows are fine — the hook re-reads its options through a ref every
+    // render. The `Math.max(0, …)` mirrors the keyboard branch below, and for the
+    // same reason: `OverlayFrame` only ever reports a clamp DOWNWARD.
     const { clearCoalescer } = useWheelRouting({
         mouseSource,
-        geometryRef,
-        geometryOverride,
         getOverlay: () => stateRef.current.overlay,
         onScroll: scrollBy,
         onOverlayScroll: (delta) => setOverlayScroll((n) => Math.max(0, n + delta)),
-        onHistoryStep: (dir) => setHistoryIntent((prev) => ({ dir, nonce: (prev?.nonce ?? 0) + 1 })),
     });
     // A fresh overlay always opens at the top; carrying the previous overlay's
     // offset over would open Help mid-list for no reason the user can see.
     //
     // `clearCoalescer()` rides along here rather than adding a second subscriber
-    // to the same transition (§4.7 rule 2): an accumulated-but-unflushed
-    // transcript scroll must not survive an overlay opening.
+    // to the same transition (wheel-scrolls-transcript-only §4.3): an
+    // accumulated-but-unflushed transcript scroll must not survive an overlay
+    // opening.
     useEffect(() => {
         setOverlayScroll(0);
         clearCoalescer();
@@ -991,7 +1222,19 @@ export function App({ controller, version, mode, initialOverlay, initialPrompt,
             }
         }
         if (key.ctrl && (input === 't' || input === 'T')) {
+            const revealing = !stateRef.current.thinkingVisible;
             dispatch({ type: 'toggleThinking' });
+            // THE ACK IS MODE-AWARE FOR THE SAME REASON THE MARKER IS (D-16 / P0-2).
+            // Inline mode cannot repaint what `<Static>` has already printed, so the
+            // toast says what it DID rather than what the user hoped. The hide
+            // direction needs no qualifier: hiding applies to everything drawn from
+            // here on, and nothing is claimed about scrollback either way.
+            if (!revealing)
+                toast('info', 'Thinking hidden.');
+            else if (fullscreen)
+                toast('info', 'Thinking shown.');
+            else
+                toast('info', 'Thinking shown for new output.');
             return;
         }
         if (key.ctrl && (input === 'o' || input === 'O')) {
@@ -1056,6 +1299,40 @@ export function App({ controller, version, mode, initialOverlay, initialPrompt,
     const tokPerSec = state.status === 'running' && elapsedMs > 500
         ? Math.max(0, Math.round((state.usageTotal.outputTokens - runBaselineOut.current) / (elapsedMs / 1000)))
         : 0;
+    // --- The activity line's seed (§3.2.3 / P1-7). --------------------------
+    //
+    // RENDER SCOPE. Without this the ref holds `0` on the first run (an arbitrary
+    // word) and the PREVIOUS run's start on every run after, so every run opens on
+    // a wrong phrase for one frame and then jumps — a flicker at the start of
+    // every single turn, which is the one moment this feature exists to make feel
+    // calm.
+    const running = state.status === 'running';
+    if (running && runStartedAt.current === 0)
+        runStartedAt.current = Date.now();
+    if (!running && runStartedAt.current !== 0)
+        runStartedAt.current = 0;
+    // --- The running tool (agent-activity-presentation-live §3.4 / L4). -----
+    //
+    // A REVERSE LOOP WITH AN EARLY EXIT, NOT `.filter(...).pop()` (P2-3).
+    // `state.entries` is bounded by `transcriptRetain`, which DEFAULTS TO 1000,
+    // and this runs in render scope at up to 30 fps — an allocating full scan
+    // there is the exact cost `tui-render-performance` exists to remove. The
+    // running tool, when there is one, is within a few entries of the end.
+    let runningTool;
+    if (running) {
+        for (let i = state.entries.length - 1; i >= 0; i -= 1) {
+            const e = state.entries[i];
+            if (e.kind === 'tool' && e.status === 'running') {
+                runningTool = e.name;
+                break;
+            }
+        }
+    }
+    // WALL-CLOCK SECONDS, and the 200 ms ticker above is what causes the render
+    // that re-reads it — so no timer is added (D-36 / E-15). Seconds rather than
+    // milliseconds because `ToolCard` is `React.memo`'d with the default
+    // comparator; `Transcript` passes it on only to running tool entries.
+    const nowSec = running ? Math.floor(Date.now() / 1000) : undefined;
     // Row budget for the viewport and everything sized against it (§4.2a). The
     // inline path has no fixed frame, hence no height to fit into: `Infinity`
     // tells `OverlayFrame` to render everything and show no position indicator.
@@ -1100,18 +1377,33 @@ export function App({ controller, version, mode, initialOverlay, initialPrompt,
             model: cfg.model,
             baseUrl: cfg.baseUrl ?? '',
             thinkingLevel: cfg.thinkingLevel,
+            // SEEDED AND READ BACK, both halves (§4.3): omitting either is the
+            // documented silent half of adding a row — the field renders empty and
+            // an untouched save writes a value the user never chose.
+            //
+            // FROM `ViewState`, NOT FROM `cfg`. `thinkingVisible` is session state
+            // that `Ctrl+T` also writes, and there is no controller setter to keep
+            // `cfg` in step — so seeding from the config would show the LAUNCH
+            // value under a transcript that has been toggled since, and an
+            // untouched save would then quietly toggle it back.
+            showThinking: state.thinkingVisible ? 'on' : 'off',
+            // FROM `cfg`, unlike its neighbour, and the difference is real: the
+            // live tail is decided at construction (the store is allocated there
+            // and there is no setter), so the config IS the current value and
+            // nothing can have toggled it since launch.
+            liveToolOutput: cfg.liveToolOutput ? 'on' : 'off',
             // `auto`, not an empty string: an empty field reads as "unset", which
             // is indistinguishable from AUTO and is not a state this can be in.
             maxTokens: cfg.maxTokens ? String(cfg.maxTokens) : 'auto',
             apiKey: '',
             logLevel: cfg.log.level,
-        }, apiKeys: cfg.apiKeys, maxRows: overlayMaxRows, cols: cols, scrollOffset: overlayScroll, onScrollClamp: setOverlayScroll, theme: theme, caps: caps, onSave: handleSettingsSave })) : overlay === 'confirm' && confirmState ? (_jsx(ConfirmDialog, { state: confirmState, maxRows: overlayMaxRows, cols: cols, theme: theme, caps: caps, onClose: closeConfirm })) : overlay === 'question' && humanRequest?.kind === 'questions' ? (_jsx(QuestionOverlay, { questions: humanRequest.questions, maxRows: overlayMaxRows, cols: cols, theme: theme, caps: caps, onSubmit: (answers) => resolveHuman({ kind: 'answers', answers, cancelled: false }) })) : overlay === 'plan' && humanRequest?.kind === 'plan' ? (_jsx(PlanReviewOverlay, { plan: humanRequest.plan, maxRows: overlayMaxRows, cols: cols, scrollOffset: overlayScroll, onScrollClamp: setOverlayScroll, theme: theme, caps: caps, onVerdict: handlePlanVerdict })) : null;
-    // A MEASUREMENT MUST NEVER OUTLIVE THE FRAME IT DESCRIBED (P1-5): neither
-    // path below renders the full-screen `AppShell`, so nothing else would
-    // overwrite a stale `bottom`. See `UNMEASURED_GEOMETRY` for why there is no
-    // arithmetic fallback.
-    if (!fullscreen || rows < MIN_FULLSCREEN_ROWS)
-        geometryRef.current = UNMEASURED_GEOMETRY;
+            // The four fast rows, seeded through the pure mapper so the screen and
+            // the save handler cannot disagree about what `(inherit)` means.
+            ...fastSettingsFrom(cfg.fast),
+        }, apiKeys: cfg.apiKeys, maxRows: overlayMaxRows, cols: cols, scrollOffset: overlayScroll, onScrollClamp: setOverlayScroll, theme: theme, caps: caps, onSave: handleSettingsSave, 
+        // Read from `cfg` (render scope, re-read every frame), so `/retry off`
+        // while the screen is open shows the new value on the next paint.
+        retrySummary: cfg.retry.enabled && cfg.retry.maxRetries > 0 ? String(cfg.retry.maxRetries) : 'off' })) : overlay === 'confirm' && confirmState ? (_jsx(ConfirmDialog, { state: confirmState, maxRows: overlayMaxRows, cols: cols, theme: theme, caps: caps, onClose: closeConfirm })) : overlay === 'question' && humanRequest?.kind === 'questions' ? (_jsx(QuestionOverlay, { questions: humanRequest.questions, maxRows: overlayMaxRows, cols: cols, theme: theme, caps: caps, onSubmit: (answers) => resolveHuman({ kind: 'answers', answers, cancelled: false }) })) : overlay === 'plan' && humanRequest?.kind === 'plan' ? (_jsx(PlanReviewOverlay, { plan: humanRequest.plan, maxRows: overlayMaxRows, cols: cols, scrollOffset: overlayScroll, onScrollClamp: setOverlayScroll, theme: theme, caps: caps, onVerdict: handlePlanVerdict })) : null;
     // A resize can drop below the usable floor. Do NOT leave the alt-screen —
     // entering and leaving it on every drag is worse than a placeholder — and take
     // the height from `frameHeight()` like everything else, because this is the
@@ -1148,13 +1440,32 @@ export function App({ controller, version, mode, initialOverlay, initialPrompt,
         viewportRows: fullscreen ? viewportBudget : rows,
         offset: scrolledLines,
     };
-    const viewport = fullscreen ? (overlayNode ? (_jsx(Box, { flexDirection: "column", flexGrow: 1, overflow: "hidden", children: overlayNode })) : (_jsxs(ScrollViewport, { intent: scrollIntent, pinToBottomNonce: pinToBottomNonce, onScrolledLinesChange: setScrolledLines, showScrollIndicator: true, cols: contentCols, theme: theme, caps: caps, children: [opener, _jsx(TranscriptList, { entries: state.entries, expandedToolIds: state.expandedToolIds, thinkingVisible: state.thinkingVisible, reducedMotion: reducedMotion, density: density, theme: theme, caps: caps, windowSize: transcriptWindow, cols: contentCols, heights: heights, mountedSink: mountedCount })] }))) : (_jsxs(_Fragment, { children: [opener, _jsx(Transcript, { entries: state.entries, expandedToolIds: state.expandedToolIds, thinkingVisible: state.thinkingVisible, reducedMotion: reducedMotion, density: density, theme: theme, caps: caps }), overlayNode] }));
+    const viewport = fullscreen ? (overlayNode ? (_jsx(Box, { flexDirection: "column", flexGrow: 1, overflow: "hidden", children: overlayNode })) : (_jsxs(ScrollViewport, { intent: scrollIntent, pinToBottomNonce: pinToBottomNonce, onScrolledLinesChange: setScrolledLines, showScrollIndicator: true, cols: contentCols, theme: theme, caps: caps, children: [opener, _jsx(TranscriptList, { entries: state.entries, expandedToolIds: state.expandedToolIds, thinkingVisible: state.thinkingVisible, reducedMotion: reducedMotion, density: density, mode: mode, nowSec: nowSec, theme: theme, caps: caps, windowSize: transcriptWindow, cols: contentCols, heights: heights, mountedSink: mountedCount })] }))) : (_jsxs(_Fragment, { children: [opener, _jsx(Transcript, { entries: state.entries, expandedToolIds: state.expandedToolIds, thinkingVisible: state.thinkingVisible, reducedMotion: reducedMotion, density: density, mode: mode, nowSec: nowSec, theme: theme, caps: caps }), overlayNode] }));
     // The completion popup lives inside the bottom chrome and can add up to 9
     // rows; unbounded, it pushes the status bar past the frame height where
     // `overflow: hidden` clips it away (R-14 / M-14). Cap it against the viewport.
     const popupMaxRows = fullscreen ? Math.max(1, viewportBudget - 4) : undefined;
-    const composer = fullscreen ? (_jsx(Composer, { isActive: overlay === null, running: state.status === 'running', history: promptHistory, commands: commandOptions, cwd: controller.getCwd(), showHint: rows >= HINT_MIN_ROWS, submitCount: cfg.submitCount, hintsEnabled: cfg.hints, agentMode: state.agentMode, popupMaxRows: popupMaxRows, historyIntent: historyIntent, theme: theme, caps: caps, onSubmit: (text) => void handleSubmit(text), onHelp: () => dispatch({ type: 'setOverlay', overlay: 'help' }) })) : (_jsx(Box, { marginTop: 1, children: _jsx(PromptInput, { isActive: overlay === null, running: state.status === 'running', history: promptHistory, commands: commandOptions, cwd: controller.getCwd(), agentMode: state.agentMode, theme: theme, caps: caps, onSubmit: (text) => void handleSubmit(text), onHelp: () => dispatch({ type: 'setOverlay', overlay: 'help' }) }) }));
-    return (_jsx(AppShell, { mode: mode, rows: rows, cols: cols, geometryRef: geometryRef, header: header, viewport: viewport, team: state.team ? (_jsx(TeamPanel, { snapshot: state.team, rows: rows, cols: cols, reducedMotion: reducedMotion, theme: theme, caps: caps })) : null, rail: showRail && state.todos ? (_jsx(TodoPanel, { snapshot: state.todos, width: railWidth, rows: railRows, running: state.status === 'running', reducedMotion: reducedMotion, theme: theme, caps: caps })) : null, strip: showStrip && state.todos ? (_jsx(TodoStrip, { snapshot: state.todos, cols: cols, theme: theme, caps: caps })) : null, toast: _jsx(ToastStack, { toasts: state.toasts, theme: theme, mode: mode }), composer: composer, status: _jsx(StatusBar, { model: cfg.model, provider: cfg.provider, usageTotal: state.usageTotal, contextTokens: state.contextTokens, contextWindow: modelInfo.contextWindow, contextWindowKnown: modelKnown, status: state.status, elapsedMs: elapsedMs, thinkingLevel: cfg.thinkingLevel, tokPerSec: tokPerSec, theme: theme, caps: caps, scrolledLines: scrolledLines, redrawNonce: redrawNonce, agentMode: state.agentMode, pendingAgentMode: state.pendingAgentMode, ecoRung: governor.rung, ...(state.team
+    const composer = fullscreen ? (_jsx(Composer, { isActive: overlay === null, running: state.status === 'running', history: promptHistory, commands: commandOptions, cwd: controller.getCwd(), showHint: rows >= HINT_MIN_ROWS, submitCount: cfg.submitCount, hintsEnabled: cfg.hints, agentMode: state.agentMode, popupMaxRows: popupMaxRows, theme: theme, caps: caps, onSubmit: (text) => void handleSubmit(text), onHelp: () => dispatch({ type: 'setOverlay', overlay: 'help' }) })) : (_jsx(Box, { marginTop: 1, children: _jsx(PromptInput, { isActive: overlay === null, running: state.status === 'running', history: promptHistory, commands: commandOptions, cwd: controller.getCwd(), agentMode: state.agentMode, theme: theme, caps: caps, onSubmit: (text) => void handleSubmit(text), onHelp: () => dispatch({ type: 'setOverlay', overlay: 'help' }) }) }));
+    return (_jsx(AppShell, { mode: mode, rows: rows, cols: cols, header: header, viewport: viewport, team: state.team ? (_jsx(TeamPanel, { snapshot: state.team, rows: rows, cols: cols, reducedMotion: reducedMotion, theme: theme, caps: caps })) : null, rail: showRail && state.todos ? (_jsx(TodoPanel, { snapshot: state.todos, width: railWidth, rows: railRows, running: state.status === 'running', reducedMotion: reducedMotion, theme: theme, caps: caps })) : null, strip: showStrip && state.todos ? (_jsx(TodoStrip, { snapshot: state.todos, cols: cols, theme: theme, caps: caps })) : null, toast: _jsx(BottomStatusRow, { mode: mode, toasts: state.toasts, 
+            // `!overlayNode` suppresses the line while an overlay owns the screen:
+            // the full-screen branch replaces the whole viewport with the overlay,
+            // and a working line under a settings screen is noise attached to a
+            // surface the run is not visible on. (Inline overlays are part of the
+            // document flow, so there the suppression is conservative rather than
+            // necessary — P2-5.)
+            activity: running && !overlayNode ? (_jsx(ActivityLine, { startedAt: runStartedAt.current, elapsedMs: elapsedMs, reducedMotion: reducedMotion, runningTool: runningTool, theme: theme, caps: caps })) : null, 
+            // PRESENCE IS DECIDED HERE, NOT BY `UpdateLine` RETURNING `null`
+            // (C-15 / cli-auto-update P0-1 / D-19). `BottomStatusRow` tests this
+            // prop for truthiness, and a React element is truthy however it
+            // renders - so a component that rendered nothing would give the row
+            // ZERO rows and silently unbalance the frame budget. Same rule the
+            // activity line above follows with `running && !overlayNode`.
+            //
+            // `!overlayNode` for the same reason it appears there: the full-screen
+            // branch replaces the whole viewport with the overlay, and an update
+            // notice under a settings screen is noise attached to a surface it is
+            // not visible on.
+            update: updateSnapshot && !overlayNode && shouldRenderUpdateLine(updateSnapshot) ? (_jsx(UpdateLine, { snapshot: updateSnapshot, compact: cols < UPDATE_LIMITS.statusCompactCols, theme: theme, caps: caps })) : null, theme: theme }), composer: composer, status: _jsx(StatusBar, { model: cfg.model, provider: cfg.provider, usageTotal: state.usageTotal, contextTokens: state.contextTokens, contextWindow: modelInfo.contextWindow, contextWindowKnown: modelKnown, status: state.status, elapsedMs: elapsedMs, thinkingLevel: cfg.thinkingLevel, tokPerSec: tokPerSec, theme: theme, caps: caps, scrolledLines: scrolledLines, redrawNonce: redrawNonce, agentMode: state.agentMode, pendingAgentMode: state.pendingAgentMode, ecoRung: governor.rung, ...(state.team
                 ? {
                     teamActive: {
                         running: state.team.runs.filter((r) => r.phase !== 'queued' && r.phase !== 'done' &&
@@ -1164,5 +1475,16 @@ export function App({ controller, version, mode, initialOverlay, initialPrompt,
                 }
                 : {}), ...(state.todos && !showRail
                 ? { todoActive: { done: state.todos.doneCount, total: state.todos.total } }
+                : {}), ...(state.fast?.live ? { fastActive: { inFlight: state.fast.inFlight } } : {}), ...(state.retry
+                ? {
+                    retryActive: {
+                        attempt: state.retry.attempt,
+                        max: state.retry.maxRetries,
+                        // Recomputed at RENDER from the absolute `resumeAt`, which is
+                        // what keeps the chip and the transcript card showing the same
+                        // number without either of them owning a second clock.
+                        secondsLeft: secondsLeft(state.retry.resumeAt, Date.now()),
+                    },
+                }
                 : {}) }) }));
 }