@aragon-agent/cli 0.6.28 → 0.6.31

package/dist/ui/frame-differ.d.ts

@@ -150,5 +150,17 @@ export interface FrameDiffer {
      * appears one frame later instead of never.
      */
     repaint(): string;
+    /**
+     * The stream was resized. Optional (tui-native-terminal-scroll §5.1): the
+     * full-screen differ does not implement it and is invalidated instead, which is
+     * its existing behaviour; the scrollback writer keeps its cache for a reflow
+     * estimate.
+     */
+    onResize?(): void;
+    /**
+     * An own write that moves neither a cell nor the cursor (OSC 52 copy). Optional
+     * for the same reason: absent, the write invalidates the cache as before.
+     */
+    cursorNeutralWrite?(): void;
 }
 export declare function createFrameDiffer(options: FrameDifferOptions): FrameDiffer;

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/overlays/HelpOverlay.d.ts

@@ -14,4 +14,4 @@ import React from 'react';
 import type { Theme } from '../theme.js';
 import type { TermCapabilities } from '../capabilities.js';
 /** Build the overlay's rows. Exported so `app.test.tsx` can count them. */
-export declare function helpRows(theme: Theme, caps: TermCapabilities): React.ReactElement[];
+export declare function helpRows(theme: Theme, caps: TermCapabilities, native?: boolean): React.ReactElement[];

package/dist/ui/overlays/HelpOverlay.js

@@ -2,7 +2,25 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { Text } from 'ink';
 import { pickGlyphs } from '../glyphs.js';
 const KEY_PAD = 24;
-function keyRows(times) {
+/**
+ * Rows that only make sense when the APPLICATION scrolls and selects. In native
+ * scroll mode (tui-native-terminal-scroll §4.7) the terminal does both, so they are
+ * dropped and one honest row replaces them.
+ */
+const APP_SCROLL_ROWS = new Set([
+    'Shift+Up / Shift+Down', 'Wheel', 'Shift+Wheel', 'Drag right edge', '^N',
+    'Drag text (left button)', 'Ctrl+C (with a selection)',
+]);
+function keyRows(times, native = false) {
+    const all = allKeyRows(times);
+    if (!native)
+        return all;
+    return all
+        .filter(([key]) => !APP_SCROLL_ROWS.has(key))
+        .map(([key, description]) => key === 'PgUp / PgDn' ? [key, 'Page through an open overlay'] : [key, description])
+        .concat([['Scroll', 'Use your terminal (wheel, Shift+PgUp, scrollbar, search)']]);
+}
+function allKeyRows(times) {
     return [
         ['Enter', 'Submit (idle) / queue steering (running); re-pins to the newest output'],
         ['Alt+Enter / Shift+Enter', 'Newline when supported; the host may intercept either binding'],
@@ -133,13 +151,13 @@ const FAST_ROWS = [
     ['<fast_review>', 'An automated second opinion from the fast model - advice, not the user'],
 ];
 /** Build the overlay's rows. Exported so `app.test.tsx` can count them. */
-export function helpRows(theme, caps) {
+export function helpRows(theme, caps, native = false) {
     const glyphs = pickGlyphs(caps);
     const rows = [];
     const section = (title) => (_jsx(Text, { wrap: "truncate", color: theme.accent, bold: true, children: title }, `s-${title}`));
     const pair = (k, d) => (_jsxs(Text, { wrap: "truncate", children: [_jsx(Text, { color: theme.primary, children: k.padEnd(KEY_PAD) }), _jsx(Text, { color: theme.muted, children: d })] }, `r-${k}`));
     rows.push(section('Keybindings'));
-    for (const [k, d] of keyRows(glyphs.times))
+    for (const [k, d] of keyRows(glyphs.times, native))
         rows.push(pair(k, d));
     rows.push(section('Slash commands'));
     for (const [c, d] of COMMANDS)

package/dist/ui/screen.d.ts

@@ -71,6 +71,22 @@ export interface AltScreenOptions {
  * CI) — writing screen-control sequences into a redirected file corrupts it.
  */
 export declare function enterAltScreen(stdout: NodeJS.WriteStream | undefined, options?: AltScreenOptions): ScreenHandle;
+export interface NativeScreenOptions {
+    /** Same discipline as `AltScreenOptions.bracketedPaste`: a filter that consumes it exists. */
+    readonly bracketedPaste?: boolean;
+}
+/**
+ * Native-scroll mode's counterpart of `enterAltScreen` (tui-native-terminal-scroll
+ * §4.8 / D6): it deliberately does almost nothing. The main buffer stays in use so
+ * the conversation lands in the terminal's own scrollback; there is no alternate
+ * screen, no mouse reporting and no DEC 1007 save/restore.
+ *
+ * The only mode it touches is DEC 2004 (bracketed paste), which changes how input
+ * is encoded and has nothing to do with scrolling. Returns the SAME `ScreenHandle`
+ * shape, so the four idempotent restore paths in `cli.tsx` need not know which mode
+ * is running. A non-TTY stdout is a hard no-op, like `enterAltScreen`.
+ */
+export declare function enterNativeScreen(stdout: NodeJS.WriteStream | undefined, options?: NativeScreenOptions): ScreenHandle;
 /**
  * Replay the session summary into the normal buffer after `restore()`, so the
  * conversation does not evaporate along with the alternate screen.

package/dist/ui/screen.js

@@ -181,6 +181,38 @@ export function enterAltScreen(stdout, options = { mouse: false }) {
         setMouseCapture,
     };
 }
+/**
+ * Native-scroll mode's counterpart of `enterAltScreen` (tui-native-terminal-scroll
+ * §4.8 / D6): it deliberately does almost nothing. The main buffer stays in use so
+ * the conversation lands in the terminal's own scrollback; there is no alternate
+ * screen, no mouse reporting and no DEC 1007 save/restore.
+ *
+ * The only mode it touches is DEC 2004 (bracketed paste), which changes how input
+ * is encoded and has nothing to do with scrolling. Returns the SAME `ScreenHandle`
+ * shape, so the four idempotent restore paths in `cli.tsx` need not know which mode
+ * is running. A non-TTY stdout is a hard no-op, like `enterAltScreen`.
+ */
+export function enterNativeScreen(stdout, options = {}) {
+    if (!stdout || !stdout.isTTY || typeof stdout.write !== 'function')
+        return NOOP_HANDLE;
+    const bracketedPaste = options.bracketedPaste === true;
+    if (bracketedPaste)
+        safeWrite(stdout, ENABLE_BRACKETED_PASTE);
+    let restored = false;
+    return {
+        restore() {
+            if (restored)
+                return;
+            restored = true;
+            // 2004 is FORCED off rather than saved/restored, for the reason recorded at
+            // `DISABLE_BRACKETED_PASTE`. The cursor is shown again because Ink's
+            // log-update hides it and a signal kill never gives it back.
+            safeWrite(stdout, (bracketedPaste ? DISABLE_BRACKETED_PASTE : '') + SHOW_CURSOR);
+        },
+        // No mouse reporting in this mode: nothing to hand back or take again.
+        setMouseCapture() { },
+    };
+}
 /**
  * Replay the session summary into the normal buffer after `restore()`, so the
  * conversation does not evaporate along with the alternate screen.