@aragon-agent/cli 0.6.10 → 0.6.12

package/dist/ui/App.js

@@ -1,4 +1,5 @@
 import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { mergePendingEntries } from '../agent/queued-messages.js';
 /**
  * App — the root Ink component. Owns the view reducer, subscribes to the
  * controller's event stream (with a streaming coalescer), wires global
@@ -18,7 +19,8 @@ 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 { getSecrets, registerSecret } from '../logging/secret-registry.js';
+import { redactText } from '../logging/redact.js';
 import { detectCapabilities } from './capabilities.js';
 import { useStartupNotices, MOUSE_NOTICE_VERSION, VT_INPUT_NOTICE_VERSION, } from './use-startup-notices.js';
 import { getTheme } from './theme.js';
@@ -433,6 +435,11 @@ export function App({ controller, version, initialOverlay, initialPrompt, confir
         // makes stale events inert WITHOUT making the next run's events inert too.
         let generation = controller.runGeneration;
         const unsubscribe = controller.subscribe((event) => {
+            // Receipts describe committed history even when force-stop invalidated the run.
+            if (event.type === 'steering_accepted') {
+                dispatch({ type: 'steeringAccepted', ids: event.ids });
+                return;
+            }
             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
@@ -937,7 +944,7 @@ export function App({ controller, version, initialOverlay, initialPrompt, confir
     // --- Exit snapshot: the only way state reaches cli.tsx (§4.4). ----------
     useEffect(() => {
         publishExitSnapshot({
-            entries: state.entries,
+            entries: mergePendingEntries(state.entries, state.pendingSteering),
             usageTotal: state.usageTotal,
             provider: cfg.provider,
             model: cfg.model,
@@ -947,7 +954,7 @@ export function App({ controller, version, initialOverlay, initialPrompt, confir
             // count (K-6).
             droppedEntries: state.droppedEntries,
         });
-    }, [state.entries, state.usageTotal, state.droppedEntries, cfg.provider, cfg.model]);
+    }, [state.entries, state.pendingSteering, state.usageTotal, state.droppedEntries, cfg.provider, cfg.model]);
     // --- `/perf` snapshot channel (tui-render-performance §5.4). ------------
     //
     // The deps are the two `useCallback`d members, NOT the handle objects: both
@@ -1306,7 +1313,11 @@ export function App({ controller, version, initialOverlay, initialPrompt, confir
         toast,
         persistConfig,
         exit: doExit,
-        submit: (text, opts) => submitMessage(text, opts),
+        submit: (text, opts) => {
+            const result = submitMessage(text, opts);
+            if (!result.accepted)
+                throw new Error(result.reason ?? 'Message was not accepted.');
+        },
         refreshSkills: () => setSkillsNonce((n) => n + 1),
         applyAgentMode: applyMode,
         // Read at command time, so `/todo status` reports the live count rather than
@@ -1361,24 +1372,18 @@ export function App({ controller, version, initialOverlay, initialPrompt, confir
      * start with `/`, recurse into command dispatch.
      */
     const submitMessage = (message, opts = {}) => {
+        if (interactionPhase.current === 'starting') {
+            return { accepted: false, reason: 'A run is still starting. Press Esc twice to cancel.' };
+        }
         // A USER MESSAGE IS A NEW INTENT AND OUTRANKS A QUEUED ONE (AC-19). First
         // line, before the steering branch: a message typed during the grace window
         // must be the one that runs, whichever branch it takes.
         cancelFollowThrough();
         cancelConfirmation();
         if (interactionPhase.current === 'running') {
-            controller.steer(message);
-            // THE TRANSCRIPT ENTRY IS THE FEEDBACK (tui-shift-enter-copy-queue
-            // 5.3). A 2.5 s toast cannot satisfy "until the message is picked
-            // up": the `queued` entry stays visible and is rewritten in place
-            // as the user message it became on the next `turn_start`. Keeping
-            // the toast too would confirm one event twice.
-            dispatch({ type: 'steerQueued', text: message });
-            return;
-        }
-        if (interactionPhase.current === 'starting') {
-            toast('info', 'A run is still starting. Press Esc twice to cancel.');
-            return;
+            const queueId = controller.queueUserMessage(message);
+            dispatch({ type: 'steerQueued', queueId, text: message });
+            return { accepted: true };
         }
         resetInterrupt();
         const sequence = ++submissionSequence.current;
@@ -1401,7 +1406,7 @@ export function App({ controller, version, initialOverlay, initialPrompt, confir
             resetInterrupt();
             autoContinuationRef.current = false;
             dispatch({ type: 'runEnd' }); // reset status; nothing was started
-            return;
+            return { accepted: true };
         }
         // Fire-and-forget: events drive the UI. prompt() never rejects.
         void controller.prompt(message, { todoPolicy: opts.todoPolicy ?? 'new-task' }).then((outcome) => {
@@ -1414,19 +1419,37 @@ export function App({ controller, version, initialOverlay, initialPrompt, confir
             autoContinuationRef.current = false;
             dispatch({ type: 'runEnd' });
         });
+        return { accepted: true };
     };
     submitRef.current = submitMessage;
-    const handleSubmit = async (raw) => {
-        if (interactionPhase.current === 'running' && /^\s*\/(reset|resume)(?:\s|$)/.test(raw)) {
-            notify('warn', 'Interrupt the current run before switching conversations.');
-            return;
+    const executeSlashInput = async (raw) => {
+        // Retain a recoverable command before any asynchronous handler can fail.
+        const safe = redactText(raw, getSecrets());
+        recordPrompt(safe);
+        notify('info', `Command: ${safe}`);
+        try {
+            await runSlashInput(registry, raw, makeCtx);
+        }
+        catch (error) {
+            const reason = error instanceof Error ? error.message : String(error);
+            notify('error', `Command failed: ${redactText(reason, getSecrets())}\nInput: ${safe}`);
+        }
+    };
+    const handleSubmit = (raw) => {
+        const trimmed = raw.trimStart();
+        const slash = trimmed.startsWith('/') && !trimmed.startsWith('//');
+        if (slash && (interactionPhase.current === 'running' || controller.isRunning()) &&
+            /^\/(reset|resume)(?:\s|$)/.test(trimmed)) {
+            return { accepted: false,
+                reason: 'Interrupt the current run before switching conversations.' };
         }
         // Submitting is an unconditional "take me to the newest output" (§4.5).
         setPinToBottomNonce((n) => n + 1);
-        const handled = await runSlashInput(registry, raw, makeCtx);
-        if (handled)
-            return;
-        submitMessage(raw.startsWith('//') ? raw.slice(1) : raw);
+        if (slash) {
+            void executeSlashInput(raw);
+            return { accepted: true };
+        }
+        return submitMessage(trimmed.startsWith('//') ? raw.replace('//', '/') : raw);
     };
     const handleSettingsSave = (values) => {
         // An unusable cap must NOT discard the rest of the form: the same Enter
@@ -1623,11 +1646,15 @@ export function App({ controller, version, initialOverlay, initialPrompt, confir
             (input === 'c' || input === 'C') &&
             (selectionController?.hasPendingSelection() ?? false)) {
             const payload = selectionController.takeSelection();
+            ctrlCArmed.current = false;
+            if (ctrlCTimer.current)
+                clearTimeout(ctrlCTimer.current);
+            ctrlCTimer.current = null;
             if (payload) {
                 const via = copyText(payload.text, terminal?.writeForeign);
                 selectionBridge?.onCopied?.(via, payload.lines, payload.text.length);
-                return; // copied -- no service stop, no arm, no clear
             }
+            return; // A consumed copy intent never becomes exit or service stop.
         }
         selectionController?.clear();
         if (key.ctrl && (input === 'c' || input === 'C')) {
@@ -2046,7 +2073,7 @@ export function App({ controller, version, initialOverlay, initialPrompt, confir
     const modeToggleKey = vtInputWarning ? MODE_TOGGLE_KEYS.fallback : MODE_TOGGLE_KEYS.primary;
     const composer = (_jsx(Composer, { measureRef: composerRef, runRow: runRowEnabled
             ? { activity: runActivity, live: runRowShown && !overlayNode, rowRef: activityRef }
-            : null, cols: contentCols, cursorVisible: cursorVisible, onInteraction: returnToComposer, reducedMotion: cfg.reducedMotion ?? false, onEscape: handleComposerEscape, onEscapeDismiss: cancelConfirmation, isActive: overlay === null && !tooSmall, running: state.status === 'running', history: promptHistory, commands: commandOptions, cwd: controller.getCwd(), showHint: rows >= HINT_MIN_ROWS, submitCount: cfg.submitCount, hintsEnabled: cfg.hints, agentMode: state.agentMode, services: liveServices, modeToggleKey: modeToggleKey, popupMaxRows: popupMaxRows, popupMaxHeight: railLayout.popupMaxHeight, onPopupRowsChange: onPopupRowsChange, scrolledLines: scrolledLines, onDraftRows: onDraftRows, onNotice: notify, theme: theme, caps: caps, onSubmit: (text) => void handleSubmit(text), onHelp: () => dispatch({ type: 'setOverlay', overlay: 'help' }) }));
+            : null, cols: contentCols, cursorVisible: cursorVisible, onInteraction: returnToComposer, reducedMotion: cfg.reducedMotion ?? false, onEscape: handleComposerEscape, onEscapeDismiss: cancelConfirmation, isActive: overlay === null && !tooSmall, running: state.status === 'running', history: promptHistory, commands: commandOptions, cwd: controller.getCwd(), showHint: rows >= HINT_MIN_ROWS, submitCount: cfg.submitCount, hintsEnabled: cfg.hints, agentMode: state.agentMode, services: liveServices, modeToggleKey: modeToggleKey, popupMaxRows: popupMaxRows, popupMaxHeight: railLayout.popupMaxHeight, onPopupRowsChange: onPopupRowsChange, scrolledLines: scrolledLines, onDraftRows: onDraftRows, onNotice: notify, theme: theme, caps: caps, onSubmit: handleSubmit, onHelp: () => dispatch({ type: 'setOverlay', overlay: 'help' }) }));
     const team = state.team ? (_jsx(TeamPanel, { snapshot: state.team, layout: teamLayout, rows: rows, cols: contentCols, reducedMotion: viewReducedMotion, theme: theme, caps: caps })) : null;
     const rail = showRail && state.todos ? (_jsx(TodoPanel, { snapshot: state.todos, width: railWidth, rows: railRows, running: running, reducedMotion: viewReducedMotion, theme: theme, caps: caps })) : null;
     const viewport = (_jsxs(ScrollViewport, { active: overlay === null && !tooSmall, overlay: tooSmall ? null : overlayNode, footer: _jsxs(_Fragment, { children: [team, composer] }), rail: rail, scrollbar: terminal?.scrollbar, composerRef: composerRef, onComposerVisibilityChange: setCursorVisible, activityRef: activityRef, onActivityVisibilityChange: setActivityRowVisible, resetKey: scrollResetKey, intent: scrollIntent, pinToBottomNonce: pinToBottomNonce, onScrolledLinesChange: setScrolledLines, onViewportShiftChange: onViewportShiftChange, tailRowsRef: tailSink, hold: selectionHold, resumeMs: cfg.scrollResumeMs, showScrollIndicator: true, cols: contentCols, theme: theme, caps: caps, children: [opener, _jsx(TranscriptList, { entries: state.entries, expandedToolIds: state.expandedToolIds, thinkingVisible: state.thinkingVisible, reducedMotion: viewReducedMotion, density: density, nowSec: nowSec, theme: theme, caps: caps, windowSize: transcriptWindow, cols: contentCols, heights: heights, mountedSink: mountedCount, tailSink: tailSink })] }));
@@ -2076,7 +2103,7 @@ export function App({ controller, version, initialOverlay, initialPrompt, confir
             // out-ranking it inside this row; with the activity line moved above
             // the input, the row can be free during a run, so the silence is stated
             // here instead of inherited.
-            update: updateSnapshot && !overlayNode && !running && shouldRenderUpdateLine(updateSnapshot) ? (_jsx(UpdateLine, { snapshot: updateSnapshot, compact: cols < UPDATE_LIMITS.statusCompactCols, theme: theme, caps: caps })) : null, theme: theme }), status: _jsx(StatusBar, { interruptHint: interruptGesture.current.phase === 'stopping'
+            update: updateSnapshot && !overlayNode && !running && shouldRenderUpdateLine(updateSnapshot) ? (_jsx(UpdateLine, { snapshot: updateSnapshot, compact: cols < UPDATE_LIMITS.statusCompactCols, theme: theme, caps: caps })) : null, theme: theme }), status: _jsx(StatusBar, { pendingSteering: state.overlay ? undefined : state.pendingSteering, interruptHint: interruptGesture.current.phase === 'stopping'
                 ? 'Esc force-stop' : 'Esc x2 interrupt', model: cfg.model, provider: cfg.provider, usageTotal: state.usageTotal, 
             // ONE OBJECT INSTEAD OF FOUR PARALLEL PROPS (§4.3). The four were a
             // projection of "many sources of truth" into the props layer, and a

package/dist/ui/Composer.d.ts

@@ -17,6 +17,7 @@ import { type DOMElement } from 'ink';
 import type { Theme } from './theme.js';
 import type { TermCapabilities } from './capabilities.js';
 import { pickGlyphs } from './glyphs.js';
+import type { ComposerSubmitResult } from './composer-input.js';
 import { type CommandOption } from './PromptInput.js';
 import { type RunActivity } from './run-status-row.js';
 import { type AgentMode } from '../agent/agent-mode.js';
@@ -109,7 +110,7 @@ export interface ComposerProps {
     onNotice?: (level: 'warn' | 'error', text: string) => void;
     theme: Theme;
     caps: TermCapabilities;
-    onSubmit: (text: string) => void;
+    onSubmit: (text: string) => ComposerSubmitResult;
     onHelp?: () => void;
 }
 /**

package/dist/ui/PromptInput.d.ts

@@ -25,6 +25,7 @@ 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 ComposerSubmitResult } from './composer-input.js';
 import type { AgentMode } from '../agent/agent-mode.js';
 export interface CommandOption {
     name: string;
@@ -51,7 +52,7 @@ interface PromptInputProps {
     /** Total menu rows, including borders and the overflow hint. */
     popupMaxHeight?: number;
     onPopupRowsChange?: (rows: number) => void;
-    onSubmit: (text: string) => void;
+    onSubmit: (text: string) => ComposerSubmitResult;
     onHelp?: () => void;
     onEscape?: () => void;
     onEscapeDismiss?: () => void;

package/dist/ui/PromptInput.js

@@ -28,8 +28,9 @@ 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';
@@ -371,18 +372,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)
@@ -447,6 +472,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 +499,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) {
@@ -497,7 +530,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) {
@@ -537,60 +570,6 @@ 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);

package/dist/ui/QueueStatusRow.d.ts

@@ -0,0 +1,22 @@
+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;
+/** 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. */
+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

@@ -20,7 +20,9 @@ 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';
+import type { PendingSteering } from '../agent/queued-messages.js';
 interface StatusBarProps {
+    pendingSteering?: readonly PendingSteering[];
     interruptHint?: string;
     model: string;
     provider: string;

package/dist/ui/StatusBar.js

@@ -11,6 +11,7 @@ import { COMPACTION_LIMITS } from '../compaction/limits.js';
 import { TEAM_LIMITS } from '../team/limits.js';
 import { TODO_LIMITS } from '../todo/limits.js';
 import { PROC_LIMITS } from '../proc/limits.js';
+import { QueueStatusRow } from './QueueStatusRow.js';
 /** Below this the `eco` chip costs the context gauge more than it is worth. */
 const ECO_MIN_COLS = 72;
 /**
@@ -51,11 +52,40 @@ const NBSP = String.fromCharCode(0x00a0);
 function redrawChar(nonce) {
     return nonce % 2 === 0 ? ' ' : NBSP;
 }
+function queueStateLabels(props, compact) {
+    const mode = props.agentMode ?? 'build';
+    const next = props.pendingAgentMode;
+    const modeLabel = compact ? mode[0].toUpperCase() : mode;
+    const nextLabel = next ? (compact ? next[0].toUpperCase() : next) : '';
+    const stopping = /force|again/i.test(props.interruptHint ?? '');
+    return [
+        nextLabel ? `${modeLabel}>${nextLabel}` : modeLabel,
+        stopping ? (compact ? 'E!' : 'Esc!')
+            : props.status === 'running' ? (compact ? 'E2' : 'Esc x2') : '',
+        props.servicesActive?.live ? (compact ? 'S+' : `svc ${props.servicesActive.live}`) : '',
+        props.todoActive?.total ? (compact ? 'T+'
+            : `todo ${props.todoActive.done}/${props.todoActive.total}`) : '',
+    ].filter(Boolean).join(' ') + ' ';
+}
+function QueueStatusBar(props) {
+    const pending = props.pendingSteering;
+    const normal = queueStateLabels(props, false);
+    const paused = props.status !== 'running';
+    const suffix = pending.length > 1 ? ` (+${pending.length - 1} more)` : '';
+    const minimum = stringWidth((paused ? 'Queue (paused): ' : 'Queue: ') + suffix)
+        + stringWidth(pickGlyphs(props.caps).ellipsis);
+    const compact = stringWidth(normal) + minimum + 1 > props.columns;
+    const labels = compact ? queueStateLabels(props, true) : normal;
+    const columns = props.columns - 1 - stringWidth(labels);
+    return _jsxs(Box, { width: props.columns, height: 1, flexShrink: 0, children: [_jsx(Text, { children: redrawChar(props.redrawNonce ?? 0) }), _jsx(Text, { color: props.theme.noticeWarn, children: labels }), _jsx(QueueStatusRow, { pending: pending, paused: paused, columns: columns, compact: compact, theme: props.theme, caps: props.caps })] });
+}
 export function StatusBar(props) {
     const { model, provider, usageTotal, context, status, elapsedMs, thinkingLevel, tokPerSec, theme, caps, scrolledLines = 0, redrawNonce = 0, agentMode = 'build', pendingAgentMode = null, teamActive, todoActive, servicesActive, retryActive, ecoRung = 0, fastActive, compactionActive, gaugeMarks, } = props;
     const { stdout } = useStdout();
     const cols = stdout?.columns ?? 80;
     const running = status === 'running';
+    if (props.pendingSteering?.length)
+        return _jsx(QueueStatusBar, { ...props, columns: cols });
     const glyphs = pickGlyphs(caps);
     // THE PERCENTAGE IS NOT RECOMPUTED HERE ANY MORE. It arrives already divided
     // and clamped by the same code the compaction trigger reads, which is the

package/dist/ui/composer-input.d.ts

@@ -0,0 +1,28 @@
+import { type EditorState, type InputSegment } from './editor-reducer.js';
+export interface ComposerSubmitResult {
+    accepted: boolean;
+    reason?: string;
+}
+export type ComposerInputIntent = InputSegment | {
+    kind: 'newline';
+} | {
+    kind: 'submit';
+};
+export interface ComposerInputOptions {
+    editor: EditorState;
+    intents: readonly ComposerInputIntent[];
+    resolveSubmit: (editor: EditorState) => string | null;
+    checkPasteLimit: (segments: InputSegment[], editor: EditorState) => string | null;
+}
+export interface ComposerInputPlan {
+    nextEditor: EditorState;
+    rejectedEditor: EditorState;
+    submission?: string;
+    notice?: string;
+    refusal?: string;
+}
+/**
+ * Plan both accepted and rejected drafts before any submission side effect.
+ * Uses caller-assigned paste IDs and pure callbacks; never mutates the source editor.
+ */
+export declare function planComposerInput(options: ComposerInputOptions): ComposerInputPlan;

package/dist/ui/composer-input.js

@@ -0,0 +1,46 @@
+import { editorReducer } from './editor-reducer.js';
+const MORE_INPUT_NOTICE = 'More input is kept in the draft; press Enter to send.';
+/**
+ * Plan both accepted and rejected drafts before any submission side effect.
+ * Uses caller-assigned paste IDs and pure callbacks; never mutates the source editor.
+ */
+export function planComposerInput(options) {
+    let nextEditor = options.editor;
+    let rejectedEditor = options.editor;
+    let acceptedBase = options.editor;
+    let acceptedPastes = [];
+    const rejectedPastes = [];
+    let submission;
+    let notice;
+    for (const intent of options.intents) {
+        if (intent.kind === 'submit') {
+            const text = options.resolveSubmit(nextEditor);
+            if (submission !== undefined) {
+                notice = MORE_INPUT_NOTICE;
+            }
+            else if (text !== null && text.trim().length > 0) {
+                submission = text;
+                nextEditor = editorReducer(nextEditor, { type: 'clear' });
+                acceptedBase = nextEditor;
+                acceptedPastes = [];
+            }
+            continue;
+        }
+        const segment = intent.kind === 'newline'
+            ? { kind: 'text', text: '\n' } : intent;
+        const segments = [segment];
+        if (segment.kind === 'paste') {
+            // Inline pastes have no map entry; count every paste in this callback as before.
+            acceptedPastes.push(segment);
+            rejectedPastes.push(segment);
+            const refusal = options.checkPasteLimit(acceptedPastes, acceptedBase)
+                ?? options.checkPasteLimit(rejectedPastes, options.editor);
+            if (refusal) {
+                return { nextEditor: options.editor, rejectedEditor: options.editor, refusal };
+            }
+        }
+        nextEditor = editorReducer(nextEditor, { type: 'input', segments });
+        rejectedEditor = editorReducer(rejectedEditor, { type: 'input', segments });
+    }
+    return { nextEditor, rejectedEditor, submission, notice };
+}

package/dist/ui/editor-reducer.d.ts

@@ -86,6 +86,11 @@ export type EditorAction = {
 } | {
     type: 'clear';
 }
+/** Only local reducer-planned states may be adopted; prune token payloads again. */
+ | {
+    type: 'adopt';
+    state: EditorState;
+}
 /**
  * ONE chunk of stdin, already split into ordered runs. The only new action,
  * and it is what keeps the one-dispatch-per-key rule true for a chunk that

package/dist/ui/editor-reducer.js

@@ -82,6 +82,8 @@ function withPrune(next) {
 }
 export function editorReducer(state, action) {
     switch (action.type) {
+        case 'adopt':
+            return withPrune(action.state);
         case 'insert': {
             // D-8: typing can never land INSIDE a token. A no-op on a buffer with no
             // tokens, which is every buffer until the first collapse.