@aragon-agent/cli 0.6.11 → 0.6.13

package/dist/ui/PromptInput.js

@@ -28,11 +28,14 @@ import { recognize } from '../input/keymap.js';
 import { AutocompletePopup } from './AutocompletePopup.js';
 import { buildAutocompleteLayout } from './layout/autocomplete.js';
 import { editorReducer, INITIAL_EDITOR_STATE, } from './editor-reducer.js';
-import { hasPasteFrame, splitPasteFrames } from './paste-frames.js';
-import { hasEnterFrame, mergeWithPasteRuns, splitEnterFrames, } from './enter-frames.js';
+import { hasPasteFrame } from './paste-frames.js';
+import { hasEnterFrame, splitEnterFrames, } from './enter-frames.js';
+import { planComposerInput } from './composer-input.js';
 import { allocatePasteId, expandPastes, expandRangeOverTokens } from './paste-tokens.js';
 import { draftMaxRows } from './composer-limits.js';
 import { layoutComposer, splitRowAtColumn } from './composer-rows.js';
+import { moveVisualCursor, snapGrapheme, stepGrapheme } from './editor-navigation.js';
+import { interactionCopy } from './interaction-copy.js';
 import { PASTE_DRAFT_MAX_BYTES, PASTE_MAX_BLOCKS, formatPasteSize, } from '../input/limits.js';
 // ---------------------------------------------------------------------------
 // The scroll chip (§4.2)
