@aragon-agent/cli 0.6.7 → 0.6.8

package/dist/ui/App.js

@@ -1,4 +1,4 @@
-import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
 /**
  * App — the root Ink component. Owns the view reducer, subscribes to the
  * controller's event stream (with a streaming coalescer), wires global
@@ -8,6 +8,7 @@ import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } 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 { advanceInterruptGesture, cancelInterruptConfirmation, } from '../input/interrupt-gesture.js';
 import { initialViewState, reduceEvent, viewReducer, } from '../agent/reducer.js';
 import { mergeDeltas } from '../agent/coalesce.js';
 import { computeCost } from '../agent/usage.js';
@@ -53,8 +54,8 @@ import { useTerminalSize } from './layout/useTerminalSize.js';
 import { useHeightStore } from './use-height-store.js';
 import { useRenderGovernor } from './use-render-governor.js';
 import { setPerfResetHook, setPerfSnapshotProvider } from '../commands/perf.js';
-import { frameHeight, MIN_FULLSCREEN_ROWS } from './layout/frame.js';
-import { HINT_MIN_ROWS, viewportRows as computeViewportRows } from './layout/budget.js';
+import { 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';
 import { installConsoleBridge } from './console-bridge.js';
 import { publishExitSnapshot } from './exit-snapshot.js';
@@ -105,15 +106,6 @@ export function resolveSettingsMaxTokens(raw, previous) {
         toast: ['warn', 'Max tokens must be a number or "auto".'],
     };
 }
-/**
- * How long rung two of the Esc ladder stays armed after rung one (§5.5).
- *
- * Four seconds: long enough that a user who watched the abort fail can react,
- * short enough that a stray Esc minutes later cannot force-stop a healthy run.
- * `runEnd` / `agent_end` disarm it too, so the window is an upper bound rather
- * than the only protection (R-9).
- */
-const ESC_ARM_MS = 4000;
 /** Services in a non-terminal state, from the live snapshot map. */
 function liveServiceCount(services) {
     let n = 0;
@@ -135,6 +127,9 @@ export function App({ controller, version, mode, initialOverlay, initialPrompt,
     const { stdout } = useStdout();
     const fullscreen = mode === 'fullscreen';
     const { rows, cols } = useTerminalSize();
+    const tooSmall = fullscreen && (rows < MIN_FULLSCREEN_ROWS || cols < MIN_FULLSCREEN_COLS);
+    const composerRef = useRef(null);
+    const [cursorVisible, setCursorVisible] = useState(true);
     // --- Render governor (tui-render-performance L4). ------------------------
     //
     // FIRST, BEFORE ANY OTHER WORK IN THIS BODY. The hook stamps
@@ -177,6 +172,7 @@ export function App({ controller, version, mode, initialOverlay, initialPrompt,
     // Scroll plumbing: intent goes down, one derived display number comes back.
     const [scrollIntent, setScrollIntent] = useState();
     const [pinToBottomNonce, setPinToBottomNonce] = useState(0);
+    const [scrollResetKey, setScrollResetKey] = useState(0);
     const [scrolledLines, setScrolledLines] = useState(0);
     /**
      * True while a selection drag holds the viewport
@@ -216,18 +212,10 @@ export function App({ controller, version, mode, initialOverlay, initialPrompt,
     confirmRef.current = confirmState;
     const ctrlCArmed = useRef(false);
     const ctrlCTimer = useRef(null);
-    /**
-     * Rung two of Esc is armed (background-service-supervision §3.6).
-     *
-     * CLEARED BY `runEnd` / `agent_end` AS WELL AS BY ITS OWN TIMER, and both
-     * halves matter: a healthy run that ended between the two presses must not be
-     * force-stoppable retroactively, and in every healthy run the second press
-     * lands on the idle branch and does nothing at all (R-9). Rung two only ever
-     * fires while the run is STILL running after rung one - i.e. only when the
-     * first press provably failed.
-     */
-    const escArmed = useRef(false);
-    const escArmTimer = useRef(null);
+    const interruptGesture = useRef({ phase: 'ready' });
+    const interactionPhase = useRef(controller.isRunning() ? 'running' : 'idle');
+    const submissionSequence = useRef(0);
+    const mounted = useRef(true);
     /**
      * Live service snapshots, keyed by id, for the status chip and the Ctrl+C rung.
      *
@@ -331,20 +319,27 @@ export function App({ controller, version, mode, initialOverlay, initialPrompt,
         aborted: false,
         errored: false,
     });
-    /**
-     * Disarm rung two of the Esc ladder.
-     *
-     * A `useCallback` so the event subscription's dependency list can name it, and
-     * so it is one function rather than three copies of "clear the flag and the
-     * timer" that can drift.
-     */
-    const disarmEsc = useCallback(() => {
-        escArmed.current = false;
-        if (escArmTimer.current) {
-            clearTimeout(escArmTimer.current);
-            escArmTimer.current = null;
-        }
+    const resetInterrupt = useCallback(() => {
+        interruptGesture.current = { phase: 'ready' };
     }, []);
+    const cancelConfirmation = useCallback(() => {
+        interruptGesture.current = cancelInterruptConfirmation(interruptGesture.current);
+    }, []);
+    useEffect(() => {
+        if (state.overlay)
+            cancelConfirmation();
+    }, [state.overlay, cancelConfirmation]);
+    useEffect(() => {
+        mounted.current = true;
+        return () => {
+            mounted.current = false;
+            submissionSequence.current += 1;
+            if (interactionPhase.current === 'starting')
+                controller.abort();
+            interactionPhase.current = 'idle';
+            resetInterrupt();
+        };
+    }, [controller, resetInterrupt]);
     /**
      * Disarm an armed continuation. Idempotent; NEVER touches the budget — a
      * cancelled continuation was never issued, so it must not be charged (AC-18).
@@ -437,7 +432,7 @@ export function App({ controller, version, mode, initialOverlay, initialPrompt,
         // emits while it unwinds - `turn_start`, `tool_call_start`, `turn_end`,
         // `agent_end` - belongs to the run the user just abandoned. `runStart` /
         // `turnStart` would set `status: 'running'` again, bouncing the view straight
-        // back out of the `idle` rung two just gave them, and stray entries would
+        // back out of the `idle` force-stop just gave them, and stray entries would
         // append to a transcript they believe is finished.
         //
         // A LOCAL `let`, RE-READ RATHER THAN CAPTURED ONCE: the generation this
@@ -453,6 +448,12 @@ export function App({ controller, version, mode, initialOverlay, initialPrompt,
                     generation = controller.runGeneration;
                 return;
             }
+            if (event.type === 'agent_start')
+                interactionPhase.current = 'running';
+            if (event.type === 'agent_end') {
+                interactionPhase.current = 'idle';
+                resetInterrupt();
+            }
             const cost = controller.getModelInfo().cost;
             for (const action of reduceEvent(event, cost, patchSource)) {
                 // MUTATED HERE, ONE INSTANT BEFORE THE ACTION THAT SETS
@@ -479,11 +480,6 @@ export function App({ controller, version, mode, initialOverlay, initialPrompt,
             }
             if (event.type !== 'agent_end')
                 return;
-            // RUNG TWO DISARMS WITH THE RUN (§3.6 / R-9). A healthy run that ended
-            // between the two Esc presses must not be force-stoppable retroactively:
-            // the second press then lands on the idle branch, which is what makes the
-            // ladder free to take rather than a footgun.
-            disarmEsc();
             // NO OVERLAY OUTLIVES ITS RUN (P1-4). `ctx.signal` already covers the
             // abort path, so this is DELIBERATE REDUNDANCY: it makes "the card cannot
             // survive the run that opened it" a property of the App's lifecycle
@@ -551,7 +547,7 @@ export function App({ controller, version, mode, initialOverlay, initialPrompt,
                         done: live.doneCount,
                         mode: 'auto',
                     });
-                    submitRef.current(decision.message, { userInitiated: false });
+                    submitRef.current(decision.message, { userInitiated: false, todoPolicy: 'continue' });
                 }, decision.graceMs);
             }
             // A deferred `plan -> build` becomes real here and nowhere else (§3.2).
@@ -573,7 +569,7 @@ export function App({ controller, version, mode, initialOverlay, initialPrompt,
             cancelFollowThrough();
             unsubscribe();
         };
-    }, [controller, patchSource, flushPending, cancelPendingHuman, cancelFollowThrough, disarmEsc]);
+    }, [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
@@ -1278,9 +1274,9 @@ export function App({ controller, version, mode, initialOverlay, initialPrompt,
             return;
         // An overlay replaces the viewport, so a selection over it would be a
         // highlight over rows that are no longer there (N4).
-        selectionController.setEnabled(state.overlay === null);
+        selectionController.setEnabled(state.overlay === null && !tooSmall);
         selectionController.clear();
-    }, [selectionController, state.overlay]);
+    }, [selectionController, state.overlay, tooSmall]);
     const persistConfig = (patch) => {
         try {
             updatePersistedConfig(patch);
@@ -1336,7 +1332,22 @@ export function App({ controller, version, mode, initialOverlay, initialPrompt,
         args,
         controller,
         state: stateRef.current,
-        dispatch,
+        dispatch: (action) => {
+            if (action.type === 'resetConversation' || action.type === 'restoreEntries') {
+                setScrollResetKey((n) => n + 1);
+                const wasStarting = interactionPhase.current === 'starting';
+                submissionSequence.current += 1;
+                interactionPhase.current = 'idle';
+                resetInterrupt();
+                cancelFollowThrough();
+                autoContinuationRef.current = false;
+                if (wasStarting) {
+                    dispatch({ type: 'abortMark' });
+                    dispatch({ type: 'runEnd' });
+                }
+            }
+            dispatch(action);
+        },
         setOverlay: (overlay) => dispatch({ type: 'setOverlay', overlay }),
         notify,
         toast,
@@ -1401,11 +1412,19 @@ export function App({ controller, version, mode, initialOverlay, initialPrompt,
         // line, before the steering branch: a message typed during the grace window
         // must be the one that runs, whichever branch it takes.
         cancelFollowThrough();
-        if (stateRef.current.status === 'running') {
+        cancelConfirmation();
+        if (interactionPhase.current === 'running') {
             controller.steer(message);
             toast('info', 'Steering queued.');
             return;
         }
+        if (interactionPhase.current === 'starting') {
+            toast('info', 'A run is still starting. Press Esc twice to cancel.');
+            return;
+        }
+        resetInterrupt();
+        const sequence = ++submissionSequence.current;
+        interactionPhase.current = 'starting';
         // `userInitiated: false` skips TWO things and both are wanted: the
         // prompt-history append, and the `submitCount` bump that drives the
         // composer's hint fade. An auto-continuation demonstrates nothing about what
@@ -1420,14 +1439,30 @@ export function App({ controller, version, mode, initialOverlay, initialPrompt,
         const pre = controller.preflight();
         if (!pre.ok) {
             notify('error', pre.message ?? 'Configuration error.');
+            interactionPhase.current = 'idle';
+            resetInterrupt();
+            autoContinuationRef.current = false;
             dispatch({ type: 'runEnd' }); // reset status; nothing was started
             return;
         }
         // Fire-and-forget: events drive the UI. prompt() never rejects.
-        void controller.prompt(message);
+        void controller.prompt(message, { todoPolicy: opts.todoPolicy ?? 'new-task' }).then((outcome) => {
+            if (!mounted.current || sequence !== submissionSequence.current)
+                return;
+            if (outcome?.status !== 'not-started')
+                return;
+            interactionPhase.current = 'idle';
+            resetInterrupt();
+            autoContinuationRef.current = false;
+            dispatch({ type: 'runEnd' });
+        });
     };
     submitRef.current = submitMessage;
     const handleSubmit = async (raw) => {
+        if (interactionPhase.current === 'running' && /^\s*\/(reset|resume)(?:\s|$)/.test(raw)) {
+            notify('warn', 'Interrupt the current run before switching conversations.');
+            return;
+        }
         // Submitting is an unconditional "take me to the newest output" (§4.5).
         setPinToBottomNonce((n) => n + 1);
         const handled = await runSlashInput(registry, raw, makeCtx);
@@ -1556,10 +1591,34 @@ export function App({ controller, version, mode, initialOverlay, initialPrompt,
     // same reason: `OverlayFrame` only ever reports a clamp DOWNWARD.
     const { clearCoalescer } = useWheelRouting({
         mouseSource,
+        isPointerCaptured: () => terminal?.scrollbar?.controller?.isCaptured() ?? false,
+        isActive: () => !tooSmall,
         getOverlay: () => stateRef.current.overlay,
         onScroll: scrollBy,
         onOverlayScroll: (delta) => setOverlayScroll((n) => Math.max(0, n + delta)),
     });
+    const returnToComposer = useCallback(() => {
+        clearCoalescer();
+        terminal?.scrollbar?.controller?.cancel();
+        if (scrolledLines > 0)
+            setPinToBottomNonce((n) => n + 1);
+    }, [clearCoalescer, terminal, scrolledLines]);
+    useEffect(() => {
+        stdout.on('resize', clearCoalescer);
+        return () => { stdout.off('resize', clearCoalescer); };
+    }, [stdout, clearCoalescer]);
+    useEffect(() => {
+        const bridge = terminal?.scrollbar;
+        if (!bridge)
+            return;
+        bridge.onStart = () => { clearCoalescer(); terminal?.selection?.controller?.clear(); };
+        bridge.requestRedraw = () => setRedrawNonce((n) => n + 1);
+        return () => { bridge.onStart = undefined; bridge.requestRedraw = undefined; };
+    }, [terminal, clearCoalescer]);
+    useEffect(() => {
+        clearCoalescer();
+        terminal?.scrollbar?.controller?.cancel();
+    }, [rows, cols, tooSmall, state.overlay, clearCoalescer, terminal]);
     // 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.
     //
@@ -1585,6 +1644,8 @@ export function App({ controller, version, mode, initialOverlay, initialPrompt,
     }, []);
     // --- Global keys -------------------------------------------------------
     useInput((input, key) => {
+        if (!key.escape)
+            cancelConfirmation();
         // I-9, the third clear trigger, and FIRST IN THE HANDLER so no `return`
         // below can skip it. Any key at all drops the selection: most of them move
         // the rows, and the ones that do not have still ended the gesture. It is
@@ -1631,10 +1692,8 @@ export function App({ controller, version, mode, initialOverlay, initialPrompt,
         }
         // R-P1-7: the overlay branch MUST come before the transcript scroll branch
         // and MUST return. `PgUp` used to fall through to `scrollBy()` while an
-        // overlay was open; `ScrollViewport` is unmounted then, but its
-        // `useEffect([intentNonce])` fires once on REMOUNT, so the stale intent was
-        // applied when the overlay closed and the transcript jumped a page on its
-        // own. Even overlays that ignore the key must swallow it here.
+        // overlay was open. The stable viewport ignores inactive intents, but routing
+        // must still give overlays exclusive ownership of their paging keys.
         if (stateRef.current.overlay) {
             const overlay = stateRef.current.overlay;
             // Modes A only. `model` / `confirm` manage their own keys; registering an
@@ -1757,6 +1816,7 @@ export function App({ controller, version, mode, initialOverlay, initialPrompt,
         if (key.escape) {
             const overlay = stateRef.current.overlay;
             if (overlay) {
+                cancelConfirmation();
                 if (overlay === 'confirm' && confirmRef.current) {
                     confirmRef.current.resolve(false);
                     setConfirmState(null);
@@ -1770,65 +1830,49 @@ export function App({ controller, version, mode, initialOverlay, initialPrompt,
                 dispatch({ type: 'setOverlay', overlay: null });
                 return;
             }
-            if (stateRef.current.status === 'running') {
-                // RUNG TWO (§3.6 / G3). The first press asked the engine to stop; if the
-                // run is STILL running when the second arrives, that request provably
-                // failed - so this one does not ask, it takes.
-                //
-                // THREE THINGS HAPPEN, AND THE THIRD IS THE BELT-AND-BRACES.
-                // `controller.forceStop()` aborts, hard-kills every tracked foreground
-                // `bash` child (which is what actually unblocks a wedged
-                // `await tool.execute`) and bumps the run generation so the unwinding
-                // engine can no longer move the view. The local `runEnd` is dispatched
-                // UNCONDITIONALLY on top: even if the engine is blocked somewhere
-                // nothing can reach, the view returns to `idle`, the composer is usable,
-                // and the reducer releases every live tail. Making the view's usability
-                // conditional on the engine recovering is what produced the reported
-                // screenshot (D-6).
-                //
-                // AND THE NEXT MESSAGE MUST STILL WORK. `AgentController.prompt()` waits
-                // a still-running engine out and never rejects (I-8) - without that,
-                // "Esc, Esc, then type" would reach `Agent.prompt()`'s synchronous throw,
-                // become an unhandled rejection, and EXIT THE PROCESS (P0-1).
-                if (escArmed.current) {
-                    disarmEsc();
-                    controller.forceStop();
-                    endReasonRef.current.aborted = true;
-                    dispatch({ type: 'abortMark' });
-                    dispatch({ type: 'runEnd' });
-                    toast('warn', 'Force-stopped.');
-                    return;
-                }
-                controller.abort();
-                // Next to `abortMark`, in the same callback, for the reason
-                // `endReasonRef`'s own comment gives (C-11). D-5 turns this into
-                // silence at `agent_end`: the user's Esc is the statement, and
-                // restating what they interrupted is the CLI arguing.
-                endReasonRef.current.aborted = true;
-                dispatch({ type: 'abortMark' });
-                escArmed.current = true;
-                if (escArmTimer.current)
-                    clearTimeout(escArmTimer.current);
-                escArmTimer.current = setTimeout(() => {
-                    escArmed.current = false;
-                    escArmTimer.current = null;
-                }, ESC_ARM_MS);
-                toast('info', 'Run aborted. Esc again to force-stop.');
-                return;
-            }
-            // IDLE. Today this branch does nothing at all, which is what makes it free
-            // to take (R-4). OVERLAY PRECEDENCE IS UNCHANGED AND DELIBERATE (P2-9):
-            // the block above returns while an overlay is open, so with one open the
-            // first Esc closes the overlay and the second cancels the continuation.
-            // Reaching past it would make "close this dialog" silently also mean
-            // "abandon the plan".
+            return;
+        }
+    });
+    const handleComposerEscape = useCallback(() => {
+        if (stateRef.current.overlay)
+            return;
+        if (interactionPhase.current === 'idle') {
             if (followTimer.current) {
                 cancelFollowThrough();
-                toast('info', 'Auto-continue cancelled.');
+                dispatch({ type: 'pushToast', level: 'info', text: 'Auto-continue cancelled.' });
             }
             return;
         }
-    });
+        const sequence = submissionSequence.current;
+        const phase = interactionPhase.current;
+        const next = advanceInterruptGesture(interruptGesture.current, performance.now());
+        interruptGesture.current = next.state;
+        if (next.action === 'hint') {
+            dispatch({ type: 'pushToast', level: 'info',
+                text: 'Press Esc again within 1.5s to interrupt.' });
+            return;
+        }
+        endReasonRef.current.aborted = true;
+        dispatch({ type: 'abortMark' });
+        if (next.action === 'force-stop' || phase === 'starting') {
+            submissionSequence.current += 1;
+            interactionPhase.current = 'idle';
+            resetInterrupt();
+            autoContinuationRef.current = false;
+            if (next.action === 'force-stop')
+                controller.forceStop();
+            else
+                controller.abort();
+            dispatch({ type: 'runEnd' });
+            dispatch({ type: 'pushToast', level: 'warn', text: next.action === 'force-stop' ? 'Force-stopped.' : 'Pending run cancelled.' });
+            return;
+        }
+        controller.abort();
+        if (sequence === submissionSequence.current && interactionPhase.current === 'running') {
+            dispatch({ type: 'pushToast', level: 'info',
+                text: 'Interrupt requested. Esc again to force-stop.' });
+        }
+    }, [controller, cancelFollowThrough, resetInterrupt]);
     // --- Render ------------------------------------------------------------
     // `const modelInfo = controller.getModelInfo()` AND ITS `modelKnown` COMPANION
     // USED TO LIVE HERE (context-usage-gauge-accuracy §4.3). They fed the status
@@ -1893,16 +1937,17 @@ export function App({ controller, version, mode, initialOverlay, initialPrompt,
     const overlayMaxRows = fullscreen ? viewportBudget : Number.POSITIVE_INFINITY;
     // 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);
     const teamLayout = buildTeamPanelLayout({
-        snapshot: state.team, terminalRows: rows, availableRows: viewportBudget,
+        snapshot: state.team, terminalRows: rows, availableRows: Math.max(0, viewportBudget - composerBaseRows),
     });
     const railLayout = buildTodoRailLayout({
-        mode, cols, panelEnabled: cfg.todo.panel, overlayOpen: overlay !== null,
+        mode, cols: fullscreen ? cols - 1 : cols, panelEnabled: cfg.todo.panel, overlayOpen: false,
         itemCount: state.todos?.items.length ?? 0, viewportBudget,
-        teamRows: teamLayout.rowCount, popupRows,
+        teamRows: teamLayout.rowCount, popupRows, composerBaseRows,
     });
-    // Every viewport consumer uses contentCols; header, composer, status and
-    // overlays keep the full terminal width. Overlay visibility is in the gate.
+    // 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).
     //
@@ -1949,14 +1994,6 @@ 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;
-    // 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
-    // one path that reaches rows < 12 and a hard-coded height here would land on
-    // `outputHeight >= rows` exactly when the user is dragging the window (§4.11).
-    if (fullscreen && rows < MIN_FULLSCREEN_ROWS) {
-        return (_jsx(Box, { flexDirection: "column", height: frameHeight(rows), width: cols, overflow: "hidden", children: _jsxs(Text, { wrap: "truncate", color: theme.noticeWarn, children: [glyphs.warn, " Terminal too small - needs at least ", MIN_FULLSCREEN_ROWS, " rows."] }) }));
-    }
     // 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`.
@@ -2020,10 +2057,7 @@ 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, 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] }));
-    // 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.
+    // Completion belongs to the document footer; cap it to keep the editor usable.
     const popupMaxRows = fullscreen ? Math.max(1, viewportBudget - 4) : undefined;
     // 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,
@@ -2035,8 +2069,11 @@ 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, { 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, 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, { 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, layout: fullscreen ? teamLayout : undefined, rows: rows, cols: cols, reducedMotion: viewReducedMotion, theme: theme, caps: caps })) : null, rail: showRail && state.todos ? (_jsx(TodoPanel, { snapshot: state.todos, width: railWidth, rows: railRows, running: running, reducedMotion: viewReducedMotion, 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, 
+    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 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
@@ -2074,7 +2111,8 @@ 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, { model: cfg.model, provider: cfg.provider, usageTotal: state.usageTotal, 
+            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'
+                ? '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
             // caller could update three of them; a single reading cannot be

package/dist/ui/Composer.d.ts

@@ -9,20 +9,26 @@
  * "the input is no longer empty", and routing that through App would re-render
  * the transcript on the first keystroke of every message.
  *
- * As of v0.4.0 this is the ONLY place keybinding hints are shown — the status
- * bar's duplicate cluster is gone (§4.6). Two hints for the same keys, one of
- * them 31 columns wide, were both redundant and the reason the status bar had a
- * `cols >= 110` breakpoint.
+ * The fixed status row retains emergency and history-navigation hints while
+ * this footer scrolls outside the viewport. Editor state stays mounted.
  */
 import React from 'react';
+import { type DOMElement } from 'ink';
 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 AgentMode } from '../agent/agent-mode.js';
 export interface ComposerProps {
+    cols?: number;
+    cursorVisible?: boolean;
+    onInteraction?: () => void;
+    measureRef?: React.RefObject<DOMElement>;
     /** False while an overlay owns the keyboard (the input is visually blurred). */
     isActive: boolean;
+    reducedMotion?: boolean;
+    onEscape?: () => void;
+    onEscapeDismiss?: () => void;
     running: boolean;
     history: string[];
     commands: CommandOption[];
@@ -119,5 +125,5 @@ declare function hintText(opts: {
  * than fishing the string out of a rendered frame.
  */
 export declare const hintTextForTest: typeof hintText;
-export declare function Composer({ isActive, 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({ 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

@@ -10,10 +10,8 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
  * "the input is no longer empty", and routing that through App would re-render
  * the transcript on the first keystroke of every message.
  *
- * As of v0.4.0 this is the ONLY place keybinding hints are shown — the status
- * bar's duplicate cluster is gone (§4.6). Two hints for the same keys, one of
- * them 31 columns wide, were both redundant and the reason the status bar had a
- * `cols >= 110` breakpoint.
+ * The fixed status row retains emergency and history-navigation hints while
+ * this footer scrolls outside the viewport. Editor state stays mounted.
  */
 import { useCallback, useState } from 'react';
 import { Box, Text } from 'ink';
@@ -46,15 +44,13 @@ function hintText(opts) {
         if (services > 0) {
             return [
                 `${glyphs.enterKey} steer`,
-                // Rung two is named because the whole point of the ladder is that the
-                // first press can fail; a user who does not know there is a second press
-                // is left exactly where the reported screenshot left them.
-                `esc abort${glyphs.times}2 force`,
+                // 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 abort', `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);
     }
     // 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
@@ -90,7 +86,7 @@ function hintText(opts) {
  * than fishing the string out of a rendered frame.
  */
 export const hintTextForTest = hintText;
-export function Composer({ isActive, 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, }) {
+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, }) {
     const [hasDraft, setHasDraft] = useState(false);
     const onDraftChange = useCallback((next) => {
         setHasDraft(next.hasDraft);
@@ -110,7 +106,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, popupMaxHeight: popupMaxHeight, onPopupRowsChange: onPopupRowsChange, onSubmit: onSubmit, onHelp: onHelp, agentMode: agentMode, bordered: { color: borderColor }, onDraftChange: onDraftChange, onNotice: onNotice, scrolledLines: scrolledLines }), visible && (
+    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 && (
             // 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({

package/dist/ui/PromptCaret.d.ts

@@ -0,0 +1,11 @@
+import React from 'react';
+export interface PromptCaretProps {
+    text: string;
+    active: boolean;
+    reducedMotion: boolean;
+    colorLevel: 0 | 1 | 2 | 3;
+    color?: string;
+    resetKey: object;
+}
+/** The only blinking state belongs to this leaf, never to the editor. */
+export declare function PromptCaret({ text, active, reducedMotion, colorLevel, color, resetKey, }: PromptCaretProps): React.ReactElement;