@aragon-agent/cli 0.5.8 → 0.5.9

package/dist/ui/App.js

@@ -28,10 +28,12 @@ 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';
@@ -43,14 +45,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 +94,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, }) {
     const { exit } = useApp();
     const { stdout } = useStdout();
     const fullscreen = mode === 'fullscreen';
@@ -110,7 +118,11 @@ 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 request the question / plan overlay is currently rendering. */
@@ -121,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
@@ -155,12 +165,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
@@ -289,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
@@ -406,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
@@ -440,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;
@@ -491,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') {
@@ -503,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) {
@@ -803,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
@@ -817,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 } : {}),
@@ -827,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 });
@@ -864,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();
@@ -991,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')) {
@@ -1056,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.
@@ -1100,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
@@ -1148,13 +1366,20 @@ 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, 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 +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()),
+                    },
+                }
                 : {}) }) }));
 }

package/dist/ui/BottomStatusRow.d.ts

@@ -0,0 +1,43 @@
+/**
+ * The bottom status row — the one already-budgeted row above the composer, now
+ * shared by two occupants (agent-activity-presentation §3.2.3 / D-17 / P0-1).
+ *
+ * THE ACTIVITY LINE IS NOT A NEW `AppShell` SLOT, AND THIS FILE IS WHY.
+ *
+ * `viewportRows()` (`layout/budget.ts`) is the ONE function that says how many
+ * rows the viewport gets, and it enumerates exactly `header + toast + composer +
+ * status`. In full-screen `AppShell`'s root is `height={frameHeight(rows)}` with
+ * `overflow="hidden"`, the bottom chrome box is `flexShrink={0}` and the viewport
+ * box is its only `flexShrink={1}` child — so an extra chrome row does not make
+ * the frame taller, Yoga takes the row out of the TRANSCRIPT. Meanwhile
+ * `viewportRows()` keeps returning the old number to `ScrollViewport`,
+ * `selectWindow`'s spacers, `overlayMaxRows`, `popupMaxRows` and `todoRailRows`.
+ * The transcript would draw one row shorter than every consumer believes, ONLY
+ * WHILE A RUN IS IN FLIGHT, so the layout would shift on submit and shift back on
+ * `agent_end`.
+ *
+ * `ToastStack.tsx` already legislates this for itself: *"in `fullscreen` this
+ * ALWAYS occupies exactly one row — an empty row when there is nothing to say.
+ * Rendering conditionally would make the viewport height (and therefore the whole
+ * transcript) jump every time a toast appears or expires."* A run starts and ends
+ * far more often than a toast appears and expires, so the activity line is the
+ * STRONGER case for that rule, not an exception to it.
+ *
+ * Sharing the row means `budget.ts` and `AppShell.tsx` come out of this round
+ * UNMODIFIED — and `budget.test.ts` asserts that they did (AC-8a, DoD #8).
+ *
+ * PRECEDENCE: a toast wins. A transient ack is a RESPONSE TO THE USER, and the
+ * row nearest the input belongs to it.
+ */
+import React from 'react';
+import type { Theme } from './theme.js';
+import type { Toast } from '../agent/reducer.js';
+import type { RenderMode } from './layout/frame.js';
+export interface BottomStatusRowProps {
+    mode: RenderMode;
+    toasts: Toast[];
+    /** `<ActivityLine>` while a run owns the screen, else `null`. */
+    activity: React.ReactNode;
+    theme: Theme;
+}
+export declare function BottomStatusRow({ mode, toasts, activity, theme, }: BottomStatusRowProps): React.ReactElement | null;

package/dist/ui/BottomStatusRow.js

@@ -0,0 +1,14 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Box } from 'ink';
+import { ToastStack } from './ToastStack.js';
+export function BottomStatusRow({ mode, toasts, activity, theme, }) {
+    // A toast wins the row; so does an empty toast stack in full-screen, whose
+    // blank `<Text> </Text>` IS the budgeted row and must keep being emitted.
+    if (toasts.length > 0 || !activity) {
+        return _jsx(ToastStack, { toasts: toasts, theme: theme, mode: mode });
+    }
+    // Inline has no frame and therefore nothing to protect: `ToastStack`'s inline
+    // branch is already a conditional 0-3 row stack, and this is simply one more
+    // conditional row above it.
+    return _jsx(Box, { flexShrink: 0, children: activity });
+}

package/dist/ui/Composer.d.ts

@@ -35,14 +35,9 @@ export interface ComposerProps {
     /** Mirror of the controller's effective mode; drives the chip and the border. */
     agentMode: AgentMode;
     popupMaxRows?: number;
-    /** Pure pass-through to `PromptInput` (mouse-wheel-region-routing §5.6). */
-    historyIntent?: {
-        dir: 'up' | 'down';
-        nonce: number;
-    };
     theme: Theme;
     caps: TermCapabilities;
     onSubmit: (text: string) => void;
     onHelp?: () => void;
 }
