@aragon-agent/cli 0.6.8 → 0.6.10

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';
@@ -70,6 +68,7 @@ import { CommandRegistry, runSlashInput } from '../commands/registry.js';
 import { registerBuiltinCommands } from '../commands/builtins.js';
 import { makeSkillsCommand, registerSkillCommands } from '../commands/skills.js';
 import { MODE_LABEL, MODE_TOGGLE_KEYS, nextMode } from '../agent/agent-mode.js';
+import { copyText } from './clipboard.js';
 import { emptyTailState } from './layout/follow-state.js';
 /**
  * Decide what the `Max tokens` field means, WITHOUT letting a bad value in it
@@ -122,14 +121,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 +239,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 +492,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 +555,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 +636,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 +904,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 +928,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);
@@ -1415,7 +1368,12 @@ export function App({ controller, version, mode, initialOverlay, initialPrompt,
         cancelConfirmation();
         if (interactionPhase.current === 'running') {
             controller.steer(message);
-            toast('info', 'Steering queued.');
+            // THE TRANSCRIPT ENTRY IS THE FEEDBACK (tui-shift-enter-copy-queue
+            // 5.3). A 2.5 s toast cannot satisfy "until the message is picked
+            // up": the `queued` entry stays visible and is rewritten in place
+            // as the user message it became on the next `turn_start`. Keeping
+            // the toast too would confirm one event twice.
+            dispatch({ type: 'steerQueued', text: message });
             return;
         }
         if (interactionPhase.current === 'starting') {
@@ -1584,11 +1542,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,
@@ -1655,6 +1608,27 @@ export function App({ controller, version, mode, initialOverlay, initialPrompt,
         // `Esc` IS DELIBERATELY NOT GIVEN A SECOND MEANING (§4.4.6). It aborts a
         // run, and an emergency exit is the last key that should silently absorb a
         // press; it clears the selection here like every other key and nothing more.
+        //
+        // THE ONE EXCEPTION, AND IT SITS AHEAD OF THE UNCONDITIONAL CLEAR
+        // (tui-shift-enter-copy-queue 4.3): Ctrl+C over a RELEASED, non-empty
+        // selection means COPY. Selecting is browsing; copying is committing,
+        // and the commit key is the one a terminal user already reaches for.
+        // `takeSelection` runs BEFORE `copyText` because the copy writes OSC
+        // 52 through `writeForeign`, which invalidates the differ and would
+        // otherwise re-clear this controller a tick later (R7). A failed copy
+        // (`via === 'none'`) still reports through the shared toast funnel and
+        // returns: the selection is already consumed, and the NEXT Ctrl+C
+        // walks the original ladder.
+        if (key.ctrl &&
+            (input === 'c' || input === 'C') &&
+            (selectionController?.hasPendingSelection() ?? false)) {
+            const payload = selectionController.takeSelection();
+            if (payload) {
+                const via = copyText(payload.text, terminal?.writeForeign);
+                selectionBridge?.onCopied?.(via, payload.lines, payload.text.length);
+                return; // copied -- no service stop, no arm, no clear
+            }
+        }
         selectionController?.clear();
         if (key.ctrl && (input === 'c' || input === 'C')) {
             // RUNG ONE: Ctrl+C acquires the meaning a terminal user already expects
@@ -1734,7 +1708,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 +1724,7 @@ export function App({ controller, version, mode, initialOverlay, initialPrompt,
             }
             return;
         }
-        if (fullscreen) {
+        {
             if (key.pageUp) {
                 scrollBy('pageUp');
                 return;
@@ -1771,17 +1745,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 +1894,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 +1946,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 +1988,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 + queue/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 +2022,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 +2044,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 +2070,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 `queue / 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 {};

package/dist/ui/Composer.js

@@ -1,4 +1,4 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
 /**
  * Composer (spec §4.7) — the thin shell around the existing `PromptInput`.
  *
@@ -15,11 +15,33 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
  */
 import { useCallback, useState } from 'react';
 import { Box, Text } from 'ink';
+import stringWidth from 'string-width';
 import { pickGlyphs } from './glyphs.js';
 import { HINT_FADE_AFTER } from '../config/schema.js';
 import { PromptInput } from './PromptInput.js';
-import { ModeChip } from './ModeChip.js';
+import { ModeChip, modeChipCols } from './ModeChip.js';
+import { ActivityLabel, resolveActivityLabel } from './ActivityLine.js';
+import { RUN_ROW_LEAD, planRunRow } from './run-status-row.js';
 import { MODE_LABEL, MODE_TOGGLE_KEYS, nextMode } from '../agent/agent-mode.js';
+/**
+ * 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 function runningHintClauses(opts) {
+    const { glyphs, services } = opts;
+    // `queue`, NOT `steer` (tui-shift-enter-copy-queue 5.5): the gesture's
+    // consequence now has a name in the transcript (`Queue: ...`), and one
+    // behaviour with two names is undiscoverable.
+    const clauses = [`${glyphs.enterKey} queue`, `esc${glyphs.times}2 interrupt`];
+    // Confirmation is named even when service controls also need space.
+    if (services > 0)
+        clauses.push(`ctrl+c stop ${services}`);
+    clauses.push(`ctrl+c${glyphs.times}2 exit`);
+    return clauses;
+}
 /**
  * Build the hint row.
  *
@@ -40,18 +62,8 @@ function hintText(opts) {
     // clauses are shown; the row is `wrap="truncate"` and they are ordered
     // most-urgent-first, so a terminal too narrow for all of them drops the exit
     // clause last rather than the abort key.
-    if (running) {
-        if (services > 0) {
-            return [
-                `${glyphs.enterKey} steer`,
-                // Confirmation is named even when service controls also need space.
-                `esc${glyphs.times}2 interrupt`,
-                `ctrl+c stop ${services}`,
-                `ctrl+c${glyphs.times}2 exit`,
-            ].join(dot);
-        }
-        return [`${glyphs.enterKey} steer`, `esc${glyphs.times}2 interrupt`, `ctrl+c${glyphs.times}2 exit`].join(dot);
-    }
+    if (running)
+        return runningHintClauses({ glyphs, services }).join(dot);
     // The hint names the DESTINATION, not the current state — the correct label
     // for a toggle affordance, and the reason the mode word here is the OPPOSITE
     // of the one on the chip beside it.
@@ -86,7 +98,21 @@ function hintText(opts) {
  * than fishing the string out of a rendered frame.
  */
 export const hintTextForTest = hintText;
