@aragon-agent/cli 0.6.28 → 0.6.29

package/CHANGELOG.md

@@ -77,6 +77,134 @@ were written.
 
 ### Fixed
 
+- **A long answer lost two characters at every hard wrap point - silently, in
+  exactly the content a user copies out.** The transcript's content column had no
+  width of its own, so Yoga laid each line out at the width it computed from the
+  parent while `virtual-window` estimated heights against `cols - GUTTER_WIDTH`:
+  two authorities for one number, and the clip kept the difference. A 240-digit
+  run in a 100-column transcript rendered as 97 + 97 + 42 = 236 digits, dropping
+  the characters at column 97 and 194 - URLs, git hashes, base64, paths and code
+  lines broke where nothing looked broken, because a paragraph with spaces re-wraps
+  at word boundaries and hides it. The column now takes `flexBasis={0}
+  flexGrow={1}` and keeps `flexShrink={0}` (invariant I-2: without it
+  `measureElement` can squeeze the column to the viewport and scrolling dies with
+  no error), so the available width is computed once, by yoga, from the parent.
+  Measured on the shipped component: 97 + 97 + 46 = 240/240, first divergence at
+  index -1.
+- **A bracketed paste could type its own markers into the draft as `[200~hello
+  world`.** The startup `ESC[?2004h` is correct, but when a read boundary landed
+  inside the six-byte marker - ordinary on a Windows console, over SSH, or in tmux
+  under load - the 12 ms pending flush released the lone `ESC` as the Esc key (it
+  must never be held hostage), and the `[200~` that followed had nothing left to
+  recognise: `indexOf` needs the ESC. The filter now remembers a marker head it has
+  just released and, on the NEXT chunk only, splices it back in front for one
+  re-scan inside the same `feed()` - so the marker is consumed before its bytes
+  become text, `PENDING_FLUSH_MS` stays at 12 ms, and a new
+  `PASTE_MARKER_RESCAN_TTL_MS` (250 ms, structural, in `input/limits.ts`) bounds
+  when that is still believable. The visible garbage is gone in all three draft
+  measurements (`> hello world_`); the one residual is stated rather than hidden -
+  a write cannot be retracted, so the Esc keypress the release already produced
+  still happens, and a marker torn into three parts still leaves its middle
+  fragment behind (both recorded in `docs/diagnoses/.../analysis.md` §D-2).
+- **A turn that only called a tool left a bare `●` bubble behind - on screen, in
+  the height table and in the saved session.** `turnStart` always appends an
+  assistant entry, so a tool-only turn, or one the user interrupted mid-stream,
+  left a bubble that `AssistantEntry` then refused to draw: the row was estimated
+  anyway (two for an aborted one, of which nothing drew the second), the scroll
+  position counted it, and `/save` exported it, so `/resume` brought it back. The
+  reducer now prunes a settled assistant entry with no text and no thinking, at
+  the three settle points only (`turnEnd`, `runEnd`, `abortMark`) - pruning earlier
+  would delete the live target of every `textDelta`, and the entry a `streamRestart`
+  is still filling in must survive. `abortMark` is the one settle path that does not
+  clear `streamingId` itself, so the helper returns the id and the caller writes it
+  back (I-L1-1); `runEnd` and `turnEnd` clear it anyway. A render-layer guard stays
+  as the second line of defence for a session file that already contains one.
+- **An empty transcript still drew a full-height scrollbar track.** One rail
+  column of track glyphs from the second row down told the user there was more
+  below when there was nothing, and cost a column of width. `thumb === null` now
+  means no cells at all - the one-column BOX is still rendered, because the
+  reserved column (not the glyphs) is what keeps the content width constant; hiding
+  the column instead would re-wrap every line, change the measured height and feed
+  that back into the decision to show it.
+- **Under `--no-color` the command palette's selected row was invisible, and a
+  bare `@` never opened file completion.** The selection was expressed only as
+  `inverse`, which is the identity at colour level 0 - and every `theme.*` colour is
+  `undefined` there too - so six commands looked identical and Enter was a guess
+  (`/clear` sits next to `/cwd`). The selected row now carries the same
+  `glyphs.caret` prefix the `/model` picker uses (`>` in the ASCII tier), with two
+  cells of padding on the unselected rows so no row changes width. Separately,
+  `README` has always promised that `@` opens a file-path completion popup while
+  the code required one more character: the `>= 1` gate and the `< 1` early return
+  are gone, and an empty `@` query lists the shallowest paths first (depth, then
+  length, then alphabetical) instead of the first twenty the filesystem happened to
+  hand back.
+- **The completion menu was pinned at six rows on every terminal.** `App` handed
+  the popup a literal `6` while the frame budget had already computed the slot
+  capacity: a 30-row terminal showed 6 of 57 commands and 14 more hidden, so
+  browsing meant holding an arrow key. The cap is now derived from
+  `frameBudget.popupMaxHeight` through `POPUP_CAPACITY_SHARE` (2) in
+  `layout/budget.ts` - 6 rows at 20 lines, 11 at 30, 16 at 40. Handing over the
+  whole capacity was measured and rejected: `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. A divisor keeps the menu derived from the frame
+  budget instead of becoming a second authority beside it, and since it does not
+  depend on `popupRows` it cannot oscillate with it.
+- **A fenced code block's language tag rendered as a body row, indented one cell
+  past the code.** The chip background and its padding spaces drew `  |  ts` above
+  code rows starting `| export ...`, so the fence header read as an extra line of
+  source. It is now a muted bold TITLE on the same rail, aligned with the code, and
+  it deliberately keeps its own row: the height estimator counts raw markdown
+  lines and has no code-block branch, so the fence line must still occupy exactly
+  one. The fence grammar was too narrow as well - `(\w*)` rejected `c++`,
+  `objective-c` and four-backtick fences, degrading the whole block to prose and
+  swallowing the closing fence, and `split('\n')` left a `\r` on every CRLF code
+  line; a block now opens for 3+ backticks with any non-backtick info string, only
+  a run at least as long as its opener closes it, and the document is split
+  CRLF-safe.
+- **A Markdown table rendered as space-separated plain text.** The `|---|` divider
+  was consumed by the parser to read alignment and never drawn, so a table had no
+  header marker, no column boundary and no rule - and under `--no-color`, where
+  bold is dropped too, nothing at all distinguished the header. `formatTable` now
+  returns `[header, divider, ...body]`, draws the rule from the caller's glyph and
+  separates columns with a visible `|` (both injected by `Markdown.tsx` from
+  `pickGlyphs`, so the parser stays ASCII-only and the pure default is `|`/`-`),
+  and pads by DISPLAY columns rather than `String.length`, which misaligned every
+  CJK cell. The separator costs one column per boundary; a table wide enough to
+  exceed the transcript is truncated rather than wrapped, which is the deliberate
+  trade recorded in §D-6.
+- **A command that succeeded said nothing, and its notice then displaced
+  `Idle` / `Running` until the next one.** `/theme light` changed the SGR, `/todo
+  panel on` changed the layout, `/expand 1` with nothing to expand did nothing -
+  and the only feedback was the echoed command, so "it worked", "the argument was
+  wrong" and "the key was never received" looked identical. Worse, the body had
+  been reaching `status-layout` all along but only rendered on the second status
+  row, behind Ctrl+G and off by default, while the phase word was REPLACED by the
+  feedback label: after `/copy` the row said `Copied` and never went back to
+  `Idle`, which is the one thing that row exists to answer. Notification kinds
+  (`notice`, `copied`, `copy-sent`, `copying`) now keep the phase word and add the
+  body as their own field, clipped to 32 display cells; action kinds (`confirm`,
+  `stopping`, `force-stop`, `exit`, `clear-input`, `copy-error`, `copy-cleanup`)
+  still take the phase slot, because "what the next key does" IS the phase. The
+  body is dropped before the phase word would be, and a copy error no longer paints
+  `Idle` red.
+- **`/help` turned 8 rows per PgDn on a 19-row window - 42% of a page.** Reading
+  the 93-row shortcut list took twelve presses and overlapped eleven rows every
+  time, while PgUp/PgDn in the transcript moved a whole page. The step is now
+  `overlayPageSize(overlayBodyRows(...))` - one window minus the two context rows
+  `scroll.pageSize` already keeps - and it reaches BOTH consumers, the keyboard
+  branch and the Shift+wheel notch (`getOverlayPage`), from the one function
+  `OverlayFrame` renders its window with, so the two cannot disagree.
+- **On a narrow terminal the header's right-hand hints collided with the
+  truncated caption.** The left half is `wrap="truncate"` and draws its ellipsis in
+  the last cell it owns, and the hint column started in the very next cell, so 52
+  columns read `aragon...Details off` as one string and 60 columns read
+  `glm-5.^L branch`. The row now spends a new `HEADER_HINT_LIMITS.separatorCells`
+  (2) between the halves, taken out of both the left half's width and the planner's
+  budget - a separate constant from `gapCells`, which spaces two hint clauses
+  inside the right column, because one constant carrying two meanings is how a
+  later spacing change silently re-lays-out the whole row. The `^I Index`
+  thresholds move with it: 54 columns collapsed and 64 expanded, two later than
+  before.
 - **A large paste arrived as runs of digits the moment it was sent - on screen,
   in the model's input, in the prompt history and in the session file.**
   `sanitisePaste` deleted the C0/C1 *introducer byte* and kept the parameter

package/dist/agent/reducer.js

@@ -402,6 +402,36 @@ function releaseLiveTails(entries) {
     });
     return touched ? next : entries;
 }
+/**
+ * Drop settled assistant entries that render nothing at all (defect 5).
+ *
+ * `turnStart` ALWAYS creates an entry, so a turn that only called a tool leaves a
+ * bubble behind that `AssistantEntry` then refuses to draw. A rendered absence is
+ * not the same thing as an absent entry: `virtual-window.ts:305` still estimates a
+ * row for it (two when `aborted`, and nothing draws the second), and `/save`
+ * exports a blank bubble. Settle is the only safe moment to prune — before it the
+ * entry is still the target of every `textDelta` / `thinkingDelta`.
+ *
+ * I-L1-1 — `streamingId` COMES BACK WITH THE ARRAY. If the dropped entry is the
+ * one that id pointed at, the id is cleared: leaving it set would point the whole
+ * reducer at an entry no `mapEntry` can ever match again, silently, because a
+ * `mapEntry` on a missing id is a no-op. `turnEnd` and `runEnd` clear the id
+ * themselves; `abortMark` does not, which is why the caller writes this back.
+ *
+ * Returns the SAME array when nothing was dropped, so every settled entry keeps
+ * its identity and `EntryView`'s memo boundary stays intact.
+ */
+function pruneEmptyAssistant(entries, streamingId) {
+    const isEmptySettledAssistant = (entry) => entry.kind === 'assistant' &&
+        !entry.streaming &&
+        entry.text.trim() === '' &&
+        (entry.thinking ?? '').trim() === '';
+    const kept = entries.filter((entry) => !isEmptySettledAssistant(entry));
+    if (kept.length === entries.length)
+        return { entries, streamingId };
+    const liveGone = streamingId !== undefined && !kept.some((entry) => entry.id === streamingId);
+    return { entries: kept, streamingId: liveGone ? undefined : streamingId };
+}
 function findToolEntryId(state, toolCallId) {
     for (let i = state.entries.length - 1; i >= 0; i -= 1) {
         const e = state.entries[i];
@@ -673,7 +703,10 @@ export function viewReducer(state, action) {
                 // branch ever had. Two branches writing one number is what P0-1 was.
                 usageTotal: addUsage(state.usageTotal, action.usage, action.costDelta),
                 // The turn produced an answer, so whatever it had to retry, it recovered.
-                ...settleRetryCard(state, entries, 'recovered'),
+                // Defect 5: prune AFTER the mapEntry above has settled the entry, so an
+                // assistant bubble this turn never filled in is gone before the retry card
+                // is settled and before the height table ever sees it.
+                ...settleRetryCard(state, pruneEmptyAssistant(entries, state.streamingId).entries, 'recovered'),
             };
         }
         case 'runEnd': {
@@ -681,6 +714,12 @@ export function viewReducer(state, action) {
             let entries = state.streamingId
                 ? mapEntry(state.entries, state.streamingId, (e) => e.kind === 'assistant' ? { ...e, streaming: false, ...sealThinkingMs(e) } : e)
                 : state.entries;
+            /*
+             * Defect 5, and BEFORE the silent-failure guard below so the guard and the
+             * retry settle both see the pruned array. `streamingId: undefined` is set in
+             * the returned state either way, so the returned id is not needed here.
+             */
+            entries = pruneEmptyAssistant(entries, state.streamingId).entries;
             let seq = state.seq;
             let droppedEntries = state.droppedEntries;
             // Silent-failure guard (R2): a swallowed throw shows nothing otherwise.
@@ -750,13 +789,19 @@ export function viewReducer(state, action) {
             const marked = state.streamingId
                 ? mapEntry(state.entries, state.streamingId, (e) => e.kind === 'assistant' ? { ...e, streaming: false, aborted: true } : e)
                 : state.entries;
+            // Defect 5 / I-L1-1: prune AFTER the entry is settled, and write the
+            // returned id back below -- `abortMark` is the one settle path that does
+            // NOT clear `streamingId`, so a prune without that write-back would leave
+            // it naming an entry this branch has just removed.
+            const pruned = pruneEmptyAssistant(marked, state.streamingId);
             return {
                 ...state,
                 aborted: true,
+                streamingId: pruned.streamingId,
                 // An abort during a tool call is the COMMON way a tail is stranded --
                 // `Esc` while `npm test` runs -- so this is the clause manual row 9
                 // exercises (D-35 / AC-40).
-                ...settleRetryCard(state, releaseLiveTails(marked), 'interrupted'),
+                ...settleRetryCard(state, releaseLiveTails(pruned.entries), 'interrupted'),
             };
         }
         // `teamEntryId` is dropped with the entries it pointed at. Keeping it would

package/dist/input/limits.d.ts

@@ -39,6 +39,26 @@ export declare const PASTE_BURST_MS = 15;
  * which is the rule `MAX_PENDING_MOUSE_CHARS` already encodes for mouse reports.
  */
 export declare const PASTE_ASSEMBLY_MAX_MS = 2000;
+/**
+ * How long a paste-marker head that was ALREADY released to the pass-through as
+ * ordinary text may still be recognised as the head of a marker (defect 2: the
+ * torn-marker rescue in `stdin-filter.ts`).
+ *
+ * STRUCTURAL, NOT POLICY: no config key exposes it, because it bounds what the
+ * byte stream can physically do -- a marker split across two reads -- and not
+ * what a user prefers. What it does NOT do is delay a keystroke: the 12 ms
+ * pending-flush window in `stdin-filter.ts` still releases a lone ESC exactly as
+ * before, and this window only governs whether that release may be spliced back
+ * in front of the next chunk so an assembled marker is consumed, not typed.
+ *
+ * THE FALSE POSITIVE IS THE TRADE-OFF, AND IT IS ACCEPTED. Firing the rescue
+ * wrongly needs the user to press Esc and then TYPE the literal characters
+ * `[200~` or `[201~` inside this window -- a sequence no keyboard produces, and
+ * at worst five characters of lost typing. Paying that buys a fix for visible
+ * `[200~` / `[201~` garbage in the draft, which is the failure the whole paste
+ * feature exists to prevent.
+ */
+export declare const PASTE_MARKER_RESCAN_TTL_MS = 250;
 /**
  * The inline frame the filter writes into the stream Ink reads (D-3 / I-5).
  *

package/dist/input/limits.js

@@ -39,6 +39,26 @@ export const PASTE_BURST_MS = 15;
  * which is the rule `MAX_PENDING_MOUSE_CHARS` already encodes for mouse reports.
  */
 export const PASTE_ASSEMBLY_MAX_MS = 2_000;
+/**
+ * How long a paste-marker head that was ALREADY released to the pass-through as
+ * ordinary text may still be recognised as the head of a marker (defect 2: the
+ * torn-marker rescue in `stdin-filter.ts`).
+ *
+ * STRUCTURAL, NOT POLICY: no config key exposes it, because it bounds what the
+ * byte stream can physically do -- a marker split across two reads -- and not
+ * what a user prefers. What it does NOT do is delay a keystroke: the 12 ms
+ * pending-flush window in `stdin-filter.ts` still releases a lone ESC exactly as
+ * before, and this window only governs whether that release may be spliced back
+ * in front of the next chunk so an assembled marker is consumed, not typed.
+ *
+ * THE FALSE POSITIVE IS THE TRADE-OFF, AND IT IS ACCEPTED. Firing the rescue
+ * wrongly needs the user to press Esc and then TYPE the literal characters
+ * `[200~` or `[201~` inside this window -- a sequence no keyboard produces, and
+ * at worst five characters of lost typing. Paying that buys a fix for visible
+ * `[200~` / `[201~` garbage in the draft, which is the failure the whole paste
+ * feature exists to prevent.
+ */
+export const PASTE_MARKER_RESCAN_TTL_MS = 250;
 /**
  * The inline frame the filter writes into the stream Ink reads (D-3 / I-5).
  *

package/dist/input/stdin-filter.js

@@ -33,8 +33,8 @@
  */
 import { PassThrough } from 'node:stream';
 import { MAX_PENDING_MOUSE_CHARS, splitMouseEvents, isMousePrefix, } from './mouse-events.js';
-import { ENTER_NEWLINE_FRAME, INDEX_KEY_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';
@@ -97,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;
@@ -417,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)
@@ -425,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;
@@ -468,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/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

package/dist/ui/layout/Gutter.js

@@ -3,7 +3,7 @@ import { Box, Text } from 'ink';
 /** Columns reserved for the rail, glyph included. */
 export const GUTTER_WIDTH = 2;
 export function Gutter({ glyph, color, children }) {
-    return (_jsxs(Box, { flexDirection: "row", children: [_jsx(Box, { flexShrink: 0, width: GUTTER_WIDTH, children: _jsx(Text, { color: color, children: glyph }) }), _jsx(Box, { flexDirection: "column", flexShrink: 0, children: children })] }));
+    return (_jsxs(Box, { flexDirection: "row", children: [_jsx(Box, { flexShrink: 0, width: GUTTER_WIDTH, children: _jsx(Text, { color: color, children: glyph }) }), _jsx(Box, { flexDirection: "column", flexBasis: 0, flexGrow: 1, flexShrink: 0, children: children })] }));
 }
 /**
  * The one-row gap between turns: a dim rail stub rather than a blank line, so

package/dist/ui/layout/OverlayFrame.d.ts

@@ -35,6 +35,21 @@ interface OverlayFrameSelfManaged extends OverlayFrameBase {
 }
 export type OverlayFrameProps = OverlayFrameControlled | OverlayFrameSelfManaged;
 export declare function OverlayFrame(props: OverlayFrameProps): React.ReactElement;
+/**
+ * Rows one PgUp/PgDn - and one Shift+wheel notch - turns inside a controlled
+ * overlay (defect 11).
+ *
+ * THIS IS THE OVERLAY'S `scroll.pageSize`, deliberately the same rule: one window
+ * minus `PAGE_CONTEXT_LINES` of overlap, so a reader keeps two rows of context
+ * across a page turn exactly as `PgDn` in the transcript does. It replaces a
+ * constant 8, which was 42% of `/help`'s 19-row window on a 100x24 terminal and
+ * made reading a 93-row shortcut list a twelve-keystroke exercise.
+ *
+ * THE WINDOW HEIGHT COMES FROM `overlayBodyRows`, which is the same expression
+ * `OverlayFrame` renders with - computed twice here would be the two-authorities
+ * defect B1 is fixing one component over.
+ */
+export declare function overlayPageSize(maxRows: number, cols: number): number;
 /** Body rows shared by controlled overlays and self-managed focused lists. */
 export declare function overlayBodyRows(maxRows: number, cols: number): number;
 export {};

package/dist/ui/layout/OverlayFrame.js

@@ -4,6 +4,7 @@ import { Box, Text } from 'ink';
 import stringWidth from 'string-width';
 import { pickGlyphs } from '../glyphs.js';
 import { sliceWindow } from './overlay-window.js';
+import { pageSize } from './scroll.js';
 /** Below this width the round border costs more than it conveys (§5.2). */
 const BORDERLESS_COLS = 48;
 /** Title + footer + top and bottom border. */
@@ -68,6 +69,23 @@ export function OverlayFrame(props) {
     }
     return (_jsx(Box, { flexDirection: "column", flexShrink: 0, borderStyle: glyphs.boxStyle, borderColor: theme.primary, paddingX: 1, marginTop: 1, children: inner }));
 }
+/**
+ * Rows one PgUp/PgDn - and one Shift+wheel notch - turns inside a controlled
+ * overlay (defect 11).
+ *
+ * THIS IS THE OVERLAY'S `scroll.pageSize`, deliberately the same rule: one window
+ * minus `PAGE_CONTEXT_LINES` of overlap, so a reader keeps two rows of context
+ * across a page turn exactly as `PgDn` in the transcript does. It replaces a
+ * constant 8, which was 42% of `/help`'s 19-row window on a 100x24 terminal and
+ * made reading a 93-row shortcut list a twelve-keystroke exercise.
+ *
+ * THE WINDOW HEIGHT COMES FROM `overlayBodyRows`, which is the same expression
+ * `OverlayFrame` renders with - computed twice here would be the two-authorities
+ * defect B1 is fixing one component over.
+ */
+export function overlayPageSize(maxRows, cols) {
+    return pageSize(overlayBodyRows(maxRows, cols));
+}
 /** Body rows shared by controlled overlays and self-managed focused lists. */
 export function overlayBodyRows(maxRows, cols) {
     if (!Number.isFinite(maxRows))

package/dist/ui/layout/ScrollIndicator.js

@@ -6,10 +6,17 @@ export const MIN_INDICATOR_COLS = 40;
 export function ScrollIndicator({ rows, thumb, dragging = false, theme, caps, }) {
     const glyphs = pickGlyphs(caps);
     const count = Math.max(0, Math.floor(rows) || 0);
+    // NO CELLS WITHOUT A THUMB (defect 6). `thumb === null` means the content fits,
+    // so there is no position to mark and a full-height column of track glyphs is
+    // pure noise next to an empty transcript. The BOX below is still rendered
+    // whatever the thumb is — see the feedback-loop note at the top of this file:
+    // the reserved column, not the glyphs, is what keeps the width constant.
     const cells = [];
-    for (let i = 0; i < count; i += 1) {
-        const onThumb = !!thumb && i >= thumb.start && i < thumb.start + thumb.size;
-        cells.push(_jsx(Text, { color: onThumb ? theme.primary : theme.muted, bold: onThumb && dragging, children: onThumb ? glyphs.scrollThumb : glyphs.scrollTrack }, i));
+    if (thumb) {
+        for (let i = 0; i < count; i += 1) {
+            const onThumb = i >= thumb.start && i < thumb.start + thumb.size;
+            cells.push(_jsx(Text, { color: onThumb ? theme.primary : theme.muted, bold: onThumb && dragging, children: onThumb ? glyphs.scrollThumb : glyphs.scrollTrack }, i));
+        }
     }
     return (_jsx(Box, { flexDirection: "column", flexShrink: 0, width: 1, children: cells }));
 }

package/dist/ui/layout/budget.d.ts

@@ -22,6 +22,21 @@ export interface FrameBudget {
 }
 /** Clamp the displayed draft, independently of any transcript or panel content. */
 export declare function clampDraftRows(rows: number, draftRows: number): number;
+/**
+ * The share of `popupMaxHeight` a completion menu may actually occupy (defect 10).
+ *
+ * `popupCapacity` answers "how much COULD the editor slot take", and its floor is
+ * one message row - right for a picker that owns the frame, wrong for a menu that
+ * opens over a conversation. At 20 rows the whole capacity is 13, which leaves one
+ * transcript row and no TODO rail at all (measured, `todo-app-layout.test.tsx`).
+ * Half keeps the menu growing with the terminal - 6 rows at 20, 11 at 30, 16 at 40 -
+ * while the conversation and the rail keep their rows.
+ *
+ * A divisor rather than a row count or a fraction of the terminal: it is the only
+ * form that stays derived from the frame budget instead of becoming a second
+ * authority beside it, and it cannot drift when `popupCapacity` changes.
+ */
+export declare const POPUP_CAPACITY_SHARE = 2;
 /** Total menu capacity, including its borders; reserve at least one message row. */
 export declare function popupCapacity(rows: number, draftRows: number, statusExpanded: boolean): number;
 /** Normalize terminal dimensions once and conserve every visible frame row. */

package/dist/ui/layout/budget.js

@@ -8,6 +8,21 @@ export function clampDraftRows(rows, draftRows) {
     const wanted = Number.isFinite(draftRows) ? Math.floor(draftRows) : 1;
     return Math.max(1, Math.min(wanted, draftMaxRows(rows)));
 }
+/**
+ * The share of `popupMaxHeight` a completion menu may actually occupy (defect 10).
+ *
+ * `popupCapacity` answers "how much COULD the editor slot take", and its floor is
+ * one message row - right for a picker that owns the frame, wrong for a menu that
+ * opens over a conversation. At 20 rows the whole capacity is 13, which leaves one
+ * transcript row and no TODO rail at all (measured, `todo-app-layout.test.tsx`).
+ * Half keeps the menu growing with the terminal - 6 rows at 20, 11 at 30, 16 at 40 -
+ * while the conversation and the rail keep their rows.
+ *
+ * A divisor rather than a row count or a fraction of the terminal: it is the only
+ * form that stays derived from the frame budget instead of becoming a second
+ * authority beside it, and it cannot drift when `popupCapacity` changes.
+ */
+export const POPUP_CAPACITY_SHARE = 2;
 /** Total menu capacity, including its borders; reserve at least one message row. */
 export function popupCapacity(rows, draftRows, statusExpanded) {
     return Math.max(0, rows - 1 - 1 - (statusExpanded ? 2 : 1)

package/dist/ui/layout/header-hints.d.ts

@@ -36,6 +36,15 @@ export declare const HEADER_HINT_LIMITS: {
     readonly minLeftCells: 24;
     /** Fixed spacing between two hint clauses. */
     readonly gapCells: 2;
+    /**
+     * Blank cells between the header's left half and this hint column (defect 12).
+     *
+     * A SEPARATE CONSTANT FROM `gapCells`. That one spaces two hint clauses INSIDE
+     * the right column (`buildPlan` below); this one separates the session
+     * description from that column. One constant carrying two meanings is how a
+     * later change to clause spacing silently re-lays-out the whole row.
+     */
+    readonly separatorCells: 2;
 };
 export type HeaderHintId = 'branch' | 'index' | 'detail';
 export interface HeaderHintClause {

package/dist/ui/layout/header-hints.js

@@ -36,6 +36,15 @@ export const HEADER_HINT_LIMITS = {
     minLeftCells: 24,
     /** Fixed spacing between two hint clauses. */
     gapCells: 2,
+    /**
+     * Blank cells between the header's left half and this hint column (defect 12).
+     *
+     * A SEPARATE CONSTANT FROM `gapCells`. That one spaces two hint clauses INSIDE
+     * the right column (`buildPlan` below); this one separates the session
+     * description from that column. One constant carrying two meanings is how a
+     * later change to clause spacing silently re-lays-out the whole row.
+     */
+    separatorCells: 2,
 };
 /** The verbatim clause text (spec 3.8, appendix A). */
 const BRANCH_CLAUSE = { collapsed: '^L branch', expanded: '^L new branch' };
@@ -69,7 +78,11 @@ export function planHeaderHints(input) {
         return buildPlan([{ id: 'detail', text: detail }], scrollCells, true);
     }
     const ladder = ladderFor(input.statusExpanded);
-    const budget = columns - HEADER_HINT_LIMITS.minLeftCells;
+    // THE SEPARATOR IS SPENT OUT OF THE SAME ROW (defect 12): left half + gap + this
+    // column have to add up to `columns`, so the gap comes off the budget instead of
+    // being assumed free.
+    const budget = columns - HEADER_HINT_LIMITS.minLeftCells
+        - HEADER_HINT_LIMITS.separatorCells;
     for (const rung of ladder) {
         const plan = buildPlan(rung, scrollCells, false);
         if (plan.cells <= budget)

package/dist/ui/layout/status-layout.js

@@ -90,6 +90,47 @@ function feedbackLabel(input, form) {
     };
     return labels[feedback.kind][form === 'full' ? 0 : form === 'short' ? 1 : 2];
 }
+/**
+ * Kinds that are NOTIFICATIONS, not a phase word (defect 8 / 9).
+ *
+ * A notification says "something happened". An ACTION kind (`confirm`,
+ * `stopping`, `force-stop`, `exit`, `clear-input`, `copy-error`,
+ * `copy-cleanup`) says what the NEXT key does - that IS the phase slot's job, so
+ * those keep replacing it. Everything in this set gets its own field instead and
+ * `phase` is never displaced: `Idle` / `Running` is the one thing this row must
+ * always answer, and a notice that lands as a turn ends is exactly when a wrong
+ * answer misleads the user about whether the agent is still working.
+ */
+const NOTIFICATION_KINDS = new Set([
+    'notice', 'copied', 'copy-sent', 'copying',
+]);
+/**
+ * The most cells a notification body may take on the primary row.
+ *
+ * The row is exactly one row high and measured, so the body is CLIPPED rather
+ * than wrapped. 32 cells carries `Theme set to light.` or `Todo panel off.`
+ * whole while leaving the phase word, the mode and the context gauge intact; a
+ * longer message still has the details row, where it is rendered in full.
+ */
+const FEEDBACK_TEXT_CELLS = 32;
+/**
+ * Clip `text` to at most `cells` display columns, never splitting a wide glyph.
+ *
+ * Local rather than `interaction-hints.clipStatusText`: that module already
+ * imports THIS one, and a cycle for a five-line guard is not worth it.
+ */
+function clipFeedbackText(text, cells) {
+    const clean = cleanStatusText(text);
+    if (stringWidth(clean) <= cells)
+        return clean;
+    let clipped = '';
+    for (const char of clean) {
+        if (stringWidth(clipped + char) > cells)
+            break;
+        clipped += char;
+    }
+    return clipped;
+}
 const thinkingCodes = { off: 'O', minimal: 'N', low: 'L', medium: 'M', high: 'H', xhigh: 'X' };
 /**
  * The mode word for the primary row: full rungs name the mode with
@@ -127,15 +168,35 @@ export function planPrimaryStatusFields(input) {
     const code = thinkingCodes[input.thinkingLevel] ?? '?';
     const pct = contextPercent(input.context);
     const speed = speedNumber(input);
+    // THE RUN'S OWN URGENCY, and the notification's, are two different things
+    // (defect 9). `tone` keeps today's meaning for an ACTION kind (it colours the
+    // phase word); a notification is painted with its own level and leaves the
+    // phase word to describe the run - a copy error must not make `Idle` red.
     const tone = input.feedback?.level === 'error' || input.runOutcome === 'failed'
         ? 'error' : input.feedback?.level === 'warn' || input.waitingForConfirmation || input.stopping ? 'warning' : 'normal';
+    const notification = !!input.feedback && NOTIFICATION_KINDS.has(input.feedback.kind);
+    const phaseTone = notification
+        ? input.runOutcome === 'failed' ? 'error'
+            : input.waitingForConfirmation || input.stopping ? 'warning' : 'normal'
+        : tone;
+    const feedbackTone = input.feedback?.level === 'error' ? 'error'
+        : input.feedback?.level === 'warn' ? 'warning' : 'normal';
     const build = (rung) => {
         const full = rung === 0;
-        const label = feedbackLabel(input, full ? 'full' : rung >= 4 ? 'tiny' : 'short')
+        const form = full ? 'full' : rung >= 4 ? 'tiny' : 'short';
+        // THE BODY IS A FIELD OF ITS OWN (defect 8). The text has been in
+        // `feedback.text` all along; it only ever reached the screen on the SECOND
+        // status row, which is behind Ctrl+G and off by default. Rung 3 and tighter
+        // drop it: the ladder exists to keep the phase word, and a body that only fits
+        // by hiding `Running` would be the original defect back with extra steps.
+        const notice = notification && rung <= 2 && input.feedback
+            ? clipFeedbackText(input.feedback.text, FEEDBACK_TEXT_CELLS) : '';
+        const label = (notification ? undefined : feedbackLabel(input, form))
             ?? (full ? labels[1] : rung >= 4 ? labels[0].slice(0, 4) : labels[0]);
         const modeText = modeFieldText(input.mode, input.pendingMode, full);
         return statusLinePlan([
-            statusField('phase', glyph + (rung >= 5 ? '' : ' ') + label, tone),
+            statusField('phase', glyph + (rung >= 5 ? '' : ' ') + label, phaseTone),
+            ...(notice ? [statusField('feedback', notice, feedbackTone)] : []),
             ...(modeText ? [statusField('mode', modeText, 'accent')] : []),
             statusField('context', (full ? 'Context ' : 'C') + pct),
             statusField('thinking', full ? 'Think ' + (thinkingCodes[input.thinkingLevel] ? input.thinkingLevel : '?')

package/dist/ui/markdown-blocks.d.ts

@@ -1,6 +1,7 @@
 /**
  * Markdown parsing layer (spec §4.7). Pure and React-free so the grammar can be
- * unit-tested without rendering anything.
+ * unit-tested without rendering anything. `string-width` is the only import and
+ * it is a pure function of its argument, so the module stays side-effect free.
  *
  * Scope is deliberately small — this is not CommonMark. It covers what a coding
  * agent's answers actually contain: fenced code, headings, lists, quotes, rules,
@@ -31,11 +32,31 @@ export declare function parseTableRow(line: string): string[] | null;
 export declare function isTableDivider(line: string): boolean;
 export declare function tableAlignments(dividerLine: string): TableBlock['align'];
 /**
- * Pad a parsed table into fixed-width columns. Returns one string per row —
- * no borders, because a bordered table inside an already-indented gutter wraps
- * on any realistic terminal.
+ * How the table is drawn. Both characters are injected by the renderer from
+ * `pickGlyphs(caps)` because this file is inside the ASCII-only scan
+ * (`glyphs.test.ts::inScope`): a Unicode box-drawing literal here would fail
+ * that guard.
  */
-export declare function formatTable(rows: string[][], align: TableBlock['align']): string[];
+export interface TableFormatOptions {
+    /** Drawn between cells; `Markdown.tsx` passes `glyphs.railVertical`. */
+    separator?: string;
+    /** Repeated to a column's padded width; `Markdown.tsx` passes `glyphs.hrule`. */
+    rule?: string;
+}
+/**
+ * Pad a parsed table into fixed-width columns and draw the header rule.
+ *
+ * Returns `[header, divider, ...bodyRows]`, one string per rendered row, so
+ * index 0 is always the header and index 1 always the divider. The divider is
+ * rendered rather than swallowed because the parser consumes the source
+ * `|---|` row to read alignment: without it, a `--no-color` terminal showed a
+ * table as unseparated prose (bold is dropped at colour level 0, and the old
+ * two-space join gave no column boundary either).
+ *
+ * Padding is by DISPLAY columns, not `String.length`: a CJK cell is one code
+ * unit but two terminal columns, so `.length` misaligned every such table.
+ */
+export declare function formatTable(rows: string[][], align: TableBlock['align'], options?: TableFormatOptions): string[];
 /**
  * One parsed top-level block.
  *

package/dist/ui/markdown-blocks.js

@@ -1,11 +1,13 @@
 /**
  * Markdown parsing layer (spec §4.7). Pure and React-free so the grammar can be
- * unit-tested without rendering anything.
+ * unit-tested without rendering anything. `string-width` is the only import and
+ * it is a pure function of its argument, so the module stays side-effect free.
  *
  * Scope is deliberately small — this is not CommonMark. It covers what a coding
  * agent's answers actually contain: fenced code, headings, lists, quotes, rules,
  * tables, and inline emphasis / code / strikethrough.
  */
+import stringWidth from 'string-width';
 const HEADING_RE = /^(#{1,6})\s+(.*)$/;
 /** `---`, `***` or `___`, three or more, nothing else on the line. */
 const RULE_RE = /^(?:-{3,}|\*{3,}|_{3,})$/;
@@ -46,53 +48,128 @@ export function tableAlignments(dividerLine) {
         return 'left';
     });
 }
+/** Default column separator: pure ASCII, so this module holds no glyph literal. */
+const DEFAULT_TABLE_SEPARATOR = '|';
+/** Default header rule: pure ASCII for the same reason. */
+const DEFAULT_TABLE_RULE = '-';
+/** One space either side of the separator, so a boundary is unmistakable. */
+const TABLE_CELL_GAP = ' ';
 /**
- * Pad a parsed table into fixed-width columns. Returns one string per row —
- * no borders, because a bordered table inside an already-indented gutter wraps
- * on any realistic terminal.
+ * Pad a parsed table into fixed-width columns and draw the header rule.
+ *
+ * Returns `[header, divider, ...bodyRows]`, one string per rendered row, so
+ * index 0 is always the header and index 1 always the divider. The divider is
+ * rendered rather than swallowed because the parser consumes the source
+ * `|---|` row to read alignment: without it, a `--no-color` terminal showed a
+ * table as unseparated prose (bold is dropped at colour level 0, and the old
+ * two-space join gave no column boundary either).
+ *
+ * Padding is by DISPLAY columns, not `String.length`: a CJK cell is one code
+ * unit but two terminal columns, so `.length` misaligned every such table.
  */
-export function formatTable(rows, align) {
+export function formatTable(rows, align, options = {}) {
+    const separator = options.separator ?? DEFAULT_TABLE_SEPARATOR;
+    const rule = options.rule ?? DEFAULT_TABLE_RULE;
     const colCount = Math.max(...rows.map((r) => r.length), 0);
     const widths = [];
     for (let c = 0; c < colCount; c += 1) {
-        widths[c] = Math.max(...rows.map((r) => (r[c] ?? '').length), 0);
+        widths[c] = Math.max(...rows.map((r) => displayColumns(r[c] ?? '')), 0);
     }
-    return rows.map((row) => row
-        .map((cell, c) => {
-        const w = widths[c] ?? 0;
-        const a = align[c] ?? 'left';
-        if (a === 'right')
-            return cell.padStart(w);
-        if (a === 'center') {
-            const total = w - cell.length;
-            const left = Math.floor(total / 2);
-            return ' '.repeat(left) + cell + ' '.repeat(total - left);
+    const gap = `${TABLE_CELL_GAP}${separator}${TABLE_CELL_GAP}`;
+    const body = rows.map((row) => padRow(row, widths, align).join(gap).trimEnd());
+    if (body.length === 0)
+        return [];
+    const divider = widths.map((w) => rule.repeat(w)).join(gap).trimEnd();
+    return [body[0], divider, ...body.slice(1)];
+}
+function padRow(row, widths, align) {
+    return row.map((cell, c) => padCell(cell, widths[c] ?? 0, align[c] ?? 'left'));
+}
+function padCell(cell, width, align) {
+    const pad = width - displayColumns(cell);
+    if (pad <= 0)
+        return cell;
+    const filler = ' '.repeat(pad);
+    if (align === 'right')
+        return filler + cell;
+    if (align === 'center') {
+        const left = Math.floor(pad / 2);
+        return `${' '.repeat(left)}${cell}${' '.repeat(pad - left)}`;
+    }
+    return cell + filler;
+}
+/**
+ * Printable ASCII with no TAB: one code unit is one cell, so the width table is
+ * not consulted at all.
+ *
+ * The same load-bearing fast path `virtual-window.displayColumns` carries, and for
+ * the same reason: `stringWidth` strips ANSI and walks the East-Asian width table
+ * per code point, while this runs once per CELL of every table row on every frame.
+ * Table cells are overwhelmingly ASCII, so the branch is taken almost always -
+ * and when it is not, the table is CJK and the table is exactly what must be used.
+ */
+const PLAIN_ASCII = /^[\x20-\x7e]*$/;
+/** Terminal columns occupied by `text` (wide glyphs count two). */
+function displayColumns(text) {
+    return PLAIN_ASCII.test(text) ? text.length : stringWidth(text);
+}
+/**
+ * An opening fence is three or more backticks plus an optional info string.
+ *
+ * The old `(\w*)` info group was too narrow for real answers: ```c++ and
+ * ```objective-c did not open a block at all, so the body degraded to prose and
+ * the closing fence was then swallowed as a new empty code block. A backtick is
+ * the one character CommonMark forbids in an info string; everything else is
+ * accepted here and the language is simply the FIRST token.
+ */
+const FENCE_OPEN_RE = /^(`{3,})[ \t]*([^`]*)$/;
+/** A closing fence carries backticks only — no info string. */
+const FENCE_CLOSE_RE = /^(`{3,})[ \t]*$/;
+function parseFenceOpen(line) {
+    const m = FENCE_OPEN_RE.exec(line);
+    if (!m)
+        return null;
+    const info = (m[2] ?? '').trim();
+    return { count: m[1].length, lang: info.split(/\s+/)[0] ?? '' };
+}
+/** Backtick count of a line that could close a fence; 0 when it could not. */
+function closingFenceLength(line) {
+    const m = FENCE_CLOSE_RE.exec(line);
+    return m ? m[1].length : 0;
+}
+/**
+ * Collect a fence body starting after the opening fence.
+ *
+ * A closer must carry AT LEAST as many backticks as its opener, so a
+ * four-backtick block may contain ``` lines — that is how a nested markdown
+ * example survives. A shorter run is content, not the end of the block.
+ */
+function readFenceBody(lines, openIndex, openCount) {
+    const body = [];
+    let i = openIndex + 1;
+    while (i < lines.length) {
+        if (closingFenceLength((lines[i] ?? '').trim()) >= openCount) {
+            return { code: body.join('\n'), next: i + 1 };
         }
-        return cell.padEnd(w);
-    })
-        .join('  ')
-        .trimEnd());
+        body.push(lines[i] ?? '');
+        i += 1;
+    }
+    return { code: body.join('\n'), next: i };
 }
-/** A fence line: ```` ```lang ```` or a bare ```` ``` ````. */
-const FENCE_RE = /^```(\w*)\s*$/;
 /** Split a document into fenced code, pipe tables, and everything else. */
 export function parseMarkdownBlocks(text) {
-    const lines = text.split('\n');
+    // CRLF-safe: a bare `split('\n')` left a '\r' on every code line, which then
+    // reached the highlighter and the display-width maths.
+    const lines = text.split(/\r?\n/);
     const blocks = [];
     let i = 0;
     while (i < lines.length) {
         const line = lines[i] ?? '';
-        const fence = FENCE_RE.exec(line.trim());
+        const fence = parseFenceOpen(line.trim());
         if (fence) {
-            const lang = fence[1] || '';
-            const codeLines = [];
-            i += 1;
-            while (i < lines.length && !FENCE_RE.test((lines[i] ?? '').trim())) {
-                codeLines.push(lines[i] ?? '');
-                i += 1;
-            }
-            i += 1; // skip the closing fence
-            blocks.push({ kind: 'code', code: codeLines.join('\n'), lang });
+            const { code, next } = readFenceBody(lines, i, fence.count);
+            blocks.push({ kind: 'code', code, lang: fence.lang });
+            i = next;
             continue;
         }
         // A pipe row followed by a divider row starts a table; consume the run.

package/dist/ui/use-wheel-routing.d.ts

@@ -22,13 +22,6 @@
 import type { Overlay } from '../agent/reducer.js';
 import type { MouseSource } from '../input/stdin-filter.js';
 import type { ScrollIntent } from './layout/scroll.js';
-/**
- * Rows a PgUp/PgDn — and a Shift+wheel notch — moves inside a controlled
- * overlay. Declared here rather than in `App.tsx` because both the keyboard
- * branch and the wheel branch need it and `App` imports this module; the other
- * direction would be a cycle.
- */
-export declare const OVERLAY_PAGE = 8;
 export interface WheelRoutingOptions {
     isPointerCaptured?: () => boolean;
     isActive?: () => boolean;
@@ -39,6 +32,16 @@ export interface WheelRoutingOptions {
     onScroll: (kind: ScrollIntent, repeat: number) => void;
     /** Signed row delta; the caller clamps at 0 the way the keyboard branch does. */
     onOverlayScroll: (delta: number) => void;
+    /**
+     * Rows one Shift+wheel notch turns inside a controlled overlay (defect 11).
+     *
+     * A GETTER, read at event time for the same reason `getOverlay` is: the window
+     * height changes with the terminal, with `statusExpanded` and with the rail, and
+     * a value captured when the subscription was built is the value that goes stale.
+     * `App` answers with `overlayPageSize(...)`, the same function its keyboard
+     * branch uses, so the wheel and `PgDn` can never disagree.
+     */
+    getOverlayPage?: () => number;
 }
 export interface WheelRouting {
     /**

package/dist/ui/use-wheel-routing.js

@@ -21,12 +21,15 @@
  */
 import { useCallback, useEffect, useRef } from 'react';
 /**
- * Rows a PgUp/PgDn — and a Shift+wheel notch — moves inside a controlled
- * overlay. Declared here rather than in `App.tsx` because both the keyboard
- * branch and the wheel branch need it and `App` imports this module; the other
- * direction would be a cycle.
+ * Page rows used ONLY when the host supplies no `getOverlayPage`.
+ *
+ * `App` always supplies one (defect 11): the step is the overlay's visible window
+ * minus two rows of context, so `PgDn` in `/help` turns a page instead of 42% of
+ * one. This fallback exists so a host that owns no overlay window - this module's
+ * own routing tests are the only such host - still gets a page rather than
+ * silently degrading a Shift+wheel to a three-row notch.
  */
-export const OVERLAY_PAGE = 8;
+const FALLBACK_OVERLAY_PAGE = 8;
 /** Transcript rows per notch. The terminal's own convention. */
 const CONTENT_LINES_PER_NOTCH = 3;
 /** Overlay rows per notch. Overlay content is short; a page needs Shift. */
@@ -113,7 +116,9 @@ export function useWheelRouting(options) {
             // D-3: the row is not consulted here either. Behind an overlay the
             // composer is inactive and the overlay is the only scrollable thing on
             // screen, so a notch anywhere scrolls it.
-            const step = event.shift ? OVERLAY_PAGE : OVERLAY_LINES_PER_NOTCH;
+            const step = event.shift
+                ? current.getOverlayPage?.() ?? FALLBACK_OVERLAY_PAGE
+                : OVERLAY_LINES_PER_NOTCH;
             current.onOverlayScroll(event.dir === 'up' ? -step : step);
             return;
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aragon-agent/cli",
-  "version": "0.6.28",
+  "version": "0.6.29",
   "description": "AragonAgent CLI — a Claude-Code / Codex-style interactive terminal UI (TUI) on top of the @aragon-agent/core engine. Installable and runnable via npm / npx.",
   "license": "MIT",
   "author": "AragonAgent contributors",
@@ -56,7 +56,7 @@
     "prepublishOnly": "npm run build"
   },
   "dependencies": {
-    "@aragon-agent/core": "^0.2.40",
+    "@aragon-agent/core": "^0.2.41",
     "chalk": "^5.6.2",
     "cli-highlight": "^2.0.0",
     "commander": "^12.1.0",