@aragon-agent/cli 0.6.2 → 0.6.4

package/dist/ui/App.js

@@ -11,14 +11,16 @@ 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, setMouseNoticeSeen, setVtInputNoticeVersion, } from '../config/ui-state.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, VT_INPUT_NOTICE_VERSION } from './use-startup-notices.js';
+import { useStartupNotices, MOUSE_NOTICE_VERSION, VT_INPUT_NOTICE_VERSION, } from './use-startup-notices.js';
 import { getTheme } from './theme.js';
 import { pickGlyphs } from './glyphs.js';
 import { Header } from './Header.js';
@@ -60,7 +62,7 @@ import { publishExitSnapshot } from './exit-snapshot.js';
 import { OverlayFrame } from './layout/OverlayFrame.js';
 import { helpRows } from './overlays/HelpOverlay.js';
 import { ModelPicker } from './overlays/ModelPicker.js';
-import { SettingsScreen, fastSettingsFrom, readFastSettings, } from './overlays/SettingsScreen.js';
+import { SettingsScreen, compactionSettingsFrom, fastSettingsFrom, readCompactionSettings, readFastSettings, } from './overlays/SettingsScreen.js';
 import { ConfirmDialog } from './overlays/ConfirmDialog.js';
 import { QuestionOverlay } from './overlays/QuestionOverlay.js';
 import { PlanReviewOverlay } from './overlays/PlanReviewOverlay.js';
@@ -68,6 +70,7 @@ import { CommandRegistry, runSlashInput } from '../commands/registry.js';
 import { registerBuiltinCommands } from '../commands/builtins.js';
 import { makeSkillsCommand, registerSkillCommands } from '../commands/skills.js';
 import { MODE_LABEL, MODE_TOGGLE_KEYS, nextMode } from '../agent/agent-mode.js';
+import { emptyTailState } from './layout/follow-state.js';
 /**
  * Decide what the `Max tokens` field means, WITHOUT letting a bad value in it
  * discard the rest of the form.
@@ -103,6 +106,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.
@@ -110,7 +131,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, }) {
+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';
@@ -133,6 +154,12 @@ export function App({ controller, version, mode, initialOverlay, initialPrompt,
     // function reference.
     const [state, dispatch] = useReducer(viewReducer, cfg.showThinking, seedViewState);
     const [elapsedMs, setElapsedMs] = useState(0);
+    /**
+     * Forces the render that re-reads `Date.now()` for the live compaction card
+     * while the run is IDLE (hardening W5). The value itself is never read - the
+     * card's elapsed figure is derived from `nowSec` like the running tool card's.
+     */
+    const [, setCompactionClock] = useState(0);
     const [confirmState, setConfirmState] = useState(null);
     /**
      * The updater's latest snapshot, or `null` while there is no service
@@ -152,6 +179,15 @@ export function App({ controller, version, mode, initialOverlay, initialPrompt,
     const [scrollIntent, setScrollIntent] = useState();
     const [pinToBottomNonce, setPinToBottomNonce] = useState(0);
     const [scrolledLines, setScrolledLines] = useState(0);
+    /**
+     * True while a selection drag holds the viewport
+     * (tui-selection-and-scroll-follow §4.3.1 / §4.4).
+     *
+     * REACT STATE RATHER THAN A REF, because `ScrollViewport` has to re-arm its
+     * resume timer on both edges and a ref cannot drive an effect. The controller
+     * is the owner; this is a mirror, pushed by `onHoldChange`.
+     */
+    const [selectionHold, setSelectionHold] = useState(false);
     // I-5 (§4.13): Ctrl+L cannot repaint by writing escapes — Ink dedupes
     // identical output twice over — so it bumps this instead, and StatusBar turns
     // it into a one-byte, zero-width change that both dedupe gates let through.
@@ -181,6 +217,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.
@@ -211,6 +278,16 @@ export function App({ controller, version, mode, initialOverlay, initialPrompt,
      * would make reading the render budget cost a render.
      */
     const mountedCount = useRef(0);
+    /**
+     * Rows the transcript has appended AT ITS TAIL — Rule A's only legal input
+     * (tui-selection-and-scroll-follow §4.3.1a).
+     *
+     * Owned here because it has TWO readers one level down each: `TranscriptList`
+     * writes it during its render, and `ScrollViewport` reads it in the layout
+     * effect that runs afterwards. A ref rather than state, exactly like
+     * `mountedCount` above and for the same reason.
+     */
+    const tailSink = useRef(emptyTailState());
     // --- Follow-through (todo-plan-followthrough §3.4). ---------------------
     //
     // THREE REFS AND NO VIEW STATE, DELIBERATELY (§5.2). Every field added to
@@ -255,6 +332,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).
@@ -341,7 +432,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
@@ -368,6 +480,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
@@ -457,7 +574,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
@@ -604,6 +751,97 @@ export function App({ controller, version, mode, initialOverlay, initialPrompt,
             }
         });
     }, [controller]);
