@aragon-agent/cli 0.5.6 → 0.5.9

package/dist/ui/App.js

@@ -11,7 +11,7 @@ import { Box, Text, useApp, useInput, useStdout } from 'ink';
 import { initialViewState, reduceEvent, viewReducer, } from '../agent/reducer.js';
 import { mergeDeltas } from '../agent/coalesce.js';
 import { computeCost } from '../agent/usage.js';
-import { parseMaxTokensInput, DEFAULT_TRANSCRIPT_WINDOW, } from '../config/schema.js';
+import { parseMaxTokensInput, DEFAULT_TRANSCRIPT_RETAIN, DEFAULT_TRANSCRIPT_WINDOW, } from '../config/schema.js';
 import { updatePersistedConfig } from '../config/store.js';
 import { appendPrompt, loadPromptHistory } from '../config/prompt-history.js';
 import { bumpSubmitCount, setMouseNoticeSeen } from '../config/ui-state.js';
@@ -28,26 +28,30 @@ 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 { AppShell } from './layout/AppShell.js';
 import { ScrollViewport } from './layout/ScrollViewport.js';
 import { todoRailRows, todoRailWidth } from './layout/rail.js';
 import { TODO_LIMITS } from '../todo/limits.js';
 import { advanceBudget, decideFollowThrough, emptyBudget, } from '../todo/follow-through.js';
 import { useTerminalSize } from './layout/useTerminalSize.js';
+import { useHeightStore } from './use-height-store.js';
+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';
@@ -90,14 +94,35 @@ export function resolveSettingsMaxTokens(raw, previous) {
         toast: ['warn', 'Max tokens must be a number or "auto".'],
     };
 }
