@aragon-agent/cli 0.6.3 → 0.6.4

package/dist/ui/PromptInput.js

@@ -1,4 +1,4 @@
-import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
 /**
  * PromptInput (spec §3.6 / §3.10) — a controlled multiline input on Ink's
  * `useInput` with: full line editing (Home/End, word jump/delete, kill-line via
@@ -25,7 +25,12 @@ import { glob as tinyGlob } from 'tinyglobby';
 import { pickGlyphs } from './glyphs.js';
 import { recognize } from '../input/keymap.js';
 import { AutocompletePopup } from './AutocompletePopup.js';
-import { editorReducer, INITIAL_EDITOR_STATE } from './editor-reducer.js';
+import { editorReducer, INITIAL_EDITOR_STATE, } from './editor-reducer.js';
+import { hasPasteFrame, splitPasteFrames } from './paste-frames.js';
+import { allocatePasteId, expandPastes, expandRangeOverTokens } from './paste-tokens.js';
+import { draftMaxRows } from './composer-limits.js';
+import { layoutComposer, splitRowAtColumn } from './composer-rows.js';
+import { PASTE_DRAFT_MAX_BYTES, PASTE_MAX_BLOCKS, formatPasteSize, } from '../input/limits.js';
 // ---------------------------------------------------------------------------
 // The scroll chip (§4.2)
 // ---------------------------------------------------------------------------
@@ -63,6 +68,63 @@ export function scrollChip(scrolledLines, cols, glyphs) {
     };
 }
 // ---------------------------------------------------------------------------
+// The draft overflow indicator (section 5.5)
+// ---------------------------------------------------------------------------
+/** `^3 v7` at its widest, so the cell is a CONSTANT (the P2-4 discipline). */
+const OVERFLOW_CELLS = 12;
+const OVERFLOW_MAX_N = 999;
+/**
+ * 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 function overflowChip(hiddenAbove, hiddenBelow, glyphs) {
+    if (hiddenAbove <= 0 && hiddenBelow <= 0)
+        return null;
+    const show = (n) => (n > OVERFLOW_MAX_N ? `${OVERFLOW_MAX_N}+` : String(n));
+    const parts = [];
+    if (hiddenAbove > 0)
+        parts.push(`${glyphs.arrowUp}${show(hiddenAbove)}`);
+    if (hiddenBelow > 0)
+        parts.push(`${glyphs.arrowDown}${show(hiddenBelow)}`);
+    return { text: parts.join(' '), cells: OVERFLOW_CELLS };
+}
+// ---------------------------------------------------------------------------
+// Draft-level paste limits (section 5.3, the P1-4 enforcement point)
+// ---------------------------------------------------------------------------
+/**
+ * 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 function draftLimitRefusal(segments, editor) {
+    let liveBytes = 0;
+    for (const record of editor.pastes.values())
+        liveBytes += Buffer.byteLength(record.text, 'utf8');
+    let blocks = editor.pastes.size;
+    for (const segment of segments) {
+        if (segment.kind !== 'paste')
+            continue;
+        liveBytes += Buffer.byteLength(segment.text, 'utf8');
+        blocks += 1;
+    }
+    if (blocks > PASTE_MAX_BLOCKS) {
+        return (`Too many pasted blocks in one message (limit is ${PASTE_MAX_BLOCKS}). ` +
+            'Nothing was inserted.');
+    }
+    if (liveBytes > PASTE_DRAFT_MAX_BYTES) {
+        return (`Pasted content in this message would reach ${formatPasteSize(liveBytes)}; ` +
+            `limit is ${formatPasteSize(PASTE_DRAFT_MAX_BYTES)}. Nothing was inserted.`);
+    }
+    return null;
+}
+// ---------------------------------------------------------------------------
 // Pure editing helpers (unit-tested in input.test.ts)
 // ---------------------------------------------------------------------------
 const isSpace = (ch) => !!ch && /\s/.test(ch);
@@ -90,9 +152,25 @@ function nextWord(buffer, cursor) {
         i += 1;
     return i;
 }
+/**
+ * Delete `[from, to)`, first growing the range over any token it clips (G5 /
+ * D-8).
+ *
+ * A no-op growth on a buffer with no tokens, so every pre-existing assertion in
+ * `input.test.ts` holds byte-for-byte. With a token present it is what stops
+ * `Ctrl+W` / `Ctrl+U` / `Ctrl+K` leaving half a label behind — which would be a
+ * label the user then sends INSTEAD of the text it stands for.
+ */
+function killRange(buffer, from, to) {
+    const range = expandRangeOverTokens(buffer, from, to);
+    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) {
     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.
         case 'home':
             return { buffer, cursor: lineStart(buffer, cursor) };
         case 'end':
@@ -101,18 +179,12 @@ export function applyEdit(buffer, cursor, intent) {
             return { buffer, cursor: prevWord(buffer, cursor) };
         case 'wordRight':
             return { buffer, cursor: nextWord(buffer, cursor) };
-        case 'deleteWordBack': {
-            const start = prevWord(buffer, cursor);
-            return { buffer: buffer.slice(0, start) + buffer.slice(cursor), cursor: start };
-        }
-        case 'killToStart': {
-            const start = lineStart(buffer, cursor);
-            return { buffer: buffer.slice(0, start) + buffer.slice(cursor), cursor: start };
-        }
-        case 'killToEnd': {
-            const end = lineEnd(buffer, cursor);
-            return { buffer: buffer.slice(0, cursor) + buffer.slice(end), cursor };
-        }
+        case 'deleteWordBack':
+            return killRange(buffer, prevWord(buffer, cursor), cursor);
+        case 'killToStart':
+            return killRange(buffer, lineStart(buffer, cursor), cursor);
+        case 'killToEnd':
+            return killRange(buffer, cursor, lineEnd(buffer, cursor));
     }
 }
 /**
@@ -174,7 +246,7 @@ function isControlSeq(input) {
 // ---------------------------------------------------------------------------
 // Component
 // ---------------------------------------------------------------------------
-export function PromptInput({ isActive, running, history, commands, cwd, theme, caps, popupMaxRows, agentMode, onSubmit, onHelp, bordered, onDraftChange, scrolledLines = 0, }) {
+export function PromptInput({ isActive, running, history, commands, cwd, theme, caps, popupMaxRows, agentMode, onSubmit, onHelp, bordered, onDraftChange, onNotice, scrolledLines = 0, }) {
     const { stdout } = useStdout();
     const [editor, dispatch] = useReducer(editorReducer, INITIAL_EDITOR_STATE);
     const { buffer, cursor, historyIndex, dismissed, sel } = editor;
@@ -221,18 +293,62 @@ export function PromptInput({ isActive, running, history, commands, cwd, theme,
             clearTimeout(id);
         };
     }, [fileQuery, cwd]);
-    // --- Draft presence, reported only on the transition. ---------------------
-    // Notifying on every keystroke would re-render the whole App tree per key.
+    // --- Layout (section 5.5). -----------------------------------------------
+    //
+    // COMPUTED HERE, ABOVE THE REPORTING EFFECT, because the number the effect
+    // sends upward has to be the number this component actually renders (I-8).
+    // Deriving it twice — once for the frame and once for the budget — is exactly
+    // the trap `BottomStatusRow.tsx:5-27` documents.
+    const glyphs = pickGlyphs(caps);
+    const cols = stdout?.columns ?? 80;
+    const terminalRows = stdout?.rows ?? 24;
+    // Full-screen only: inline mode has no self-drawn viewport, so `scrolledLines`
+    // is always 0 there and the branch is unreachable rather than merely unused.
+    // The guard is explicit so it stays that way.
+    const chip = bordered ? scrollChip(scrolledLines, cols, glyphs) : null;
+    // Err NARROW. Wrapping wider than the box Ink gives us would make Ink wrap a
+    // second time, and then `layout.rows.length` is a lie — which is the one thing
+    // this module may not be.
+    const chromeCols = bordered ? 2 /* border */ + 2 /* paddingX */ + 2 /* marker */ : 2;
+    const baseCols = Math.max(8, cols - chromeCols - (chip ? chip.cells + 1 : 0));
+    const measure = (wrapCols) => layoutComposer({
+        buffer,
+        cursor,
+        cols: wrapCols,
+        maxRows: draftMaxRows(terminalRows),
+        active: isActive,
+    });
+    // TWO PASSES, AND THE SECOND ONE IS LOAD-BEARING (I-8). The overflow indicator
+    // rides the last rendered row INSIDE the box the draft wraps in, so its cells
+    // have to come out of the wrap width. Measured at the full width instead, a
+    // last row that fills the line is wrapped a SECOND time by Ink, and the
+    // composer then draws one row more than `layout.rows.length` — which is the
+    // number this component hands to `viewportRows`. That is defect C again, in
+    // precisely the situation this feature exists for: a draft too tall to show.
+    //
+    // It settles in two. Narrowing can only ADD rows, so a draft that overflowed
+    // the first pass still overflows the second, and a third pass would measure
+    // the same width as the second.
+    const wide = measure(baseCols);
+    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 draftRowCount = Math.max(1, layout.rows.length);
+    // --- Draft presence and height, reported only on a transition. -----------
+    // Notifying on every keystroke would re-render the whole App tree per key. The
+    // row count changes on a line break or a wrap boundary, not per character
+    // (R-6), so widening this callback does not widen how often it fires.
     const hasDraft = buffer.length > 0;
     const lastReportedDraft = useRef(null);
     useEffect(() => {
         if (!onDraftChange)
             return;
-        if (lastReportedDraft.current === hasDraft)
+        const last = lastReportedDraft.current;
+        if (last && last.hasDraft === hasDraft && last.rows === draftRowCount)
             return;
-        lastReportedDraft.current = hasDraft;
-        onDraftChange(hasDraft);
-    }, [hasDraft, onDraftChange]);
+        lastReportedDraft.current = { hasDraft, rows: draftRowCount };
+        onDraftChange({ hasDraft, rows: draftRowCount });
+    }, [hasDraft, draftRowCount, onDraftChange]);
     // --- Mutators. -----------------------------------------------------------
     // ONE DISPATCH EACH, and that is the rule §3.4 asks a reviewer to check line
     // by line. Two dispatches from one key would put the legacy root back to two
