@aragon-agent/cli 0.6.27 → 0.6.29

package/dist/ui/display-tab.d.ts

@@ -0,0 +1,51 @@
+/**
+ * TAB expansion that agrees with the TERMINAL, not with UTF-16 (fix A'-2 of
+ * paste-control-sequence-residue).
+ *
+ * WHY THIS IS A MODULE OF ITS OWN. A TAB has no width; it advances the pen to
+ * the next tab stop, so what it occupies depends on where the line currently
+ * is. That makes "one TAB" a property of a CURSOR, and the same character was
+ * being read three different ways in this package:
+ *
+ * - `ui/editor-navigation.ts` painted it at FOUR-column stops in the composer,
+ * - `entries/UserEntry.tsx` handed the raw byte to `<Text>`, so the terminal
+ *   painted it at EIGHT-column stops in the transcript,
+ * - `tools/terminal-output.ts` expanded it by UTF-16 code-unit count, so a
+ *   pasted `中文<TAB>X` table came out two columns short.
+ *
+ * A user who pastes a TAB-indented block or an Excel/Word table therefore saw
+ * the draft and the sent message disagree about their own text. One function,
+ * used by the composer AND by every renderer of stored text, is what makes the
+ * "before send" and "after send" rows character-identical.
+ *
+ * `input/` is the wrong home for it: `cli/input` may depend on `node:stream`
+ * and nothing else (`.claude-index/index.md`), and column arithmetic needs the
+ * width table. `ui/` already owns that (`selection/selection.ts` uses
+ * `string-width` for exactly this reason).
+ *
+ * Pure, React-free, Ink-free.
+ */
+/**
+ * Tab stop width, matching every terminal's default.
+ *
+ * A COPY OF `tools/terminal-output.ts`'s number, on purpose and in the same
+ * shape `composer-limits.ts` copies `budget.ts::HINT_MIN_ROWS`: importing the
+ * tools module here would point an arrow from `ui/` into `tools/` for one
+ * integer, and the two are asserted equal by a test instead. (`tools/` keeps
+ * its own expander because its rows are clipped to 200 columns before anyone
+ * looks at them, so a code-unit approximation there cannot reach a user.)
+ */
+export declare const TAB_WIDTH = 8;
+/**
+ * Expand every TAB in `text` to spaces up to the next `TAB_WIDTH` stop, given
+ * the display column the first character will be painted at.
+ *
+ * `fromColumn` is a DISPLAY column, not an offset: a caller that has already
+ * painted `中文` must pass 4. Lines are independent -- a `\n` resets the column
+ * to zero, because the terminal's pen returns to column 0.
+ *
+ * Non-ASCII text is measured with `string-width`, which is the whole point: a
+ * CJK glyph occupies two cells, and counting it as one space is what left
+ * CJK-plus-TAB tables misaligned.
+ */
+export declare function expandTabs(text: string, fromColumn?: number): string;

package/dist/ui/display-tab.js

