@aragon-agent/cli 0.6.27 → 0.6.29

package/dist/input/paste-parse.d.ts

@@ -56,16 +56,28 @@ export declare function classifyChunk(text: string, minBurstChars?: number): 'pa
  *    newline in pasted text, and a lone LF is dropped by Ink's key parser
  *    entirely, so both have to be normalised here or a pasted line break either
  *    submits the message or silently vanishes.
- * 2. Every C0 byte except `\n` and `\t` is removed. Ink writes `<Text>` children
- *    to the terminal without escaping anything, so a surviving `\r` overwrites
- *    the row it is drawn on and a surviving `\x1b` repaints the frame's colours.
- * 3. DEL and every C1 byte (U+0080..U+009F) go too, and that is NOT padding:
- *    U+009B is the single-byte CSI and U+0085 is NEL, and a terminal that decodes
- *    them acts on them exactly as it acts on `\x1b[`. A file pasted out of a
- *    non-UTF-8 editor walks straight through a "strip C0" rule.
- * 4. TAB is KEPT. Indentation is content, and it is what the model receives.
+ * 2. Every escape SEQUENCE is removed AS A SEQUENCE (`stripControlSequences`).
+ *    Deleting only the introducer byte is what produced the reported defect:
+ *    `ESC [ 3 8 ; 2 ; 1 8 ; 5 2 ; 8 6 m` minus its ESC is `[38;2;18;52;86m`,
+ *    a run of digits Ink then writes to the terminal as ordinary text -- and it
+ *    reached the model, the prompt history and the session file too, because
+ *    this function is the only cleaning the payload ever gets.
+ * 3. Every remaining C0 byte except `\n` and `\t` is removed. Ink writes
+ *    `<Text>` children to the terminal without escaping anything, so a
+ *    surviving `\r` overwrites the row it is drawn on and a surviving `ESC`
+ *    repaints the frame colours. Sequences are gone by this point, so what is
+ *    left for this step is a stray byte, never half of one.
+ * 4. DEL and every C1 byte (U+0080..U+009F) go too, and that is NOT padding:
+ *    U+009B is the single-byte CSI and U+0085 is NEL, and a terminal that
+ *    decodes them acts on them exactly as it acts on `ESC [`. A file pasted out
+ *    of a non-UTF-8 editor walks straight through a "strip C0" rule.
+ * 5. TAB is KEPT. Indentation is content, and it is what the model receives.
+ *    Expanding it is the RENDERERS' job (`ui/display-tab.ts`), so the model
+ *    keeps the original indentation while the screen, the composer and the
+ *    terminal all agree on what column a TAB lands on.
  *
  * Applied to PAYLOAD ONLY, never to keystrokes, so `Ctrl+A` and Escape keep
- * working. Non-ASCII text (CJK, emoji) is untouched.
+ * working. Non-ASCII text (CJK, emoji) is untouched. Idempotent, so the
+ * second pass in `ui/paste-frames.ts` stays a byte-identical no-op.
  */
 export declare function sanitisePaste(raw: string): string;

package/dist/input/paste-parse.js

@@ -16,6 +16,7 @@
  * `DECSET 2004`. Both are about what a keyboard can physically emit.
  */
 import { PASTE_MIN_BURST_CHARS } from './limits.js';
+import { stripControlSequences } from './control-sequences.js';
 /** `DECSET 2004` wraps a paste in these two markers. */
 export const PASTE_BEGIN_MARK = '\x1b[200~';
 export const PASTE_END_MARK = '\x1b[201~';