@@ -240,8 +356,16 @@ export function PromptInput({ isActive, running, history, commands, cwd, theme,
     const insert = (text) => {
         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) => {
-        onSubmit(text);
+        onSubmit(expandPastes(text, editor.pastes));
         dispatch({ type: 'clear' });
     };
     const recallUp = () => {
@@ -382,11 +506,32 @@ export function PromptInput({ isActive, running, history, commands, cwd, theme,
             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.
+        if (hasPasteFrame(input)) {
+            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;
+            }
+            dispatch({ type: 'input', segments });
+            return;
+        }
         // Printable input — drop any unrecognized control/escape byte.
         if (input && !key.tab && !isControlSeq(input))
             insert(input);
     }, { isActive });
-    const glyphs = pickGlyphs(caps);
     const marker = running ? glyphs.steer : glyphs.caret;
     const markerColor = running ? theme.toolRunning : theme.primary;
     const placeholder = running
@@ -394,12 +539,22 @@ export function PromptInput({ isActive, running, history, commands, cwd, theme,
         : 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 lines = renderWithCursor(buffer, cursor, isActive);
-    // Full-screen only: inline mode has no self-drawn viewport, so `scrolledLines`
-    // is always 0 there and the branch is unreachable rather than merely unused.
-    // The guard is explicit so it stays that way.
-    const chip = bordered ? scrollChip(scrolledLines, stdout?.columns ?? 80, glyphs) : null;
-    const inputRow = (_jsxs(Box, { flexDirection: "row", children: [_jsxs(Text, { color: markerColor, bold: true, children: [marker, ' '] }), _jsx(Box, { flexDirection: "column", flexGrow: 1, flexShrink: 1, children: buffer.length === 0 ? (_jsx(Text, { color: theme.muted, children: placeholder })) : (lines.map((line, i) => _jsx(Text, { children: line }, i))) }), chip && (
+    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}`)));
+    const rowNodes = layout.rows.map((row, i) => {
+        if (i !== layout.cursorRow)
+            return _jsx(_Fragment, { children: renderSegments(row.segments, `s${i}.`) });
+        // The caret is drawn as one inverse cell, split at the column
+        // `layoutComposer` reported — the same width table it wrapped with (I-9).
+        const split = splitRowAtColumn(row, layout.cursorCol);
+        return (_jsxs(_Fragment, { children: [renderSegments(split.before, `b${i}.`), _jsx(Text, { inverse: true, children: split.at ? split.at.text : ' ' }), renderSegments(split.after, `a${i}.`)] }));
+    });
+    const inputRow = (_jsxs(Box, { flexDirection: "row", children: [_jsxs(Text, { color: markerColor, bold: true, children: [marker, ' '] }), _jsx(Box, { flexDirection: "column", flexGrow: 1, flexShrink: 1, children: buffer.length === 0 ? (_jsx(Text, { color: theme.muted, children: placeholder })) : (rowNodes.map((node, i) => overflow && i === rowNodes.length - 1 ? (
+                // The overflow indicator rides the LAST rendered row rather than
+                // taking one of its own: an extra row would put the composer's
+                // real height one above the `draftRows` it just reported (I-8).
+                _jsxs(Box, { flexDirection: "row", children: [_jsx(Box, { flexGrow: 1, flexShrink: 1, children: _jsx(Text, { children: node }) }), _jsx(Box, { flexShrink: 0, width: overflow.cells, justifyContent: "flex-end", children: _jsx(Text, { wrap: "truncate", color: theme.hintFg ?? theme.muted, children: overflow.text }) })] }, i)) : (_jsx(Text, { children: node }, i)))) }), chip && (
             // `alignSelf="flex-start"` pins the chip to the FIRST row of a multi-line
             // draft. Yoga's default `stretch` sizes this box to the full height of the
             // editor; it renders on the top row either way today, and relying on that
@@ -412,26 +567,3 @@ export function PromptInput({ isActive, running, history, commands, cwd, theme,
             _jsx(Box, { flexShrink: 0, alignSelf: "flex-start", marginLeft: 1, width: chip.cells, justifyContent: "flex-end", children: _jsx(Text, { wrap: "truncate", color: theme.hintFg ?? theme.muted, children: chip.text }) }))] }));
     return (_jsxs(Box, { flexDirection: "column", flexShrink: 0, children: [popupItems.length > 0 && (_jsx(AutocompletePopup, { items: popupItems, selected: clampedSel, theme: theme, caps: caps, maxRows: popupMaxRows })), bordered ? (_jsx(Box, { flexDirection: "column", flexShrink: 0, borderStyle: glyphs.boxStyle, borderColor: bordered.color, paddingX: 1, children: inputRow })) : (inputRow)] }));
 }
-/** Split the buffer into lines and render an inverse cursor at `cursor`. */
-function renderWithCursor(buffer, cursor, active) {
-    if (!active)
-        return buffer.split('\n');
-    const before = buffer.slice(0, cursor);
-    const at = buffer[cursor] ?? ' ';
-    const after = buffer.slice(cursor + 1);
-    const beforeLines = before.split('\n');
-    const afterLines = after.split('\n');
-    const nodes = [];
-    const lastBeforeIdx = beforeLines.length - 1;
-    for (let i = 0; i < lastBeforeIdx; i += 1) {
-        nodes.push(_jsx(Text, { children: beforeLines[i] }, `b${i}`));
-    }
-    const cursorChar = at === '\n' ? ' ' : at;
-    const firstAfter = afterLines[0] ?? '';
-    nodes.push(_jsxs(Text, { children: [beforeLines[lastBeforeIdx], _jsx(Text, { inverse: true, children: cursorChar }), at === '\n' ? '' : firstAfter] }, "cursor-line"));
-    const remainingAfter = at === '\n' ? afterLines : afterLines.slice(1);
-    for (let i = 0; i < remainingAfter.length; i += 1) {
-        nodes.push(_jsx(Text, { children: remainingAfter[i] }, `a${i}`));
-    }
-    return nodes;
-}

package/dist/ui/StatusBar.d.ts

@@ -88,6 +88,25 @@ interface StatusBarProps {
         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.

package/dist/ui/StatusBar.js

@@ -9,6 +9,7 @@ import { FAST_LIMITS } from '../fast/limits.js';
 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';
 /** Below this the `eco` chip costs the context gauge more than it is worth. */
 const ECO_MIN_COLS = 72;
 /**
@@ -30,7 +31,7 @@ function redrawChar(nonce) {
     return nonce % 2 === 0 ? ' ' : NBSP;
 }
 export function StatusBar(props) {
-    const { model, provider, usageTotal, contextTokens, contextWindow, contextWindowKnown, status, elapsedMs, thinkingLevel, tokPerSec, theme, caps, scrolledLines = 0, redrawNonce = 0, agentMode = 'build', pendingAgentMode = null, teamActive, todoActive, retryActive, ecoRung = 0, fastActive, compactionActive, gaugeMarks, contextEstimated = false, } = props;
+    const { model, provider, usageTotal, contextTokens, contextWindow, contextWindowKnown, status, elapsedMs, thinkingLevel, tokPerSec, theme, caps, scrolledLines = 0, redrawNonce = 0, agentMode = 'build', pendingAgentMode = null, teamActive, todoActive, servicesActive, retryActive, ecoRung = 0, fastActive, compactionActive, gaugeMarks, contextEstimated = false, } = props;
     const { stdout } = useStdout();
     const cols = stdout?.columns ?? 80;
     const running = status === 'running';
@@ -66,5 +67,7 @@ export function StatusBar(props) {
                                 ? `agents ${teamActive.running}/${teamActive.total}`
                                 : `[${teamActive.running}]`] })), retryActive && (_jsxs(Text, { color: theme.noticeWarn, bold: true, children: ['  ', formatRetryChip(retryActive, cols)] })), todoActive && (_jsxs(Text, { color: theme.accent, children: ['  ', cols >= TODO_LIMITS.statusCompactCols
                                 ? `todo ${todoActive.done}/${todoActive.total}`
-                                : `[${todoActive.done}/${todoActive.total}]`] })), cols >= 60 && (_jsxs(Text, { color: theme.muted, children: ['  ', provider, ":", model] })), thinkingLevel !== 'off' && cols >= 72 && (_jsxs(Text, { color: theme.accent, children: ["  think:", thinkingLevel] }))] }), _jsxs(Box, { flexDirection: "row", children: [compactionActive && cols >= COMPACTION_LIMITS.statusCompactCols && (_jsxs(Text, { color: compactionActive.inFlight ? theme.accent : theme.muted, children: [compactionActive.inFlight ? 'compacting' : 'compact', '  '] })), fastActive && cols >= FAST_LIMITS.statusCompactCols && (_jsxs(Text, { color: theme.muted, children: ["fast", fastActive.inFlight ? '*' : '', '  '] })), ecoRung > 0 && cols >= ECO_MIN_COLS && (_jsxs(Text, { color: theme.muted, children: ["eco", '  '] })), scrolledLines > 0 && (_jsxs(Text, { color: theme.noticeWarn, children: [glyphs.arrowUp, scrolledLines, '  '] })), cols >= 60 && (_jsxs(Text, { children: [_jsx(Text, { color: theme.muted, children: "[" }), _jsx(Text, { color: gauge.fillColor, children: gauge.filled }), _jsx(Text, { color: gauge.trackColor, children: gauge.empty }), _jsx(Text, { color: theme.muted, children: "] " })] })), _jsx(Text, { color: theme.muted, children: pctLabel }), cols >= 72 && _jsxs(Text, { color: theme.muted, children: ["  ", tokens] }), _jsxs(Text, { color: theme.muted, children: ["  ", formatCost(usageTotal.costUsd)] }), running && (_jsxs(Text, { color: theme.muted, children: [tokPerSec > 0 && cols >= 72 ? `  ${tokPerSec} tok/s` : '', "  ", formatDuration(elapsedMs)] }))] })] }));
+                                : `[${todoActive.done}/${todoActive.total}]`] })), servicesActive && (_jsxs(Text, { color: theme.accent, children: ['  ', cols >= PROC_LIMITS.statusCompactCols
+                                ? `svc ${servicesActive.live}`
+                                : `[${servicesActive.live}]`] })), cols >= 60 && (_jsxs(Text, { color: theme.muted, children: ['  ', provider, ":", model] })), thinkingLevel !== 'off' && cols >= 72 && (_jsxs(Text, { color: theme.accent, children: ["  think:", thinkingLevel] }))] }), _jsxs(Box, { flexDirection: "row", children: [compactionActive && cols >= COMPACTION_LIMITS.statusCompactCols && (_jsxs(Text, { color: compactionActive.inFlight ? theme.accent : theme.muted, children: [compactionActive.inFlight ? 'compacting' : 'compact', '  '] })), fastActive && cols >= FAST_LIMITS.statusCompactCols && (_jsxs(Text, { color: theme.muted, children: ["fast", fastActive.inFlight ? '*' : '', '  '] })), ecoRung > 0 && cols >= ECO_MIN_COLS && (_jsxs(Text, { color: theme.muted, children: ["eco", '  '] })), scrolledLines > 0 && (_jsxs(Text, { color: theme.noticeWarn, children: [glyphs.arrowUp, scrolledLines, '  '] })), cols >= 60 && (_jsxs(Text, { children: [_jsx(Text, { color: theme.muted, children: "[" }), _jsx(Text, { color: gauge.fillColor, children: gauge.filled }), _jsx(Text, { color: gauge.trackColor, children: gauge.empty }), _jsx(Text, { color: theme.muted, children: "] " })] })), _jsx(Text, { color: theme.muted, children: pctLabel }), cols >= 72 && _jsxs(Text, { color: theme.muted, children: ["  ", tokens] }), _jsxs(Text, { color: theme.muted, children: ["  ", formatCost(usageTotal.costUsd)] }), running && (_jsxs(Text, { color: theme.muted, children: [tokPerSec > 0 && cols >= 72 ? `  ${tokPerSec} tok/s` : '', "  ", formatDuration(elapsedMs)] }))] })] }));
 }

package/dist/ui/Transcript.js

@@ -40,6 +40,7 @@ import { TodoCard, todoCardColor } from './entries/TodoCard.js';
 import { RetryCard, retryCardColor } from './entries/RetryCard.js';
 import { FastCard, fastCardColor } from './entries/FastCard.js';
 import { CompactionCard, compactionCardColor } from './entries/CompactionCard.js';
+import { ServiceCard, serviceCardColor, serviceGlyph } from './entries/ServiceCard.js';
 import { MeasuredEntry } from './layout/MeasuredEntry.js';
 import { useViewportGeometry } from './layout/viewport-geometry.js';
 import { estimateEntryRows, heightKey, selectWindow, VIRTUAL_LIMITS, } from './layout/virtual-window.js';
@@ -107,6 +108,31 @@ export function computeSettledCount(entries, expandedToolIds) {
         // which is the other half.
         if (e.kind === 'compaction' && e.live)
             break;
+        /**
+         * A SERVICE BLOCKS ONLY WHILE IT IS `starting` (D-11 / P0-4).
+         *
+         * Every clause above is bounded by an OPERATION — a dispatch, a turn, one
+         * LLM call, one countdown — which is why each of them can safely pin this
+         * prefix scan: the wait is short and it ends. A service is bounded by the
+         * USER'S INTENT. A dev server left up for an hour is the normal case, not
+         * the pathological one, so treating it like the other five would pin the
+         * boundary at the card and re-render the whole transcript from there on
+         * EVERY FRAME, FOREVER, on exactly the long sessions where it is least
+         * likely to be noticed.
+         *
+         * `starting` is different, and it is different for the reason that makes
+         * every other clause here legitimate: it is bounded by `readyTimeoutMs`,
+         * after which the supervisor calls the service `running` whatever happened.
+         *
+         * The cost of the rest is that a printed card stops mirroring live state —
+         * which is what a transcript IS. A terminal transition appends a NEW one-row
+         * entry rather than rewriting a card `<Static>` has already drawn, and live
+         * state lives in the status chip, `/bg` and `bash_output`. Weakening this to
+         * "any non-terminal service blocks" is the change D-11 exists to prevent;
+         * see condition 5 of the design's review verdict before making it.
+         */
+        if (e.kind === 'service' && e.status === 'starting')
+            break;
         count = i + 1;
     }
     return count;
@@ -148,7 +174,7 @@ function EntryViewImpl({ entry, prev, expanded, thinkingVisible, reducedMotion,
     const frame = (glyph, color, children) => (_jsx(EntryFrame, { glyph: glyph, color: color, continuation: glyphs.railVertical, separation: separation, spacerColor: theme.border, children: children }));
     switch (entry.kind) {
         case 'user':
-            return frame(glyphs.user, theme.user, _jsx(UserEntry, { text: entry.text, theme: theme }));
+            return frame(glyphs.user, theme.user, _jsx(UserEntry, { text: entry.text, theme: theme, caps: caps }));
         case 'assistant': {
             // While text streams, the spinner IS the role marker. Braille dots are
             // both an animation and a Unicode-only glyph, so reduced motion and an
@@ -208,6 +234,8 @@ function EntryViewImpl({ entry, prev, expanded, thinkingVisible, reducedMotion,
                 elapsedMs: entry.live && nowSec !== undefined && entry.startedAt !== undefined
                     ? Math.max(0, nowSec * 1000 - entry.startedAt)
                     : undefined, live: entry.live, expanded: expanded, reducedMotion: reducedMotion, theme: theme, caps: caps }));
+        case 'service':
+            return frame(serviceGlyph(entry, glyphs), serviceCardColor(entry, theme), _jsx(ServiceCard, { serviceId: entry.serviceId, command: entry.command, status: entry.status, url: entry.url, port: entry.port, exitCode: entry.exitCode, startedAt: entry.startedAt, readyAt: entry.readyAt, endedAt: entry.endedAt, rows: entry.rows, terminal: entry.terminal, killIncomplete: entry.killIncomplete, expanded: expanded, reducedMotion: reducedMotion, theme: theme, caps: caps }));
         case 'notice':
             return frame(noticeSymbol(entry.level, theme), noticeColor(entry.level, theme), _jsx(Text, { color: noticeColor(entry.level, theme), children: entry.text }));
         default:

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

@@ -0,0 +1,31 @@
+/**
+ * Composer and transcript row ceilings (tui-paste-handling section 5.5 / 5.6).
+ *
+ * Structural, not policy (D-10): the only user-facing key this feature adds is
+ * the boolean `paste`. Everything here is a bound that keeps the frame's row
+ * arithmetic true, and every one of them is switchable by returning a larger
+ * number rather than by a config flag.
+ */
+/** At or below BOTH of these a paste is inserted verbatim rather than collapsed. */
+export declare const PASTE_INLINE_MAX_LINES = 6;
+export declare const PASTE_INLINE_MAX_CHARS = 400;
+/**
+ * Rows one submitted user message may RENDER in the transcript, before the
+ * `... +N more lines` tail (G7).
+ *
+ * `ui/layout/virtual-window.ts` imports this rather than duplicating the number,
+ * unlike `DIFF_COLLAPSED_LINES` / `TOOL_LIVE_TAIL_ROWS` beside it: I-13 makes the
+ * render cap and the height estimate THE SAME NUMBER, and there is no
+ * import-cycle reason here for them to be two.
+ */
+export declare const USER_ENTRY_MAX_ROWS = 40;
+/**
+ * Ceiling on the composer's DRAFT rows at a given terminal height.
+ *
+ * Non-decreasing in `terminalRows`. Returning `Infinity` reduces the whole
+ * height-bound layer to the rung below it (section 12, S4), which is what makes
+ * that stage revertible on its own.
+ */
+export declare function draftMaxRows(terminalRows: number): number;
+/** The terminal height at which `draftMaxRows` steps from 3 to 6. Pinned by test. */
+export declare const DRAFT_MAX_ROWS_HINT_TIER = 20;

package/dist/ui/composer-limits.js

@@ -0,0 +1,50 @@
+/**
+ * Composer and transcript row ceilings (tui-paste-handling section 5.5 / 5.6).
+ *
+ * Structural, not policy (D-10): the only user-facing key this feature adds is
+ * the boolean `paste`. Everything here is a bound that keeps the frame's row
+ * arithmetic true, and every one of them is switchable by returning a larger
+ * number rather than by a config flag.
+ */
+/** At or below BOTH of these a paste is inserted verbatim rather than collapsed. */
+export const PASTE_INLINE_MAX_LINES = 6;
+export const PASTE_INLINE_MAX_CHARS = 400;
+/**
+ * Rows one submitted user message may RENDER in the transcript, before the
+ * `... +N more lines` tail (G7).
+ *
+ * `ui/layout/virtual-window.ts` imports this rather than duplicating the number,
+ * unlike `DIFF_COLLAPSED_LINES` / `TOOL_LIVE_TAIL_ROWS` beside it: I-13 makes the
+ * render cap and the height estimate THE SAME NUMBER, and there is no
+ * import-cycle reason here for them to be two.
+ */
+export const USER_ENTRY_MAX_ROWS = 40;
+/**
+ * The terminal height at which the composer's hint row starts to fit.
+ *
+ * DELIBERATELY A SECOND COPY of `ui/layout/budget.ts::HINT_MIN_ROWS` rather than
+ * an import: `budget.ts` calls `draftMaxRows` to clamp its composer term, so an
+ * import in this direction would close an ESM cycle whose only protection is
+ * that neither side reads the other at module scope -- true today, and a
+ * confusing TDZ crash the first time someone hoists a use. `budget.test.ts`
+ * asserts the two numbers are equal, so they cannot drift in silence.
+ */
+const DRAFT_TIER_MIN_ROWS = 20;
+/**
+ * Ceiling on the composer's DRAFT rows at a given terminal height.
+ *
+ * Non-decreasing in `terminalRows`. Returning `Infinity` reduces the whole
+ * height-bound layer to the rung below it (section 12, S4), which is what makes
+ * that stage revertible on its own.
+ */
+export function draftMaxRows(terminalRows) {
+    if (!Number.isFinite(terminalRows))
+        return 3;
+    if (terminalRows >= 30)
+        return 10;
+    if (terminalRows >= DRAFT_TIER_MIN_ROWS)
+        return 6;
+    return 3;
+}
+/** The terminal height at which `draftMaxRows` steps from 3 to 6. Pinned by test. */
+export const DRAFT_MAX_ROWS_HINT_TIER = DRAFT_TIER_MIN_ROWS;

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

@@ -0,0 +1,73 @@
+/**
+ * Composer layout (tui-paste-handling section 5.5) -- pure. No Ink, no React.
+ *
+ * THE ONE PLACE THAT MAPS A BUFFER INDEX TO A SCREEN CELL (I-9). The composer
+ * used to hand its buffer to Ink one `<Text>` per logical line and let Yoga wrap
+ * it, which is fine until the draft is taller than the frame: `AppShell` gives
+ * the bottom chrome `flexShrink={0}`, so a tall composer does not grow the frame
+ * -- Yoga takes the rows out of the transcript and `overflow: hidden` clips them
+ * away, while `layout/budget.ts` keeps telling five consumers the composer is
+ * three rows tall. Four hundred presses of `Shift+Enter` do it without pasting
+ * anything.
+ *
+ * So the wrap happens HERE, the row count is a number this module returns, and
+ * `budget.ts` is told that number (I-8).
+ *
+ * HARD WRAP BY DISPLAY COLUMN, NEVER `layout/wrap-rows.ts::wrapToRows` (D-15).
+ * That function is a PROSE wrapper: it splits on `/\s+/` and rejoins with single
+ * spaces, so it destroys indentation and makes the character-index-to-screen-cell
+ * mapping the caret depends on impossible to state, let alone compute.
+ */
+export interface ComposerSegment {
+    readonly text: string;
+    readonly kind: 'text' | 'token';
+}
+export interface ComposerRow {
+    readonly segments: ComposerSegment[];
+}
+export interface ComposerLayout {
+    /** At most `maxRows`, and always containing the caret when `active`. */
+    readonly rows: ComposerRow[];
+    /** Index into `rows`, or -1 when the composer is not focused. */
+    readonly cursorRow: number;
+    /** Display column within that row. */
+    readonly cursorCol: number;
+    /** Rows the buffer occupies BEFORE the window was applied. */
+    readonly totalRows: number;
+    readonly hiddenAbove: number;
+    readonly hiddenBelow: number;
+}
+export interface ComposerLayoutInput {
+    readonly buffer: string;
+    readonly cursor: number;
+    readonly cols: number;
+    readonly maxRows: number;
+    readonly active: boolean;
+}
+/** Total display width of a run, using the same table the layout used. */
+export declare function displayWidth(text: string): number;
+/**
+ * Wrap `buffer` into rows, locate the caret, and select a window of at most
+ * `maxRows` rows that contains it.
+ *
+ * The window is pinned to the BOTTOM -- where the user is typing -- and pulled up
+ * only far enough to keep the caret visible. That is deterministic, which matters
+ * because this function holds no state between calls: a scroll offset would have
+ * to live in the reducer and would then need its own invalidation rules.
+ */
+export declare function layoutComposer(input: ComposerLayoutInput): ComposerLayout;
+export interface RowSplit {
+    readonly before: ComposerSegment[];
+    /** The one cell the caret sits on, or `null` when it sits past the last one. */
+    readonly at: ComposerSegment | null;
+    readonly after: ComposerSegment[];
+}
+/**
+ * Split one row at a display column so the renderer can draw an inverse caret on
+ * exactly one cell.
+ *
+ * Lives here rather than in the component because it walks the SAME width table
+ * `layoutComposer` walked (I-9): a second, subtly different measurement is how
+ * the caret ends up drawn on a cell that does not hold the character it is on.
+ */
+export declare function splitRowAtColumn(row: ComposerRow, column: number): RowSplit;