+    // --- Compaction event stream (context-auto-compaction §5.2). -------------
+    //
+    // A SIXTH SUBSCRIPTION, for the reason the team, todo and fast ones record:
+    // `CompactionEvent` is deliberately not a member of core's `AgentEvent` union,
+    // so it cannot arrive through `controller.subscribe`.
+    //
+    // AND IT IS THE **SOLE** DISPATCHER OF THE FIVE COMPACTION ACTIONS (D-20 /
+    // P1-6). `reduceEvent` gains no cases for core's `compaction_start` /
+    // `compaction_end` — its `default: return []` is already correct for them —
+    // because one compaction arriving through two channels is two transcript cards
+    // and a doubled `tokensReclaimed`, with nothing naming the authority. This
+    // stream is the right authority because it is strictly richer: the wiring IS
+    // the `ContextManager`, so it knows the summarizer's model, its cost and the
+    // session totals, and it learns `applied` by subscribing to the core event one
+    // layer earlier.
+    //
+    // `subscribeCompaction` returns a no-op unsubscribe when compaction was off at
+    // construction, so this can subscribe unconditionally and an ordinary session
+    // pays one closure for the whole run.
+    useEffect(() => {
+        // Seed the chip and the gauge marks from the snapshot resolved at
+        // construction, so a compaction-enabled session shows them on the FIRST
+        // frame rather than after the first turn.
+        if (controller.isCompactionRegistered()) {
+            dispatch({ type: 'compactionSnapshot', snapshot: controller.getCompactionSnapshot() });
+        }
+        return controller.subscribeCompaction((event) => {
+            switch (event.type) {
+                case 'compaction_start':
+                    dispatch({
+                        type: 'compactionStart',
+                        index: event.index,
+                        trigger: event.trigger,
+                        model: event.model,
+                    });
+                    break;
+                case 'compaction_end': {
+                    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
+                    // ref is ASKED FOR rather than assumed. `getModelInfo()` here would
+                    // price a Haiku summarization at the lead's Opus rates, which is the
+                    // same class of lie as the `$0.00` `pricingUnknown` exists to prevent,
+                    // just in the other direction.
+                    const snapshot = controller.getCompactionSnapshot();
+                    const ref = controller.getCompactionSummarizerRef();
+                    const costDelta = snapshot.pricingUnknown || !ref
+                        ? 0
+                        : computeCost(event.usage, controller.getModelInfoFor(ref).cost);
+                    dispatch({ type: 'compactionUsage', usage: event.usage, costDelta });
+                    break;
+                }
+                case 'snapshot':
+                    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;
+            }
+        });
+    }, [controller]);
     // --- Live tool output (agent-activity-presentation-live §3.3.2). --------
     //
     // A FIFTH SUBSCRIPTION, and THE ONE THAT DOES GO THROUGH THE STREAMING
@@ -647,6 +885,17 @@ export function App({ controller, version, mode, initialOverlay, initialPrompt,
         const id = setInterval(() => setElapsedMs(Date.now() - startedAt), 200);
         return () => clearInterval(id);
     }, [state.status]);
+    // --- Live compaction elapsed tick (hardening §3.6 / W5). ---------------
+    //
+    // ONLY WHILE A CARD IS LIVE AND THE RUN IS NOT, so an ordinary session has no
+    // timer and an in-loop compaction reuses the 200 ms elapsed ticker rather than
+    // adding a second one. 1 Hz, because the card shows whole seconds.
+    useEffect(() => {
+        if (state.compactionEntryId === undefined || state.status === 'running')
+            return undefined;
+        const id = setInterval(() => setCompactionClock(Date.now()), 1000);
+        return () => clearInterval(id);
+    }, [state.compactionEntryId, state.status]);
     // --- Retry countdown tick (llm-api-retry-backoff §6.5). ----------------
     //
     // ONLY WHILE A BACKOFF IS ACTUALLY WAITING, and the effect's teardown clears it —