-export declare function Composer({ isActive, running, history, commands, cwd, showHint, submitCount, hintsEnabled, agentMode, popupMaxRows, historyIntent, theme, caps, onSubmit, onHelp, }: ComposerProps): React.ReactElement;
+export declare function Composer({ isActive, running, history, commands, cwd, showHint, submitCount, hintsEnabled, agentMode, popupMaxRows, theme, caps, onSubmit, onHelp, }: ComposerProps): React.ReactElement;

package/dist/ui/Composer.js

@@ -56,7 +56,7 @@ function hintText(running, submitCount, glyphs, mode) {
         '? help',
     ].join(dot);
 }
-export function Composer({ isActive, running, history, commands, cwd, showHint, submitCount, hintsEnabled, agentMode, popupMaxRows, historyIntent, theme, caps, onSubmit, onHelp, }) {
+export function Composer({ isActive, running, history, commands, cwd, showHint, submitCount, hintsEnabled, agentMode, popupMaxRows, theme, caps, onSubmit, onHelp, }) {
     const [hasDraft, setHasDraft] = useState(false);
     const onDraftChange = useCallback((next) => setHasDraft(next), []);
     // Plan mode inserts ONE branch, above `draft` and below `running`. The
@@ -73,7 +73,7 @@ export function Composer({ isActive, running, history, commands, cwd, showHint,
                     : theme.idleBorder ?? theme.border;
     const glyphs = pickGlyphs(caps);
     const visible = showHint && hintsEnabled;
-    return (_jsxs(Box, { flexDirection: "column", flexShrink: 0, children: [_jsx(PromptInput, { isActive: isActive, running: running, history: history, commands: commands, cwd: cwd, theme: theme, caps: caps, popupMaxRows: popupMaxRows, onSubmit: onSubmit, onHelp: onHelp, agentMode: agentMode, bordered: { color: borderColor }, onDraftChange: onDraftChange, historyIntent: historyIntent }), visible && (
+    return (_jsxs(Box, { flexDirection: "column", flexShrink: 0, children: [_jsx(PromptInput, { isActive: isActive, running: running, history: history, commands: commands, cwd: cwd, theme: theme, caps: caps, popupMaxRows: popupMaxRows, onSubmit: onSubmit, onHelp: onHelp, agentMode: agentMode, bordered: { color: borderColor }, onDraftChange: onDraftChange }), visible && (
             // The chip rides the EXISTING hint row rather than adding one, so it
             // costs zero rows on a 24-row terminal.
             _jsxs(Box, { flexDirection: "row", flexShrink: 0, children: [_jsx(Text, { children: '  ' }), _jsx(ModeChip, { mode: agentMode, theme: theme, caps: caps }), _jsx(Text, { wrap: "truncate", color: theme.hintFg ?? theme.muted, children: hintText(running, submitCount, glyphs, agentMode) })] }))] }));

package/dist/ui/PromptInput.d.ts

@@ -55,20 +55,6 @@ interface PromptInputProps {
     };
     /** Fires only when the draft flips empty ⇄ non-empty, for the border color. */
     onDraftChange?: (hasDraft: boolean) => void;
-    /**
-     * One prompt-history step, pushed by the wheel router when a notch lands on
-     * the composer band (mouse-wheel-region-routing §5.6). `nonce` is monotonic
-     * so two notches in the same direction are two steps.
-     *
-     * Applied through the SAME `verticalOrHistory` / popup-selection branches the
-     * keyboard uses, deliberately: it means the wheel and `↑`/`↓` cannot drift
-     * apart, and the "never clobber an in-progress draft" guard protects the
-     * wheel for free.
-     */
-    historyIntent?: {
-        dir: 'up' | 'down';
-        nonce: number;
-    };
 }
 /** Apply an edit intent as a pure buffer/cursor transform. */
 export declare function applyEdit(buffer: string, cursor: number, intent: EditIntent): {
@@ -98,5 +84,5 @@ export declare function fileTokenAt(buffer: string, cursor: number): {
     end: number;
     query: string;
 } | null;
-export declare function PromptInput({ isActive, running, history, commands, cwd, theme, caps, popupMaxRows, agentMode, onSubmit, onHelp, bordered, onDraftChange, historyIntent, }: PromptInputProps): React.ReactElement;
+export declare function PromptInput({ isActive, running, history, commands, cwd, theme, caps, popupMaxRows, agentMode, onSubmit, onHelp, bordered, onDraftChange, }: PromptInputProps): React.ReactElement;
 export {};