@aragon-agent/cli 0.6.3 → 0.6.4

package/dist/ui/App.js

@@ -17,6 +17,7 @@ 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';
@@ -105,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.
@@ -112,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, 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 +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.
@@ -282,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).
@@ -368,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
@@ -395,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
@@ -484,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
@@ -983,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
@@ -1119,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();
     };
     /**
@@ -1407,6 +1587,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 +1726,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 +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
@@ -1561,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
@@ -1583,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;
@@ -1627,7 +1873,10 @@ 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). --------------------------
     //
@@ -1782,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, 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' }) }) }));
+    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,
@@ -1831,7 +2080,7 @@ 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 },
                     gaugeMarks: {

package/dist/ui/Composer.d.ts

@@ -17,6 +17,7 @@
 import React from 'react';
 import type { Theme } from './theme.js';
 import type { TermCapabilities } from './capabilities.js';
+import { pickGlyphs } from './glyphs.js';
 import { type CommandOption } from './PromptInput.js';
 import { type AgentMode } from '../agent/agent-mode.js';
 export interface ComposerProps {
@@ -60,9 +61,61 @@ export interface ComposerProps {
      * un-faded in `hintText`.
      */
     scrolledLines?: number;
+    /**
+     * Live background services (background-service-supervision §3.8), 0 when none.
+     *
+     * IT IS STATE, NOT A FADEABLE HINT, exactly like `scrolledLines` above: the
+     * clause it adds is the only visible way to stop something, and `hintText`
+     * below keeps it out of the faded form for the same reason `esc abort` is kept
+     * there.
+     */
+    services?: number;
+    /**
+     * The composer's DRAFT row count, forwarded upward (tui-paste-handling
+     * section 5.5).
+     *
+     * `hasDraft` stays here, because the border reacts to it and routing that
+     * through `App` would re-render the transcript on the first keystroke of every
+     * message. The row count is the opposite case: `layout/budget.ts` needs it, so
+     * it has to reach `App` — and it changes on a line break rather than on a
+     * character, which is what keeps the re-render rate the same (R-6).
+     */
+    onDraftRows?: (rows: number) => void;
+    /** Paste refusals from `PromptInput`, routed to `App`'s notice dispatch. */
+    onNotice?: (level: 'warn' | 'error', text: string) => void;
     theme: Theme;
     caps: TermCapabilities;
     onSubmit: (text: string) => void;
     onHelp?: () => void;
 }
-export declare function Composer({ isActive, running, history, commands, cwd, showHint, submitCount, hintsEnabled, agentMode, modeToggleKey, popupMaxRows, scrolledLines, theme, caps, onSubmit, onHelp, }: ComposerProps): React.ReactElement;
+/**
+ * Build the hint row.
+ *
+ * The `running` branch is NEVER abbreviated, no matter how experienced the user
+ * is. Once the status bar's hint cluster was removed, the composer became the
+ * only place that names the abort key — and fading that out after eight
+ * submissions would leave a long-running task with no visible way to stop it.
+ * Progressive disclosure is for teaching discoverable things, not for retiring
+ * an emergency exit (§4.6 / A-14 / M-10b).
+ */
+declare function hintText(opts: {
+    running: boolean;
+    submitCount: number;
+    glyphs: ReturnType<typeof pickGlyphs>;
+    mode: AgentMode;
+    toggleKey: string;
+    /** Live background services; 0 leaves both rows byte-identical to today's. */
+    services: number;
+}): string;
+/**
+ * `hintText`, for the interrupt-ladder tests (AC-43).
+ *
+ * EXPORTED UNDER A TEST-FACING NAME rather than exporting `hintText` itself, so
+ * the private helper stays private in the module graph and nothing in `src/`
+ * grows a second caller by accident. The row is the ONLY visible way to stop a
+ * process the agent left running, so it is worth asserting on directly rather
+ * than fishing the string out of a rendered frame.
+ */
+export declare const hintTextForTest: typeof hintText;
+export declare function Composer({ isActive, running, history, commands, cwd, showHint, submitCount, hintsEnabled, agentMode, services, modeToggleKey, popupMaxRows, scrolledLines, onDraftRows, onNotice, theme, caps, onSubmit, onHelp, }: ComposerProps): React.ReactElement;
+export {};

package/dist/ui/Composer.js

@@ -32,9 +32,28 @@ import { MODE_LABEL, MODE_TOGGLE_KEYS, nextMode } from '../agent/agent-mode.js';
  * Progressive disclosure is for teaching discoverable things, not for retiring
  * an emergency exit (§4.6 / A-14 / M-10b).
  */