@@ -697,9 +946,17 @@ export function App({ controller, version, mode, initialOverlay, initialPrompt,
     // so on a console that reports nothing there is no source and no advice.
     useStartupNotices(dispatch, {
         enabled: !!mouseSource,
+        // NOT re-derived here (see `MouseNoticeOptions`): `cli.tsx` computes
+        // `mouseFilter !== null && cfg.mouseSelect` once and four things read it,
+        // so a second derivation is a second chance for them to disagree.
+        selectEnabled: terminal?.mouseSelect ?? false,
         // `state.json`, not `config.json`: whether a one-shot notice has been shown
         // is bookkeeping, and the comment on the old persisted key said so.
-        onSeen: () => setMouseNoticeSeen(true),
+        //
+        // THE VERSION, NOT `true` (P1-8). The gate compares against
+        // `MOUSE_NOTICE_VERSION`, so storing anything else either replays the
+        // notice forever or silences a future revision of the text.
+        onSeen: () => setMouseNoticeVersion(MOUSE_NOTICE_VERSION),
     }, 
     // Present only when `loadConfig` had to raise the user's own
     // `transcriptRetain` to `transcriptWindow` (tui-render-performance §5.1).
@@ -846,6 +1103,56 @@ 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 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
@@ -888,6 +1195,83 @@ export function App({ controller, version, mode, initialOverlay, initialPrompt,
         // every render and defeat the ref guard's purpose rather than its mechanism.
         // eslint-disable-next-line react-hooks/exhaustive-deps
     }, [updateSnapshot?.phase, updateSnapshot?.latestVersion]);
+    // --- Selection (tui-selection-and-scroll-follow §4.4). -------------------
+    //
+    // The controller is built by `cli.tsx` before `render()`, so what it is
+    // missing when it starts is exactly the two things that only exist once this
+    // component is mounted: somewhere to put a toast, and a way to ask for a React
+    // redraw when the frame differ has no cache to repaint from. Both are assigned
+    // here and cleared on unmount, the same shape `updateBridge` uses.
+    const selectionBridge = terminal?.selection;
+    useEffect(() => {
+        if (!selectionBridge)
+            return undefined;
+        selectionBridge.onCopied = (via, lines, chars) => {
+            // IT NAMES THE MECHANISM RATHER THAN CLAIMING SUCCESS (R-7). Neither OSC 52
+            // nor a spawned `xclip` is detectable: tmux without `set -g set-clipboard
+            // on` swallows the first silently, and the second is best-effort by
+            // construction. A toast that said "copied successfully" would be guessing.
+            const noun = lines === 1 ? 'line' : 'lines';
+            if (via === 'none') {
+                toast('warn', 'Nothing could be copied - no clipboard mechanism is available.');
+                return;
+            }
+            const how = via === 'osc52' ? 'terminal clipboard' : 'system clipboard';
+            toast('success', `Sent ${lines} ${noun} (${chars} chars) to the ${how}.`);
+        };
+        // I-5 of `frame-differ.ts`: writing escapes here would be a foreign write.
+        // The nonce is the carrier Ctrl+L already uses (§4.13).
+        selectionBridge.requestRedraw = () => setRedrawNonce((n) => n + 1);
+        const unsubscribe = selectionBridge.controller?.onHoldChange(setSelectionHold);
+        return () => {
+            selectionBridge.onCopied = null;
+            selectionBridge.requestRedraw = null;
+            unsubscribe?.();
+        };
+        // `toast` is a stable dispatch wrapper; depending on it would rebuild this
+        // subscription on every render.
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [selectionBridge]);
+    const selectionController = selectionBridge?.controller ?? null;
+    /**
+     * I-9, the DERIVED half — and the one that matters (D-14 / P1-4).
+     *
+     * `shiftUp` changes exactly when the rows on screen move: a wheel notch, a key,
+     * PgDn, the bottom snap, `pinToBottomNonce`, the idle auto-resume, a height
+     * correction above the reading position. An enumerated list of gestures was
+     * already incomplete on the day it was written — it missed this feature's OWN
+     * auto-resume, which would have left a five-second-old highlight sitting over
+     * rows that had scrolled out from under it — and a derived condition cannot be
+     * forgotten by the next person who adds a way to move the viewport.
+     *
+     * Rule A holds `shiftUp` CONSTANT while a drag is in progress, which is why a
+     * selection survives output streaming in below it and only that.
+     *
+     * Referentially stable, because `ScrollViewport` publishes it from an effect
+     * keyed on the callback.
+     */
+    const onViewportShiftChange = useCallback(() => {
+        selectionController?.clear();
+    }, [selectionController]);
+    // I-9, the ENUMERATED half. `shiftUp` covers every movement of the rows and is
+    // wired straight into `ScrollViewport` below; these three are the cases that
+    // change the screen while leaving `shiftUp` untouched — a key that scrolls
+    // nothing, an overlay swap, and a re-wrap (P1-7).
+    useEffect(() => {
+        if (!selectionController)
+            return;
+        // Screen coordinates stop meaning anything the moment every line re-wraps,
+        // and a resize is exactly that (N6).
+        selectionController.clear();
+    }, [selectionController, rows, cols]);
+    useEffect(() => {
+        if (!selectionController)
+            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.clear();
+    }, [selectionController, state.overlay]);
     const persistConfig = (patch) => {
         try {
             updatePersistedConfig(patch);
@@ -905,6 +1289,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();
     };
     /**
@@ -951,6 +1345,19 @@ export function App({ controller, version, mode, initialOverlay, initialPrompt,
         // cache, and `/update` would report "disabled" on a session where it is on.
         // `?? undefined` because the bridge holds `null` and the port is optional.
         update: updateBridge?.service ?? undefined,
+        // Read at command time so `/mouse` reports the LIVE state rather than
+        // whatever it was when this closure was first built — `/mouse off` followed
+        // by a bare `/mouse` has to say "off".
+        ...(terminal?.setMouseCapture
+            ? {
+                mouse: {
+                    captured: () => terminal.isMouseCaptured?.() ?? true,
+                    selectEnabled: () => terminal.mouseSelect,
+                    setCapture: (on) => terminal.setMouseCapture?.(on),
+                },
+            }
+            : {}),
+        ...(terminal?.writeForeign ? { writeForeign: terminal.writeForeign } : {}),
     });
     /**
      * Submitting a prompt no longer touches `config.json` at all — it appends one
@@ -1079,6 +1486,23 @@ export function App({ controller, version, mode, initialOverlay, initialPrompt,
         const fastPatch = readFastSettings(values);
         controller.setFastConfig(fastPatch);
         patch.fast = fastPatch;
+        // --- Context compaction (context-auto-compaction §4.5) ------------------
+        //
+        // THE SAME SETTER-AND-PERSIST PAIR, and the same reason. `setCompactionConfig`
+        // additionally re-emits the snapshot, which is what moves the status chip and
+        // the gauge's marks without waiting for the next turn.
+        //
+        // `enabled` here flips the LIVE switch only. Whether the wiring exists at all
+        // was decided at construction and cannot be undone in this session (§3.2), so
+        // a user who turns it ON in a `--no-compaction` session gets the persisted
+        // value for next launch and nothing this session — which is exactly what
+        // `/compact on` reports in words.
+        const compactionPatch = readCompactionSettings(values);
+        controller.setCompactionConfig(compactionPatch);
+        if (compactionPatch.enabled !== undefined) {
+            controller.setCompactionEnabled(compactionPatch.enabled);
+        }
+        patch.compaction = compactionPatch;
         persistConfig(patch);
         getLogger().reconfigure({ ...controller.getConfig().log, level: values.logLevel });
         dispatch({ type: 'setOverlay', overlay: null });
@@ -1152,7 +1576,37 @@ export function App({ controller, version, mode, initialOverlay, initialPrompt,
     }, []);
     // --- Global keys -------------------------------------------------------
     useInput((input, key) => {
+        // 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
+        // also the way out of a `hold` that lost its release (I-11), alongside the
+        // watchdog.
+        //
+        // `Esc` IS DELIBERATELY NOT GIVEN A SECOND MEANING (§4.4.6). It aborts a
+        // run, and an emergency exit is the last key that should silently absorb a
+        // press; it clears the selection here like every other key and nothing more.
+        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;
@@ -1266,13 +1720,29 @@ export function App({ controller, version, mode, initialOverlay, initialPrompt,
             // `team` joins `tool` here (team-subagents §6.3): a dispatch card collapses
             // its per-agent summaries behind the same key, and `toggleExpand` is keyed
             // on entry id so it needs no change.
+            // `compaction` joins `tool` and `team` here (context-auto-compaction §6.3 /
+            // C-15 / P1-8). `expandedToolIds` is keyed by entry id so the STORAGE was
+            // already generic — but both surfaces that CHOOSE a target filter by kind,
+            // 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');
+                .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
+            // old wording would be wrong in two of the three empty cases.
             else
-                toast('info', 'No tool output to expand.');
+                toast('info', 'Nothing to expand.');
             return;
         }
         if (key.escape) {
@@ -1292,6 +1762,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
@@ -1299,7 +1797,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
@@ -1321,6 +1826,9 @@ export function App({ controller, version, mode, initialOverlay, initialPrompt,
     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;
@@ -1332,6 +1840,10 @@ export function App({ controller, version, mode, initialOverlay, initialPrompt,
     // every single turn, which is the one moment this feature exists to make feel
     // calm.
     const running = state.status === 'running';
+    // The live compaction card's clock (hardening W5). While the run is going the
+    // 200 ms elapsed ticker already causes the render that re-reads this; an IDLE
+    // `/compact` has no ticker at all, which is what `compactionClock` is for.
+    const compactionLive = state.compactionEntryId !== undefined;
     if (running && runStartedAt.current === 0)
         runStartedAt.current = Date.now();
     if (!running && runStartedAt.current !== 0)
@@ -1357,11 +1869,14 @@ export function App({ controller, version, mode, initialOverlay, initialPrompt,
     // that re-reads it — so no timer is added (D-36 / E-15). Seconds rather than
     // milliseconds because `ToolCard` is `React.memo`'d with the default
     // comparator; `Transcript` passes it on only to running tool entries.
-    const nowSec = running ? Math.floor(Date.now() / 1000) : undefined;
+    const nowSec = running || compactionLive ? Math.floor(Date.now() / 1000) : undefined;
     // Row budget for the viewport and everything sized against it (§4.2a). The
     // inline path has no fixed frame, hence no height to fit into: `Infinity`
     // tells `OverlayFrame` to render everything and show no position indicator.
-    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). --------------------------
     //
@@ -1425,6 +1940,7 @@ export function App({ controller, version, mode, initialOverlay, initialPrompt,
             // The four fast rows, seeded through the pure mapper so the screen and
             // the save handler cannot disagree about what `(inherit)` means.
             ...fastSettingsFrom(cfg.fast),
+            ...compactionSettingsFrom(cfg.compaction),
         }, apiKeys: cfg.apiKeys, maxRows: overlayMaxRows, cols: cols, scrollOffset: overlayScroll, onScrollClamp: setOverlayScroll, theme: theme, caps: caps, onSave: handleSettingsSave, 
         // 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.
@@ -1500,7 +2016,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, 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 })] }))) : (_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] }));
+    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.
@@ -1515,7 +2031,7 @@ 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, 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' }) }) }));
+    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, 
             // `!overlayNode` suppresses the line while an overlay owns the screen:
             // the full-screen branch replaces the whole viewport with the overlay,
@@ -1528,7 +2044,13 @@ export function App({ controller, version, mode, initialOverlay, initialPrompt,
             // SIGNAL IS DERIVED FROM (D-4): inlining it here again is how the two
             // drift apart, and the drift is silent in whichever branch is not
             // edited.
-            activity: activityVisible ? (_jsx(ActivityLine, { startedAt: runStartedAt.current, elapsedMs: elapsedMs, reducedMotion: reducedMotion, runningTool: runningTool, theme: theme, caps: caps })) : null, 
+            activity: activityVisible ? (_jsx(ActivityLine, { startedAt: runStartedAt.current, elapsedMs: elapsedMs, reducedMotion: reducedMotion, runningTool: runningTool, 
+                // THE ROW MUST NEVER SAY SOMETHING FALSE (§6.1). Compaction runs
+                // BEFORE `turn_start`, so `status` is `'running'` with no tool in
+                // flight — precisely the window in which the rotating phrase
+                // would claim the model is thinking while it is actually waiting
+                // on a 30k-token summarization.
+                compacting: state.compaction?.inFlight === true, theme: theme, caps: caps })) : null, 
             // THE FORM THE LIFE SIGNAL TAKES WHEN A TOAST HAS THE ROW
             // (`activity-spinner-vanishes-behind-toast`). Passed UNCONDITIONALLY:
             // `BottomStatusRow` reads it only when `activity` above is non-null,
@@ -1548,7 +2070,7 @@ 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, 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, 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
                 ? {
                     teamActive: {
                         running: state.team.runs.filter((r) => r.phase !== 'queued' && r.phase !== 'done' &&
@@ -1558,7 +2080,15 @@ 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.retry
+                : {}), ...(liveServices > 0 ? { servicesActive: { live: liveServices } } : {}), ...(state.fast?.live ? { fastActive: { inFlight: state.fast.inFlight } } : {}), ...(state.compaction?.live
+                ? {
+                    compactionActive: { inFlight: state.compaction.inFlight },
+                    gaugeMarks: {
+                        warn: cfg.compaction.warnThreshold * 100,
+                        high: cfg.compaction.threshold * 100,
+                    },
+                }
+                : {}), ...(state.retry
                 ? {
                     retryActive: {
                         attempt: state.retry.attempt,