-export function Composer({ cols, cursorVisible, onInteraction, measureRef, isActive, reducedMotion, onEscape, onEscapeDismiss, running, history, commands, cwd, showHint, submitCount, hintsEnabled, agentMode, services = 0, modeToggleKey = MODE_TOGGLE_KEYS.primary, popupMaxRows, popupMaxHeight, onPopupRowsChange, scrolledLines = 0, onDraftRows, onNotice, theme, caps, onSubmit, onHelp, }) {
+function RunRow({ runRow, cols, services, agentMode, theme, caps, }) {
+    const glyphs = pickGlyphs(caps);
+    const separator = ` ${glyphs.midDot} `;
+    const clauses = runningHintClauses({ glyphs, services });
+    const plan = planRunRow({
+        cols,
+        // Spinner glyph + the space after it, then the label.
+        labelCols: 2 + stringWidth(resolveActivityLabel(runRow.activity, glyphs)),
+        hintClauseCols: clauses.map((clause) => stringWidth(clause)),
+        separatorCols: stringWidth(separator),
+        chipCols: modeChipCols(agentMode),
+    });
+    return (_jsxs(Box, { ref: runRow.rowRef, flexDirection: "row", flexShrink: 0, children: [_jsx(Box, { width: RUN_ROW_LEAD, flexShrink: 0, children: _jsx(Text, { children: ' ' }) }), _jsx(Box, { width: plan.labelCols, flexShrink: 0, children: _jsx(ActivityLabel, { ...runRow.activity, spinnerLive: runRow.live, theme: theme, caps: caps }) }), plan.hintClauses > 0 && (_jsxs(Text, { wrap: "truncate", color: theme.hintFg ?? theme.muted, children: [separator, clauses.slice(0, plan.hintClauses).join(separator)] })), plan.chip && (_jsxs(_Fragment, { children: [_jsx(Box, { flexGrow: 1 }), _jsx(ModeChip, { mode: agentMode, theme: theme, caps: caps })] }))] }));
+}
+export function Composer({ runRow, cols, cursorVisible, onInteraction, measureRef, isActive, reducedMotion, onEscape, onEscapeDismiss, running, history, commands, cwd, showHint, submitCount, hintsEnabled, agentMode, services = 0, modeToggleKey = MODE_TOGGLE_KEYS.primary, popupMaxRows, popupMaxHeight, onPopupRowsChange, scrolledLines = 0, onDraftRows, onNotice, theme, caps, onSubmit, onHelp, }) {
     const [hasDraft, setHasDraft] = useState(false);
     const onDraftChange = useCallback((next) => {
         setHasDraft(next.hasDraft);
@@ -105,8 +131,11 @@ export function Composer({ cols, cursorVisible, onInteraction, measureRef, isAct
                     ? theme.focusBorder ?? theme.primary
                     : theme.idleBorder ?? theme.border;
     const glyphs = pickGlyphs(caps);
-    const visible = showHint && hintsEnabled;
-    return (_jsxs(Box, { ref: measureRef, flexDirection: "column", flexShrink: 0, children: [_jsx(PromptInput, { cols: cols, cursorVisible: cursorVisible, onInteraction: onInteraction, isActive: isActive, reducedMotion: reducedMotion, onEscape: onEscape, onEscapeDismiss: onEscapeDismiss, running: running, history: history, commands: commands, cwd: cwd, theme: theme, caps: caps, popupMaxRows: popupMaxRows, popupMaxHeight: popupMaxHeight, onPopupRowsChange: onPopupRowsChange, onSubmit: onSubmit, onHelp: onHelp, agentMode: agentMode, bordered: { color: borderColor }, onDraftChange: onDraftChange, onNotice: onNotice, scrolledLines: scrolledLines }), visible && (
+    // While the run row is up it REPLACES the hint row below the input (same row
+    // count, so starting a run never moves the layout).
+    const runRowActive = running && !!runRow;
+    const visible = showHint && hintsEnabled && !runRowActive;
+    return (_jsxs(Box, { ref: measureRef, flexDirection: "column", flexShrink: 0, children: [runRowActive && (_jsx(RunRow, { runRow: runRow, cols: cols ?? process.stdout.columns ?? 80, services: services, agentMode: agentMode, theme: theme, caps: caps })), _jsx(PromptInput, { cols: cols, cursorVisible: cursorVisible, onInteraction: onInteraction, isActive: isActive, reducedMotion: reducedMotion, onEscape: onEscape, onEscapeDismiss: onEscapeDismiss, running: running, history: history, commands: commands, cwd: cwd, theme: theme, caps: caps, popupMaxRows: popupMaxRows, popupMaxHeight: popupMaxHeight, onPopupRowsChange: onPopupRowsChange, onSubmit: onSubmit, onHelp: onHelp, agentMode: agentMode, borderColor: borderColor, onDraftChange: onDraftChange, onNotice: onNotice, scrolledLines: scrolledLines }), 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({