@aragon-agent/cli 0.6.2 → 0.6.4

package/dist/ui/Composer.d.ts

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

package/dist/ui/Composer.js

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

package/dist/ui/PromptInput.d.ts

@@ -21,8 +21,10 @@
 import React from 'react';
 import type { Theme } from './theme.js';
 import type { TermCapabilities } from './capabilities.js';
+import { pickGlyphs } from './glyphs.js';
 import { type EditIntent } from '../input/keymap.js';
 import { type Suggestion } from './AutocompletePopup.js';
+import { type EditorState, type InputSegment } from './editor-reducer.js';
 import type { AgentMode } from '../agent/agent-mode.js';
 export interface CommandOption {
     name: string;
@@ -63,9 +65,86 @@ interface PromptInputProps {
     bordered?: {
         color?: string;
     };
-    /** Fires only when the draft flips empty ⇄ non-empty, for the border color. */
-    onDraftChange?: (hasDraft: boolean) => void;
+    /**
+     * Fires when the draft flips empty ⇄ non-empty (for the border color) OR when
+     * its ROW COUNT changes (for `layout/budget.ts`) — never per keystroke.
+     *
+     * Widened from `(hasDraft: boolean)` by tui-paste-handling section 5.5. The row
+     * count is what makes I-8 true: the composer's rendered height and the
+     * `draftRows` handed to `viewportRows` have to be the same number, and the only
+     * component that knows the first one is this one. It is reported ALREADY
+     * CLAMPED, so a 218-line draft and a 400-line draft report the same value and
+     * the transcript stops moving once the composer is full (R-12).
+     */
+    onDraftChange?: (state: {
+        hasDraft: boolean;
+        rows: number;
+    }) => void;
+    /**
+     * Tell the user a paste was refused (D-11 / P1-4).
+     *
+     * `PASTE_DRAFT_MAX_BYTES` and `PASTE_MAX_BLOCKS` cannot be enforced in the
+     * filter (it does not know the draft) and cannot be enforced in the reducer (it
+     * is pure, so it can neither raise a toast nor say why it refused). This
+     * component is the only place that holds both facts.
+     */
+    onNotice?: (level: 'warn' | 'error', text: string) => void;
+    /**
+     * Rows of newer output hidden BELOW the viewport — `ScrollViewport`'s offset
+     * (tui-selection-and-scroll-follow §4.2 / G7).
+     *
+     * Rendered as a right-aligned chip ON THE INPUT ROW, INSIDE THE BORDER, which
+     * is what the requirement asks for (输入框内部) and what makes the hint cost
+     * zero rows. It used to take the viewport's own last row, which spent a line of
+     * the user's content exactly when the transcript was longest AND fed the number
+     * back into its own derivation (§3.3).
+     *
+     * IT IS STATE, NOT A HINT. It deliberately ignores `showHint` / `hintsEnabled`
+     * — those govern the teaching row BELOW the box, which fades with experience
+     * and is dropped on a short terminal. "You are 12 rows behind the newest
+     * output" must survive both (T-23).
+     *
+     * Only meaningful in full-screen mode, so it renders only when `bordered` is
+     * set: inline mode has no self-drawn viewport and this is always 0 there.
+     */
+    scrolledLines?: number;
 }
+export interface ScrollChip {
+    text: string;
+    /** FIXED width, so the number gaining a digit cannot re-wrap the draft (P2-4). */
+    cells: number;
+}
+/**
+ * Build the chip, or `null` when the viewport is pinned to the newest output.
+ *
+ * Every glyph comes from `pickGlyphs` and none from a literal (I-5): on a legacy
+ * console this renders `v12` rather than mojibake, and `glyphs.test.ts`'s static
+ * scan fails the build if that rule is broken here.
+ */
+export declare function scrollChip(scrolledLines: number, cols: number, glyphs: ReturnType<typeof pickGlyphs>): ScrollChip | null;
+export interface OverflowChip {
+    text: string;
+    /** FIXED width, so a number gaining a digit cannot re-wrap the draft. */
+    cells: number;
+}
+/**
+ * Build the "there is more draft above / below this window" indicator, or `null`
+ * when the whole draft is on screen.
+ *
+ * Every glyph comes from `pickGlyphs` and none from a literal (I-5): on a legacy
+ * console this renders `^3 v7` rather than mojibake, and `glyphs.test.ts`'s
+ * static scan fails the build if that rule is broken here.
+ */
+export declare function overflowChip(hiddenAbove: number, hiddenBelow: number, glyphs: ReturnType<typeof pickGlyphs>): OverflowChip | null;
+/**
+ * Would these segments push the draft past a limit? Returns the refusal text, or
+ * `null` when the paste is allowed.
+ *
+ * Checked BEFORE `dispatch`, so a refusal dispatches nothing at all and the draft
+ * is left byte-for-byte unchanged (AC-9). The one-dispatch-per-key rule is
+ * unaffected for the same reason.
+ */
+export declare function draftLimitRefusal(segments: InputSegment[], editor: Pick<EditorState, 'pastes'>): string | null;
 /** Apply an edit intent as a pure buffer/cursor transform. */
 export declare function applyEdit(buffer: string, cursor: number, intent: EditIntent): {
     buffer: string;
@@ -94,5 +173,5 @@ export declare function fileTokenAt(buffer: string, cursor: number): {
     end: number;
     query: string;
 } | null;
-export declare function PromptInput({ isActive, running, history, commands, cwd, theme, caps, popupMaxRows, agentMode, onSubmit, onHelp, bordered, onDraftChange, }: PromptInputProps): React.ReactElement;
+export declare function PromptInput({ isActive, running, history, commands, cwd, theme, caps, popupMaxRows, agentMode, onSubmit, onHelp, bordered, onDraftChange, onNotice, scrolledLines, }: PromptInputProps): React.ReactElement;
 export {};

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
@@ -20,12 +20,110 @@ import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
  * rather than from a key.
  */
 import { useEffect, useReducer, useRef, useState } from 'react';
-import { Box, Text, useInput } from 'ink';
+import { Box, Text, useInput, useStdout } from 'ink';
 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)
+// ---------------------------------------------------------------------------
+/** Below this the full sentence does not fit beside a draft; the chip goes terse. */
+const CHIP_FULL_MIN_COLS = 64;
+/**
+ * Ceiling on the number the chip prints, so `chipCells` is a CONSTANT per branch
+ * rather than a function of how far behind the user is (P2-4). Past it the chip
+ * reads `999+`.
+ */
+const CHIP_MAX_N = 999;
+/** `↓ 999+ new lines · PgDn` — the widest form the full branch can produce. */
+const CHIP_FULL_CELLS = 24;
+/** `↓999+` — the widest form the terse branch can produce. */
+const CHIP_TERSE_CELLS = 6;
+/**
+ * Build the chip, or `null` when the viewport is pinned to the newest output.
+ *
+ * Every glyph comes from `pickGlyphs` and none from a literal (I-5): on a legacy
+ * console this renders `v12` rather than mojibake, and `glyphs.test.ts`'s static
+ * scan fails the build if that rule is broken here.
+ */
+export function scrollChip(scrolledLines, cols, glyphs) {
+    if (!Number.isFinite(scrolledLines) || scrolledLines <= 0)
+        return null;
+    const n = Math.floor(scrolledLines);
+    const shown = n > CHIP_MAX_N ? `${CHIP_MAX_N}+` : String(n);
+    if (cols < CHIP_FULL_MIN_COLS) {
+        return { text: `${glyphs.arrowDown}${shown}`, cells: CHIP_TERSE_CELLS };
+    }
+    const noun = n === 1 ? 'line' : 'lines';
+    return {
+        text: `${glyphs.arrowDown} ${shown} new ${noun} ${glyphs.midDot} PgDn`,
+        cells: CHIP_FULL_CELLS,
+    };
+}
+// ---------------------------------------------------------------------------
+// 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)
 // ---------------------------------------------------------------------------
@@ -54,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':
@@ -65,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));
     }
 }
 /**
@@ -138,7 +246,8 @@ function isControlSeq(input) {
 // ---------------------------------------------------------------------------
 // Component
 // ---------------------------------------------------------------------------
-export function PromptInput({ isActive, running, history, commands, cwd, theme, caps, popupMaxRows, agentMode, onSubmit, onHelp, bordered, onDraftChange, }) {
+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;
     const [fileMatches, setFileMatches] = useState([]);
@@ -184,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
@@ -203,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 = () => {
@@ -345,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
@@ -357,30 +539,31 @@ 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);
-    const inputRow = (_jsxs(Box, { flexDirection: "row", children: [_jsxs(Text, { color: markerColor, bold: true, children: [marker, ' '] }), _jsx(Box, { flexDirection: "column", children: buffer.length === 0 ? (_jsx(Text, { color: theme.muted, children: placeholder })) : (lines.map((line, i) => _jsx(Text, { children: line }, i))) })] }));
+    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
+            // is how a later `justifyContent` edit moves it without failing anything.
+            //
+            // `width={chip.cells}` is a FIXED cell, not the chip's natural width
+            // (P2-4). The chip is the only thing on this row whose width changes while
+            // the user is typing — `↓ 9` becomes `↓ 10` becomes `↓ 100` — and every
+            // change would otherwise re-wrap a draft that fills the line.
+            _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;
-}