@@ -76,20 +77,31 @@ export function classifyChunk(text, minBurstChars = PASTE_MIN_BURST_CHARS) {
  *    newline in pasted text, and a lone LF is dropped by Ink's key parser
  *    entirely, so both have to be normalised here or a pasted line break either
  *    submits the message or silently vanishes.
- * 2. Every C0 byte except `\n` and `\t` is removed. Ink writes `<Text>` children
- *    to the terminal without escaping anything, so a surviving `\r` overwrites
- *    the row it is drawn on and a surviving `\x1b` repaints the frame's colours.
- * 3. DEL and every C1 byte (U+0080..U+009F) go too, and that is NOT padding:
- *    U+009B is the single-byte CSI and U+0085 is NEL, and a terminal that decodes
- *    them acts on them exactly as it acts on `\x1b[`. A file pasted out of a
- *    non-UTF-8 editor walks straight through a "strip C0" rule.
- * 4. TAB is KEPT. Indentation is content, and it is what the model receives.
+ * 2. Every escape SEQUENCE is removed AS A SEQUENCE (`stripControlSequences`).
+ *    Deleting only the introducer byte is what produced the reported defect:
+ *    `ESC [ 3 8 ; 2 ; 1 8 ; 5 2 ; 8 6 m` minus its ESC is `[38;2;18;52;86m`,
+ *    a run of digits Ink then writes to the terminal as ordinary text -- and it
+ *    reached the model, the prompt history and the session file too, because
+ *    this function is the only cleaning the payload ever gets.
+ * 3. Every remaining C0 byte except `\n` and `\t` is removed. Ink writes
+ *    `<Text>` children to the terminal without escaping anything, so a
+ *    surviving `\r` overwrites the row it is drawn on and a surviving `ESC`
+ *    repaints the frame colours. Sequences are gone by this point, so what is
+ *    left for this step is a stray byte, never half of one.
+ * 4. DEL and every C1 byte (U+0080..U+009F) go too, and that is NOT padding:
+ *    U+009B is the single-byte CSI and U+0085 is NEL, and a terminal that
+ *    decodes them acts on them exactly as it acts on `ESC [`. A file pasted out
+ *    of a non-UTF-8 editor walks straight through a "strip C0" rule.
+ * 5. TAB is KEPT. Indentation is content, and it is what the model receives.
+ *    Expanding it is the RENDERERS' job (`ui/display-tab.ts`), so the model
+ *    keeps the original indentation while the screen, the composer and the
+ *    terminal all agree on what column a TAB lands on.
  *
  * Applied to PAYLOAD ONLY, never to keystrokes, so `Ctrl+A` and Escape keep
- * working. Non-ASCII text (CJK, emoji) is untouched.
+ * working. Non-ASCII text (CJK, emoji) is untouched. Idempotent, so the
+ * second pass in `ui/paste-frames.ts` stays a byte-identical no-op.
  */
 export function sanitisePaste(raw) {
-    return raw
-        .replace(/\r\n?/g, '\n')
+    return stripControlSequences(raw.replace(/\r\n?/g, '\n'))
         .replace(/[\u0000-\u0008\u000B\u000C\u000E-\u001F\u007F-\u009F]/g, '');
 }

package/dist/input/stdin-filter.js

@@ -33,8 +33,9 @@
  */
 import { PassThrough } from 'node:stream';
 import { MAX_PENDING_MOUSE_CHARS, splitMouseEvents, isMousePrefix, } from './mouse-events.js';
-import { ENTER_NEWLINE_FRAME, PASTE_ASSEMBLY_MAX_MS, PASTE_BURST_MS, PASTE_CLOSE, PASTE_MAX_BYTES, PASTE_OPEN, formatPasteSize, } from './limits.js';
-import { PASTE_BEGIN_MARK, PASTE_END_MARK, classifyChunk, sanitisePaste, trailingPastePrefixLength, } from './paste-parse.js';
+import { ENTER_NEWLINE_FRAME, INDEX_KEY_FRAME, PASTE_ASSEMBLY_MAX_MS, PASTE_BURST_MS, PASTE_CLOSE, PASTE_MARKER_RESCAN_TTL_MS, PASTE_MAX_BYTES, PASTE_OPEN, formatPasteSize, } from './limits.js';
+import { PASTE_BEGIN_MARK, PASTE_END_MARK, classifyChunk, isPastePrefix, sanitisePaste, trailingPastePrefixLength, } from './paste-parse.js';
+import { hasPasteOnlySequence } from './control-sequences.js';
 import { splitEnterSequences, trailingEnterPrefixLength } from './enter-sequences.js';
 import { splitCsiUKeys, trailingCsiUPrefixLength, translateCsiUKey } from './csiu-keys.js';
 import { splitWin32KeySequences, trailingWin32PrefixLength, translateWin32Key, } from './win32-input-mode.js';
@@ -96,6 +97,23 @@ export function createStdinFilter(real, features, bridge, onWarn) {
     let paste = { kind: 'idle' };
     let discardBracketed = false;
     let outputBatch = null;
+    /**
+     * A marker head that has ALREADY been released to Ink, kept for one more
+     * chunk (defect 2: the torn-marker rescue in `onData`).
+     *
+     * WHY IT EXISTS. `flushPending` releases a lone ESC after 12 ms because the
+     * Esc key must not be held hostage. When the split point lands inside a paste
+     * marker -- `ESC` in one read and `[200~hello` in the next, which is ordinary
+     * for a Windows console, SSH or tmux under load -- `feed` can no longer find
+     * the marker and `[200~` is typed into the draft. Nothing downstream can undo
+     * that: the marker has to be recognised BEFORE its bytes become text.
+     *
+     * WHAT IT CANNOT DO, STATED HONESTLY. The released ESC has already reached Ink
+     * as an Esc key press and this filter cannot retract a write. The rescue
+     * guarantees the marker CHARACTERS never become draft text; it does NOT undo
+     * that keypress (an armed interrupt gesture, a dismissed popup).
+     */
+    let rescuedPrefix = null;
     const writeInput = (text) => {
         if (disposed || outputBatch?.refused)
             return;
@@ -206,8 +224,8 @@ export function createStdinFilter(real, features, bridge, onWarn) {
     // The scan (section 5.1, and the ORDER below is the specification)
     // -----------------------------------------------------------------------
     /**
-     * Text that reached the pass-through: Tier 2 classification, then mouse
-     * stripping, then Ink.
+     * Text that reached the pass-through: a sequence a KEYBOARD cannot produce
+     * first (R-2), then Tier 2 classification, then mouse stripping, then Ink.
      *
      * MOUSE PARSING IS SUSPENDED FOR THE DURATION OF ANY PASTE BODY (I-3), burst
      * and bracketed alike. The Tier 2 population is precisely the terminals with
@@ -225,6 +243,23 @@ export function createStdinFilter(real, features, bridge, onWarn) {
             burstTimer = arm(flushBurst, PASTE_BURST_MS);
             return;
         }
+        // A SEQUENCE A KEYBOARD CANNOT PRODUCE IS A PASTE, FRAMED OR NOT (R-2).
+        //
+        // WHY THE CLASSIFIER BELOW IS NOT ENOUGH. `classifyChunk` needs either a
+        // line break or a chunk with no control byte but TAB, and a SINGLE-LINE
+        // paste carrying ESC satisfies neither -- so it travels the keystroke path
+        // with `sanitisePaste` never called. Measured on the real component that
+        // cost either a draft holding `[38;2;18;52;86m` ALONGSIDE A LIVE ESC (which
+        // then reached the model, the history and the session file) or an uncaught
+        // `TypeError` in Ink's parser, because `parse-keypress.js` maps `ESC [ 3 2 m`
+        // to a ctrl key whose `name` is undefined. Framing it here routes it through
+        // the ONE cleaning path every other paste already takes.
+        if (features.paste && hasPasteOnlySequence(text)) {
+            paste = { kind: 'burst', body: text, bytes: byteLength(text) };
+            burstTimer = clearTimer(burstTimer);
+            burstTimer = arm(flushBurst, PASTE_BURST_MS);
+            return;
+        }
         if (features.paste && classifyChunk(text) === 'paste') {
             paste = { kind: 'burst', body: text, bytes: byteLength(text) };
             burstTimer = clearTimer(burstTimer);
@@ -300,14 +335,47 @@ export function createStdinFilter(real, features, bridge, onWarn) {
             }
         }
     };
+    /**
+     * win32-input-mode records that arrived INSIDE a paste frame (R-4).
+     *
+     * DATA FIDELITY, NOT POLISH. Every character of a `?9001h` session arrives as
+     * `ESC [ vk ; sc ; char ; down ; mods ; rep _`, and once the frame opens
+     * nothing translated them: `sanitisePaste` then removed each record's ESC and
+     * left 15 visible characters of digits per key. Translating them is also what
+     * keeps the fix honest in the OTHER direction -- a whole-sequence stripper
+     * deletes such a record outright, so "clean" would have meant the user's
+     * characters silently vanishing. A record carrying a key FRAME (modified
+     * Enter, Ctrl+I) becomes the byte that frame stands for, because a frame
+     * inside a body is content and never a key.
+     */
+    const translateInPaste = (text) => {
+        if (!enhancedKeys || !text.includes('\x1b['))
+            return text;
+        let out = '';
+        for (const segment of splitWin32KeySequences(text)) {
+            if (segment.kind === 'text') {
+                out += segment.text;
+                continue;
+            }
+            const legacy = translateWin32Key(segment.record);
+            if (legacy === ENTER_NEWLINE_FRAME)
+                out += '\n';
+            else if (legacy === INDEX_KEY_FRAME)
+                out += '\t';
+            else
+                out += legacy;
+        }
+        return out;
+    };
     const appendBracketed = (text) => {
         if (paste.kind !== 'bracketed' || text.length === 0 || discardBracketed)
             return;
-        const bytes = paste.bytes + byteLength(text);
+        const body = translateInPaste(text);
+        const bytes = paste.bytes + byteLength(body);
         const overflow = paste.overflow || bytes > PASTE_MAX_BYTES;
         paste = {
             kind: 'bracketed',
-            body: overflow ? paste.body : paste.body + text,
+            body: overflow ? paste.body : paste.body + body,
             bytes,
             overflow,
         };
@@ -366,6 +434,18 @@ export function createStdinFilter(real, features, bridge, onWarn) {
             rest = rest.slice(first + PASTE_BEGIN_MARK.length);
         }
     };
+    /**
+     * Hand a held tail to the ordinary text path, remembering it when it could
+     * still be the head of a paste marker.
+     *
+     * THE TAIL IS RELEASED EXACTLY AS BEFORE. Remembering it costs no latency: a
+     * real Esc keypress still reaches Ink after `PENDING_FLUSH_MS`, and the
+     * remembered head is only ever consulted for the NEXT chunk.
+     */
+    const flushTailAsText = (text) => {
+        rescuedPrefix = isPastePrefix(text) ? { text, at: Date.now() } : null;
+        handleOutsidePaste(text, false);
+    };
     const flushPending = () => {
         flushTimer = clearTimer(flushTimer);
         if (pending.length === 0 || disposed)
@@ -374,20 +454,54 @@ export function createStdinFilter(real, features, bridge, onWarn) {
         pending = '';
         // A tail that never completed is ordinary text; it goes through the same
         // scan so a burst already open keeps coalescing it.
-        handleOutsidePaste(text, false);
+        flushTailAsText(text);
+    };
+    /**
+     * One-shot rescue of a marker whose ESC was already flushed as text.
+     *
+     * Returns the string `feed` should scan -- the remembered head followed by
+     * this chunk -- when the chunk COMPLETES that head into a whole marker, and
+     * `null` otherwise. On `null` the chunk travels the normal path: the head has
+     * already been emitted, so re-feeding it would type its bytes twice, and
+     * holding the chunk instead would swallow characters the user really typed.
+     *
+     * STARTS WITH, NOT CONTAINS. A marker completed at the junction starts at
+     * index 0 of the joined text; one starting anywhere later lies wholly inside
+     * `chunk` (the head holds an ESC at index 0 and nothing else that could begin
+     * a marker), and `feed` finds that on its own. Only the junction case needs
+     * re-scanning, and it is the only case where prepending cannot duplicate a
+     * byte that Ink has already seen.
+     *
+     * ONE-SHOT BY CONSTRUCTION: the remembered head is cleared here on every call,
+     * whether or not the rescue fired, so at most one chunk is ever re-scanned
+     * against it and no stale head can outlive its `PASTE_MARKER_RESCAN_TTL_MS`.
+     */
+    const takeRescuedPrefix = (carried, chunk) => {
+        const rescue = rescuedPrefix;
+        rescuedPrefix = null;
+        if (rescue === null || carried.length > 0 || !features.paste)
+            return null;
+        if (Date.now() - rescue.at > PASTE_MARKER_RESCAN_TTL_MS)
+            return null;
+        const joined = rescue.text + chunk;
+        const completes = joined.startsWith(PASTE_BEGIN_MARK) || joined.startsWith(PASTE_END_MARK);
+        return completes ? joined : null;
     };
     const onData = (chunk) => {
         if (disposed || finished)
             return;
         flushTimer = clearTimer(flushTimer);
         const decoded = typeof chunk === 'string' ? chunk : chunk.toString('utf8');
+        // Stripped on BOTH paths, because a NUL in a payload must never be able to
+        // forge a `PASTE_OPEN` frame boundary.
+        const cleaned = decoded.replace(/\u0000/g, '');
         const carried = pending;
         pending = '';
         // A rejected paste must not leave earlier text or a later Enter executable.
         const batch = { chunks: [], refused: false };
         outputBatch = batch;
         try {
-            feed(carried + decoded.replace(/\u0000/g, ''));
+            feed(takeRescuedPrefix(carried, cleaned) ?? (carried + cleaned));
         }
         finally {
             outputBatch = null;
@@ -417,7 +531,7 @@ export function createStdinFilter(real, features, bridge, onWarn) {
             // input: past the ceiling the tail becomes ordinary text.
             const text = pending;
             pending = '';
-            handleOutsidePaste(text, false);
+            flushTailAsText(text);
             return;
         }
         flushTimer = arm(flushPending, PENDING_FLUSH_MS);

package/dist/tools/terminal-output.d.ts

@@ -65,6 +65,14 @@ export interface SanitizeResult {
 /**
  * Remove every escape sequence and control byte except `\t` `\n` `\r`.
  *
+ * SEQUENCE SYNTAX HAS ONE OWNER (`input/control-sequences.ts`); this function
+ * adds only the control-byte sweep a DISPLAY row wants. Both call sites in this
+ * module already cut an unfinished escape off into the carry before calling it
+ * (`partialEscapeStart`), so the shared one-shot rule for a truncated sequence
+ * is exactly what they need -- and it fixes AC-24's failure in place: the old
+ * two-byte rule consumed the `\x1b[` of an unfinished CSI and left the
+ * PARAMETERS behind, so `\x1b[31m` split across chunks rendered as `red 3`.
+ *
  * Exported for the tests, and used by `toDisplayRow` as the second line of
  * defence over a carry that ends mid-escape.
  */

package/dist/tools/terminal-output.js

@@ -22,6 +22,7 @@
  * interpreting cursor motion would mean owning a screen buffer. Neither is a
  * presentation round's job.
  */
+import { stripControlSequences } from '../input/control-sequences.js';
 /** Columns a live row may occupy before it is clipped. */
 export const LIVE_ROW_MAX_CHARS = 200;
 /** Tab stop width, matching every terminal's default. */
@@ -57,22 +58,24 @@ export const TRUNCATION_MARK = '...';
  * and holding it forever would pin the carry.
  */
 const MAX_PARTIAL_ESCAPE = 64;
-/** CSI: `\x1b[` params intermediates final. */
-const CSI = /\x1b\[[0-?]*[ -/]*[@-~]/g;
-/** OSC: `\x1b]` ... terminated by BEL or ST. */
-const OSC = /\x1b\][\s\S]*?(?:\x07|\x1b\\)/g;
-/** The two-byte forms: `\x1b` followed by one character. */
-const ESC_PAIR = /\x1b[\s\S]/g;
 /** C1, plus every C0 control except `\t` `\n` `\r`. */
 const CONTROLS = /[\x00-\x08\x0b\x0c\x0e-\x1f\x7f-\x9f]/g;
 /**
  * Remove every escape sequence and control byte except `\t` `\n` `\r`.
  *
+ * SEQUENCE SYNTAX HAS ONE OWNER (`input/control-sequences.ts`); this function
+ * adds only the control-byte sweep a DISPLAY row wants. Both call sites in this
+ * module already cut an unfinished escape off into the carry before calling it
+ * (`partialEscapeStart`), so the shared one-shot rule for a truncated sequence
+ * is exactly what they need -- and it fixes AC-24's failure in place: the old
+ * two-byte rule consumed the `\x1b[` of an unfinished CSI and left the
+ * PARAMETERS behind, so `\x1b[31m` split across chunks rendered as `red 3`.
+ *
  * Exported for the tests, and used by `toDisplayRow` as the second line of
  * defence over a carry that ends mid-escape.
  */
 export function stripAnsi(text) {
-    return text.replace(CSI, '').replace(OSC, '').replace(ESC_PAIR, '').replace(CONTROLS, '');
+    return stripControlSequences(text).replace(CONTROLS, '');
 }
 /**
  * Index at which a trailing INCOMPLETE escape begins, or `-1`.

package/dist/ui/App.js

@@ -46,14 +46,14 @@ import { useTerminalSize } from './layout/useTerminalSize.js';
 import { useHeightStore } from './use-height-store.js';
 import { useRenderGovernor } from './use-render-governor.js';
 import { readScrollbarPerf, setPerfResetHook, setPerfSnapshotProvider, } from '../commands/perf.js';
-import { buildFrameBudget } from './layout/budget.js';
-import { OVERLAY_PAGE, useWheelRouting } from './use-wheel-routing.js';
+import { buildFrameBudget, POPUP_CAPACITY_SHARE } from './layout/budget.js';
+import { useWheelRouting } from './use-wheel-routing.js';
 import { INDEX_KEY_FRAME } from '../input/limits.js';
 import { INDEX_SKILL_NAME, buildIndexConfirmSummary, hasProjectIndex, indexBuildInvocationArgs, } from '../commands/index-build.js';
 import { installConsoleBridge } from './console-bridge.js';
 import { publishExitSnapshot } from './exit-snapshot.js';
 import { publishSessionView } from './session-bridge.js';
-import { OverlayFrame } from './layout/OverlayFrame.js';
+import { OverlayFrame, overlayPageSize } from './layout/OverlayFrame.js';
 import { helpRows } from './overlays/HelpOverlay.js';
 import { ModelPicker } from './overlays/ModelPicker.js';
 import { createModelProbe } from '../agent/model-probe.js';
@@ -148,6 +148,23 @@ export function App({ controller, version, initialOverlay, initialPrompt, confir
     const [statusExpanded, setStatusExpanded] = useState(false);
     const dimensions = buildFrameBudget({ ...size, draftRows, popupRows, statusExpanded });
     const { rows, cols } = dimensions;
+    /**
+     * Rows one PgUp/PgDn - and one Shift+wheel notch - turns inside a controlled
+     * overlay (defect 11).
+     *
+     * ONE VALUE FOR BOTH BRANCHES, derived from the overlay's real window: a
+     * constant 8 was 42% of `/help`'s 19-row window, so a shortcut list needed
+     * twelve keystrokes and overlapped itself by eleven rows on every turn. The
+     * wheel branch gets it through `getOverlayPage`, so the two can never disagree.
+     *
+     * MEASURED FROM THIS BUDGET, NOT `frameBudget` BELOW. The two agree on every
+     * frame except the one that opens an overlay with the completion menu still
+     * reported (`frameBudget` zeroes `popupRows` there), and that exception only
+     * makes the real window LARGER - so this page can under-turn for one frame but
+     * can never step past the window and skip content. The unsafe direction is the
+     * one that matters, and it is unreachable.
+     */
+    const overlayPage = overlayPageSize(dimensions.viewportRows, cols);
     const tooSmall = dimensions.inactive;
     // --- Render governor (tui-render-performance L4). ------------------------
     //
@@ -1764,6 +1781,7 @@ export function App({ controller, version, initialOverlay, initialPrompt, confir
         isPointerCaptured: () => terminal?.scrollbar?.controller?.isCaptured() ?? false,
         isActive: () => !tooSmall,
         getOverlay: () => stateRef.current.overlay,
+        getOverlayPage: () => overlayPage,
         onScroll: scrollBy,
         onOverlayScroll: (delta) => setOverlayScroll((n) => Math.max(0, n + delta)),
     });
@@ -1975,12 +1993,12 @@ export function App({ controller, version, initialOverlay, initialPrompt, confir
             const controlled = overlay === 'help' || overlay === 'settings' || overlay === 'plan' || overlay === 'queue';
             if (key.pageUp) {
                 if (controlled)
-                    setOverlayScroll((n) => Math.max(0, n - OVERLAY_PAGE));
+                    setOverlayScroll((n) => Math.max(0, n - overlayPage));
                 return;
             }
             if (key.pageDown) {
                 if (controlled)
-                    setOverlayScroll((n) => n + OVERLAY_PAGE);
+                    setOverlayScroll((n) => n + overlayPage);
                 return;
             }
             // `settings` keeps Up/Down for field movement — a high-frequency action
@@ -2319,7 +2337,17 @@ export function App({ controller, version, initialOverlay, initialPrompt, confir
         },
     };
     // Completion shares the fixed editor slot and its frame budget.
-    const popupMaxRows = 6;
+    //
+    // THE FRAME BUDGET, NOT A LITERAL 6 (defect 10), BUT NOT ALL OF IT EITHER.
+    // `popupMaxHeight` is the capacity `buildFrameBudget` already computed, and a
+    // second, smaller constant here is what made 57 commands browsable six at a time
+    // on a 30-row terminal. Handing over the WHOLE capacity is wrong in the other
+    // direction: `popupCapacity` reserves exactly one message row, so at 20 rows it
+    // grants 13, the transcript collapses to a single row and the TODO rail
+    // disappears - measured, `todo-app-layout.test.tsx` catches it. Half the granted
+    // capacity keeps the menu growing with the terminal (6 rows at 20, 11 at 30, 16
+    // at 40) while the conversation and the rail keep theirs.
+    const popupMaxRows = Math.floor(frameBudget.popupMaxHeight / POPUP_CAPACITY_SHARE);
     // WHICH KEY THE HINT ROW NAMES (shift-tab-mode-toggle-still-dead-on-windows,
     // C3-1). Derived from `vtInputWarning` rather than from a probe of its own,
     // because that prop is already the single answer to "can this console deliver

package/dist/ui/AutocompletePopup.js

@@ -12,6 +12,6 @@ export function AutocompletePopup({ items, selected, theme, caps, maxRows, layou
     return (_jsxs(Box, { flexDirection: "column", flexShrink: 0, borderStyle: glyphs.boxStyle, borderColor: theme.border, paddingX: 1, children: [visible.map((item, i) => {
                 const idx = windowStart + i;
                 const active = idx === selected;
-                return (_jsxs(Text, { inverse: active, wrap: "truncate", children: [_jsx(Text, { color: active ? undefined : theme.primary, children: item.label.replace(/\s+/g, ' ') }), item.hint ? _jsxs(Text, { color: theme.muted, children: ["  ", item.hint.replace(/\s+/g, ' ')] }) : null] }, idx));
+                return (_jsxs(Text, { inverse: active, wrap: "truncate", children: [_jsx(Text, { color: active ? theme.accent : theme.muted, children: active ? `${glyphs.caret} ` : '  ' }), _jsx(Text, { color: active ? undefined : theme.primary, children: item.label.replace(/\s+/g, ' ') }), item.hint ? _jsxs(Text, { color: theme.muted, children: ["  ", item.hint.replace(/\s+/g, ' ')] }) : null] }, idx));
             }), showMore && _jsxs(Text, { wrap: "truncate", color: theme.muted, children: ["  +", moreBelow, " more"] })] }));
 }

package/dist/ui/Header.js

@@ -2,7 +2,7 @@ import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-run
 import { basename } from 'node:path';
 import { Box, Text } from 'ink';
 import { Logo } from './Logo.js';
-import { planHeaderHints } from './layout/header-hints.js';
+import { planHeaderHints, HEADER_HINT_LIMITS } from './layout/header-hints.js';
 export function Header({ cwd, provider, model, hasKey, variant, theme, caps, columns = 80, statusExpanded = false, scrolledLines = 0, overlayOpen = false }) {
     // The right-hand hints are planned, not assembled (tui-branch-terminal-shortcut
     // 3.9 / D-11). `plan.text` is exactly `plan.cells` wide and already carries the
@@ -10,5 +10,10 @@ export function Header({ cwd, provider, model, hasKey, variant, theme, caps, col
     // hint by guessing one cell short - and the ladder that decides which hints
     // survive a narrow terminal lives in a pure function with its own tests.
     const plan = planHeaderHints({ columns, statusExpanded, overlayOpen, scrolledLines });
-    return _jsxs(Box, { flexDirection: "row", height: 1, width: columns, flexShrink: 0, overflow: "hidden", children: [_jsx(Box, { width: Math.max(0, columns - plan.cells), flexShrink: 0, overflow: "hidden", children: _jsxs(Text, { wrap: "truncate", children: [_jsx(Logo, { variant: variant === 'mini' ? 'mini' : 'bar', theme: theme, caps: caps }), variant !== 'mini' && _jsxs(_Fragment, { children: [_jsxs(Text, { color: theme.accent, children: ['  ', provider, ":", model] }), _jsxs(Text, { color: theme.muted, children: ['  ', basename(cwd) || cwd] }), _jsxs(Text, { color: hasKey ? theme.toolDone : theme.toolRunning, children: ['  ', hasKey ? theme.symbols.keyOn : theme.symbols.keyOff] })] })] }) }), _jsx(Box, { width: plan.cells, flexShrink: 0, justifyContent: "flex-end", children: _jsx(Text, { color: theme.muted, wrap: "truncate", children: plan.text }) })] });
+    // THE TWO HALVES ARE SEPARATED BY CELLS, NOT BY LUCK (defect 12). The left half
+    // is `wrap="truncate"`, which draws its ellipsis in the LAST cell it owns; with
+    // the right half starting in the very next cell a narrow terminal read
+    // `aragon...Details off` as one string. The blank column comes out of the left
+    // half's width, so the row still spans exactly `columns`.
+    return _jsxs(Box, { flexDirection: "row", height: 1, width: columns, flexShrink: 0, overflow: "hidden", children: [_jsx(Box, { width: Math.max(0, columns - plan.cells - HEADER_HINT_LIMITS.separatorCells), flexShrink: 0, overflow: "hidden", children: _jsxs(Text, { wrap: "truncate", children: [_jsx(Logo, { variant: variant === 'mini' ? 'mini' : 'bar', theme: theme, caps: caps }), variant !== 'mini' && _jsxs(_Fragment, { children: [_jsxs(Text, { color: theme.accent, children: ['  ', provider, ":", model] }), _jsxs(Text, { color: theme.muted, children: ['  ', basename(cwd) || cwd] }), _jsxs(Text, { color: hasKey ? theme.toolDone : theme.toolRunning, children: ['  ', hasKey ? theme.symbols.keyOn : theme.symbols.keyOff] })] })] }) }), _jsx(Box, { width: HEADER_HINT_LIMITS.separatorCells, flexShrink: 0 }), _jsx(Box, { width: plan.cells, flexShrink: 0, justifyContent: "flex-end", children: _jsx(Text, { color: theme.muted, wrap: "truncate", children: plan.text }) })] });
 }

package/dist/ui/Markdown.js

@@ -16,22 +16,49 @@ function renderBlock(block, key, theme, glyphs) {
         case 'code':
             return (_jsx(CodeBlock, { code: block.code, lang: block.lang, theme: theme, glyphs: glyphs }, `b${key}`));
         case 'table': {
-            const formatted = formatTable(block.rows, block.align);
-            return (_jsx(Box, { flexDirection: "column", children: formatted.map((row, r) => (_jsx(Text, { wrap: "truncate", bold: r === 0, color: r === 0 ? theme.accent : undefined, children: row }, r))) }, `b${key}`));
+            // Glyphs are injected rather than hardcoded: this module is inside the
+            // ASCII-only scan, and the pure parser defaults to ASCII `|` / `-`.
+            const formatted = formatTable(block.rows, block.align, {
+                separator: glyphs.railVertical,
+                rule: glyphs.hrule,
+            });
+            return (_jsx(Box, { flexDirection: "column", children: formatted.map((row, r) => (_jsx(Text, { wrap: "truncate", bold: r === 0, color: tableRowColor(r, theme), children: row }, r))) }, `b${key}`));
         }
         default:
             return _jsx(InlineLine, { line: block.text, theme: theme, glyphs: glyphs }, `b${key}`);
     }
 }
+/**
+ * Table row 0 is the header (bold + accent); row 1 is the divider drawn under it.
+ *
+ * The divider must stay distinguishable at colour level 0, where bold is dropped
+ * to nothing, so it is MUTED and never bold: in `--no-color` the `----` run is
+ * itself the signal, and in a coloured tier the weight difference separates the
+ * header from the rule beneath it.
+ */
+function tableRowColor(index, theme) {
+    if (index === 0)
+        return theme.accent;
+    if (index === 1)
+        return theme.muted;
+    return undefined;
+}
 /**
  * Fenced code. The round border is gone (§4.3): nested inside a tool card it
  * produced a box inside a box and squeezed an 80-column terminal down to 74
  * usable columns. A left rail plus the language tag conveys the same "this is
  * code" boundary for 1 column and 0 rows.
+ *
+ * The language tag is a muted TITLE, not a body row: it used to carry a chip
+ * background and one padding space either side of the text, so it rendered as
+ * `  |  ts` above code rows that start at `| export ...` — a body line that
+ * happened to be the language. It keeps its own row on purpose: the height
+ * estimator (`virtual-window.estimateEntryRows`) counts RAW markdown lines and
+ * has no code-block branch, so the fence line must still occupy exactly 1 row.
  */
 function CodeBlock({ code, lang, theme, glyphs, }) {
     const rendered = highlightCached(code, lang);
-    return (_jsxs(Box, { flexDirection: "column", flexShrink: 0, paddingLeft: 1, ...railBorderProps(glyphs.railVertical, theme.border), children: [lang.length > 0 && (_jsx(Text, { color: theme.chip.fg, backgroundColor: theme.chip.bg, children: ` ${lang} ` })), _jsx(Text, { children: rendered })] }));
+    return (_jsxs(Box, { flexDirection: "column", flexShrink: 0, paddingLeft: 1, ...railBorderProps(glyphs.railVertical, theme.border), children: [lang.length > 0 && (_jsx(Text, { bold: true, color: theme.muted, children: lang })), _jsx(Text, { children: rendered })] }));
 }
 /** Six heading levels used to render identically; now they carry three weights. */
 function headingStyle(level, theme) {

package/dist/ui/PromptInput.js

@@ -234,6 +234,31 @@ export function fileTokenAt(buffer, cursor) {
         end += 1;
     return { start, end, query: buffer.slice(start + 1, end) };
 }
+/**
+ * How many `@file` candidates reach the popup.
+ *
+ * The popup has its own row budget; this is the list it windows. Twenty ranked
+ * paths are enough to spot the one you meant, and it bounds the array that every
+ * draft edit re-renders.
+ */
+const FILE_MATCH_LIMIT = 20;
+/**
+ * Segments in a path - the first ranking key for an EMPTY `@` query (defect 10).
+ *
+ * A bare `@` matches every file in the tree, and `tinyGlob` returns them in
+ * whatever order the filesystem walked, so opening the popup without a rank gave
+ * a correct-but-arbitrary twenty. Shallowest first, then shortest, then
+ * alphabetical: the paths a user is reaching for (`src/`, a root config) come
+ * before `packages/cli/src/ui/layout/deep/thing.ts`.
+ */
+function pathDepth(path) {
+    let depth = 1;
+    for (const char of path) {
+        if (char === '/' || char === '\\')
+            depth += 1;
+    }
+    return depth;
+}
 /** A leading C0 control byte or ESC sequence should never be inserted raw. */
 function isControlSeq(input) {
     if (input.length === 0)
@@ -253,7 +278,11 @@ export function PromptInput({ cols: colsProp, terminalRows: terminalRowsProp, st
     const slashSug = dismissed ? null : slashSuggestions(buffer, commands);
     const fileTok = fileTokenAt(buffer, cursor);
     const fileQuery = fileTok ? fileTok.query : null;
-    const fileActive = !dismissed && !!fileTok && fileTok.query.length >= 1 && fileMatches.length > 0;
+    // A BARE `@` OPENS THE POPUP (defect 10). The `query.length >= 1` gate here and
+    // the `< 1` early return in the scan effect below were the whole reason a lone
+    // `@` showed nothing while `README.md` promises "@ opens a file-path completion
+    // popup". An empty query is a legitimate one: it lists the shallowest paths.
+    const fileActive = !dismissed && !!fileTok && fileMatches.length > 0;
     const popupKind = slashSug && slashSug.length > 0 ? 'slash' : fileActive ? 'file' : null;
     const popupItems = popupKind === 'slash'
         ? slashSug
@@ -263,7 +292,7 @@ export function PromptInput({ cols: colsProp, terminalRows: terminalRowsProp, st
     const clampedSel = popupItems.length > 0 ? Math.min(sel, popupItems.length - 1) : 0;
     // --- Debounced `@file` scan. ---------------------------------------------
     useEffect(() => {
-        if (fileQuery === null || fileQuery.length < 1) {
+        if (fileQuery === null) {
             setFileMatches([]);
             return;
         }
@@ -279,7 +308,16 @@ export function PromptInput({ cols: colsProp, terminalRows: terminalRowsProp, st
                 if (cancelled)
                     return;
                 const q = fileQuery.toLowerCase();
-                setFileMatches(matches.filter((m) => m.toLowerCase().includes(q)).slice(0, 20));
+                // RANKED, NOT WALK ORDER (defect 10). An empty query matches every path
+                // in the tree, so without a sort the popup for a bare `@` was
+                // correct-but-arbitrary - the first twenty the filesystem happened to
+                // hand back.
+                const ranked = matches
+                    .filter((m) => m.toLowerCase().includes(q))
+                    .sort((a, b) => pathDepth(a) - pathDepth(b)
+                    || a.length - b.length || (a < b ? -1 : a > b ? 1 : 0))
+                    .slice(0, FILE_MATCH_LIMIT);
+                setFileMatches(ranked);
             })
                 .catch(() => {
                 if (!cancelled)

package/dist/ui/Transcript.js

@@ -65,6 +65,13 @@ function EntryViewImpl({ entry, prev, expanded, thinkingVisible, reducedMotion,
             // place by `turnStart` (5.2.3).
             return frame(glyphs.queued, theme.muted, _jsx(QueuedEntry, { text: entry.text, theme: theme, caps: caps }));
         case 'assistant': {
+            // Render-layer backstop for the reducer prune (defect 5) - the reducer is the
+            // source of truth, and this only catches a settled, entirely empty bubble
+            // that reached here some other way. Returned BEFORE `frame(...)`, so neither
+            // the glyph row nor the separation row is drawn.
+            if (!entry.streaming && entry.text.trim() === '' && (entry.thinking ?? '').trim() === '') {
+                return null;
+            }
             const animate = entry.streaming && !reducedMotion && caps.unicode;
             return frame(animate ? _jsx(Spinner, { type: "dots" }) : glyphs.assistant, theme.primary, _jsx(AssistantEntry, { text: entry.text, thinking: entry.thinking, thinkingOpen: entry.thinkingOpen, thinkingVisible: thinkingVisible, streaming: entry.streaming, aborted: entry.aborted, 
                 // `EntryViewImpl` hands each renderer EXPLICIT SCALAR PROPS, so