@@ -132,6 +135,8 @@ export function draftLimitRefusal(segments, editor) {
 // ---------------------------------------------------------------------------
 const isSpace = (ch) => !!ch && /\s/.test(ch);
 function lineStart(buffer, cursor) {
+    if (cursor <= 0)
+        return 0;
     const nl = buffer.lastIndexOf('\n', cursor - 1);
     return nl === -1 ? 0 : nl + 1;
 }
@@ -165,23 +170,23 @@ function nextWord(buffer, cursor) {
  * label the user then sends INSTEAD of the text it stands for.
  */
 function killRange(buffer, from, to) {
-    const range = expandRangeOverTokens(buffer, from, to);
+    const range = expandRangeOverTokens(buffer, snapGrapheme(buffer, from), snapGrapheme(buffer, to, true));
     return { buffer: buffer.slice(0, range.from) + buffer.slice(range.to), cursor: range.from };
 }
 /** Apply an edit intent as a pure buffer/cursor transform. */
 export function applyEdit(buffer, cursor, intent) {
+    cursor = snapGrapheme(buffer, cursor);
     switch (intent) {
-        // Cursor MOVEMENT is deliberately not token-aware (D-8): arrows, Home/End
-        // and word jumps step by character, because re-deriving `moveVertical` around
-        // a synthetic unit buys a correctness the user cannot notice.
+        // Navigation may enter a token label; insertion and range deletion retain
+        // the existing token snapping and expansion contracts.
         case 'home':
             return { buffer, cursor: lineStart(buffer, cursor) };
         case 'end':
             return { buffer, cursor: lineEnd(buffer, cursor) };
         case 'wordLeft':
-            return { buffer, cursor: prevWord(buffer, cursor) };
+            return { buffer, cursor: snapGrapheme(buffer, prevWord(buffer, cursor)) };
         case 'wordRight':
-            return { buffer, cursor: nextWord(buffer, cursor) };
+            return { buffer, cursor: snapGrapheme(buffer, nextWord(buffer, cursor), true) };
         case 'deleteWordBack':
             return killRange(buffer, prevWord(buffer, cursor), cursor);
         case 'killToStart':
@@ -196,19 +201,8 @@ export function applyEdit(buffer, cursor, intent) {
  * prompt-history recall.
  */
 export function moveVertical(buffer, cursor, dir) {
-    const lines = buffer.split('\n');
-    if (lines.length < 2)
-        return null;
-    const before = buffer.slice(0, cursor);
-    const idx = before.split('\n').length - 1;
-    const col = before.length - (before.lastIndexOf('\n') + 1);
-    const target = dir === 'up' ? idx - 1 : idx + 1;
-    if (target < 0 || target >= lines.length)
-        return null;
-    let start = 0;
-    for (let i = 0; i < target; i += 1)
-        start += lines[i].length + 1;
-    return { cursor: start + Math.min(col, lines[target].length) };
+    const moved = moveVisualCursor({ buffer, cursor, direction: dir, cols: Number.MAX_SAFE_INTEGER });
+    return moved ? { cursor: moved.cursor } : null;
 }
 /**
  * Slash-command suggestions when the buffer is a bare `/word` (no space yet).
@@ -249,7 +243,7 @@ function isControlSeq(input) {
 // ---------------------------------------------------------------------------
 // Component
 // ---------------------------------------------------------------------------
-export function PromptInput({ cols: colsProp, cursorVisible = true, onInteraction, isActive, running, history, commands, cwd, theme, caps, popupMaxRows, popupMaxHeight, onPopupRowsChange, agentMode, onSubmit, onHelp, onEscape, onEscapeDismiss, reducedMotion = false, borderColor, onDraftChange, onNotice, scrolledLines = 0, }) {
+export function PromptInput({ cols: colsProp, cursorVisible = true, onInteraction, isActive, running, history, commands, cwd, theme, caps, popupMaxRows, popupMaxHeight, onPopupRowsChange, onCompletionContextChange, deleteDisambiguated = false, agentMode, onSubmit, onHelp, onEscape, onEscapeDismiss, reducedMotion = false, borderColor, onDraftChange, onNotice, scrolledLines = 0, }) {
     const { stdout } = useStdout();
     const [editor, dispatch] = useReducer(editorReducer, INITIAL_EDITOR_STATE);
     const { buffer, cursor, historyIndex, dismissed, sel } = editor;
@@ -279,6 +273,17 @@ export function PromptInput({ cols: colsProp, cursorVisible = true, onInteractio
         onPopupRowsChange?.(popupLayout.rowCount);
     }, [onPopupRowsChange, popupLayout.rowCount]);
     useLayoutEffect(() => () => onPopupRowsChange?.(0), [onPopupRowsChange]);
+    const completion = popupVisible ? popupKind ?? 'none' : 'none';
+    const completionCallback = useRef(onCompletionContextChange);
+    completionCallback.current = onCompletionContextChange;
+    const lastCompletion = useRef();
+    useLayoutEffect(() => {
+        if (!onCompletionContextChange || lastCompletion.current === completion)
+            return;
+        lastCompletion.current = completion;
+        onCompletionContextChange?.(completion);
+    }, [onCompletionContextChange, completion]);
+    useLayoutEffect(() => () => completionCallback.current?.('none'), []);
     // --- Debounced `@file` scan. ---------------------------------------------
     useEffect(() => {
         if (fileQuery === null || fileQuery.length < 1) {
@@ -346,6 +351,8 @@ export function PromptInput({ cols: colsProp, cursorVisible = true, onInteractio
     const overflows = wide.hiddenAbove > 0 || wide.hiddenBelow > 0;
     const usableCols = overflows ? Math.max(8, baseCols - OVERFLOW_CELLS - 1) : baseCols;
     const layout = overflows ? measure(usableCols) : wide;
+    const preferredColumnWidth = useRef();
+    useLayoutEffect(() => { preferredColumnWidth.current = undefined; }, [usableCols]);
     const draftRowCount = Math.max(1, layout.rows.length);
     const caretResetKey = useMemo(() => ({}), [buffer, cursor, isActive, usableCols]);
     // --- Draft presence and height, reported only on a transition. -----------
@@ -371,18 +378,42 @@ export function PromptInput({ cols: colsProp, cursorVisible = true, onInteractio
         onInteraction?.();
         dispatch({ type: 'insert', text });
     };
-    /**
-     * Expand every token back to its payload, then send (D-7 / D-9).
-     *
-     * `onSubmit`'s signature is unchanged, so `Composer`, `App.handleSubmit`,
-     * `runSlashInput` and `submitMessage` are all untouched — and a slash command
-     * therefore sees the EXPANDED text, which is what `/skill foo <pasted body>`
-     * needs. `clear` releases every payload in the same dispatch.
-     */
-    const submit = (text) => {
+    const resolveSubmit = (state) => {
+        const suggestions = state.dismissed ? null : slashSuggestions(state.buffer, commands);
+        const selectedIndex = Math.min(state.sel, (suggestions?.length ?? 0) - 1);
+        const suggestionLayout = buildAutocompleteLayout({
+            itemCount: isActive ? suggestions?.length ?? 0 : 0,
+            selected: selectedIndex, maxRows: popupMaxRows, maxHeight: popupMaxHeight,
+        });
+        const selected = suggestionLayout.rowCount > 0 ? suggestions?.[selectedIndex] : undefined;
+        const text = selected?.label ?? expandPastes(state.buffer, state.pastes);
+        return text.trim().length > 0 ? text : null;
+    };
+    const transact = (intents) => {
+        const plan = planComposerInput({
+            editor, intents, resolveSubmit, checkPasteLimit: draftLimitRefusal,
+        });
+        if (plan.refusal) {
+            onNotice?.('warn', plan.refusal);
+            return;
+        }
         onInteraction?.();
-        onSubmit(expandPastes(text, editor.pastes));
-        dispatch({ type: 'clear' });
+        let result = { accepted: true };
+        if (plan.submission !== undefined) {
+            try {
+                result = onSubmit(plan.submission);
+            }
+            catch (error) {
+                result = { accepted: false, reason: error instanceof Error ? error.message : String(error) };
+            }
+        }
+        dispatch({ type: 'adopt', state: result.accepted ? plan.nextEditor : plan.rejectedEditor });
+        if (!result.accepted) {
+            onNotice?.('error', result.reason ?? 'Message was not accepted; input is kept in the draft.');
+        }
+        else if (plan.notice) {
+            onNotice?.('warn', plan.notice);
+        }
     };
     const recallUp = () => {
         if (history.length === 0)
@@ -421,9 +452,12 @@ export function PromptInput({ cols: colsProp, cursorVisible = true, onInteractio
     };
     const verticalOrHistory = (dir) => {
         onInteraction?.();
-        const moved = moveVertical(buffer, cursor, dir);
+        const moved = moveVisualCursor({ buffer, cursor, cols: usableCols, direction: dir,
+            preferredVisualColumn: preferredColumnWidth.current === usableCols
+                ? editor.preferredVisualColumn : undefined });
         if (moved) {
-            dispatch({ type: 'moveCursor', cursor: moved.cursor });
+            preferredColumnWidth.current = usableCols;
+            dispatch({ type: 'moveCursor', ...moved });
             return;
         }
         // At an edge: recall history only from an empty buffer or while already
@@ -447,6 +481,16 @@ export function PromptInput({ cols: colsProp, cursorVisible = true, onInteractio
             return;
         if (key.pageUp || key.pageDown || (key.shift && (key.upArrow || key.downArrow)))
             return;
+        if ((key.return || input === '\r') && (key.meta || key.shift)) {
+            insert('\n');
+            return;
+        }
+        if (hasPasteFrame(input) || hasEnterFrame(input) || /[\r\n]/.test(input)) {
+            const intents = splitEnterFrames(input).map((frame) => frame.kind === 'paste' ? { ...frame, id: allocatePasteId() } : frame);
+            if (intents.length > 0)
+                transact(intents);
+            return;
+        }
         // Popup navigation owns Up/Down/Tab/→/Enter/Esc while it is open.
         if (popupVisible) {
             if (key.upArrow) {
@@ -464,9 +508,7 @@ export function PromptInput({ cols: colsProp, cursorVisible = true, onInteractio
                 return;
             }
             if (key.return && popupKind === 'slash') {
-                const label = popupItems[clampedSel]?.label;
-                if (label)
-                    submit(label);
+                transact([{ kind: 'submit' }]);
                 return;
             }
             if (key.escape) {
@@ -481,11 +523,15 @@ export function PromptInput({ cols: colsProp, cursorVisible = true, onInteractio
             return;
         }
         // Line-editing intents (Home/End/word/kill) recognized from raw keys.
-        const intent = recognize(input, key);
+        const intent = key.meta && (key.backspace || key.delete)
+            ? 'deleteWordBack' : recognize(input, key);
         if (intent) {
             onInteraction?.();
             const next = applyEdit(buffer, cursor, intent);
-            dispatch({ type: 'replace', buffer: next.buffer, cursor: next.cursor });
+            const moving = intent === 'home' || intent === 'end'
+                || intent === 'wordLeft' || intent === 'wordRight';
+            dispatch(moving ? { type: 'moveCursor', cursor: next.cursor }
+                : { type: 'replace', buffer: next.buffer, cursor: next.cursor });
             return;
         }
         if (key.ctrl)
@@ -497,7 +543,7 @@ export function PromptInput({ cols: colsProp, cursorVisible = true, onInteractio
             }
             if (buffer.trim().length === 0)
                 return;
-            submit(buffer);
+            transact([{ kind: 'submit' }]);
             return;
         }
         if (key.backspace || key.delete) {
@@ -506,19 +552,17 @@ export function PromptInput({ cols: colsProp, cursorVisible = true, onInteractio
             // unconditional dispatch and a no-op at the left edge returns the same
             // state object — which React bails out on, exactly as the old
             // `if (cursor > 0)` skipped the `setState`s.
-            dispatch({ type: 'backspace' });
+            dispatch({ type: key.delete && deleteDisambiguated ? 'delete' : 'backspace' });
             return;
         }
         if (key.leftArrow) {
             onInteraction?.();
-            const step = cursor >= 2 && (buffer.codePointAt(cursor - 2) ?? 0) > 0xffff ? 2 : 1;
-            dispatch({ type: 'moveCursor', cursor: Math.max(0, cursor - step) });
+            dispatch({ type: 'moveCursor', cursor: stepGrapheme(buffer, cursor, 'left') });
             return;
         }
         if (key.rightArrow) {
             onInteraction?.();
-            const step = (buffer.codePointAt(cursor) ?? 0) > 0xffff ? 2 : 1;
-            dispatch({ type: 'moveCursor', cursor: Math.min(buffer.length, cursor + step) });
+            dispatch({ type: 'moveCursor', cursor: stepGrapheme(buffer, cursor, 'right') });
             return;
         }
         // `!key.shift` is load-bearing: Shift+↑/↓ is the viewport's line-scroll
@@ -537,71 +581,13 @@ export function PromptInput({ cols: colsProp, cursorVisible = true, onInteractio
             onHelp();
             return;
         }
-        // A PASTE (section 5.4). It sits AFTER every key branch so a paste can
-        // never be shadowed by a key test, and BEFORE `isControlSeq` because a
-        // framed string starts with NUL and would otherwise be dropped.
-        //
-        // The text runs inside `segments` are already sanitised (I-14): Ink drains
-        // its whole buffer in one `read()`, so this same string can carry the `\r`
-        // of a user who pasted and pressed Enter inside the burst window.
-        //
-        // NO NEWLINE INTENT IN THE CHUNK (tui-shift-enter-copy-queue 3.5):
-        // that same one-`read()` coalescing means a paste frame can share an
-        // `input` with an enter frame or a bare Ctrl+J, and those chunks
-        // belong to the newline branch below, whose `mergeWithPasteRuns`
-        // interleaves both families in byte order. This branch's
-        // `splitPasteFrames` would strip the enter frame's NUL and leak its
-        // letter as text. A multi-line payload (a `\n` of its own) routes
-        // there too and comes back byte-identical inside its paste segment.
-        if (hasPasteFrame(input) && !hasEnterFrame(input) && !input.includes('\n')) {
-            const runs = splitPasteFrames(input);
-            const segments = runs.map((run) => run.kind === 'paste' ? { kind: 'paste', text: run.text, id: allocatePasteId() } : run);
-            if (segments.length === 0)
-                return;
-            const refusal = draftLimitRefusal(segments, editor);
-            if (refusal) {
-                // A refusal dispatches NOTHING, so the draft is byte-for-byte
-                // unchanged (AC-9) — and it is never silent (D-11).
-                onNotice?.('warn', refusal);
-                return;
-            }
-            onInteraction?.();
-            dispatch({ type: 'input', segments });
-            return;
-        }
-        // A NEWLINE INTENT, from either source (tui-shift-enter-copy-queue
-        // 3.5): the NUL frame the filter wrote for Shift+Enter / Alt+Enter /
-        // CSI-u Enter, or a bare `\n` (Ctrl+J), which Ink delivers WITHOUT
-        // `key.return`. Sits beside the paste branch -- after every key test so
-        // it can never shadow one, before `isControlSeq` because both sources
-        // begin with a control byte and would otherwise be dropped. ONE
-        // dispatch carries the whole ordered chunk, paste runs included when
-        // Ink coalesced the filter's two writes into one input string.
-        if (hasEnterFrame(input) || input.includes('\n')) {
-            const runs = mergeWithPasteRuns(input, splitEnterFrames(input));
-            const segments = runs.map((run) => run.kind === 'paste' ? { kind: 'paste', text: run.text, id: allocatePasteId() } : run);
-            if (segments.length === 0)
-                return;
-            const refusal = draftLimitRefusal(segments, editor);
-            if (refusal) {
-                onNotice?.('warn', refusal);
-                return;
-            }
-            onInteraction?.();
-            dispatch({ type: 'input', segments });
-            return;
-        }
         // Printable input — drop any unrecognized control/escape byte.
         if (input && !key.tab && !isControlSeq(input))
             insert(input);
     }, { isActive });
     const marker = running ? glyphs.steer : glyphs.caret;
     const markerColor = running ? theme.toolRunning : theme.primary;
-    const placeholder = running
-        ? `Type to queue a message, Esc twice to interrupt${glyphs.ellipsis}`
-        : agentMode === 'plan'
-            ? `Describe what you want to build; I'll research and plan it first${glyphs.ellipsis}`
-            : `Send a message (/ for commands, @ for files)${glyphs.ellipsis}`;
+    const placeholder = running ? interactionCopy.runningPlaceholder : interactionCopy.idlePlaceholder;
     const overflow = overflowChip(layout.hiddenAbove, layout.hiddenBelow, glyphs);
     const tokenColor = theme.hintFg ?? theme.muted;
     const renderSegments = (segments, keyPrefix) => segments.map((segment, i) => (_jsx(Text, { color: segment.kind === 'token' ? tokenColor : undefined, children: segment.text }, `${keyPrefix}${i}`)));

package/dist/ui/QueuePanel.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+import type { QueueLayout } from './layout/queue-layout.js';
+import type { Theme } from './theme.js';
+/** Persistent receipt-backed footer, with no timer or separate queue state. */
+export declare const QueuePanel: React.NamedExoticComponent<{
+    layout: QueueLayout;
+    theme: Theme;
+}>;

package/dist/ui/QueuePanel.js

@@ -0,0 +1,9 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import React from 'react';
+import { Box, Text } from 'ink';
+/** Persistent receipt-backed footer, with no timer or separate queue state. */
+export const QueuePanel = React.memo(function QueuePanel({ layout, theme }) {
+    if (!layout.rows)
+        return null;
+    return _jsxs(Box, { flexDirection: "column", flexShrink: 0, height: layout.rows, children: [_jsx(Text, { color: theme.accent, wrap: "truncate", children: layout.title }), layout.rows > 1 && layout.items.map((item) => _jsx(Text, { color: theme.muted, wrap: "truncate", children: item.label }, item.queueId))] });
+});

package/dist/ui/QueueStatusRow.d.ts

@@ -0,0 +1,24 @@
+import React from 'react';
+import type { PendingSteering } from '../agent/queued-messages.js';
+import type { TermCapabilities } from './capabilities.js';
+import type { Theme } from './theme.js';
+export interface QueueStatusRowProps {
+    pending: readonly PendingSteering[];
+    paused: boolean;
+    columns: number;
+    compact: boolean;
+    theme: Theme;
+    caps: TermCapabilities;
+}
+/** Return the first nonempty logical line without terminal control characters. */
+export declare function queueSummary(text: string): string;
+/** Truncate at a whole grapheme, reserving the ellipsis in the same cell budget. */
+export declare function truncateSummary(text: string, columns: number, ellipsis: string): string;
+/** Format a queue using only the columns assigned by the status bar. */
+export declare function formatQueueStatus(props: Omit<QueueStatusRowProps, 'theme'>): {
+    prefix: string;
+    body: string;
+    suffix: string;
+};
+/** Fixed single-line pending receipt feedback; no timeout or spinner. */
+export declare function QueueStatusRow(props: QueueStatusRowProps): React.ReactElement;

package/dist/ui/QueueStatusRow.js

@@ -0,0 +1,51 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Text } from 'ink';
+import stringWidth from 'string-width';
+import stripAnsi from 'strip-ansi';
+import { pickGlyphs } from './glyphs.js';
+const segmenter = new Intl.Segmenter(undefined, { granularity: 'grapheme' });
+/** Return the first nonempty logical line without terminal control characters. */
+export function queueSummary(text) {
+    return stripAnsi(text).split(/\r\n|[\r\n]/)
+        .map((line) => line.replace(/\t/g, ' ').replace(/[\x00-\x1f\x7f-\x9f]/g, '').trim())
+        .find(Boolean) ?? '(empty)';
+}
+/** Truncate at a whole grapheme, reserving the ellipsis in the same cell budget. */
+export function truncateSummary(text, columns, ellipsis) {
+    if (stringWidth(text) <= columns)
+        return text;
+    if (columns < stringWidth(ellipsis))
+        return '';
+    let out = '';
+    let used = stringWidth(ellipsis);
+    for (const { segment } of segmenter.segment(text)) {
+        const width = stringWidth(segment);
+        if (used + width > columns)
+            break;
+        used += width;
+        out += segment;
+    }
+    return out + ellipsis;
+}
+/** Format a queue using only the columns assigned by the status bar. */
+export function formatQueueStatus(props) {
+    if (!props.pending.length)
+        return { prefix: '', body: '', suffix: '' };
+    const prefix = props.paused
+        ? (props.compact ? 'Queue(p): ' : 'Queue (paused): ') : 'Queue: ';
+    const remaining = props.pending.length - 1;
+    const suffix = remaining === 0 ? '' : props.compact
+        ? `(+${remaining > 99 ? '99+' : remaining})` : `(+${remaining} more)`;
+    const tail = suffix ? ` ${suffix}` : '';
+    const budget = Math.max(0, props.columns - stringWidth(prefix + tail));
+    return {
+        prefix,
+        body: truncateSummary(queueSummary(props.pending[0].text), budget, pickGlyphs(props.caps).ellipsis),
+        suffix: tail,
+    };
+}
+/** Fixed single-line pending receipt feedback; no timeout or spinner. */
+export function QueueStatusRow(props) {
+    const parts = formatQueueStatus(props);
+    return _jsxs(Text, { children: [_jsx(Text, { color: props.theme.accent, children: parts.prefix }), _jsxs(Text, { color: props.theme.muted, children: [parts.body, parts.suffix] })] });
+}

package/dist/ui/StatusBar.d.ts

@@ -1,40 +1,27 @@
-/**
- * Status bar (spec §4.8). Width-aware, borderless, EXACTLY one row: a left
- * cluster (run status, model, thinking level) and a right cluster (context
- * gauge, occupancy pair, session total, cost, tokens/sec + elapsed while
- * running, off-bottom `↑N`). Clusters drop out gracefully on narrow terminals.
- *
- * THE RIGHT CLUSTER'S WIDTH LADDER (context-usage-gauge-accuracy §3.6):
- *
- *   >= 96   [####....] 43%  86.0k/200.0k  total 1.2M^ 48.0k v  $3.21  12 tok/s  1m02s
- *   72-95   [####....] 43%  86.0k/200.0k  $3.21
- *   60-71   [####....] 43%  $3.21
- *   < 60    43%  $3.21
- *
- * Dropping the round border here buys back 3 rows of a 24-row terminal — an
- * eighth of the screen was being spent framing a single line of text.
- */
+/** A single row of complete, measured status fields. */
 import React from 'react';
 import type { Theme } from './theme.js';
 import type { TermCapabilities } from './capabilities.js';
 import type { UsageTotal } from '../agent/reducer.js';
 import type { ContextUsageSnapshot } from '../compaction/types.js';
-import { type AgentMode } from '../agent/agent-mode.js';
-interface StatusBarProps {
+import type { AgentMode } from '../agent/agent-mode.js';
+import type { PendingSteering } from '../agent/queued-messages.js';
+import { type RunPhase } from './layout/status-layout.js';
+export interface StatusBarProps {
+    runPhase?: RunPhase;
+    activeTool?: {
+        name: string;
+        toolCallId: string;
+    } | null;
+    runOutcome?: "none" | "ended" | "interrupted" | "failed";
+    reducedMotion?: boolean;
+    waitingForConfirmation?: boolean;
+    stopping?: boolean;
+    pendingSteering?: readonly PendingSteering[];
     interruptHint?: string;
     model: string;
     provider: string;
     usageTotal: UsageTotal;
-    /**
-     * Context occupancy, as one object (context-usage-gauge-accuracy §4.3).
-     *
-     * IT REPLACED FOUR PARALLEL PROPS - `contextTokens`, `contextWindow`,
-     * `contextWindowKnown`, `contextEstimated`. Four props describing one reading
-     * are four chances for a caller to update three of them, which is the props-
-     * layer form of the "many writers" defect this feature removed from the
-     * reducer. `usageTotal` stays separate because it genuinely IS another
-     * quantity: session spend, not occupancy.
-     */
     context: ContextUsageSnapshot;
     status: 'idle' | 'running';
     elapsedMs: number;
@@ -42,157 +29,36 @@ interface StatusBarProps {
     tokPerSec: number;
     theme: Theme;
     caps: TermCapabilities;
-    /**
-     * Lines scrolled off the bottom; > 0 renders `↑N`. Inline mode has no
-     * self-drawn viewport, so it simply never sends anything but 0 — the bar
-     * needs no render-mode branch of its own.
-     */
     scrolledLines?: number;
-    /**
-     * Ctrl+L redraw carrier — invariant I-5 (spec §4.13). See `redrawChar`.
-     */
     redrawNonce?: number;
     agentMode?: AgentMode;
-    /** Non-null while a deferred `plan -> build` waits for `agent_end`. */
     pendingAgentMode?: AgentMode | null;
-    /**
-     * Live subagent counts (team-subagents §6.2), or absent when no dispatch is
-     * running — an ordinary session's bar is then unchanged.
-     *
-     * LEFT CLUSTER, and it degrades (D-20 / P2-1). The left cluster is
-     * `flexShrink={0}`, so every column it takes comes out of the context gauge
-     * and the cost readout opposite it; on an 80-column terminal the full
-     * `agents 3/5` visibly squeezes them, and the gauge is how a user notices they
-     * are about to run out of context. Below `TEAM_LIMITS.statusCompactCols` this
-     * therefore renders as `[3]` — the running count alone.
-     *
-     * This does NOT contradict the "no `cols >= N` breakpoint" rule above: that
-     * rule is written about `agentMode`, whose reason is that the mode must never
-     * be unreportable. The team counter has a second, fuller home in `TeamPanel`
-     * and a third in `TeamCard`; it is the one readout on this bar that can afford
-     * to degrade.
-     */
     teamActive?: {
         running: number;
         total: number;
     };
-    /**
-     * Live todo counts (todo-plan-execution §6.3), or absent.
-     *
-     * `App` sends this ONLY when a list exists AND the rail does not: with the
-     * rail on screen the numbers are already there in a larger typeface, and
-     * duplicating them costs the context gauge columns it cannot spare. This is
-     * therefore the INLINE-MODE and NARROW-TERMINAL fallback for R-d, which is
-     * exactly why it is here rather than being folded into the rail's own gate.
-     *
-     * Degrades below `TODO_LIMITS.statusCompactCols` from `todo 2/7` to `[2/7]`,
-     * the same treatment and the same justification as the team counter's
-     * `agents 3/5` -> `[3]`. See the note on `agentMode` for why that rule does
-     * NOT apply to the mode word.
-     */
     todoActive?: {
         done: number;
         total: number;
     };
-    /**
-     * Live background services (background-service-supervision §3.8), or absent
-     * when none are running — an ordinary session's bar is then unchanged.
-     *
-     * LEFT CLUSTER, after the todo chip, and it DEGRADES rather than hiding below
-     * `PROC_LIMITS.statusCompactCols`. That is the `todoActive` / `teamActive`
-     * ladder rather than `compactionActive`'s hide-below-threshold one, and the
-     * choice is deliberate: `compact` and `fast` describe something the CLI is
-     * doing to itself, whereas this is a PROCESS ON THE USER'S MACHINE HOLDING A
-     * PORT. A narrow terminal is a reason to shorten it, never a reason to stop
-     * saying it.
-     *
-     * `live` counts `starting | ready | running`. The transcript records events
-     * about a service (D-11); this is where "what is running right now" lives,
-     * alongside `/bg` and `bash_output`.
-     */
     servicesActive?: {
         live: number;
     };
-    /**
-     * Live retry state (llm-api-retry-backoff §6.6), or absent when nothing is
-     * retrying — an ordinary session's bar is then unchanged.
-     *
-     * LEFT CLUSTER, after `teamActive`, and it DEGRADES. It is a run-state fact like
-     * `agents 3/5`, and the left cluster is `flexShrink={0}` so every column it takes
-     * comes out of the context gauge; below `RETRY_UI.statusCompactCols` it renders
-     * as `[r3]`.
-     *
-     * This does NOT contradict the "no `cols >= N` breakpoint" rule on `agentMode`
-     * above: that rule exists because the MODE must never be unreportable. The retry
-     * has a second, fuller home in the transcript card, which is exactly why it is
-     * the kind of readout that can afford to shrink.
-     */
     retryActive?: {
         attempt: number;
         max: number;
         secondsLeft: number;
     };
-    /**
-     * Render-governor rung (tui-render-performance L4). `> 0` renders a muted
-     * `eco` chip.
-     *
-     * I-L4-2 — THE GOVERNOR IS USER-VISIBLE, and this is where. A user who cannot
-     * see why the stream got chunkier will conclude the model got slower, and
-     * degrading silently is the one thing a claim of robustness cannot afford.
-     * It sits in the RIGHT cluster next to the other derived numbers and is
-     * suppressed on a narrow terminal, which is the `teamActive` treatment rather
-     * than the `agentMode` one: the mode must never be unreportable, whereas an
-     * eco chip on a 50-column terminal costs the context gauge more than it says.
-     */
     ecoRung?: number;
-    /**
-     * The live fast tier (fast-model-tier §6), or absent when it is off for this
-     * session — in which case an ordinary session's bar is byte-identical.
-     *
-     * RIGHT CLUSTER, next to `eco`, and it DEGRADES below
-     * `FAST_LIMITS.statusCompactCols`. This is the `teamActive` / `ecoRung`
-     * treatment rather than the `agentMode` one, and the distinction is the note
-     * on `agentMode` above: the mode must never be unreportable, whereas the fast
-     * tier has a fuller home in `/fast status` — which is the GUARANTEED reporting
-     * surface — and a chip on a 60-column terminal costs the context gauge more
-     * than it says.
-     *
-     * `inFlight` renders `fast*`, so a review that is taking a while is visible
-     * without a spinner competing with the run's own.
-     */
     fastActive?: {
         inFlight: boolean;
     };
-    /**
-     * Live context compaction (context-auto-compaction §6.2), or absent when it is
-     * off for this session — in which case an ordinary session's bar is unchanged.
-     *
-     * RIGHT CLUSTER, next to `fast` and `eco`, and it DEGRADES below
-     * `COMPACTION_LIMITS.statusCompactCols`. The `teamActive` / `ecoRung` /
-     * `fastActive` treatment rather than the `agentMode` one, for the reason the
-     * note on `agentMode` gives: the mode must never be unreportable, whereas
-     * compaction has a fuller home in `/compact status` — the GUARANTEED reporting
-     * surface (§6.5) — and a chip on a 60-column terminal costs the context gauge
-     * more than it says.
-     *
-     * `inFlight` renders `compacting`, so a summarization that is taking a while is
-     * visible on this row without a spinner competing with the activity line's.
-     */
     compactionActive?: {
         inFlight: boolean;
     };
-    /**
-     * Where the gauge turns amber and red (§6.2).
-     *
-     * ABSENT means today's hardcoded `{ warn: 60, high: 85 }`, so a session with
-     * compaction off renders a byte-identical bar. When present these are
-     * `warnThreshold * 100` and `threshold * 100`, which is what makes the colour
-     * the user sees agree with the number the trigger fires on.
-     */
     gaugeMarks?: {
         warn: number;
         high: number;
     };
 }
 export declare function StatusBar(props: StatusBarProps): React.ReactElement;
-export {};