@@ -0,0 +1,82 @@
+/**
+ * TAB expansion that agrees with the TERMINAL, not with UTF-16 (fix A'-2 of
+ * paste-control-sequence-residue).
+ *
+ * WHY THIS IS A MODULE OF ITS OWN. A TAB has no width; it advances the pen to
+ * the next tab stop, so what it occupies depends on where the line currently
+ * is. That makes "one TAB" a property of a CURSOR, and the same character was
+ * being read three different ways in this package:
+ *
+ * - `ui/editor-navigation.ts` painted it at FOUR-column stops in the composer,
+ * - `entries/UserEntry.tsx` handed the raw byte to `<Text>`, so the terminal
+ *   painted it at EIGHT-column stops in the transcript,
+ * - `tools/terminal-output.ts` expanded it by UTF-16 code-unit count, so a
+ *   pasted `中文<TAB>X` table came out two columns short.
+ *
+ * A user who pastes a TAB-indented block or an Excel/Word table therefore saw
+ * the draft and the sent message disagree about their own text. One function,
+ * used by the composer AND by every renderer of stored text, is what makes the
+ * "before send" and "after send" rows character-identical.
+ *
+ * `input/` is the wrong home for it: `cli/input` may depend on `node:stream`
+ * and nothing else (`.claude-index/index.md`), and column arithmetic needs the
+ * width table. `ui/` already owns that (`selection/selection.ts` uses
+ * `string-width` for exactly this reason).
+ *
+ * Pure, React-free, Ink-free.
+ */
+import stringWidth from 'string-width';
+/**
+ * Tab stop width, matching every terminal's default.
+ *
+ * A COPY OF `tools/terminal-output.ts`'s number, on purpose and in the same
+ * shape `composer-limits.ts` copies `budget.ts::HINT_MIN_ROWS`: importing the
+ * tools module here would point an arrow from `ui/` into `tools/` for one
+ * integer, and the two are asserted equal by a test instead. (`tools/` keeps
+ * its own expander because its rows are clipped to 200 columns before anyone
+ * looks at them, so a code-unit approximation there cannot reach a user.)
+ */
+export const TAB_WIDTH = 8;
+/**
+ * Expand every TAB in `text` to spaces up to the next `TAB_WIDTH` stop, given
+ * the display column the first character will be painted at.
+ *
+ * `fromColumn` is a DISPLAY column, not an offset: a caller that has already
+ * painted `中文` must pass 4. Lines are independent -- a `\n` resets the column
+ * to zero, because the terminal's pen returns to column 0.
+ *
+ * Non-ASCII text is measured with `string-width`, which is the whole point: a
+ * CJK glyph occupies two cells, and counting it as one space is what left
+ * CJK-plus-TAB tables misaligned.
+ */
+export function expandTabs(text, fromColumn = 0) {
+    if (text.indexOf('\t') === -1)
+        return text;
+    let out = '';
+    let column = Math.max(0, Math.floor(fromColumn));
+    let run = '';
+    for (const part of graphemesOf(text)) {
+        if (part === '\t') {
+            out += run;
+            run = '';
+            const width = TAB_WIDTH - (column % TAB_WIDTH);
+            out += ' '.repeat(width);
+            column += width;
+            continue;
+        }
+        run += part;
+        if (part === '\n')
+            column = 0;
+        else
+            column += stringWidth(part);
+    }
+    return out + run;
+}
+const segmenter = new Intl.Segmenter(undefined, { granularity: 'grapheme' });
+/**
+ * Grapheme clusters rather than code units, so a combining mark or an emoji ZWJ
+ * sequence advances the column once, exactly as the terminal draws it.
+ */
+function graphemesOf(text) {
+    return Array.from(segmenter.segment(text), ({ segment }) => segment);
+}

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

@@ -25,7 +25,17 @@ export interface EditorVisualMap {
     readonly positions: VisualPosition[];
     readonly cursor: VisualPosition;
 }
