@aragon-agent/cli 0.6.46 → 0.6.48

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

@@ -1,107 +0,0 @@
-/**
- * Markdown parsing layer (spec §4.7). Pure and React-free so the grammar can be
- * 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.
- */
-/** Heading levels are rendered with three distinct weights, not one (§4.7). */
-export interface HeadingBlock {
-    kind: 'heading';
-    level: 1 | 2 | 3 | 4 | 5 | 6;
-    text: string;
-}
-export interface RuleBlock {
-    kind: 'rule';
-}
-/** Column alignment carried by a table's `|---|:--:|` divider row. */
-export type Align = 'left' | 'right' | 'center';
-export interface TableBlock {
-    kind: 'table';
-    /** Already column-aligned; render as plain monospace rows. */
-    rows: string[][];
-    align: Align[];
-}
-export declare function parseHeading(line: string): HeadingBlock | null;
-export declare function isRule(line: string): boolean;
-/** Split one `| a | b |` row into trimmed cells. Returns null if not a row. */
-export declare function parseTableRow(line: string): string[] | null;
-/** Is this the `|---|:--:|` divider that makes the preceding row a header? */
-export declare function isTableDivider(line: string): boolean;
-export declare function tableAlignments(dividerLine: string): TableBlock['align'];
-/**
- * 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 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.
- *
- * `line` is deliberately UNPARSED: heading / rule / quote / bullet detection is
- * a handful of regexes over one short string and is done at render time, where
- * the theme and the glyph set live. Caching a themed element instead would make
- * `/theme` a no-op until the cache evicted (K-5).
- */
-export type MdBlock = {
-    kind: 'code';
-    code: string;
-    lang: string;
-} | {
-    kind: 'table';
-    rows: string[][];
-    align: Align[];
-} | {
-    kind: 'line';
-    text: string;
-};
-/** Split a document into fenced code, pipe tables, and everything else. */
-export declare function parseMarkdownBlocks(text: string): MdBlock[];
-export type InlineSpan = {
-    kind: 'text';
-    text: string;
-} | {
-    kind: 'code';
-    text: string;
-} | {
-    kind: 'bold';
-    text: string;
-} | {
-    kind: 'italic';
-    text: string;
-} | {
-    kind: 'strike';
-    text: string;
-};
-/**
- * Two passes, and that ordering is the fix (§4.7).
- *
- * The old single regex alternated `code | bold | italic` at the same level, so
- * `**bold with `code` inside**` matched neither branch cleanly and rendered as
- * literal asterisks. Splitting code out FIRST — and never looking for emphasis
- * inside a code span — resolves both cases: emphasis around code now works, and
- * asterisks inside code stay literal, which is what a shell snippet needs.
- */
-export declare function parseInline(text: string): InlineSpan[];

package/dist/ui/markdown-blocks.js

