@aragon-agent/cli 0.6.3 → 0.6.7

package/dist/ui/App.js

@@ -11,12 +11,12 @@ import { Box, Text, useApp, useInput, useStdout } from 'ink';
 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';
 import { bumpSubmitCount, setMouseNoticeVersion, setVtInputNoticeVersion, } from '../config/ui-state.js';
 import { getLogger } from '../logging/logger.js';
+import { isTerminalStatus } from '../proc/types.js';
 import { registerSecret } from '../logging/secret-registry.js';
 import { detectCapabilities } from './capabilities.js';
 import { useStartupNotices, MOUSE_NOTICE_VERSION, VT_INPUT_NOTICE_VERSION, } from './use-startup-notices.js';
@@ -46,8 +46,8 @@ 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';
@@ -105,6 +105,24 @@ 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;
+    for (const service of Object.values(services)) {
+        if (!isTerminalStatus(service.status))
+            n += 1;
+    }
+    return n;
+}
 /**
  * The lazy `useReducer` initializer. Module scope, so the reference is stable
  * across renders and React never re-runs it.
@@ -112,7 +130,7 @@ export function resolveSettingsMaxTokens(raw, previous) {
 function seedViewState(thinkingVisible) {
     return initialViewState({ thinkingVisible });
 }
-export function App({ controller, version, mode, initialOverlay, initialPrompt, confirmBridge, humanInputBridge, mouseSource, vtInputWarning, updateBridge, terminal, }) {
+export function App({ controller, version, mode, initialOverlay, initialPrompt, confirmBridge, humanInputBridge, mouseSource, vtInputWarning, updateBridge, pasteBridge, terminal, }) {
     const { exit } = useApp();
     const { stdout } = useStdout();
     const fullscreen = mode === 'fullscreen';
@@ -198,6 +216,37 @@ 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);
+    /**
+     * Live service snapshots, keyed by id, for the status chip and the Ctrl+C rung.
+     *
+     * A `useState` MAP rather than a ref, because the chip has to re-render when it
+     * changes; and separate from `ViewState`, because a service is not a
+     * transcript entry - the transcript records EVENTS about a service (D-11) and
+     * this is the live state those events are about.
+     */
+    const [services, setServices] = useState({});
+    /**
+     * Read by the Ctrl+C handler, which `useInput` registers ONCE.
+     *
+     * The same reason `stateRef` exists two lines up: a value captured in that
+     * closure would be pinned to the mount render, so the key handler would
+     * believe there are never any services and Ctrl+C would arm exit while a dev
+     * server was up.
+     */
+    const servicesRef = useRef(services);
+    servicesRef.current = services;
     const runBaselineOut = useRef(0);
     /**
      * Epoch ms the current run began — the activity phrase's seed.
@@ -282,6 +331,20 @@ 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;
+        }
+    }, []);
     /**
      * Disarm an armed continuation. Idempotent; NEVER touches the budget — a
      * cancelled continuation was never issued, so it must not be charged (AC-18).
@@ -368,7 +431,28 @@ export function App({ controller, version, mode, initialOverlay, initialPrompt,
      */
     const patchSource = useMemo(() => ({ take: (id) => controller.takeFilePatch(id) }), [controller]);
     useEffect(() => {
+        // CAPTURED AT SUBSCRIBE TIME AND COMPARED ON EVERY EVENT (I-7 / P1-7).
+        //
+        // `forceStop()` bumps the controller's generation, and everything the engine
+        // 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
+        // append to a transcript they believe is finished.
+        //
+        // A LOCAL `let`, RE-READ RATHER THAN CAPTURED ONCE: the generation this
+        // listener considers current advances with every submit, so a force-stop
+        // makes stale events inert WITHOUT making the next run's events inert too.
+        let generation = controller.runGeneration;
         const unsubscribe = controller.subscribe((event) => {
+            if (controller.runGeneration !== generation) {
+                // The engine is unwinding a force-stopped run. Adopt the new generation
+                // only once it has finished doing so, so a late `agent_end` cannot be
+                // mistaken for the next run's.
+                if (event.type === 'agent_end')
+                    generation = controller.runGeneration;
+                return;
+            }
             const cost = controller.getModelInfo().cost;
             for (const action of reduceEvent(event, cost, patchSource)) {
                 // MUTATED HERE, ONE INSTANT BEFORE THE ACTION THAT SETS
@@ -395,6 +479,11 @@ 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
@@ -484,7 +573,37 @@ export function App({ controller, version, mode, initialOverlay, initialPrompt,
             cancelFollowThrough();
             unsubscribe();
         };
-    }, [controller, patchSource, flushPending, cancelPendingHuman, cancelFollowThrough]);
+    }, [controller, patchSource, flushPending, cancelPendingHuman, cancelFollowThrough, disarmEsc]);
+    // --- 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;
+            setServices((prev) => ({ ...prev, [service.id]: service }));
+            if (event.type === 'started') {
+                dispatch({ type: 'serviceStart', service });
+                return;
+            }
+            if (event.type === 'exited' || event.type === 'stopped') {
+                dispatch({ type: 'serviceEnd', service });
+                return;
+            }
+            dispatch({ type: 'serviceUpdate', service });
+        });
+    }, [controller]);
     // --- Team-mode event stream (team-subagents §5.2 / §3.9). --------------
     //
     // A SEPARATE SUBSCRIPTION, not a branch in the one above: `TeamEvent` is