-/** Map graphemes to hard-wrapped rows, sharing tab stops and caret reservation. */
+/**
+ * Map graphemes to hard-wrapped rows, sharing tab stops and caret reservation.
+ *
+ * THE TAB STOP IS THE TERMINAL'S (`TAB_WIDTH`), NOT AN EDITOR-SIZED FOUR. It
+ * used to be four, while the transcript handed the raw `\t` to `<Text>` and
+ * the terminal painted it at eight: the same pasted table sat one column off
+ * from itself before and after sending. A tab that would cross the right edge
+ * is still clipped to the row (the caret cannot point past the last cell), so
+ * a tab STRADDLING the wrap is the one shape where the draft and the stored
+ * text can differ by the remainder of the advance.
+ */
 export declare function buildEditorVisualMap(input: {
     buffer: string;
     cols: number;

package/dist/ui/editor-navigation.js

@@ -1,5 +1,6 @@
 /** Shared UTF-16 grapheme boundaries and terminal-cell layout for the editor. */
 import stringWidth from 'string-width';
+import { TAB_WIDTH } from './display-tab.js';
 const segmenter = new Intl.Segmenter(undefined, { granularity: 'grapheme' });
 /** Segment text without changing its UTF-16 offsets or stored whitespace. */
 export function graphemes(text) {
@@ -31,7 +32,17 @@ export function graphemeWidth(text) {
         return 1;
     return stringWidth(text);
 }
-/** Map graphemes to hard-wrapped rows, sharing tab stops and caret reservation. */
+/**
+ * Map graphemes to hard-wrapped rows, sharing tab stops and caret reservation.
+ *
+ * THE TAB STOP IS THE TERMINAL'S (`TAB_WIDTH`), NOT AN EDITOR-SIZED FOUR. It
+ * used to be four, while the transcript handed the raw `\t` to `<Text>` and
+ * the terminal painted it at eight: the same pasted table sat one column off
+ * from itself before and after sending. A tab that would cross the right edge
+ * is still clipped to the row (the caret cannot point past the last cell), so
+ * a tab STRADDLING the wrap is the one shape where the draft and the stored
+ * text can differ by the remainder of the advance.
+ */
 export function buildEditorVisualMap(input) {
     const cols = Math.max(1, Math.floor(input.cols));
     const cursor = snapGrapheme(input.buffer, input.cursor);
@@ -50,12 +61,12 @@ export function buildEditorVisualMap(input) {
             breakRow();
             continue;
         }
-        let width = part.text === '\t' ? Math.min(cols, 4 - column % 4)
+        let width = part.text === '\t' ? Math.min(cols, TAB_WIDTH - column % TAB_WIDTH)
             : graphemeWidth(part.text);
         if (column > 0 && column + width > cols) {
             breakRow();
             if (part.text === '\t')
-                width = Math.min(cols, 4);
+                width = Math.min(cols, TAB_WIDTH);
         }
         locate(part.index);
         rows[rows.length - 1].push({ ...part,

package/dist/ui/entries/QueuedEntry.js

@@ -13,10 +13,13 @@ import { jsx as _jsx } from "react/jsx-runtime";
 import React from 'react';
 import { Text } from 'ink';
 import { pickGlyphs } from '../glyphs.js';
+import { expandTabs } from '../display-tab.js';
 function QueuedEntryImpl({ text, theme, caps, }) {
     const glyphs = pickGlyphs(caps);
     const lines = text.split('\n');
-    const first = lines[0] ?? '';
+    // Same reason as `UserEntry`: a queued draft is a draft, so its TABs must
+    // occupy the columns the composer showed them at.
+    const first = expandTabs(lines[0] ?? '');
     const extra = lines.length - 1;
     const suffix = extra > 0 ? ` ${glyphs.ellipsis}+${extra} line${extra === 1 ? '' : 's'}` : '';
     return (_jsx(Text, { wrap: "truncate", color: theme.muted, children: `Queue: ${first}${suffix}` }));

package/dist/ui/entries/UserEntry.js

@@ -14,9 +14,16 @@ import React from 'react';
 import { Box, Text } from 'ink';
 import { pickGlyphs } from '../glyphs.js';
 import { USER_ENTRY_MAX_ROWS } from '../composer-limits.js';
+import { expandTabs } from '../display-tab.js';
 function UserEntryImpl({ text, theme, caps, }) {
     const glyphs = pickGlyphs(caps);
-    const all = text.split('\n');
+    // TAB IS EXPANDED HERE, AT THE RENDER BOUNDARY, AND NOWHERE ABOVE IT.
+    // The payload keeps its `\t` (the model must receive the original
+    // indentation), so `<Text>` used to hand the raw byte to the terminal and
+    // the terminal painted an EIGHT-column stop while the composer painted a
+    // FOUR-column one. Splitting first and expanding per line keeps this row
+    // identical to the row the user saw in the draft.
+    const all = text.split('\n').map((line) => expandTabs(line));
     // A submitted 5 000-line paste otherwise asks Yoga to lay out 5 000 nodes
     // inside a measured entry -- the hazard `render-cache.ts:37` already records
     // in the same words ("a multi-megabyte 'code block' is almost always a pasted

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/layout/virtual-window.js

@@ -32,9 +32,11 @@
  * `selectWindow` takes `offset` as an INPUT, would close a loop from the offset
  * through the mounted set and the measured heights back to the offset.
  */
+import stringWidth from 'string-width';
 import { FAST_LIMITS } from '../../fast/limits.js';
 import { COMPACTION_LIMITS } from '../../compaction/limits.js';
 import { GUTTER_WIDTH } from './Gutter.js';
+import { expandTabs } from '../display-tab.js';
 import { USER_ENTRY_MAX_ROWS } from '../composer-limits.js';
 export const VIRTUAL_LIMITS = {
     /**
@@ -159,21 +161,52 @@ export function entryRevision(entry) {
 export function heightKey(entry, cols, expanded, density, flags = '') {
     return `${entry.id}|${entryRevision(entry)}|${cols}|${expanded ? 1 : 0}|${density}|${flags}`;
 }
-/** Rows a string occupies at `usable` columns, wrapping included. At least 1. */
+/**
+ * Rows a string occupies at `usable` columns, wrapping included. At least 1.
+ *
+ * COUNTED IN DISPLAY COLUMNS, NOT UTF-16 CODE UNITS, and the difference is a
+ * correctness bug rather than a nicety: a CJK glyph is one code unit and two
+ * cells, and a TAB is one code unit and up to `TAB_WIDTH` cells. Counting code
+ * units therefore UNDER-estimates, which this file's own note names as the
+ * unsafe direction ("an over-estimate makes the scroll position slightly
+ * conservative and self-corrects ... an under-estimate can put the newest
+ * output off the bottom of a viewport the user believes is pinned"). It also
+ * had to change together with the renderers: a stored `\t` is now expanded at
+ * paint time, so measuring the unexpanded string would keep the estimate short
+ * while the painted row got taller.
+ */
 function wrappedRows(text, usable) {
     const width = Math.max(1, usable);
     let rows = 0;
-    let lineLen = 0;
-    for (let i = 0; i < text.length; i += 1) {
-        if (text.charCodeAt(i) === 10) {
-            rows += Math.max(1, Math.ceil(lineLen / width));
-            lineLen = 0;
-        }
-        else {
-            lineLen += 1;
-        }
+    let start = 0;
+    for (;;) {
+        const end = text.indexOf('\n', start);
+        const line = end === -1 ? text.slice(start) : text.slice(start, end);
+        rows += Math.max(1, Math.ceil(displayColumns(line) / width));
+        if (end === -1)
+            return rows;
+        start = end + 1;
     }
-    return rows + Math.max(1, Math.ceil(lineLen / width));
+}
+/**
+ * Printable ASCII with no TAB: one code unit is one cell, so the width table is
+ * not consulted at all.
+ *
+ * THE FAST PATH IS LOAD-BEARING, not a micro-optimisation. `stringWidth`
+ * strips ANSI and walks the East-Asian width table for every code point, and
+ * this function runs over EVERY unmeasured entry of a 10 000-entry document
+ * (`render-budget.test.tsx` mounts exactly that); measuring them all with the
+ * table turned that test into a timeout. Transcript text is overwhelmingly
+ * ASCII, so the branch is taken almost always.
+ */
+const PLAIN_ASCII = /^[\x20-\x7e]*$/;
+/** Display columns of one logical line: TABs expanded, CJK counted twice. */
+function displayColumns(line) {
+    if (line.indexOf('\t') === -1 && PLAIN_ASCII.test(line))
+        return line.length;
+    // `expandTabs` mirrors what `entries/*` paints; `stringWidth` is the width
+    // table the composer already wraps with, so the two agree on CJK and emoji.
+    return stringWidth(expandTabs(line));
 }
 /** Collapsed preview rows in `ToolCard`; duplicated as a NUMBER, not imported. */
 const TOOL_COLLAPSED_LINES = 8;

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.
  *