@aragon-agent/cli 0.6.4 → 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,10 +8,10 @@ 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';
-import { isApproximate } from '../compaction/pressure.js';
 import { parseMaxTokensInput, DEFAULT_TRANSCRIPT_RETAIN, DEFAULT_TRANSCRIPT_WINDOW, } from '../config/schema.js';
 import { updatePersistedConfig } from '../config/store.js';
 import { appendPrompt, loadPromptHistory } from '../config/prompt-history.js';
@@ -47,15 +47,15 @@ import { shouldRenderUpdateLine } from '../update/types.js';
 import { UPDATE_LIMITS } from '../update/limits.js';
 import { AppShell } from './layout/AppShell.js';
 import { ScrollViewport } from './layout/ScrollViewport.js';
-import { todoRailRows, todoRailWidth } from './layout/rail.js';
-import { TODO_LIMITS } from '../todo/limits.js';
+import { buildTodoRailLayout } from './layout/todo-layout.js';
+import { buildTeamPanelLayout } from './layout/team-panel.js';
 import { advanceBudget, decideFollowThrough, emptyBudget, } from '../todo/follow-through.js';
 import { useTerminalSize } from './layout/useTerminalSize.js';
 import { useHeightStore } from './use-height-store.js';
 import { useRenderGovernor } from './use-render-governor.js';
 import { setPerfResetHook, setPerfSnapshotProvider } from '../commands/perf.js';
-import { frameHeight, MIN_FULLSCREEN_ROWS } from './layout/frame.js';
-import { HINT_MIN_ROWS, viewportRows as computeViewportRows } from './layout/budget.js';
+import { 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';
@@ -106,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;
@@ -136,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
@@ -178,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
@@ -217,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.
      *
@@ -332,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).
@@ -438,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
@@ -454,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
@@ -480,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
@@ -552,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).
@@ -574,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
@@ -751,6 +746,27 @@ export function App({ controller, version, mode, initialOverlay, initialPrompt,
             }
         });
     }, [controller]);
+    // --- Context occupancy (context-usage-gauge-accuracy §3.3 / I-1). --------
+    //
+    // A SEVENTH SUBSCRIPTION, AND THE SOLE DISPATCHER OF `contextUsage`. The gauge
+    // used to be written from three reducer branches fed by two upstreams, which
+    // is what let a stale `snapshot` bounce the bar back to the pre-compaction
+    // figure one statement after a compaction correctly dropped it (P0-1). One
+    // writer makes that unrepresentable.
+    //
+    // IT SUBSCRIBES UNCONDITIONALLY. `subscribeContextUsage` is not a compaction
+    // forwarder - the meter exists in every session, including one started with
+    // `--no-compaction`, which is precisely the session whose gauge previously had
+    // one sample per turn and read 0 % after a `/resume`.
+    useEffect(() => {
+        // SEED ON MOUNT so a resumed session shows a real occupancy on frame 1
+        // rather than after its first completed turn. `getContextUsage()` measures
+        // on demand, so this works before any event has ever arrived.
+        dispatch({ type: 'contextUsage', snapshot: controller.getContextUsage() });
+        return controller.subscribeContextUsage((snapshot) => {
+            dispatch({ type: 'contextUsage', snapshot });
+        });
+    }, [controller]);
     // --- Compaction event stream (context-auto-compaction §5.2). -------------
     //
     // A SIXTH SUBSCRIPTION, for the reason the team, todo and fast ones record:
@@ -787,23 +803,20 @@ export function App({ controller, version, mode, initialOverlay, initialPrompt,
                         model: event.model,
                     });
                     break;