-function hintText(running, submitCount, glyphs, mode, toggleKey) {
+function hintText(opts) {
+    const { running, submitCount, glyphs, mode, toggleKey, services } = opts;
     const dot = ` ${glyphs.midDot} `;
+    // THE EXIT CLAUSE SURVIVES IN BOTH ROWS (P1-4). The obvious edit here is to
+    // replace `ctrl+c*2 exit` with `ctrl+c stop N` — and that would delete the
+    // only visible way to quit at exactly the moment Ctrl+C stops meaning "quit",
+    // on the screen a user reaches when something has already gone wrong. Both
+    // clauses are shown; the row is `wrap="truncate"` and they are ordered
+    // most-urgent-first, so a terminal too narrow for all of them drops the exit
+    // clause last rather than the abort key.
     if (running) {
+        if (services > 0) {
+            return [
+                `${glyphs.enterKey} steer`,
+                // Rung two is named because the whole point of the ladder is that the
+                // first press can fail; a user who does not know there is a second press
+                // is left exactly where the reported screenshot left them.
+                `esc abort${glyphs.times}2 force`,
+                `ctrl+c stop ${services}`,
+                `ctrl+c${glyphs.times}2 exit`,
+            ].join(dot);
+        }
         return [`${glyphs.enterKey} steer`, 'esc abort', `ctrl+c${glyphs.times}2 exit`].join(dot);
     }
     // The hint names the DESTINATION, not the current state — the correct label
@@ -45,9 +64,14 @@ function hintText(running, submitCount, glyphs, mode, toggleKey) {
     // retire things the user has demonstrably learned, and `submitCount` counts
     // submissions — a user can send fifty messages without ever discovering
     // Shift+Tab. Same argument that keeps `esc abort` un-faded above.
+    // NEVER FADED, for the reason the props doc gives: it is the only visible way
+    // to stop a process the agent left running, and progressive disclosure retires
+    // things the user has demonstrably learned — not emergency exits.
+    const stop = services > 0 ? [`ctrl+c stop ${services}`] : [];
     if (submitCount >= HINT_FADE_AFTER)
-        return [toggle, '? help'].join(dot);
+        return [...stop, toggle, '? help'].join(dot);
     return [
+        ...stop,
         `${glyphs.enterKey} send`,
         `${glyphs.shiftEnter} newline`,
         '/ commands',
@@ -56,9 +80,22 @@ function hintText(running, submitCount, glyphs, mode, toggleKey) {
         '? help',
     ].join(dot);
 }
-export function Composer({ isActive, running, history, commands, cwd, showHint, submitCount, hintsEnabled, agentMode, modeToggleKey = MODE_TOGGLE_KEYS.primary, popupMaxRows, scrolledLines = 0, theme, caps, onSubmit, onHelp, }) {
+/**
+ * `hintText`, for the interrupt-ladder tests (AC-43).
+ *
+ * EXPORTED UNDER A TEST-FACING NAME rather than exporting `hintText` itself, so
+ * the private helper stays private in the module graph and nothing in `src/`
+ * grows a second caller by accident. The row is the ONLY visible way to stop a
+ * process the agent left running, so it is worth asserting on directly rather
+ * than fishing the string out of a rendered frame.
+ */
+export const hintTextForTest = hintText;
+export function Composer({ isActive, running, history, commands, cwd, showHint, submitCount, hintsEnabled, agentMode, services = 0, modeToggleKey = MODE_TOGGLE_KEYS.primary, popupMaxRows, scrolledLines = 0, onDraftRows, onNotice, theme, caps, onSubmit, onHelp, }) {
     const [hasDraft, setHasDraft] = useState(false);
-    const onDraftChange = useCallback((next) => setHasDraft(next), []);
+    const onDraftChange = useCallback((next) => {
+        setHasDraft(next.hasDraft);
+        onDraftRows?.(next.rows);
+    }, [onDraftRows]);
     // Plan mode inserts ONE branch, above `draft` and below `running`. The
     // ordering is load-bearing: an in-flight run's border must stay `toolRunning`,
     // because "is it running" is more urgent than "which mode".
@@ -73,8 +110,15 @@ export function Composer({ isActive, running, history, commands, cwd, showHint,
                     : theme.idleBorder ?? theme.border;
     const glyphs = pickGlyphs(caps);
     const visible = showHint && hintsEnabled;
-    return (_jsxs(Box, { flexDirection: "column", flexShrink: 0, children: [_jsx(PromptInput, { isActive: isActive, running: running, history: history, commands: commands, cwd: cwd, theme: theme, caps: caps, popupMaxRows: popupMaxRows, onSubmit: onSubmit, onHelp: onHelp, agentMode: agentMode, bordered: { color: borderColor }, onDraftChange: onDraftChange, scrolledLines: scrolledLines }), visible && (
+    return (_jsxs(Box, { flexDirection: "column", flexShrink: 0, children: [_jsx(PromptInput, { isActive: isActive, running: running, history: history, commands: commands, cwd: cwd, theme: theme, caps: caps, popupMaxRows: popupMaxRows, onSubmit: onSubmit, onHelp: onHelp, agentMode: agentMode, bordered: { color: borderColor }, onDraftChange: onDraftChange, onNotice: onNotice, scrolledLines: scrolledLines }), visible && (
             // The chip rides the EXISTING hint row rather than adding one, so it
             // costs zero rows on a 24-row terminal.
-            _jsxs(Box, { flexDirection: "row", flexShrink: 0, children: [_jsx(Text, { children: '  ' }), _jsx(ModeChip, { mode: agentMode, theme: theme, caps: caps }), _jsx(Text, { wrap: "truncate", color: theme.hintFg ?? theme.muted, children: hintText(running, submitCount, glyphs, agentMode, modeToggleKey) })] }))] }));
+            _jsxs(Box, { flexDirection: "row", flexShrink: 0, children: [_jsx(Text, { children: '  ' }), _jsx(ModeChip, { mode: agentMode, theme: theme, caps: caps }), _jsx(Text, { wrap: "truncate", color: theme.hintFg ?? theme.muted, children: hintText({
+                            running,
+                            submitCount,
+                            glyphs,
+                            mode: agentMode,
+                            toggleKey: modeToggleKey,
+                            services,
+                        }) })] }))] }));
 }

package/dist/ui/PromptInput.d.ts

@@ -24,6 +24,7 @@ import type { TermCapabilities } from './capabilities.js';
 import { pickGlyphs } from './glyphs.js';
 import { type EditIntent } from '../input/keymap.js';
 import { type Suggestion } from './AutocompletePopup.js';
+import { type EditorState, type InputSegment } from './editor-reducer.js';
 import type { AgentMode } from '../agent/agent-mode.js';
 export interface CommandOption {
     name: string;
@@ -64,8 +65,30 @@ interface PromptInputProps {
     bordered?: {
         color?: string;
     };
-    /** Fires only when the draft flips empty ⇄ non-empty, for the border color. */
-    onDraftChange?: (hasDraft: boolean) => void;
+    /**
+     * Fires when the draft flips empty ⇄ non-empty (for the border color) OR when
+     * its ROW COUNT changes (for `layout/budget.ts`) — never per keystroke.
+     *
+     * Widened from `(hasDraft: boolean)` by tui-paste-handling section 5.5. The row
+     * count is what makes I-8 true: the composer's rendered height and the
+     * `draftRows` handed to `viewportRows` have to be the same number, and the only
+     * component that knows the first one is this one. It is reported ALREADY
+     * CLAMPED, so a 218-line draft and a 400-line draft report the same value and
+     * the transcript stops moving once the composer is full (R-12).
+     */
+    onDraftChange?: (state: {
+        hasDraft: boolean;
+        rows: number;
+    }) => void;
+    /**
+     * Tell the user a paste was refused (D-11 / P1-4).
+     *
+     * `PASTE_DRAFT_MAX_BYTES` and `PASTE_MAX_BLOCKS` cannot be enforced in the
+     * filter (it does not know the draft) and cannot be enforced in the reducer (it
+     * is pure, so it can neither raise a toast nor say why it refused). This
+     * component is the only place that holds both facts.
+     */
+    onNotice?: (level: 'warn' | 'error', text: string) => void;
     /**
      * Rows of newer output hidden BELOW the viewport — `ScrollViewport`'s offset
      * (tui-selection-and-scroll-follow §4.2 / G7).
@@ -99,6 +122,29 @@ export interface ScrollChip {
  * scan fails the build if that rule is broken here.
  */
 export declare function scrollChip(scrolledLines: number, cols: number, glyphs: ReturnType<typeof pickGlyphs>): ScrollChip | null;
+export interface OverflowChip {
+    text: string;
+    /** FIXED width, so a number gaining a digit cannot re-wrap the draft. */
+    cells: number;
+}
+/**
+ * Build the "there is more draft above / below this window" indicator, or `null`
+ * when the whole draft is on screen.
+ *
+ * Every glyph comes from `pickGlyphs` and none from a literal (I-5): on a legacy
+ * console this renders `^3 v7` rather than mojibake, and `glyphs.test.ts`'s
+ * static scan fails the build if that rule is broken here.
+ */
+export declare function overflowChip(hiddenAbove: number, hiddenBelow: number, glyphs: ReturnType<typeof pickGlyphs>): OverflowChip | null;
+/**
+ * Would these segments push the draft past a limit? Returns the refusal text, or
+ * `null` when the paste is allowed.
+ *
+ * Checked BEFORE `dispatch`, so a refusal dispatches nothing at all and the draft
+ * is left byte-for-byte unchanged (AC-9). The one-dispatch-per-key rule is
+ * unaffected for the same reason.
+ */
+export declare function draftLimitRefusal(segments: InputSegment[], editor: Pick<EditorState, 'pastes'>): string | null;
 /** Apply an edit intent as a pure buffer/cursor transform. */
 export declare function applyEdit(buffer: string, cursor: number, intent: EditIntent): {
     buffer: string;
@@ -127,5 +173,5 @@ export declare function fileTokenAt(buffer: string, cursor: number): {
     end: number;
     query: string;
 } | null;
-export declare function PromptInput({ isActive, running, history, commands, cwd, theme, caps, popupMaxRows, agentMode, onSubmit, onHelp, bordered, onDraftChange, scrolledLines, }: PromptInputProps): React.ReactElement;
+export declare function PromptInput({ isActive, running, history, commands, cwd, theme, caps, popupMaxRows, agentMode, onSubmit, onHelp, bordered, onDraftChange, onNotice, scrolledLines, }: PromptInputProps): React.ReactElement;
 export {};