@@ -631,6 +750,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:
@@ -667,23 +807,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
@@ -700,24 +837,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;
             }
         });
@@ -983,6 +1108,60 @@ export function App({ controller, version, mode, initialOverlay, initialPrompt,
     // --- Helpers -----------------------------------------------------------
     const notify = (level, text) => dispatch({ type: 'notice', level, text });
     const toast = (level, text) => dispatch({ type: 'pushToast', level, text });
+    // --- Paste bridge (tui-paste-handling section 5.1.2 / I-15). -------------
+    //
+    // The filter exists before this component does, so it holds a slot rather than
+    // a callback. Cleared on unmount: a rejection that somehow arrived after the
+    // tree came down would otherwise dispatch into a dead reducer.
+    useEffect(() => {
+        if (!pasteBridge)
+            return undefined;
+        const bridge = pasteBridge;
+        bridge.notify = (level, text) => dispatch({ type: 'notice', level, text });
+        return () => {
+            bridge.notify = null;
+        };
+    }, [pasteBridge]);
+    // --- The composer's height (tui-paste-handling section 5.5 / D-12). ------
+    //
+    // GROWTH IS IMMEDIATE, SHRINK IS DEFERRED BY ONE TICK (R-12). Growing late
+    // overdraws the frame for a frame; shrinking early makes a `Backspace` that
+    // crosses a wrap boundary bounce the whole transcript, and a run of deletions
+    // bounce it repeatedly. Deferring coalesces the run into one move.
+    //
+    // The ref mirrors the state so the decision is made OUTSIDE the updater: React
+    // 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) => {
+        const wanted = Math.max(1, next);
+        if (shrinkTimer.current) {
+            clearTimeout(shrinkTimer.current);
+            shrinkTimer.current = null;
+        }
+        if (wanted === draftRowsRef.current)
+            return;
+        if (wanted > draftRowsRef.current) {
+            draftRowsRef.current = wanted;
+            setDraftRows(wanted);
+            return;
+        }
+        shrinkTimer.current = setTimeout(() => {
+            shrinkTimer.current = null;
+            draftRowsRef.current = wanted;
+            setDraftRows(wanted);
+        }, 0);
+    }, []);
+    useEffect(() => () => {
+        if (shrinkTimer.current)
+            clearTimeout(shrinkTimer.current);
+    }, []);
     // --- Auto-update bridge (cli-auto-update section 3.8 / 6.3). ------------
     //
     // TWO ARRIVAL ORDERS, AND BOTH HAPPEN. The service is built by a dynamic