-                case 'compaction_end': {
+                case 'compaction_end':
+                    // THE CARD, AND NOTHING ELSE (context-usage-gauge-accuracy §3.3).
+                    //
+                    // A `contextTokensEstimated` dispatch used to live here, hand-building
+                    // the post-compaction occupancy out of `record.tokensAfter` plus the
+                    // snapshot's `estimateOffset`. It is gone because the gauge now has ONE
+                    // writer: `ContextMeter` learns about the splice from
+                    // `CompactionWiring.settlePending` itself and re-measures, so the bar
+                    // falls in the same frame WITHOUT this branch and without the `snapshot`
+                    // branch below racing it. Those two dispatches were the second and
+                    // third writers of one number, and the loser of that race was the
+                    // correct value (P0-1).
                     dispatch({ type: 'compactionEnd', record: event.record });
-                    // THE GAUGE MUST FALL IMMEDIATELY (§6.2 / AC-5), and it must fall to a
-                    // number in the SAME UNIT as the one it replaces (P1-11). The value
-                    // being overwritten came from `occupiedTokens(usage)` — a provider
-                    // measurement that includes the tool schemas — while
-                    // `record.tokensAfter` comes from core's `estimatePromptTokens`, which
-                    // never counts them. Writing the raw estimate makes the bar fall too
-                    // far and then visibly climb again on the next `turn_end` for no reason
-                    // the user can see, which is the same is-this-thing-working doubt the
-                    // immediate drop exists to prevent, one turn later.
-                    if (event.record.applied) {
-                        const offset = controller.getCompactionSnapshot().pressure.estimateOffset ?? 0;
-                        dispatch({ type: 'contextTokensEstimated', tokens: event.record.tokensAfter + offset });
-                    }
                     break;
-                }
                 case 'usage': {
                     // Compaction spend is REAL SPEND at the SUMMARIZER's price (§6.4 /
                     // AC-15), which may be neither the lead's nor the fast tier's — so the
@@ -820,24 +833,12 @@ export function App({ controller, version, mode, initialOverlay, initialPrompt,
                     break;
                 }
                 case 'snapshot':
+                    // THE CHIP, THE COUNTS AND THE SUMMARIZER (§3.3). The occupancy that
+                    // rides along on `snapshot.pressure` is deliberately NOT dispatched
+                    // here: the meter that produced it publishes it on its own channel, and
+                    // a second dispatch of the same number is the second writer this
+                    // feature removed.
                     dispatch({ type: 'compactionSnapshot', snapshot: event.snapshot });
-                    // ONE NUMBER ON SCREEN AND IN THE TRIGGER (R-11 / hardening §3.2.4).
-                    // The checkpoint's occupancy is a measured base PLUS an estimate of
-                    // what was appended after it, and without this the gauge would still
-                    // show the bare base from the last `turn_end` - so a user watching
-                    // 76 % would see compaction fire and conclude the feature is broken.
-                    //
-                    // `contextTokensEstimated` IS REUSED RATHER THAN A SECOND WRITER ADDED:
-                    // it is the one existing action for "this figure is derived", and it
-                    // already sets the `~`. Gated on `isApproximate`, which is precisely
-                    // the case it was built for - a wholly measured figure belongs to
-                    // `turnEnd`.
-                    if (isApproximate(event.snapshot.pressure)) {
-                        dispatch({
-                            type: 'contextTokensEstimated',
-                            tokens: event.snapshot.pressure.occupied,
-                        });
-                    }
                     break;
             }
         });
