@aragon-agent/cli 0.6.8 → 0.6.9

package/dist/ui/App.d.ts

@@ -10,7 +10,6 @@ import type { AgentController } from '../agent/controller.js';
 import type { ConfirmRequest } from '../tools/index.js';
 import { type Overlay, type ToastLevel } from '../agent/reducer.js';
 import type { UpdateBridge } from '../update/types.js';
-import { type RenderMode } from './layout/frame.js';
 import type { MouseSource } from '../input/stdin-filter.js';
 import type { PasteBridge } from '../input/limits.js';
 import type { SelectionBridge } from './selection/selection-controller.js';
@@ -43,15 +42,11 @@ export interface AppProps {
     controller: AgentController;
     version: string;
     /** Decided once in `cli.tsx::runInteractive()`; never switched at run time. */
-    mode: RenderMode;
     initialOverlay?: Overlay;
     initialPrompt?: string;
     confirmBridge?: ConfirmBridge;
     /** The plan-mode human channel; absent in tests that do not exercise it. */
     humanInputBridge?: HumanInputBridge;
-    /** Wheel events, already stripped out of stdin. Absent whenever mouse support
-     *  is off: inline mode, `--no-mouse`, a non-TTY, or a filter that failed to
-     *  build (mouse-wheel-region-routing §4.2). */
     mouseSource?: MouseSource;
     /**
      * Present ONLY on a console that can deliver neither `CSI Z` nor a mouse
@@ -87,28 +82,8 @@ export interface AppProps {
      * on a non-TTY, and in every test that does not exercise it.
      */
     pasteBridge?: PasteBridge;
-    /**
-     * The terminal-facing services `cli.tsx` owns and this component cannot build
-     * (tui-selection-and-scroll-follow §4.4).
-     *
-     * ONE PROP RATHER THAN FOUR, and every FIELD of it is independently optional,
-     * so `--no-mouse`, `--no-diff-render` and inline mode each drop exactly the
-     * services they do not have. Absent altogether on a non-TTY and in every test
-     * that does not exercise selection, which is what keeps those trees
-     * byte-identical.
-     */
     terminal?: TerminalBridge;
 }