@@ -1,240 +0,0 @@
-/**
- * Markdown parsing layer (spec §4.7). Pure and React-free so the grammar can be
- * 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,})$/;
-const TABLE_ROW_RE = /^\s*\|(.+)\|\s*$/;
-const TABLE_DIVIDER_CELL_RE = /^:?-{1,}:?$/;
-export function parseHeading(line) {
-    const m = HEADING_RE.exec(line);
-    if (!m)
-        return null;
-    return { kind: 'heading', level: m[1].length, text: m[2] ?? '' };
-}
-export function isRule(line) {
-    return RULE_RE.test(line.trim());
-}
-/** Split one `| a | b |` row into trimmed cells. Returns null if not a row. */
-export function parseTableRow(line) {
-    const m = TABLE_ROW_RE.exec(line);
-    if (!m)
-        return null;
-    return m[1].split('|').map((c) => c.trim());
-}
-/** Is this the `|---|:--:|` divider that makes the preceding row a header? */
-export function isTableDivider(line) {
-    const cells = parseTableRow(line);
-    if (!cells || cells.length === 0)
-        return false;
-    return cells.every((c) => TABLE_DIVIDER_CELL_RE.test(c));
-}
-export function tableAlignments(dividerLine) {
-    const cells = parseTableRow(dividerLine) ?? [];
-    return cells.map((c) => {
-        const left = c.startsWith(':');
-        const right = c.endsWith(':');
-        if (left && right)
-            return 'center';
-        if (right)
-            return 'right';
-        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 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, 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) => displayColumns(r[c] ?? '')), 0);
-    }
-    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 };
-        }
-        body.push(lines[i] ?? '');
-        i += 1;
-    }
-    return { code: body.join('\n'), next: i };
-}
-/** Split a document into fenced code, pipe tables, and everything else. */
-export function parseMarkdownBlocks(text) {
-    // 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 = parseFenceOpen(line.trim());
-        if (fence) {
-            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.
-        const headerCells = parseTableRow(line);
-        if (headerCells && i + 1 < lines.length && isTableDivider(lines[i + 1] ?? '')) {
-            const align = tableAlignments(lines[i + 1] ?? '');
-            const rows = [headerCells];
-            i += 2;
-            while (i < lines.length) {
-                const cells = parseTableRow(lines[i] ?? '');
-                if (!cells)
-                    break;
-                rows.push(cells);
-                i += 1;
-            }
-            blocks.push({ kind: 'table', rows, align });
-            continue;
-        }
-        blocks.push({ kind: 'line', text: line });
-        i += 1;
-    }
-    return blocks;
-}
-const CODE_RE = /`[^`]+`/g;
-const EMPHASIS_RE = /(\*\*[^*]+\*\*|~~[^~]+~~|\*[^*]+\*)/g;
-/**
- * Two passes, and that ordering is the fix (§4.7).
- *
- * The old single regex alternated `code | bold | italic` at the same level, so
- * `**bold with `code` inside**` matched neither branch cleanly and rendered as
- * literal asterisks. Splitting code out FIRST — and never looking for emphasis
- * inside a code span — resolves both cases: emphasis around code now works, and
- * asterisks inside code stay literal, which is what a shell snippet needs.
- */
-export function parseInline(text) {
-    const spans = [];
-    let last = 0;
-    let m;
-    CODE_RE.lastIndex = 0;
-    while ((m = CODE_RE.exec(text)) !== null) {
-        if (m.index > last)
-            pushEmphasis(spans, text.slice(last, m.index));
-        spans.push({ kind: 'code', text: m[0].slice(1, -1) });
-        last = m.index + m[0].length;
-    }
-    if (last < text.length)
-        pushEmphasis(spans, text.slice(last));
-    return spans;
-}
-function pushEmphasis(out, text) {
-    let last = 0;
-    let m;
-    EMPHASIS_RE.lastIndex = 0;
-    while ((m = EMPHASIS_RE.exec(text)) !== null) {
-        if (m.index > last)
-            out.push({ kind: 'text', text: text.slice(last, m.index) });
-        const token = m[0];
-        if (token.startsWith('**'))
-            out.push({ kind: 'bold', text: token.slice(2, -2) });
-        else if (token.startsWith('~~'))
-            out.push({ kind: 'strike', text: token.slice(2, -2) });
-        else
-            out.push({ kind: 'italic', text: token.slice(1, -1) });
-        last = m.index + token.length;
-    }
-    if (last < text.length)
-        out.push({ kind: 'text', text: text.slice(last) });
-}

package/dist/ui/overlays/AgentsBoardOverlay.d.ts

@@ -1,57 +0,0 @@
-/**
- * AgentsBoardOverlay — the read-only detail board behind `Ctrl+B` / `/agents`
- * (tui-subagent-panel §4.4 / §6.3).
- *
- * READ-ONLY IS THE SAFETY BOUNDARY (§2.2). Nothing here nudges, kills or re-dispatches
- * a child, and no new `TeamEvent` member was introduced to feed it: a board that can
- * only read can never kill a healthy child, which is the whole reason this is a
- * second surface rather than a control panel.
- *
- * ONE SCREEN, CONTROLLED MODE. `OverlayFrame`'s controlled form already owns paging,
- * the position indicator and the narrow-terminal degradation, and `helpRows` /
- * `projectQueueRows` are the precedent. A second pane would mean a second horizontal
- * budget inside Ink for a benefit the board's 2-up field rows already deliver.
- *
- * IT DOES NOT GO BLANK WHEN THE DISPATCH ENDS (D-9). `state.team` becomes `null` the
- * frame the dispatch settles, and a reader would lose the child they were reading
- * about at the exact moment they wanted the post-mortem. The last live snapshot is
- * therefore FROZEN (a copy, held in a ref) and keeps rendering with a
- * `dispatch ended` row; a board opened AFTER the dispatch has ended builds from the
- * transcript's settled `team` entry instead (`resolveBoardSource`), which is where the
- * `result` section earns its place - the error is the one fact that is never stripped.
- *
- * NO `ink-spinner` HERE (D-13): `spinner-census.test.ts` pins the exact list of files
- * that mount an animated spinner, and this is a reading surface, not an animation.
- * The panel is where motion belongs.
- *
- * AND NO MOTION PROP (v2 implementation note, appended to the spec's
- * "implementation findings"). Because nothing here animates, a motion flag would be a
- * prop with no consumer - and worse, the same census counts how many times `App.tsx`
- * hands the RAW motion flag to a child and asserts the count is EXACTLY ONE, so passing
- * it from the board's branch would break a shipped guard rail for no gain.
- *
- * ASCII ONLY: every symbol comes through `glyphs`.
- */
-import React from 'react';
-import type { Entry } from '../../agent/reducer.js';
-import type { Theme } from '../theme.js';
-import type { TermCapabilities } from '../capabilities.js';
-import type { TeamSnapshot } from '../../team/types.js';
-export interface AgentsBoardOverlayProps {
-    /** The live snapshot; `null` once the dispatch has settled. */
-    team: TeamSnapshot | null;
-    /** The transcript, for the settled fallback (D-9 path 4). */
-    entries: readonly Entry[];
-    /** Overlay content width (`App`'s `viewCols`). */
-    cols: number;
-    maxRows: number;
-    scrollOffset: number;
-    onScrollClamp: (offset: number) => void;
-    isActive: boolean;
-    native: boolean;
-    theme: Theme;
-    caps: TermCapabilities;
-    /** Injectable clock, so the board's tests do not depend on wall time. */
-    now?: number;
-}
-export declare function AgentsBoardOverlay({ team, entries, cols, maxRows, scrollOffset, onScrollClamp, isActive, native, theme, caps, now, }: AgentsBoardOverlayProps): React.ReactElement;

package/dist/ui/overlays/AgentsBoardOverlay.js

@@ -1,183 +0,0 @@
-import { jsx as _jsx } from "react/jsx-runtime";
-/**
- * AgentsBoardOverlay — the read-only detail board behind `Ctrl+B` / `/agents`
- * (tui-subagent-panel §4.4 / §6.3).
- *
- * READ-ONLY IS THE SAFETY BOUNDARY (§2.2). Nothing here nudges, kills or re-dispatches
- * a child, and no new `TeamEvent` member was introduced to feed it: a board that can
- * only read can never kill a healthy child, which is the whole reason this is a
- * second surface rather than a control panel.
- *
- * ONE SCREEN, CONTROLLED MODE. `OverlayFrame`'s controlled form already owns paging,
- * the position indicator and the narrow-terminal degradation, and `helpRows` /
- * `projectQueueRows` are the precedent. A second pane would mean a second horizontal
- * budget inside Ink for a benefit the board's 2-up field rows already deliver.
- *
- * IT DOES NOT GO BLANK WHEN THE DISPATCH ENDS (D-9). `state.team` becomes `null` the
- * frame the dispatch settles, and a reader would lose the child they were reading
- * about at the exact moment they wanted the post-mortem. The last live snapshot is
- * therefore FROZEN (a copy, held in a ref) and keeps rendering with a
- * `dispatch ended` row; a board opened AFTER the dispatch has ended builds from the
- * transcript's settled `team` entry instead (`resolveBoardSource`), which is where the
- * `result` section earns its place - the error is the one fact that is never stripped.
- *
- * NO `ink-spinner` HERE (D-13): `spinner-census.test.ts` pins the exact list of files
- * that mount an animated spinner, and this is a reading surface, not an animation.
- * The panel is where motion belongs.
- *
- * AND NO MOTION PROP (v2 implementation note, appended to the spec's
- * "implementation findings"). Because nothing here animates, a motion flag would be a
- * prop with no consumer - and worse, the same census counts how many times `App.tsx`
- * hands the RAW motion flag to a child and asserts the count is EXACTLY ONE, so passing
- * it from the board's branch would break a shipped guard rail for no gain.
- *
- * ASCII ONLY: every symbol comes through `glyphs`.
- */
-import { useCallback, useEffect, useRef, useState } from 'react';
-import { Text, useInput } from 'ink';
-import { pickGlyphs } from '../glyphs.js';
-import { OverlayFrame } from '../layout/OverlayFrame.js';
-import { buildAgentBoardRows, resolveBoardSource, resolveSelection, } from '../layout/agents-board.js';
-/** `OverlayFrame`'s own breakpoint, mirrored so the chrome estimate cannot drift. */
-const FRAME_BORDERLESS_COLS = 48;
-/**
- * Close a frozen live snapshot: the dispatch it described has ended.
- *
- * `durationMs` is derived from the LAST frame the snapshot was live, so the board's
- * summary shows the dispatch's real total instead of a clock that keeps running against
- * a dispatch nobody can see any more. When the snapshot never had a `startedAt` there is
- * nothing to derive and the field stays absent - the LIVE-ONLY rule turns that into an
- * empty clock cell rather than an invented number (§4.4.2).
- */
-function settleFrozen(frozen) {
-    const { source, at } = frozen;
-    const total = source.startedAt === undefined ? undefined : Math.max(0, at - source.startedAt);
-    return {
-        ...source,
-        active: false,
-        ...(total !== undefined ? { durationMs: total } : {}),
-    };
-}
-/** Palette slot -> theme colour. One place, so a tone can never be spelled twice. */
-function toneColor(tone, theme) {
-    switch (tone) {
-        case 'accent':
-            return theme.accent;
-        case 'primary':
-            return theme.primary;
-        case 'muted':
-            return theme.muted;
-        case 'warn':
-            return theme.noticeWarn;
-        case 'error':
-            return theme.noticeError;
-        case 'done':
-            return theme.toolDone;
-        case 'hint':
-            return theme.hintFg;
-    }
-}
-export function AgentsBoardOverlay({ team, entries, cols, maxRows, scrollOffset, onScrollClamp, isActive, native, theme, caps, now, }) {
-    const glyphs = pickGlyphs(caps);
-    const at = now ?? Date.now();
-    const [selectedLabel, setSelectedLabel] = useState(null);
-    /**
-     * THE FROZEN SNAPSHOT (D-9), plus the clock reading it was frozen at.
-     *
-     * A ref rather than state on purpose: it is written from an effect that must not
-     * trigger a render of its own, and reading it during the render that FIRST sees
-     * `team === null` is what keeps the board from blinking empty for one frame. The
-     * timestamp is kept WITH the snapshot because a frozen live source still says
-     * `active: true` - it was live when it was copied - and a board that kept believing
-     * that would never show its `dispatch ended` row nor stop its clock.
-     */
-    const frozen = useRef(null);
-    const live = team === null ? null : resolveBoardSource({ team, entries });
-    useEffect(() => {
-        if (live !== null)
-            frozen.current = { source: live, at };
-    }, [live, at]);
-    // PRIORITY: live > frozen > the most recent settled entry (§4.4.5). The frozen copy
-    // only ever takes over on the frame the live snapshot disappears, and a NEW dispatch
-    // overwrites it on its own first frame, so the two paths cannot both be active.
-    //
-    // A FROZEN SOURCE IS SETTLED, and it is closed here rather than at the moment of
-    // copying: `active: false` is what draws `dispatch ended` (task AC-17), and taking
-    // `durationMs` from the freeze instant stops the clock at the dispatch's real end
-    // instead of letting it count up forever from a snapshot that no longer exists.
-    const frozenSource = frozen.current === null ? null : settleFrozen(frozen.current);
-    const source = live ?? frozenSource ?? resolveBoardSource({ team: null, entries });
-    const selected = source === null ? null : resolveSelection(source.runs, selectedLabel);
-    /**
-     * UP/DOWN MOVES THE CHILD CURSOR, and a change of child RESETS the scroll.
-     *
-     * `agents` deliberately does NOT join `App`'s row-scroll set (`help | plan | queue`):
-     * the same trade `settings` makes with its field cursor, where Up/Down is worth more
-     * as navigation than as a six-row scroll. `PgUp` / `PgDn` / the wheel still page the
-     * board through `App`'s `controlled` set, so no reading gesture is lost.
-     */
-    const move = useCallback((delta) => {
-        const runs = source?.runs ?? [];
-        if (runs.length === 0)
-            return;
-        const current = resolveSelection(runs, selectedLabel);
-        const index = current === null ? -1 : runs.findIndex((run) => run.label === current.label);
-        const next = runs[Math.min(runs.length - 1, Math.max(0, index + delta))];
-        if (next === undefined || next.label === current?.label)
-            return;
-        setSelectedLabel(next.label);
-        // The documented semantic of this port is "the offset should now be 0" (§6.3).
-        onScrollClamp(0);
-    }, [onScrollClamp, selectedLabel, source]);
-    useInput((_input, key) => {
-        if (!isActive)
-            return;
-        if (key.upArrow)
-            move(-1);
-        else if (key.downArrow)
-            move(1);
-    }, { isActive });
-    // THE FRAME'S CHROME IS NOT FREE (v2 implementation note). `cols` arrives as the
-    // overlay's FRAME width (`App`'s `viewCols`), and `OverlayFrame` spends 4 of those
-    // columns on its border plus `paddingX={1}` (2 in the narrow rail form, which drops
-    // the right border and the right padding). A board laid out against the frame width
-    // therefore has its LAST four columns eaten by Ink's truncation - which lands exactly
-    // on the right-anchored figures this board exists to align. `helpRows` gets away with
-    // it because its rows are prose; these are a table.
-    const contentCols = Math.max(1, cols - (cols >= FRAME_BORDERLESS_COLS ? 4 : 2));
-    const rows = source === null
-        ? [{
-                key: 'empty',
-                kind: 'hint',
-                text: 'No subagent dispatch yet.',
-                tone: 'muted',
-            }]
-        : buildAgentBoardRows({
-            source,
-            cols: contentCols,
-            now: at,
-            selectedLabel: selected?.label ?? null,
-            glyphs,
-            native,
-        });
-    // The `dispatch ended` banner is a ROW rather than a title swap: the title is the
-    // frame's own ("Agents"), and replacing it would hide which screen the reader is on.
-    const endedRow = source !== null && !source.active
-        ? [{
-                key: 'ended',
-                kind: 'hint',
-                text: `dispatch ended ${glyphs.midDot} Esc to close`,
-                tone: 'warn',
-            }]
-        : [];
-    const elements = [...endedRow, ...rows].map((row) => (_jsx(Text, { wrap: "truncate", color: toneColor(row.tone, theme), ...(row.kind === 'section' ? { bold: true } : {}), children: row.text }, row.key)));
-    // THE HINT SHRINKS WITH THE FRAME. `OverlayFrame` prints the hint as one unwrapped
-    // row, so a 41-column hint inside a 30-column frame makes the FRAME 41 wide - the
-    // board would overflow the terminal and take the overlay's border with it.
-    const hint = contentCols >= 60
-        ? `Esc close ${glyphs.midDot} Up/Down child ${glyphs.midDot} PgUp/PgDn scroll`
-        : contentCols >= 30
-            ? `Esc close ${glyphs.midDot} Up/Down child`
-            : 'Esc close';
-    return (_jsx(OverlayFrame, { title: "Agents", hint: hint, maxRows: maxRows, cols: cols, rows: elements, scrollOffset: scrollOffset, onScrollClamp: onScrollClamp, theme: theme, caps: caps }));
-}

package/dist/ui/overlays/ConfirmDialog.d.ts

@@ -1,31 +0,0 @@
-/**
- * Confirm dialog — Yes/No gate for `confirmTools` mode. Resolves the pending
- * tool-execution promise (spec §3.6). `y` = approve; `n`/Enter/Esc = reject
- * (Enter follows the safe default shown by the capital N in the "(y/N)" prompt,
- * since this gates mutating tools like write_file/edit_file/bash).
- */
-import React from 'react';
-import type { Theme } from '../theme.js';
-import type { TermCapabilities } from '../capabilities.js';
-export interface ConfirmState {
-    summary: string;
-    resolve: (approved: boolean) => void;
-}
-interface ConfirmDialogProps {
-    isActive?: boolean;
-    state: ConfirmState;
-    maxRows: number;
-    cols: number;
-    theme: Theme;
-    caps: TermCapabilities;
-    onClose: () => void;
-}
-/**
- * Self-managed (mode B) and deliberately without a position indicator: five
- * rows do not need scrolling, and `state.summary` may itself be multi-line, so
- * element slicing would be meaningless here. The frame is used purely so the
- * title and border match the other three overlays; the existing `useInput` is
- * untouched.
- */
-export declare function ConfirmDialog({ state, isActive, maxRows, cols, theme, caps, onClose, }: ConfirmDialogProps): React.ReactElement;
-export {};

package/dist/ui/overlays/ConfirmDialog.js

@@ -1,44 +0,0 @@
-import { jsx as _jsx } from "react/jsx-runtime";
-/**
- * Confirm dialog — Yes/No gate for `confirmTools` mode. Resolves the pending
- * tool-execution promise (spec §3.6). `y` = approve; `n`/Enter/Esc = reject
- * (Enter follows the safe default shown by the capital N in the "(y/N)" prompt,
- * since this gates mutating tools like write_file/edit_file/bash).
- */
-import { useState } from 'react';
-import { Text, useInput } from 'ink';
-import { pickGlyphs } from '../glyphs.js';
-import { wrapToRows } from '../layout/wrap-rows.js';
-import { OverlayFrame } from '../layout/OverlayFrame.js';
-/**
- * Self-managed (mode B) and deliberately without a position indicator: five
- * rows do not need scrolling, and `state.summary` may itself be multi-line, so
- * element slicing would be meaningless here. The frame is used purely so the
- * title and border match the other three overlays; the existing `useInput` is
- * untouched.
- */
-export function ConfirmDialog({ state, isActive = true, maxRows, cols, theme, caps, onClose, }) {
-    const glyphs = pickGlyphs(caps);
-    const [offset, setOffset] = useState(0);
-    useInput((input, key) => {
-        if (!isActive)
-            return;
-        if (key.pageUp || key.upArrow) {
-            setOffset(n => Math.max(0, n - 1));
-            return;
-        }
-        if (key.pageDown || key.downArrow) {
-            setOffset(n => n + 1);
-            return;
-        }
-        if (input === 'y' || input === 'Y') {
-            state.resolve(true);
-            onClose();
-        }
-        else if (input === 'n' || input === 'N' || key.return || key.escape) {
-            state.resolve(false);
-            onClose();
-        }
-    });
-    return (_jsx(OverlayFrame, { title: "Confirm action", hint: "y approve | n/Enter/Esc reject | PgDn", maxRows: maxRows, cols: cols, theme: theme, caps: caps, scrollOffset: offset, onScrollClamp: setOffset, rows: wrapToRows(state.summary, Math.max(1, cols - 4)).map((line, index) => _jsx(Text, { wrap: "truncate", color: theme.assistant, children: line || ' ' }, index)) }));
-}