@@ -1119,6 +1298,16 @@ export function App({ controller, version, mode, initialOverlay, initialPrompt,
     };
     const doExit = () => {
         controller.abort();
+        // G5. `force: true` means `reapSync()` SEMANTICS - immediate SIGKILL, no
+        // grace ladder - because THIS FUNCTION AWAITS NOTHING AND MUST NOT START
+        // (§3.6 step 3). An async `stopAll` with a 3 s escalation would still be
+        // running when `exit()` tore the tree down, and every child would survive.
+        //
+        // IT IS DELIBERATELY REDUNDANT with the signal hook the controller
+        // registered: a normal quit reaches both, and `reapSync` is idempotent
+        // precisely so that is safe. The hook covers SIGINT/SIGTERM and a crash;
+        // this covers `/exit` and `Ctrl+C x2`, which are not signals at all.
+        void controller.stopAllServices({ force: true });
         exit();
     };
     /**
@@ -1407,6 +1596,26 @@ export function App({ controller, version, mode, initialOverlay, initialPrompt,
         // press; it clears the selection here like every other key and nothing more.
         selectionController?.clear();
         if (key.ctrl && (input === 'c' || input === 'C')) {
+            // RUNG ONE: Ctrl+C acquires the meaning a terminal user already expects
+            // it to have (§3.6 / G4 / D-5). While services are live it stops THEM, and
+            // only once nothing is running does it fall through to the existing
+            // arm/exit ladder.
+            //
+            // IT DOES NOT ARM EXIT. Stopping a server and quitting the app are
+            // different intentions, and a user who pressed Ctrl+C to kill a dev server
+            // must not find themselves one keystroke from losing the session. The
+            // composer hint still names an exit clause, so quitting stays discoverable
+            // (P1-4).
+            //
+            // THE GRACEFUL LADDER, not `force`: this path has a live event loop to run
+            // the SIGTERM -> SIGKILL escalation on, and a dev server given a chance to
+            // shut down cleanly releases its port.
+            const live = liveServiceCount(servicesRef.current);
+            if (live > 0) {
+                void controller.stopAllServices();
+                toast('warn', `Stopping ${live} service${live === 1 ? '' : 's'}.`);
+                return;
+            }
             if (ctrlCArmed.current) {
                 doExit();
                 return;
@@ -1526,9 +1735,17 @@ export function App({ controller, version, mode, initialOverlay, initialPrompt,
             // and without this the compaction card renders its own `ctrl+o to expand`
             // hint, the keystroke silently expands an older tool card instead, and
             // nothing errors. AC-21 is the assertion that the hint does not lie.
+            // `service` joins the closed list (P1-3). Omitting it is not a missing
+            // feature but an actively wrong one: `ServiceCard` draws its own
+            // `ctrl+o log` hint, the keystroke would silently expand AN OLDER TOOL
+            // CARD, and nothing would error. The terminal one-row record is skipped -
+            // it has nothing to reveal, and expanding it would consume the press.
             const last = [...stateRef.current.entries]
                 .reverse()
-                .find((e) => e.kind === 'tool' || e.kind === 'team' || e.kind === 'compaction');
+                .find((e) => e.kind === 'tool' ||
+                e.kind === 'team' ||
+                e.kind === 'compaction' ||
+                (e.kind === 'service' && !e.terminal));
             if (last)
                 dispatch({ type: 'toggleExpand', id: last.id });
             // WIDENED FROM `No tool output to expand.`: with three expandable kinds the
@@ -1554,6 +1771,34 @@ export function App({ controller, version, mode, initialOverlay, initialPrompt,
                 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
@@ -1561,7 +1806,14 @@ export function App({ controller, version, mode, initialOverlay, initialPrompt,
                 // restating what they interrupted is the CLI arguing.
                 endReasonRef.current.aborted = true;
                 dispatch({ type: 'abortMark' });
-                toast('info', 'Run aborted.');
+                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
@@ -1578,11 +1830,18 @@ export function App({ controller, version, mode, initialOverlay, initialPrompt,
         }
     });
     // --- 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;
+    // RENDER SCOPE, so the chip and the composer hint agree with what the Ctrl+C
+    // handler will do on the very next keystroke.
+    const liveServices = liveServiceCount(services);
     const tokPerSec = state.status === 'running' && elapsedMs > 500
         ? Math.max(0, Math.round((state.usageTotal.outputTokens - runBaselineOut.current) / (elapsedMs / 1000)))
         : 0;
@@ -1627,24 +1886,24 @@ export function App({ controller, version, mode, initialOverlay, initialPrompt,
     // 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.
-    const viewportBudget = computeViewportRows(rows);
+    // `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;
-    // --- 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 teamLayout = buildTeamPanelLayout({
+        snapshot: state.team, terminalRows: rows, availableRows: viewportBudget,
+    });
+    const railLayout = buildTodoRailLayout({
+        mode, cols, panelEnabled: cfg.todo.panel, overlayOpen: overlay !== null,
+        itemCount: state.todos?.items.length ?? 0, viewportBudget,
+        teamRows: teamLayout.rowCount, popupRows,
+    });
+    // Every viewport consumer uses contentCols; header, composer, status and
+    // overlays keep the full terminal width. Overlay visibility is in the gate.
+    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
@@ -1657,12 +1916,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,
@@ -1782,8 +2035,8 @@ 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, modeToggleKey: modeToggleKey, popupMaxRows: popupMaxRows, scrolledLines: scrolledLines, 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, { 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, 
             // `!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
@@ -1821,7 +2074,14 @@ 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, { 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' &&
@@ -1831,9 +2091,10 @@ export function App({ controller, version, mode, initialOverlay, initialPrompt,
                 }
                 : {}), ...(state.todos && !showRail
                 ? { todoActive: { done: state.todos.doneCount, total: state.todos.total } }
-                : {}), ...(state.fast?.live ? { fastActive: { inFlight: state.fast.inFlight } } : {}), ...(state.compaction?.live
+                : {}), ...(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,

package/dist/ui/AutocompletePopup.d.ts

@@ -6,6 +6,7 @@
 import React from 'react';
 import type { Theme } from './theme.js';
 import type { TermCapabilities } from './capabilities.js';
+import { type AutocompleteLayout } from './layout/autocomplete.js';
 export interface Suggestion {
     label: string;
     hint?: string;
@@ -16,6 +17,7 @@ interface AutocompletePopupProps {
     theme: Theme;
     caps: TermCapabilities;
     maxRows?: number;
+    layout?: AutocompleteLayout;
 }
-export declare function AutocompletePopup({ items, selected, theme, caps, maxRows, }: AutocompletePopupProps): React.ReactElement | null;
+export declare function AutocompletePopup({ items, selected, theme, caps, maxRows, layout, }: AutocompletePopupProps): React.ReactElement | null;
 export {};

package/dist/ui/AutocompletePopup.js

@@ -1,19 +1,17 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { Box, Text } from 'ink';
 import { pickGlyphs } from './glyphs.js';
-const DEFAULT_MAX_ROWS = 6;
-export function AutocompletePopup({ items, selected, theme, caps, maxRows = DEFAULT_MAX_ROWS, }) {
-    if (items.length === 0)
+import { buildAutocompleteLayout } from './layout/autocomplete.js';
+export function AutocompletePopup({ items, selected, theme, caps, maxRows, layout, }) {
+    const projection = layout ?? buildAutocompleteLayout({ itemCount: items.length, selected, maxRows });
+    if (projection.rowCount === 0)
         return null;
     const glyphs = pickGlyphs(caps);
-    // Keep the highlighted row within a window of `maxRows`.
-    const start = Math.max(0, Math.min(selected - maxRows + 1, items.length - maxRows));
-    const windowStart = Math.max(0, start);
-    const visible = items.slice(windowStart, windowStart + maxRows);
-    const moreBelow = items.length - (windowStart + visible.length);
-    return (_jsxs(Box, { flexDirection: "column", borderStyle: glyphs.boxStyle, borderColor: theme.border, paddingX: 1, children: [visible.map((item, i) => {
+    const { start: windowStart, count, moreBelow, showMore } = projection;
+    const visible = items.slice(windowStart, windowStart + count);
+    return (_jsxs(Box, { flexDirection: "column", flexShrink: 0, borderStyle: glyphs.boxStyle, borderColor: theme.border, paddingX: 1, children: [visible.map((item, i) => {
                 const idx = windowStart + i;
                 const active = idx === selected;
-                return (_jsxs(Text, { inverse: active, children: [_jsx(Text, { color: active ? undefined : theme.primary, children: item.label }), item.hint ? _jsxs(Text, { color: theme.muted, children: ["  ", item.hint] }) : null] }, item.label));
-            }), moreBelow > 0 && _jsxs(Text, { color: theme.muted, children: ["  +", moreBelow, " more"] })] }));
+                return (_jsxs(Text, { inverse: active, wrap: "truncate", children: [_jsx(Text, { color: active ? undefined : theme.primary, children: item.label.replace(/\s+/g, ' ') }), item.hint ? _jsxs(Text, { color: theme.muted, children: ["  ", item.hint.replace(/\s+/g, ' ')] }) : null] }, idx));
+            }), showMore && _jsxs(Text, { wrap: "truncate", color: theme.muted, children: ["  +", moreBelow, " more"] })] }));
 }

package/dist/ui/BottomStatusRow.d.ts

@@ -11,7 +11,7 @@
  * box is its only `flexShrink={1}` child — so an extra chrome row does not make
  * the frame taller, Yoga takes the row out of the TRANSCRIPT. Meanwhile
  * `viewportRows()` keeps returning the old number to `ScrollViewport`,
- * `selectWindow`'s spacers, `overlayMaxRows`, `popupMaxRows` and `todoRailRows`.
+ * `selectWindow`'s spacers, `overlayMaxRows`, `popupMaxRows` and `buildTodoRailLayout`.
  * The transcript would draw one row shorter than every consumer believes, ONLY
  * WHILE A RUN IS IN FLIGHT, so the layout would shift on submit and shift back on
  * `agent_end`.