-/**
- * Terminal-level services, almost all of which exist only in a full-screen TTY
- * session — `writeForeign` is the exception, because `/copy` is available in
- * inline mode too and OSC 52 is what makes it work over SSH (§4.4.5).
- *
- * `selection` is a LATE-BOUND BRIDGE for the reason `updateBridge` above is one:
- * the controller is constructed before `render()` and must not hold React state,
- * while the toast sink and the redraw nonce only exist once this component has
- * mounted. The effect below assigns both and clears them on unmount.
- */
 export interface TerminalBridge {
     scrollbar?: ScrollbarBridge;
     /** Whether drag-select is on for this session (`mouseSelect` + a filter). */
@@ -117,22 +92,7 @@ export interface TerminalBridge {
     setMouseCapture?: (on: boolean) => void;
     /** Whether the mouse is captured right now — read at command time. */
     isMouseCaptured?: () => boolean;
-    /**
-     * Write bytes that are ours but are not a frame (OSC 52).
-     *
-     * IT MUST NOT BE `stdout.write` WITH THE DIFFER IN FRONT OF STDOUT (P1-6):
-     * that goes through the frame-writer proxy, which does not recognise an OSC 52
-     * chunk, counts it as a foreign write and prints `FRAME_FALLBACK_NOTICE` at
-     * the user the first time they copy anything. Without a differ — inline mode,
-     * `--no-diff-render` — stdout IS the real stream and `cli.tsx` supplies a
-     * direct write instead.
-     *
-     * Absent only when there is no terminal to accept it at all. It is never a
-     * function that writes nowhere: `copyText` reports `'osc52'` whenever its door
-     * took the text, so a no-op door would make the toast name a mechanism that
-     * was never attempted.
-     */
     writeForeign?: (text: string) => void;
     selection?: SelectionBridge;
 }
-export declare function App({ controller, version, mode, initialOverlay, initialPrompt, confirmBridge, humanInputBridge, mouseSource, vtInputWarning, updateBridge, pasteBridge, terminal, }: AppProps): React.ReactElement;
+export declare function App({ controller, version, initialOverlay, initialPrompt, confirmBridge, humanInputBridge, mouseSource, vtInputWarning, updateBridge, pasteBridge, terminal, }: AppProps): React.ReactElement;

package/dist/ui/App.js

@@ -7,7 +7,7 @@ import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-run
  */
 import { useCallback, useEffect, useMemo, useReducer, useRef, useState } from 'react';
 import process from 'node:process';
-import { Box, Text, useApp, useInput, useStdout } from 'ink';
+import { Text, useApp, useInput, useStdout } from 'ink';
 import { advanceInterruptGesture, cancelInterruptConfirmation, } from '../input/interrupt-gesture.js';
 import { initialViewState, reduceEvent, viewReducer, } from '../agent/reducer.js';
 import { mergeDeltas } from '../agent/coalesce.js';
@@ -26,14 +26,12 @@ import { pickGlyphs } from './glyphs.js';
 import { Header } from './Header.js';
 import { pickHeaderVariant, pickOpenerVariant } from './Logo.js';
 import { SessionOpener } from './SessionOpener.js';
-import { Transcript, TranscriptList } from './Transcript.js';
-import { PromptInput } from './PromptInput.js';
+import { TranscriptList } from './Transcript.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 { ActivityLine, liveSpinner } from './ActivityLine.js';
 import { BottomStatusRow } from './BottomStatusRow.js';
 import { UpdateLine } from './UpdateLine.js';
@@ -53,7 +51,7 @@ import { advanceBudget, decideFollowThrough, emptyBudget, } from '../todo/follow
 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 { readScrollbarPerf, setPerfResetHook, setPerfSnapshotProvider, } from '../commands/perf.js';
 import { MIN_FULLSCREEN_ROWS, MIN_FULLSCREEN_COLS } from './layout/frame.js';
 import { HINT_MIN_ROWS, clampDraftRows, viewportRows as computeViewportRows } from './layout/budget.js';
 import { OVERLAY_PAGE, useWheelRouting } from './use-wheel-routing.js';
@@ -122,14 +120,18 @@ function liveServiceCount(services) {
 function seedViewState(thinkingVisible) {
     return initialViewState({ thinkingVisible });
 }
-export function App({ controller, version, mode, initialOverlay, initialPrompt, confirmBridge, humanInputBridge, mouseSource, vtInputWarning, updateBridge, pasteBridge, terminal, }) {
+export function App({ controller, version, initialOverlay, initialPrompt, confirmBridge, humanInputBridge, mouseSource, vtInputWarning, updateBridge, pasteBridge, terminal, }) {
     const { exit } = useApp();
     const { stdout } = useStdout();
-    const fullscreen = mode === 'fullscreen';
     const { rows, cols } = useTerminalSize();
-    const tooSmall = fullscreen && (rows < MIN_FULLSCREEN_ROWS || cols < MIN_FULLSCREEN_COLS);
+    const tooSmall = (rows < MIN_FULLSCREEN_ROWS || cols < MIN_FULLSCREEN_COLS);
     const composerRef = useRef(null);
+    const activityRef = useRef(null);
     const [cursorVisible, setCursorVisible] = useState(true);
+    // Whether the run status row above the input is inside the viewport. It is
+    // `true` while the row is not mounted (`elementVisible(null)`), so it is NEVER
+    // a decision on its own - always AND it with `runRowEnabled` (`runRowShown`).
+    const [activityRowVisible, setActivityRowVisible] = useState(true);
     // --- Render governor (tui-render-performance L4). ------------------------
     //
     // FIRST, BEFORE ANY OTHER WORK IN THIS BODY. The hook stamps
@@ -236,16 +238,6 @@ export function App({ controller, version, mode, initialOverlay, initialPrompt,
     const servicesRef = useRef(services);
     servicesRef.current = services;
     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
@@ -499,14 +491,6 @@ export function App({ controller, version, mode, initialOverlay, initialPrompt,
             budgetRef.current = advanceBudget(budgetRef.current, todos, autoContinuationRef.current);
             autoContinuationRef.current = false;
             const decision = decideFollowThrough({
-                // FROM THE CONTROLLER, NOT FROM `cfg` (P1-1). This effect's dependency
-                // list never changes, so it closes over the `cfg` object from the render
-                // in which it mounted — and `setTodoConfig` builds a NEW object, which
-                // that closure will never see. `cfg.todo.followThrough` would therefore
-                // be pinned to the launch value for the whole session and
-                // `/todo follow auto` would report success and do nothing. Note the
-                // asymmetry with `showStrip` further down, which is right to use `cfg`
-                // because it runs in render scope where `cfg` is re-read every frame.
                 mode: controller.getTodoConfig().followThrough,
                 snapshot: todos,
                 runEnd: { ...endReasonRef.current },
@@ -570,21 +554,6 @@ export function App({ controller, version, mode, initialOverlay, initialPrompt,
             unsubscribe();
         };
     }, [controller, patchSource, flushPending, cancelPendingHuman, cancelFollowThrough, resetInterrupt]);
-    // --- Background services (background-service-supervision §3.8). ---------
-    //
-    // A SEPARATE SUBSCRIPTION, not a branch in the one above: `ProcEvent` is
-    // deliberately not a member of core's `AgentEvent` union (I-5 / D-1), so it
-    // cannot arrive through `controller.subscribe`.
-    //
-    // TWO SINKS PER EVENT, and they are not redundant. `setServices` holds the
-    // LIVE state the status chip, the composer hint and the Ctrl+C rung read;
-    // `dispatch` writes the TRANSCRIPT, which records events about a service
-    // rather than mirroring it (D-11). Feeding one from the other would make the
-    // chip lie about a card that has already been printed into `<Static>`.
-    //
-    // NOT ROUTED THROUGH THE STREAMING COALESCER. `output` is already coalesced at
-    // the SOURCE, inside the supervisor, because `/bg` and `bash_output` consume
-    // the same event (§6); a second buffer here would only add latency.
     useEffect(() => {
         return controller.subscribeProc((event) => {
             const service = event.service;
@@ -666,9 +635,6 @@ export function App({ controller, version, mode, initialOverlay, initialPrompt,
         });
         return () => {
             unsubscribeTeam();
-            // Nothing else disposes the runtime on an inline-mode exit or a crash
-            // that unmounts the tree, and an orphaned child holds the event loop open
-            // (R-15). `cli.tsx` calls this too; `dispose()` is idempotent.
             controller.dispose();
         };
     }, [controller]);
@@ -937,10 +903,8 @@ export function App({ controller, version, mode, initialOverlay, initialPrompt,
     // Ink's own patchConsole writes straight to stdout, which shifts the fixed
     // frame by a row and breaks its line accounting for good.
     useEffect(() => {
-        if (!fullscreen)
-            return undefined;
         return installConsoleBridge((level, text) => dispatch({ type: 'notice', level, text }));
-    }, [fullscreen]);
+    }, []);
     // `enabled` is `mouseSource`, not `cfg.mouse`: a user whose terminal drops
     // the events must never be shown advice about a mode not in effect (§6.1).
     // `cli.tsx::wantMouse` now folds the platform check into the same expression,
@@ -963,21 +927,9 @@ export function App({ controller, version, mode, initialOverlay, initialPrompt,
     // `transcriptRetain` to `transcriptWindow` (tui-render-performance §5.1).
     cfg.transcriptRetainRequested !== undefined
         ? { requested: cfg.transcriptRetainRequested, resolved: cfg.transcriptRetain }
-        : undefined, 
-    // Its own one-shot key, NOT `mouseNoticeSeen`: everyone this notice is for
-    // has already run aragon at least once and already has that flag set. That
-    // key is now a VERSION for the same reason, one turn later — the audience
-    // for the text that finally names the fallback key is, again, exactly the
-    // set of users who already have the old flag on disk.
-    //
-    // `fullscreen` goes with it because only half of the damage is mode-
-    // independent: `Shift+Tab` is broken either way, but inline never asked for
-    // wheel reports and does not own the scroll keys, so it must not be told
-    // about either.
-    vtInputWarning
+        : undefined, vtInputWarning
         ? {
             nodeVersion: vtInputWarning.nodeVersion,
-            fullscreen,
             onSeen: () => setVtInputNoticeVersion(VT_INPUT_NOTICE_VERSION),
         }
         : undefined);
@@ -1584,11 +1536,6 @@ export function App({ controller, version, mode, initialOverlay, initialPrompt,
         }
         resolveHuman({ kind: 'planDecision', decision: verdict.decision, feedback: verdict.feedback });
     };
-    // --- 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,
         isPointerCaptured: () => terminal?.scrollbar?.controller?.isCaptured() ?? false,
@@ -1734,7 +1681,7 @@ export function App({ controller, version, mode, initialOverlay, initialPrompt,
             return;
         }
         if (key.ctrl && (input === 'l' || input === 'L')) {
-            if (fullscreen) {
+            {
                 // Writing \x1B[2J here would erase the screen and then leave it blank:
                 // Ink sees no output change and skips the repaint (ink.js:132 +
                 // log-update.js:13), possibly forever on an idle empty session. Bump
@@ -1750,7 +1697,7 @@ export function App({ controller, version, mode, initialOverlay, initialPrompt,
             }
             return;
         }
-        if (fullscreen) {
+        {
             if (key.pageUp) {
                 scrollBy('pageUp');
                 return;
@@ -1771,17 +1718,10 @@ 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.');
+                toast('info', 'Thinking shown.');
             return;
         }
         if (key.ctrl && (input === 'o' || input === 'O')) {
@@ -1927,40 +1867,25 @@ export function App({ controller, version, mode, initialOverlay, initialPrompt,
     // milliseconds because `ToolCard` is `React.memo`'d with the default
     // comparator; `Transcript` passes it on only to running tool entries.
     const nowSec = running || compactionLive ? 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.
-    // `draftRows` is the number `PromptInput` just reported for the rows it is
-    // ACTUALLY RENDERING (I-8). Defaulting it to 1 is what makes the inline path
-    // and every test that never types byte-identical to before.
     const viewportBudget = computeViewportRows(rows, draftRows);
-    const overlayMaxRows = fullscreen ? viewportBudget : Number.POSITIVE_INFINITY;
+    const overlayMaxRows = viewportBudget;
     // Renderers consume these same projections. Team capacity does not depend on
     // popup occupancy, so a menu cannot toggle the team's collapsed state.
-    const composerBaseRows = 2 + clampDraftRows(rows, draftRows)
-        + Number(rows >= HINT_MIN_ROWS && cfg.hints);
+    // THE ONE CONDITION for "the hint row exists": it sizes the footer below AND
+    // decides whether the run status row may replace that hint row while running,
+    // so starting a run can never add or remove a footer row.
+    const hintRowEnabled = rows >= HINT_MIN_ROWS && cfg.hints;
+    const composerBaseRows = 2 + clampDraftRows(rows, draftRows) + Number(hintRowEnabled);
     const teamLayout = buildTeamPanelLayout({
         snapshot: state.team, terminalRows: rows, availableRows: Math.max(0, viewportBudget - composerBaseRows),
     });
     const railLayout = buildTodoRailLayout({
-        mode, cols: fullscreen ? cols - 1 : cols, panelEnabled: cfg.todo.panel, overlayOpen: false,
+        cols: cols - 1, panelEnabled: cfg.todo.panel, overlayOpen: false,
         itemCount: state.todos?.items.length ?? 0, viewportBudget,
         teamRows: teamLayout.rowCount, popupRows, composerBaseRows,
     });
     // Transcript and composer share contentCols; fixed chrome and overlays use terminal width.
     const { visible: showRail, width: railWidth, rows: railRows, contentCols } = railLayout;
-    // The inline plan strip (todo-plan-followthrough §3.7 / W2).
-    //
-    // DELIBERATELY NOT `!showRail`, which is true for FOUR different reasons and
-    // three of them mean "do not draw this". `cfg.todo.panel` is included because
-    // `--no-todo-panel` means "keep the planning, drop the display" and a strip is
-    // a display. Overlays are NOT consulted: inline mode's overlays are part of
-    // the document flow, not a modal that owns the screen.
-    //
-    // `cfg` is the right read here and `controller.getTodoConfig()` would be
-    // needless — this runs in RENDER scope, where `cfg` is re-read every frame.
-    // The asymmetry with the `agent_end` handler above is the whole of P1-1.
-    const showStrip = !fullscreen && cfg.todo.panel && state.todos !== null;
     const overlayNode = overlay === 'help' ? (_jsx(OverlayFrame, { title: "Help", hint: `Esc close ${glyphs.midDot} PgUp/PgDn scroll`, maxRows: overlayMaxRows, cols: cols, rows: helpRows(theme, caps), scrollOffset: overlayScroll, onScrollClamp: setOverlayScroll, theme: theme, caps: caps })) : overlay === 'model' ? (_jsx(ModelPicker, { registry: controller.getModelRegistry(), currentProvider: cfg.provider, currentModel: cfg.model, maxRows: overlayMaxRows, cols: cols, theme: theme, caps: caps, onSelect: handleModelSelect })) : overlay === 'settings' ? (_jsx(SettingsScreen, { initial: {
             provider: cfg.provider,
             model: cfg.model,
@@ -1994,14 +1919,11 @@ export function App({ controller, version, mode, initialOverlay, initialPrompt,
         // 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;
-    // Full-screen: a constant one-row brand bar at every size, which is what makes
-    // the viewport monotonic and the first submit jump-free (§4.2). Inline keeps
-    // its v0.3.0 ternary and never calls `pickHeaderVariant`.
-    const header = (_jsx(Header, { version: version, cwd: controller.getCwd(), provider: cfg.provider, model: cfg.model, hasKey: hasKey, variant: fullscreen ? pickHeaderVariant(cols) : empty ? 'banner' : 'bar', theme: theme, caps: caps }));
+    const header = (_jsx(Header, { cwd: controller.getCwd(), provider: cfg.provider, model: cfg.model, hasKey: hasKey, variant: pickHeaderVariant(cols), theme: theme, caps: caps }));
     // The wordmark + getting-started card now live INSIDE the viewport, as its
     // first block of content, so they scroll away instead of being yanked out of
     // 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 opener = empty ? (_jsx(SessionOpener, { variant: pickOpenerVariant(viewportBudget, contentCols, caps), version: version, cwd: controller.getCwd(), hasKey: hasKey, viewportRows: viewportBudget, theme: theme, caps: caps })) : null;
     const density = cfg.density;
     const transcriptWindow = cfg.transcriptWindow ?? DEFAULT_TRANSCRIPT_WINDOW;
     // --- One spinner per run (single-spinner-while-running D-1 .. D-5). ------
@@ -2039,6 +1961,26 @@ export function App({ controller, version, mode, initialOverlay, initialPrompt,
     // threading the raw flag into a fifth consumer is the one silent way back to
     // two spinners (R-2).
     const viewReducedMotion = reducedMotion || activityVisible;
+    // The run status row (spinner + phrase + steer/interrupt hint) replaces the idle
+    // hint row ABOVE the input while running; it exists only when that hint row
+    // would, so the footer height is identical with and without it. `running`, not
+    // `activityVisible`: an overlay must not flip the Composer between two layouts.
+    const runRowEnabled = running && hintRowEnabled;
+    // The raw `reducedMotion` flag lives here and nowhere else (D-5).
+    const runActivity = {
+        startedAt: runStartedAt.current,
+        elapsedMs,
+        reducedMotion,
+        runningTool,
+        // THE ROW MUST NEVER SAY SOMETHING FALSE (§6.1). Compaction runs BEFORE
+        // `turn_start`, so `status` is `'running'` with no tool in flight - precisely
+        // the window in which the rotating phrase would claim the model is thinking
+        // while it is actually waiting on a 30k-token summarization.
+        compacting: state.compaction?.inFlight === true,
+    };
+    // The fixed bottom row takes over the life signal once the run row scrolls out
+    // of the viewport; exactly one of the two ever animates.
+    const runRowShown = runRowEnabled && activityRowVisible;
     // 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 = {
@@ -2053,12 +1995,18 @@ export function App({ controller, version, mode, initialOverlay, initialPrompt,
         heightsMeasured: heights.stats().measured,
         heightsEstimated: heights.stats().estimated,
         cols: contentCols,
-        mode: fullscreen ? 'fullscreen' : 'inline',
-        viewportRows: fullscreen ? viewportBudget : rows,
+        mode: 'fullscreen',
+        viewportRows: viewportBudget,
         offset: scrolledLines,
+        // A getter: the bridge's `frameReady` and geometry change outside React renders.
+        get scrollbar() {
+            return readScrollbarPerf({
+                bridge: terminal?.scrollbar, diffRender: cfg.diffRender, unicode: caps.unicode,
+            });
+        },
     };
     // Completion belongs to the document footer; cap it to keep the editor usable.
-    const popupMaxRows = fullscreen ? Math.max(1, viewportBudget - 4) : undefined;
+    const popupMaxRows = Math.max(1, viewportBudget - 4);
     // WHICH KEY THE HINT ROW NAMES (shift-tab-mode-toggle-still-dead-on-windows,
     // C3-1). Derived from `vtInputWarning` rather than from a probe of its own,
     // because that prop is already the single answer to "can this console deliver
@@ -2069,29 +2017,13 @@ export function App({ controller, version, mode, initialOverlay, initialPrompt,
     // Both keys always WORK (they share one branch in the input handler); this
     // only decides which one the user is taught.
     const modeToggleKey = vtInputWarning ? MODE_TOGGLE_KEYS.fallback : MODE_TOGGLE_KEYS.primary;
-    const composer = fullscreen ? (_jsx(Composer, { measureRef: composerRef, cols: contentCols, cursorVisible: cursorVisible, onInteraction: returnToComposer, reducedMotion: cfg.reducedMotion ?? false, onEscape: handleComposerEscape, onEscapeDismiss: cancelConfirmation, isActive: overlay === null && !tooSmall, 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, services: liveServices, modeToggleKey: modeToggleKey, popupMaxRows: popupMaxRows, popupMaxHeight: railLayout.popupMaxHeight, onPopupRowsChange: onPopupRowsChange, scrolledLines: scrolledLines, onDraftRows: onDraftRows, onNotice: notify, theme: theme, caps: caps, onSubmit: (text) => void handleSubmit(text), onHelp: () => dispatch({ type: 'setOverlay', overlay: 'help' }) })) : (_jsx(Box, { marginTop: 1, children: _jsx(PromptInput, { reducedMotion: cfg.reducedMotion ?? false, onEscape: handleComposerEscape, onEscapeDismiss: cancelConfirmation, isActive: overlay === null && !tooSmall, 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' }) }) }));
-    const team = state.team ? (_jsx(TeamPanel, { snapshot: state.team, layout: fullscreen ? teamLayout : undefined, rows: rows, cols: fullscreen ? contentCols : cols, reducedMotion: viewReducedMotion, theme: theme, caps: caps })) : null;
+    const composer = (_jsx(Composer, { measureRef: composerRef, runRow: runRowEnabled
+            ? { activity: runActivity, live: runRowShown && !overlayNode, rowRef: activityRef }
+            : null, cols: contentCols, cursorVisible: cursorVisible, onInteraction: returnToComposer, reducedMotion: cfg.reducedMotion ?? false, onEscape: handleComposerEscape, onEscapeDismiss: cancelConfirmation, isActive: overlay === null && !tooSmall, 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, services: liveServices, modeToggleKey: modeToggleKey, popupMaxRows: popupMaxRows, popupMaxHeight: railLayout.popupMaxHeight, onPopupRowsChange: onPopupRowsChange, scrolledLines: scrolledLines, onDraftRows: onDraftRows, onNotice: notify, theme: theme, caps: caps, onSubmit: (text) => void handleSubmit(text), onHelp: () => dispatch({ type: 'setOverlay', overlay: 'help' }) }));
+    const team = state.team ? (_jsx(TeamPanel, { snapshot: state.team, layout: teamLayout, rows: rows, cols: contentCols, reducedMotion: viewReducedMotion, theme: theme, caps: caps })) : null;
     const rail = showRail && state.todos ? (_jsx(TodoPanel, { snapshot: state.todos, width: railWidth, rows: railRows, running: running, reducedMotion: viewReducedMotion, theme: theme, caps: caps })) : null;
-    const viewport = fullscreen ? (_jsxs(ScrollViewport, { active: overlay === null && !tooSmall, overlay: tooSmall ? null : overlayNode, footer: _jsxs(_Fragment, { children: [team, composer] }), rail: rail, scrollbar: terminal?.scrollbar, composerRef: composerRef, onComposerVisibilityChange: setCursorVisible, resetKey: scrollResetKey, intent: scrollIntent, pinToBottomNonce: pinToBottomNonce, onScrolledLinesChange: setScrolledLines, onViewportShiftChange: onViewportShiftChange, tailRowsRef: tailSink, hold: selectionHold, resumeMs: cfg.scrollResumeMs, showScrollIndicator: true, cols: contentCols, theme: theme, caps: caps, children: [opener, _jsx(TranscriptList, { entries: state.entries, expandedToolIds: state.expandedToolIds, thinkingVisible: state.thinkingVisible, reducedMotion: viewReducedMotion, density: density, mode: mode, nowSec: nowSec, theme: theme, caps: caps, windowSize: transcriptWindow, cols: contentCols, heights: heights, mountedSink: mountedCount, tailSink: tailSink })] })) : (_jsxs(_Fragment, { children: [opener, _jsx(Transcript, { entries: state.entries, expandedToolIds: state.expandedToolIds, thinkingVisible: state.thinkingVisible, reducedMotion: viewReducedMotion, density: density, mode: mode, nowSec: nowSec, theme: theme, caps: caps }), overlayNode] }));
-    return (_jsx(AppShell, { inactive: tooSmall, placeholder: _jsxs(Text, { wrap: "truncate", color: theme.noticeWarn, children: [glyphs.warn, " Terminal too small - needs at least 40 columns and 12 rows."] }), mode: mode, rows: rows, cols: cols, header: header, viewport: viewport, team: team, 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.)
-            //
-            // THE CONDITION IS `activityVisible`, THE SAME CONST THE SUPPRESSION
-            // SIGNAL IS DERIVED FROM (D-4): inlining it here again is how the two
-            // drift apart, and the drift is silent in whichever branch is not
-            // edited.
-            activity: activityVisible ? (_jsx(ActivityLine, { startedAt: runStartedAt.current, elapsedMs: elapsedMs, reducedMotion: reducedMotion, runningTool: runningTool, 
-                // THE ROW MUST NEVER SAY SOMETHING FALSE (§6.1). Compaction runs
-                // BEFORE `turn_start`, so `status` is `'running'` with no tool in
-                // flight — precisely the window in which the rotating phrase
-                // would claim the model is thinking while it is actually waiting
-                // on a 30k-token summarization.
-                compacting: state.compaction?.inFlight === true, theme: theme, caps: caps })) : null, 
+    const viewport = (_jsxs(ScrollViewport, { active: overlay === null && !tooSmall, overlay: tooSmall ? null : overlayNode, footer: _jsxs(_Fragment, { children: [team, composer] }), rail: rail, scrollbar: terminal?.scrollbar, composerRef: composerRef, onComposerVisibilityChange: setCursorVisible, activityRef: activityRef, onActivityVisibilityChange: setActivityRowVisible, resetKey: scrollResetKey, intent: scrollIntent, pinToBottomNonce: pinToBottomNonce, onScrolledLinesChange: setScrolledLines, onViewportShiftChange: onViewportShiftChange, tailRowsRef: tailSink, hold: selectionHold, resumeMs: cfg.scrollResumeMs, showScrollIndicator: true, cols: contentCols, theme: theme, caps: caps, children: [opener, _jsx(TranscriptList, { entries: state.entries, expandedToolIds: state.expandedToolIds, thinkingVisible: state.thinkingVisible, reducedMotion: viewReducedMotion, density: density, nowSec: nowSec, theme: theme, caps: caps, windowSize: transcriptWindow, cols: contentCols, heights: heights, mountedSink: mountedCount, tailSink: tailSink })] }));
+    return (_jsx(AppShell, { inactive: tooSmall, placeholder: _jsxs(Text, { wrap: "truncate", color: theme.noticeWarn, children: [glyphs.warn, " Terminal too small - needs at least 40 columns and 12 rows."] }), rows: rows, cols: cols, header: header, viewport: viewport, toast: _jsx(BottomStatusRow, { toasts: state.toasts, activity: activityVisible && !runRowShown ? (_jsx(ActivityLine, { ...runActivity, theme: theme, caps: caps })) : null, 
             // THE FORM THE LIFE SIGNAL TAKES WHEN A TOAST HAS THE ROW
             // (`activity-spinner-vanishes-behind-toast`). Passed UNCONDITIONALLY:
             // `BottomStatusRow` reads it only when `activity` above is non-null,
@@ -2111,7 +2043,13 @@ export function App({ controller, version, mode, initialOverlay, initialPrompt,
             // 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, { interruptHint: interruptGesture.current.phase === 'stopping'
+            //
+            // `!running` (cli-auto-update D-2): the update notice stays silent for
+            // the whole run. It used to be guaranteed by the activity line
+            // out-ranking it inside this row; with the activity line moved above
+            // the input, the row can be free during a run, so the silence is stated
+            // here instead of inherited.
+            update: updateSnapshot && !overlayNode && !running && shouldRenderUpdateLine(updateSnapshot) ? (_jsx(UpdateLine, { snapshot: updateSnapshot, compact: cols < UPDATE_LIMITS.statusCompactCols, theme: theme, caps: caps })) : null, theme: theme }), status: _jsx(StatusBar, { interruptHint: interruptGesture.current.phase === 'stopping'
                 ? 'Esc force-stop' : 'Esc x2 interrupt', model: cfg.model, provider: cfg.provider, usageTotal: state.usageTotal, 
             // ONE OBJECT INSTEAD OF FOUR PARALLEL PROPS (§4.3). The four were a
             // projection of "many sources of truth" into the props layer, and a

package/dist/ui/BottomStatusRow.d.ts

@@ -54,9 +54,7 @@
 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;
@@ -94,4 +92,4 @@ export interface BottomStatusRowProps {
     update?: React.ReactNode;
     theme: Theme;
 }
-export declare function BottomStatusRow({ mode, toasts, activity, activityGlyph, update, theme, }: BottomStatusRowProps): React.ReactElement | null;
+export declare function BottomStatusRow({ toasts, activity, activityGlyph, update, theme, }: BottomStatusRowProps): React.ReactElement | null;

package/dist/ui/BottomStatusRow.js

@@ -1,15 +1,14 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { Box, Text } from 'ink';
 import { ToastStack } from './ToastStack.js';
-export function BottomStatusRow({ mode, toasts, activity, activityGlyph, update, theme, }) {
+export function BottomStatusRow({ toasts, activity, activityGlyph, update, theme, }) {
     // A toast wins the row outright — but a run in flight keeps its spinner on it.
     if (toasts.length > 0) {
         const spinner = activity ? activityGlyph : null;
         // Byte-identical to the old branch whenever there is no live spinner to
         // carry: no run, an ASCII terminal, or `reducedMotion`.
         if (!spinner)
-            return _jsx(ToastStack, { toasts: toasts, theme: theme, mode: mode });
-        const fullscreen = mode === 'fullscreen';
+            return _jsx(ToastStack, { toasts: toasts, theme: theme });
         return (
         // `flexDirection` SPELLED OUT even though `row` is Yoga's default: it is
         // what keeps two children on ONE row, and the header above turns on that
@@ -17,15 +16,12 @@ export function BottomStatusRow({ mode, toasts, activity, activityGlyph, update,
         // below that declares `column` — and "make them match" is a one-word edit
         // that doubles the row, takes it from the transcript, and desynchronises
         // every `viewportRows()` consumer without failing a type or a lint.
-        _jsxs(Box, { flexDirection: "row", flexShrink: 0, children: [_jsx(Box, { flexShrink: 0, marginTop: fullscreen ? 0 : 1, children: _jsxs(Text, { color: theme.thinking, children: [fullscreen ? ' ' : '', spinner, fullscreen ? '' : ' '] }) }), _jsx(Box, { flexDirection: "column", flexGrow: 1, flexShrink: 1, overflow: "hidden", children: _jsx(ToastStack, { toasts: toasts, theme: theme, mode: mode }) })] }));
+        _jsxs(Box, { flexDirection: "row", flexShrink: 0, children: [_jsx(Box, { flexShrink: 0, children: _jsxs(Text, { color: theme.thinking, children: [' ', spinner] }) }), _jsx(Box, { flexDirection: "column", flexGrow: 1, flexShrink: 1, overflow: "hidden", children: _jsx(ToastStack, { toasts: toasts, theme: theme }) })] }));
     }
-    // Inline has no frame and therefore nothing to protect: `ToastStack`'s inline
-    // branch is already a conditional 0-3 row stack, and these are simply one more
-    // conditional row above it.
     if (activity)
         return _jsx(Box, { flexShrink: 0, children: activity });
     if (update)
         return _jsx(Box, { flexShrink: 0, children: update });
     // The blank full-screen row that IS the budget must keep being emitted.
-    return _jsx(ToastStack, { toasts: toasts, theme: theme, mode: mode });
+    return _jsx(ToastStack, { toasts: toasts, theme: theme });
 }

package/dist/ui/Composer.d.ts

@@ -18,8 +18,24 @@ import type { Theme } from './theme.js';
 import type { TermCapabilities } from './capabilities.js';
 import { pickGlyphs } from './glyphs.js';
 import { type CommandOption } from './PromptInput.js';
+import { type RunActivity } from './run-status-row.js';
 import { type AgentMode } from '../agent/agent-mode.js';
+/**
+ * The run status row (tui-scrollbar-edge-and-run-row §3.3): the spinner, the phrase
+ * and the `steer / interrupt / exit` clauses on ONE row above the input box.
+ * `App` passes it only while a run is in flight AND the idle hint row would have
+ * been shown, so enabling it never changes the footer's height.
+ */
+export interface RunRowProps {
+    activity: RunActivity;
+    /** The row is in the viewport with no overlay: draw the animated spinner. */
+    live: boolean;
+    /** Measured by `ScrollViewport` to learn whether the row has scrolled away. */
+    rowRef?: React.RefObject<DOMElement>;
+}
 export interface ComposerProps {
+    /** Present only while the run status row replaces the hint row below the input. */
+    runRow?: RunRowProps | null;
     cols?: number;
     cursorVisible?: boolean;
     onInteraction?: () => void;
@@ -96,6 +112,17 @@ export interface ComposerProps {
     onSubmit: (text: string) => void;
     onHelp?: () => void;
 }
+/**
+ * The running-state hint as separate clauses, most urgent first.
+ *
+ * `hintText` joins them (its output is pinned by AC-43), and the run status row
+ * consumes the SAME array so it can drop whole clauses from the tail on a narrow
+ * terminal instead of cutting `interrupt` in half. One source, two consumers.
+ */
+export declare function runningHintClauses(opts: {
+    glyphs: ReturnType<typeof pickGlyphs>;
+    services: number;
+}): string[];
 /**
  * Build the hint row.
  *
@@ -125,5 +152,5 @@ declare function hintText(opts: {
  * than fishing the string out of a rendered frame.
  */
 export declare const hintTextForTest: typeof hintText;
-export declare function Composer({ cols, cursorVisible, onInteraction, measureRef, isActive, reducedMotion, onEscape, onEscapeDismiss, running, history, commands, cwd, showHint, submitCount, hintsEnabled, agentMode, services, modeToggleKey, popupMaxRows, popupMaxHeight, onPopupRowsChange, scrolledLines, onDraftRows, onNotice, theme, caps, onSubmit, onHelp, }: ComposerProps): React.ReactElement;
+export declare function Composer({ runRow, cols, cursorVisible, onInteraction, measureRef, isActive, reducedMotion, onEscape, onEscapeDismiss, running, history, commands, cwd, showHint, submitCount, hintsEnabled, agentMode, services, modeToggleKey, popupMaxRows, popupMaxHeight, onPopupRowsChange, scrolledLines, onDraftRows, onNotice, theme, caps, onSubmit, onHelp, }: ComposerProps): React.ReactElement;
 export {};