-/** Merge pending delta actions ~33 ms and flush the coalescer buffer. */
-const COALESCE_MS = 33;
-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, }) {
     const { exit } = useApp();
     const { stdout } = useStdout();
     const fullscreen = mode === 'fullscreen';
     const { rows, cols } = useTerminalSize();
-    const [state, dispatch] = useReducer(viewReducer, undefined, initialViewState);
+    // --- Render governor (tui-render-performance L4). ------------------------
+    //
+    // FIRST, BEFORE ANY OTHER WORK IN THIS BODY. The hook stamps
+    // `performance.now()` during render and reads it again in a layout effect, so
+    // the span it measures is only the whole commit if nothing precedes it here.
+    const cfg = controller.getConfig();
+    const governor = useRenderGovernor({
+        enabled: cfg.renderGovernor,
+        maxIntervalMs: cfg.maxRenderIntervalMs,
+    });
+    /** The transcript height cache, owned here and read by `TranscriptList` (L3). */
+    const heights = useHeightStore();
+    // 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 request the question / plan overlay is currently rendering. */
@@ -108,8 +133,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
@@ -124,7 +147,6 @@ export function App({ controller, version, mode, initialOverlay, initialPrompt,
     // the completion list are memoized against it, so a skill installed mid-session
     // gets its `/<name>` command and its autocomplete entry immediately.
     const [skillsNonce, setSkillsNonce] = useState(0);
-    const cfg = controller.getConfig();
     const caps = useMemo(() => {
         const detected = detectCapabilities(process.env, stdout);
         return {
@@ -143,12 +165,35 @@ 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
+     * an effect closure would be one commit stale on every readout.
+     */
+    const perfRef = useRef(null);
+    /**
+     * How many entries `TranscriptList` actually mounted this frame.
+     *
+     * A ref written during the child's render, not state: this is the number
+     * `render-budget.test.tsx` gates on (AC-1 / AC-9), and turning it into state
+     * would make reading the render budget cost a render.
+     */
+    const mountedCount = useRef(0);
     // --- Follow-through (todo-plan-followthrough §3.4). ---------------------
     //
     // THREE REFS AND NO VIEW STATE, DELIBERATELY (§5.2). Every field added to
@@ -249,6 +294,8 @@ export function App({ controller, version, mode, initialOverlay, initialPrompt,
     // --- Streaming coalescer + controller subscription. --------------------
     const pending = useRef([]);
     const flushTimer = useRef(null);
+    /** Alias so the subscription effect below reads one stable ref, not a hook. */
+    const governorInterval = governor.intervalMs;
     const flushPending = useCallback(() => {
         if (flushTimer.current) {
             clearTimeout(flushTimer.current);
@@ -261,10 +308,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
@@ -276,7 +329,10 @@ export function App({ controller, version, mode, initialOverlay, initialPrompt,
                 if (action.type === 'textDelta' || action.type === 'thinkingDelta') {
                     pending.current.push(action);
                     if (!flushTimer.current) {
-                        flushTimer.current = setTimeout(() => flushPending(), COALESCE_MS);
+                        // READ FROM THE REF AT ARM TIME (L4). This effect's dependency list
+                        // never changes by construction, so a captured number would be
+                        // pinned to the mount render and the ladder would move nothing.
+                        flushTimer.current = setTimeout(() => flushPending(), governorInterval.current);
                     }
                 }
                 else {
@@ -375,7 +431,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
@@ -409,16 +465,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;
@@ -460,6 +532,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') {
@@ -472,6 +621,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) {
@@ -510,7 +672,12 @@ export function App({ controller, version, mode, initialOverlay, initialPrompt,
         // `state.json`, not `config.json`: whether a one-shot notice has been shown
         // is bookkeeping, and the comment on the old persisted key said so.
         onSeen: () => setMouseNoticeSeen(true),
-    });
+    }, 
+    // Present only when `loadConfig` had to raise the user's own
+    // `transcriptRetain` to `transcriptWindow` (tui-render-performance §5.1).
+    cfg.transcriptRetainRequested !== undefined
+        ? { requested: cfg.transcriptRetainRequested, resolved: cfg.transcriptRetain }
+        : undefined);
     // --- Exit snapshot: the only way state reaches cli.tsx (§4.4). ----------
     useEffect(() => {
         publishExitSnapshot({
@@ -519,8 +686,30 @@ export function App({ controller, version, mode, initialOverlay, initialPrompt,
             provider: cfg.provider,
             model: cfg.model,
             startedAt: startedAt.current,
+            // Carried so the exit replay can say what the retain ring removed. A
+            // transcript that silently omits entries is worse than one that names the
+            // count (K-6).
+            droppedEntries: state.droppedEntries,
+        });
+    }, [state.entries, state.usageTotal, state.droppedEntries, cfg.provider, cfg.model]);
+    // --- `/perf` snapshot channel (tui-render-performance §5.4). ------------
+    //
+    // The deps are the two `useCallback`d members, NOT the handle objects: both
+    // hooks return a fresh literal per render, so depending on them would re-run
+    // this effect on every frame.
+    const governorReset = governor.reset;
+    const heightsClear = heights.clear;
+    useEffect(() => {
+        setPerfSnapshotProvider(() => perfRef.current);
+        setPerfResetHook(() => {
+            governorReset();
+            heightsClear();
         });
-    }, [state.entries, state.usageTotal, cfg.provider, cfg.model]);
+        return () => {
+            setPerfSnapshotProvider(null);
+            setPerfResetHook(null);
+        };
+    }, [governorReset, heightsClear]);
     // --- Confirm bridge (confirmTools mode + skill approvals). -------------
     useEffect(() => {
         if (!confirmBridge)
@@ -745,6 +934,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
@@ -759,6 +956,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 } : {}),
@@ -769,6 +972,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 });
@@ -806,26 +1023,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();
@@ -933,7 +1148,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')) {
@@ -998,6 +1225,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.
@@ -1042,18 +1303,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
@@ -1071,13 +1347,39 @@ export function App({ controller, version, mode, initialOverlay, initialPrompt,
     // the header the moment the first message lands.
     const opener = empty ? (_jsx(SessionOpener, { variant: fullscreen ? pickOpenerVariant(viewportBudget, contentCols, caps) : 'none', version: version, cwd: controller.getCwd(), hasKey: hasKey, viewportRows: fullscreen ? viewportBudget : Number.POSITIVE_INFINITY, theme: theme, caps: caps })) : null;
     const density = cfg.density;
-    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: cfg.transcriptWindow ?? DEFAULT_TRANSCRIPT_WINDOW })] }))) : (_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 transcriptWindow = cfg.transcriptWindow ?? DEFAULT_TRANSCRIPT_WINDOW;
+    // Assigned during render so `/perf` reads the CURRENT frame (see `perfRef`).
+    // `mountedEntries` is the same number `render-budget.test.tsx` asserts (AC-9).
+    perfRef.current = {
+        rung: governor.rung,
+        intervalMs: governor.intervalMs.current,
+        lastCommitMs: governor.lastCommitMs(),
+        governorEnabled: cfg.renderGovernor,
+        totalEntries: state.entries.length,
+        retain: cfg.transcriptRetain ?? DEFAULT_TRANSCRIPT_RETAIN,
+        droppedEntries: state.droppedEntries,
+        mountedEntries: mountedCount.current,
+        heightsMeasured: heights.stats().measured,
+        heightsEstimated: heights.stats().estimated,
+        cols: contentCols,
+        mode: fullscreen ? 'fullscreen' : 'inline',
+        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, 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, ...(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, 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' &&
@@ -1087,5 +1389,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()),
+                    },
+                }
                 : {}) }) }));
 }