@@ -1128,6 +1129,10 @@ export function App({ controller, version, mode, initialOverlay, initialPrompt,
     // may call an updater more than once, and scheduling a timer from inside one
     // would arm it twice.
     const [draftRows, setDraftRows] = useState(1);
+    const [popupRows, setPopupRows] = useState(0);
+    const onPopupRowsChange = useCallback((next) => {
+        setPopupRows(previous => previous === next ? previous : next);
+    }, []);
     const draftRowsRef = useRef(1);
     const shrinkTimer = useRef(null);
     const onDraftRows = useCallback((next) => {
@@ -1269,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);
@@ -1327,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,
@@ -1392,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
@@ -1411,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);
@@ -1547,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.
     //
@@ -1576,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
@@ -1622,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
@@ -1748,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);
@@ -1761,68 +1830,56 @@ 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();
-    const modelKnown = !!controller.getModelRegistry().getModel(cfg.provider, cfg.model);
+    // `const modelInfo = controller.getModelInfo()` AND ITS `modelKnown` COMPANION
+    // USED TO LIVE HERE (context-usage-gauge-accuracy §4.3). They fed the status
+    // bar's `contextWindow` / `contextWindowKnown` props, which no longer exist:
+    // the denominator and its trustworthiness are resolved inside `ContextMeter`,
+    // which is what lets the user's `contextWindow` override reach the gauge at
+    // all. Nothing else in this render read them.
     const overlay = state.overlay;
     const hasKey = controller.hasApiKey();
     const empty = state.entries.length === 0;
@@ -1878,22 +1935,20 @@ export function App({ controller, version, mode, initialOverlay, initialPrompt,
     // and every test that never types byte-identical to before.
     const viewportBudget = computeViewportRows(rows, draftRows);
     const overlayMaxRows = fullscreen ? viewportBudget : Number.POSITIVE_INFINITY;
-    // --- The todo rail (todo-plan-execution §3.9). --------------------------
-    //
-    // ONE NUMBER FOR THE GATE AND FOR THE LAYOUT (I-10). `railRows` is both what
-    // decides whether the panel mounts and what the panel lays out against; a
-    // panel that mounts on one number and renders against another shows nothing
-    // and reports nothing. `todoRailRows` is NOT `viewportBudget`: the live team
-    // roster costs up to 8 rows inside `AppShell`'s measured bottom box that the
-    // budget knows nothing about (P1-3).
-    const railRows = todoRailRows(viewportBudget, state.team !== null);
-    const railWidth = todoRailWidth(cols);
-    const showRail = fullscreen && // non-goal 4: inline mode has no fixed frame
-        cfg.todo.panel && // `/todo panel off`, persisted
-        overlay === null && // a modal owns the screen (D-7)
-        state.todos !== null && // no list -> no furniture, zero layout cost
-        railWidth > 0 && // too narrow (under 80 columns)
-        railRows >= TODO_LIMITS.panelMinRows; // too short to say anything useful
+    // 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: Math.max(0, viewportBudget - composerBaseRows),
+    });
+    const railLayout = buildTodoRailLayout({
+        mode, cols: fullscreen ? cols - 1 : cols, 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
@@ -1906,12 +1961,6 @@ export function App({ controller, version, mode, initialOverlay, initialPrompt,
     // 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;
-    // Every consumer INSIDE the viewport slot switches to this; the header,
-    // composer, status bar, toasts and every overlay keep the full frame width
-    // (C-7). Overlays keep it because `showRail` already includes `overlay ===
-    // null`: splitting the screen with a status panel behind a modal is both worse
-    // design and a second source of width-contract bugs in six components.
-    const contentCols = cols - (showRail ? railWidth : 0);
     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,
@@ -1945,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`.
@@ -2016,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,
@@ -2031,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, 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, 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
@@ -2070,7 +2111,15 @@ 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, contextTokens: state.contextTokens, contextWindow: modelInfo.contextWindow, contextWindowKnown: modelKnown, contextEstimated: state.contextTokensEstimated, status: state.status, elapsedMs: elapsedMs, thinkingLevel: cfg.thinkingLevel, tokPerSec: tokPerSec, theme: theme, caps: caps, scrolledLines: scrolledLines, redrawNonce: redrawNonce, agentMode: state.agentMode, pendingAgentMode: state.pendingAgentMode, ecoRung: governor.rung, ...(state.team
+            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
+            // partially stale. The window and its `known` flag now travel INSIDE
+            // it, resolved by the meter - which is what makes the user's
+            // `contextWindow` override reach the bar.
+            context: state.context, status: state.status, elapsedMs: elapsedMs, thinkingLevel: cfg.thinkingLevel, tokPerSec: tokPerSec, theme: theme, caps: caps, scrolledLines: scrolledLines, redrawNonce: redrawNonce, agentMode: state.agentMode, pendingAgentMode: state.pendingAgentMode, ecoRung: governor.rung, ...(state.team
                 ? {
                     teamActive: {
                         running: state.team.runs.filter((r) => r.phase !== 'queued' && r.phase !== 'done' &&
@@ -2081,8 +2130,9 @@ export function App({ controller, version, mode, initialOverlay, initialPrompt,
                 : {}), ...(state.todos && !showRail
                 ? { todoActive: { done: state.todos.doneCount, total: state.todos.total } }
                 : {}), ...(liveServices > 0 ? { servicesActive: { live: liveServices } } : {}), ...(state.fast?.live ? { fastActive: { inFlight: state.fast.inFlight } } : {}), ...(state.compaction?.live
+                ? { compactionActive: { inFlight: state.compaction.inFlight } }
+                : {}), ...(controller.isCompactionEnabled()
                 ? {
-                    compactionActive: { inFlight: state.compaction.inFlight },
                     gaugeMarks: {
                         warn: cfg.compaction.warnThreshold * 100,
                         high: cfg.compaction.threshold * 100,