@aragon-agent/cli 0.6.47 → 0.6.48

package/dist/ui/Composer.js

@@ -1,64 +0,0 @@
-import { jsx as _jsx } from "react/jsx-runtime";
-/** Input border and draft shell. Global action hints and activity live below the viewport. */
-import { useCallback, useState } from 'react';
-import { Box } from 'ink';
-import { HINT_FADE_AFTER } from '../config/schema.js';
-import { PromptInput } from './PromptInput.js';
-import { MODE_LABEL, nextMode } from '../agent/agent-mode.js';
-import { isGovernedModeValue } from './governance-status.js';
-/** Legacy helper retained for consumers and contract tests; not rendered by Composer. */
-export function runningHintClauses(opts) {
-    const { glyphs, services } = opts;
-    const clauses = [`${glyphs.enterKey} queue`, `esc${glyphs.times}2 interrupt`];
-    if (services > 0)
-        clauses.push(`ctrl+c stop ${services}`);
-    clauses.push(`ctrl+c${glyphs.times}2 exit`);
-    return clauses;
-}
-/** Compatibility formatter. Product hints use interaction-hints.ts. */
-function hintText(opts) {
-    const { running, submitCount, glyphs, mode, toggleKey, services } = opts;
-    const dot = ` ${glyphs.midDot} `;
-    if (running)
-        return runningHintClauses({ glyphs, services }).join(dot);
-    const toggle = `${toggleKey} ${MODE_LABEL[nextMode(mode)].toLowerCase()}`;
-    const stop = services > 0 ? [`ctrl+c stop ${services}`] : [];
-    if (submitCount >= HINT_FADE_AFTER)
-        return [...stop, toggle, '? help'].join(dot);
-    return [
-        ...stop,
-        `${glyphs.enterKey} send`,
-        `${glyphs.shiftEnter} newline`,
-        '/ commands',
-        '@ files',
-        toggle,
-        '? help',
-    ].join(dot);
-}
-/** Compatibility export for existing hint contract tests. */
-export const hintTextForTest = hintText;
-export function Composer({ deleteDisambiguated, onCompletionContextChange, cols, terminalRows, statusExpanded, cursorVisible, onInteraction, measureRef, isActive, reducedMotion, onEscape, onEscapeDismiss, running, history, commands, cwd, agentMode, posture, popupMaxRows, popupMaxHeight, onPopupRowsChange, onDraftRows, onDraftPresence, draftClearNonce, draftFill, insertMode, onNotice, theme, caps, onSubmit, onHelp, }) {
-    const [hasDraft, setHasDraft] = useState(false);
-    const onDraftChange = useCallback((next) => {
-        setHasDraft(next.hasDraft);
-        // Presence FIRST: the App ref must be current before the row-count
-        // report below can trigger the App render that reads it.
-        onDraftPresence?.(next.hasDraft);
-        onDraftRows?.(next.rows);
-    }, [onDraftPresence, onDraftRows]);
-    // Plan mode inserts ONE branch, above `draft` and below `running`. The
-    // ordering is load-bearing: an in-flight run's border must stay `toolRunning`,
-    // because "is it running" is more urgent than "which mode".
-    const borderColor = !isActive
-        ? theme.toolPending
-        : running
-            ? theme.toolRunning
-            : isGovernedModeValue(posture)
-                ? theme.governAccent
-                : agentMode === 'plan'
-                    ? theme.accent
-                    : hasDraft
-                        ? theme.focusBorder ?? theme.primary
-                        : theme.idleBorder ?? theme.border;
-    return (_jsx(Box, { ref: measureRef, width: cols, flexDirection: "column", flexShrink: 0, children: _jsx(PromptInput, { deleteDisambiguated: deleteDisambiguated, onCompletionContextChange: onCompletionContextChange, cols: cols, terminalRows: terminalRows, statusExpanded: statusExpanded, cursorVisible: cursorVisible, onInteraction: onInteraction, isActive: isActive, reducedMotion: reducedMotion, onEscape: onEscape, onEscapeDismiss: onEscapeDismiss, running: running, history: history, commands: commands, cwd: cwd, theme: theme, caps: caps, popupMaxRows: popupMaxRows, popupMaxHeight: popupMaxHeight, onPopupRowsChange: onPopupRowsChange, onSubmit: onSubmit, onHelp: onHelp, agentMode: agentMode, borderColor: borderColor, onDraftChange: onDraftChange, draftClearNonce: draftClearNonce, draftFill: draftFill, insertMode: insertMode, onNotice: onNotice }) }));
-}

package/dist/ui/GovernancePanel.d.ts

@@ -1,50 +0,0 @@
-/**
- * GovernancePanel - the legion panel (governance-mode section 10.3).
- *
- * ASCII ONLY: every glyph comes from `pickGlyphs`, through the layout.
- *
- * THIS COMPONENT ONLY COLOURS AND PLACES. Every decision - which tier, which columns, how
- * wide, what each cell says, which row is hidden - was made by
- * `layout/governance-panel.ts`, and the `layout` prop is REQUIRED: `App` builds it once to
- * learn the panel's height (the native band and the TODO rail both budget against it) and
- * hands the very same object here, so the number that decides whether the panel mounts is
- * the number it is drawn from. A panel that re-planned itself could draw a taller tier than
- * the one the band reserved, and the band clips the overflow in silence.
- *
- * IT REPLACES `TeamPanel` WHILE A GOVERNED STAGE RUNS (D-17), it does not stack with it:
- * the repo has been bitten by a "double roster" once (tui-subagent-double-roster), and a
- * governed dispatch is the one case where two live rosters would be the same children
- * listed twice.
- *
- * NO `ink-spinner` HERE, on purpose. While a governed stage runs the lead's turn is
- * running, the activity row owns the one spinner (single-spinner-while-running), and every
- * panel is handed the widened reduced-motion signal anyway - an animation here would never
- * play. The working marker is `statusGlyph(...)`, and `reducedMotion` is the USER's
- * preference: it only decides whether a score change flashes for four seconds or stays put.
- *
- * COLUMNS ARE FIXED-WIDTH BOXES with exactly one elastic cell (`governance-roster.ts`), the
- * lesson `TeamPanel` records at length: a flex-grown column under a fixed-height parent
- * stretches to its widest child and the cells to its right lose their offsets.
- */
-import React from 'react';
-import type { GovernanceSnapshot } from '../governance/types.js';
-import type { Theme } from './theme.js';
-import type { TermCapabilities } from './capabilities.js';
-import { type EliminatedSince } from './governance-status.js';
-import type { GovernancePanelLayout } from './layout/governance-panel.js';
-/**
- * The first-seen-eliminated map, kept across snapshots so a replaced member shows its
- * `replaced by ...` note for exactly one phase. Reset when the run changes or ends.
- *
- * A ref written during render is acceptable here because the write is idempotent
- * (`trackEliminated` returns the same object when nothing is new) and no other component
- * reads the ref - `App` reads only the returned value.
- */
-export declare function useEliminatedSince(snapshot: GovernanceSnapshot | null): EliminatedSince;
-export interface GovernancePanelProps {
-    /** Built by `buildGovernancePanelLayout`; the SAME object `App` read the height from. */
-    layout: GovernancePanelLayout;
-    theme: Theme;
-    caps: TermCapabilities;
-}
-export declare function GovernancePanel({ layout, theme, caps }: GovernancePanelProps): React.ReactElement | null;

package/dist/ui/GovernancePanel.js

@@ -1,77 +0,0 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-/**
- * GovernancePanel - the legion panel (governance-mode section 10.3).
- *
- * ASCII ONLY: every glyph comes from `pickGlyphs`, through the layout.
- *
- * THIS COMPONENT ONLY COLOURS AND PLACES. Every decision - which tier, which columns, how
- * wide, what each cell says, which row is hidden - was made by
- * `layout/governance-panel.ts`, and the `layout` prop is REQUIRED: `App` builds it once to
- * learn the panel's height (the native band and the TODO rail both budget against it) and
- * hands the very same object here, so the number that decides whether the panel mounts is
- * the number it is drawn from. A panel that re-planned itself could draw a taller tier than
- * the one the band reserved, and the band clips the overflow in silence.
- *
- * IT REPLACES `TeamPanel` WHILE A GOVERNED STAGE RUNS (D-17), it does not stack with it:
- * the repo has been bitten by a "double roster" once (tui-subagent-double-roster), and a
- * governed dispatch is the one case where two live rosters would be the same children
- * listed twice.
- *
- * NO `ink-spinner` HERE, on purpose. While a governed stage runs the lead's turn is
- * running, the activity row owns the one spinner (single-spinner-while-running), and every
- * panel is handed the widened reduced-motion signal anyway - an animation here would never
- * play. The working marker is `statusGlyph(...)`, and `reducedMotion` is the USER's
- * preference: it only decides whether a score change flashes for four seconds or stays put.
- *
- * COLUMNS ARE FIXED-WIDTH BOXES with exactly one elastic cell (`governance-roster.ts`), the
- * lesson `TeamPanel` records at length: a flex-grown column under a fixed-height parent
- * stretches to its widest child and the cells to its right lose their offsets.
- */
-import { useRef } from 'react';
-import { Box, Text } from 'ink';
-import { pickGlyphs } from './glyphs.js';
-import { trackEliminated } from './governance-status.js';
-import { GovernanceLine } from './GovernanceRun.js';
-import { PANEL_MARGIN_CELLS, } from './layout/governance-roster.js';
-/**
- * The first-seen-eliminated map, kept across snapshots so a replaced member shows its
- * `replaced by ...` note for exactly one phase. Reset when the run changes or ends.
- *
- * A ref written during render is acceptable here because the write is idempotent
- * (`trackEliminated` returns the same object when nothing is new) and no other component
- * reads the ref - `App` reads only the returned value.
- */
-export function useEliminatedSince(snapshot) {
-    const ref = useRef({ runId: null, since: {} });
-    if (snapshot === null) {
-        if (ref.current.runId !== null)
-            ref.current = { runId: null, since: {} };
-        return ref.current.since;
-    }
-    const base = ref.current.runId === snapshot.runId ? ref.current.since : {};
-    ref.current = { runId: snapshot.runId, since: trackEliminated(base, snapshot) };
-    return ref.current.since;
-}
-function Margin() {
-    return (_jsx(Box, { width: PANEL_MARGIN_CELLS, flexShrink: 0, children: _jsx(Text, { children: " " }) }));
-}
-function LineView({ line, theme }) {
-    return (_jsxs(Box, { flexDirection: "row", width: "100%", height: 1, flexShrink: 0, overflow: "hidden", children: [_jsx(Margin, {}), _jsx(Box, { flexGrow: 1, flexShrink: 1, overflow: "hidden", children: _jsx(GovernanceLine, { segments: line.left, theme: theme }) }), line.rightCells > 0 && (_jsx(Box, { width: line.rightCells, flexShrink: 0, justifyContent: "flex-end", children: _jsx(GovernanceLine, { segments: line.right, theme: theme }) }))] }));
-}
-function CellView({ cell, theme }) {
-    const content = _jsx(GovernanceLine, { segments: cell.segments, theme: theme });
-    if (cell.elastic) {
-        return _jsx(Box, { flexGrow: 1, flexShrink: 1, overflow: "hidden", children: content });
-    }
-    return (_jsx(Box, { width: cell.width, flexShrink: 0, overflow: "hidden", justifyContent: cell.align === 'right' ? 'flex-end' : 'flex-start', children: content }));
-}
-function RosterView({ line, theme }) {
-    return (_jsxs(Box, { flexDirection: "row", width: "100%", height: 1, flexShrink: 0, overflow: "hidden", children: [_jsx(Margin, {}), line.cells.map((cell) => (_jsx(CellView, { cell: cell, theme: theme }, cell.key)))] }));
-}
-export function GovernancePanel({ layout, theme, caps }) {
-    if (layout.height === 0 || layout.header === null)
-        return null;
-    const glyphs = pickGlyphs(caps);
-    const rule = layout.ruleCells > 0 ? (_jsxs(Box, { flexDirection: "row", width: "100%", height: 1, flexShrink: 0, overflow: "hidden", children: [_jsx(Margin, {}), _jsx(Text, { wrap: "truncate", color: theme.border, children: glyphs.hrule.repeat(layout.ruleCells) })] })) : null;
-    return (_jsxs(Box, { flexDirection: "column", width: "100%", flexShrink: 0, children: [_jsx(LineView, { line: layout.header, theme: theme }), layout.pipeline !== null && _jsx(LineView, { line: layout.pipeline, theme: theme }), rule, layout.rosterRows.map((line) => (_jsx(RosterView, { line: line, theme: theme }, line.key))), layout.overflow !== null && (_jsxs(Box, { flexDirection: "row", width: "100%", height: 1, flexShrink: 0, overflow: "hidden", children: [_jsx(Margin, {}), _jsx(Text, { wrap: "truncate", color: theme.muted, children: layout.overflow })] })), rule, layout.ticker.map((line, index) => (_jsx(LineView, { line: line, theme: theme }, `ticker-${index}`)))] }));
-}

package/dist/ui/GovernanceRun.d.ts

@@ -1,18 +0,0 @@
-/**
- * GovernanceRun - paints one `Segment[]` run: the single place a governance layout's
- * semantic tones become Ink colours.
- *
- * ASCII ONLY. The panel, the card and the board all draw the same `Segment` vocabulary,
- * and three private copies of this loop is how their bold / tone handling drifts apart.
- */
-import React from 'react';
-import type { Theme } from './theme.js';
-import { type Segment } from './governance-status.js';
-export interface GovernanceRunProps {
-    segments: readonly Segment[];
-    theme: Theme;
-}
-/** The segments as nested `Text`; the CALLER owns wrapping and truncation. */
-export declare function GovernanceRun({ segments, theme }: GovernanceRunProps): React.ReactElement;
-/** One display row: the run inside a `wrap="truncate"` `Text`, so it can never wrap. */
-export declare function GovernanceLine({ segments, theme }: GovernanceRunProps): React.ReactElement;

package/dist/ui/GovernanceRun.js

@@ -1,11 +0,0 @@
-import { jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
-import { Text } from 'ink';
-import { toneColor } from './governance-status.js';
-/** The segments as nested `Text`; the CALLER owns wrapping and truncation. */
-export function GovernanceRun({ segments, theme }) {
-    return (_jsx(_Fragment, { children: segments.map((part, index) => (_jsx(Text, { color: toneColor(part.tone, theme), ...(part.bold ? { bold: true } : {}), children: part.text }, index))) }));
-}
-/** One display row: the run inside a `wrap="truncate"` `Text`, so it can never wrap. */
-export function GovernanceLine({ segments, theme }) {
-    return (_jsx(Text, { wrap: "truncate", children: _jsx(GovernanceRun, { segments: segments, theme: theme }) }));
-}

package/dist/ui/Header.d.ts

@@ -1,48 +0,0 @@
-/**
- * One-row brand bar: word mark, identity, working directory, task summary and a
- * fixed-width hint column (tui-shortcut-drawer-and-task-summary §4.2 / §4.3).
- *
- * THIS COMPONENT COMPUTES NO WIDTHS ANY MORE. Both halves come from pure
- * planners - `planHeaderHints` for the right column and `planHeaderLeft` for the
- * clause ladder - so the only arithmetic left here is "join what I was given".
- * The old shape carried a `statusExpanded` flag, a kit switch and a prompts
- * switch, all of which existed to choose between header clauses; the clauses are
- * gone (the drawer lists the keys instead), so the props are gone with them.
- */
-import React from 'react';
-import type { Theme } from './theme.js';
-import type { TermCapabilities } from './capabilities.js';
-import { type HeaderVariant } from './Logo.js';
-import { type HeaderPanelState } from './layout/header-hints.js';
-interface HeaderProps {
-    cwd: string;
-    provider: string;
-    model: string;
-    hasKey: boolean;
-    variant: HeaderVariant;
-    theme: Theme;
-    caps: TermCapabilities;
-    columns?: number;
-    /**
-     * What the right column says. Derived in ONE place - the line that renders
-     * `<Header>` - so the two overlay slots cannot disagree about it.
-     */
-    panel?: HeaderPanelState;
-    scrolledLines?: number;
-    /**
-     * The session's task label, or `null` while there is none.
-     *
-     * `null` WHILE PENDING TOO: a placeholder here would spend eight columns of the
-     * row to draw an ellipsis and then move everything back when the label lands,
-     * so the first submit visibly jogged the header. The label now appears once,
-     * complete (P2-10).
-     */
-    taskSummary?: {
-        text: string;
-        tone: 'model' | 'fallback';
-    } | null;
-    /** `config.taskSummary.enabled`; `false` removes the cell without removing the words. */
-    summaryEnabled?: boolean;
-}
-export declare function Header({ cwd, provider, model, hasKey, variant, theme, caps, columns, panel, scrolledLines, taskSummary, summaryEnabled, }: HeaderProps): React.ReactElement;
-export {};

package/dist/ui/Header.js

@@ -1,27 +0,0 @@
-import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
-import { basename } from 'node:path';
-import { Box, Text } from 'ink';
-import { Logo } from './Logo.js';
-import { pickGlyphs } from './glyphs.js';
-import { planHeaderHints, HEADER_HINT_LIMITS, } from './layout/header-hints.js';
-import { planHeaderLeft } from './layout/header-left.js';
-export function Header({ cwd, provider, model, hasKey, variant, theme, caps, columns = 80, panel = 'none', scrolledLines = 0, taskSummary = null, summaryEnabled = true, }) {
-    const glyphs = pickGlyphs(caps);
-    // THE RIGHT COLUMN FIRST: it is the only clause that may never be dropped, so
-    // the left half is planned against what is left after it (defect 12).
-    const plan = planHeaderHints({ columns, panel, scrolledLines });
-    const leftCells = Math.max(0, columns - plan.cells - HEADER_HINT_LIMITS.separatorCells);
-    const left = planHeaderLeft({
-        leftCells,
-        provider,
-        model,
-        cwd: basename(cwd) || cwd,
-        hasKey,
-        summary: taskSummary,
-        summaryEnabled,
-        ellipsis: glyphs.ellipsis,
-    });
-    return _jsxs(Box, { flexDirection: "row", height: 1, width: columns, flexShrink: 0, overflow: "hidden", children: [_jsx(Box, { width: leftCells, flexShrink: 0, overflow: "hidden", children: _jsxs(Text, { wrap: "truncate", children: [_jsx(Logo, { variant: variant === 'mini' ? 'mini' : 'bar', theme: theme, caps: caps }), variant !== 'mini' && _jsxs(_Fragment, { children: [left.text.model && _jsxs(Text, { color: theme.accent, children: ['  ', left.text.model] }), left.text.cwd && _jsxs(Text, { color: theme.muted, children: ['  ', left.text.cwd] }), left.text.summary && _jsxs(Text, { color: theme.muted, children: ['  ', glyphs.midDot, ' '] }), left.text.summary && (taskSummary?.tone === 'fallback'
-                                    ? _jsx(Text, { color: theme.muted, dimColor: true, children: left.text.summary })
-                                    : _jsx(Text, { color: theme.primary, children: left.text.summary })), _jsxs(Text, { color: hasKey ? theme.toolDone : theme.toolRunning, children: ['  ', hasKey ? theme.symbols.keyOn : theme.symbols.keyOff] })] })] }) }), _jsx(Box, { width: HEADER_HINT_LIMITS.separatorCells, flexShrink: 0 }), _jsx(Box, { width: plan.cells, flexShrink: 0, justifyContent: "flex-end", children: _jsx(Text, { color: theme.muted, wrap: "truncate", children: plan.text }) })] });
-}

package/dist/ui/Logo.d.ts

@@ -1,32 +0,0 @@
-/**
- * Brand wordmark (spec §5.1 / R1). The first row of the frame always starts
- * with a brand glyph, at every terminal size and every capability tier.
- */
-import React from 'react';
-import type { Theme } from './theme.js';
-import type { TermCapabilities } from './capabilities.js';
-/** 6 rows × 52 columns, every row equal width (pinned by logo.test.ts). */
-export declare const LOGO_ART: readonly string[];
-export declare const LOGO_ART_WIDTH = 52;
-export type HeaderVariant = 'bar' | 'mini';
-/** How the one-off opening wordmark renders inside the viewport (§4.2). */
-export type OpenerVariant = 'art' | 'banner' | 'none';
-export declare function pickHeaderVariant(cols: number): HeaderVariant;
-/**
- * Pick the opening wordmark tier.
- *
- * Judged against VIEWPORT rows rather than terminal rows because the wordmark
- * now spends the viewport's budget, not the frame's: the test has to be against
- * the account being charged.
- *
- * Color preferences must not change geometry: a monochrome TUI gets the same
- * wordmark as a colored one when there is room for it.
- */
-export declare function pickOpenerVariant(viewportRows: number, cols: number): OpenerVariant;
-export interface LogoProps {
-    /** `art` / `banner` come from `SessionOpener`; `bar` / `mini` from `Header`. */
-    variant: HeaderVariant | OpenerVariant;
-    theme: Theme;
-    caps: TermCapabilities;
-}
-export declare function Logo({ variant, theme, caps }: LogoProps): React.ReactElement | null;

package/dist/ui/Logo.js

@@ -1,65 +0,0 @@
-import { jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
-import { Text } from 'ink';
-import { gradientLine } from './gradient.js';
-/** 6 rows × 52 columns, every row equal width (pinned by logo.test.ts). */
-export const LOGO_ART = [
-    ' █████╗ ██████╗  █████╗  ██████╗  ██████╗ ███╗   ██╗',
-    '██╔══██╗██╔══██╗██╔══██╗██╔════╝ ██╔═══██╗████╗  ██║',
-    '███████║██████╔╝███████║██║  ███╗██║   ██║██╔██╗ ██║',
-    '██╔══██║██╔══██╗██╔══██║██║   ██║██║   ██║██║╚██╗██║',
-    '██║  ██║██║  ██║██║  ██║╚██████╔╝╚██████╔╝██║ ╚████║',
-    '╚═╝  ╚═╝╚═╝  ╚═╝╚═╝  ╚═╝ ╚═════╝  ╚═════╝ ╚═╝  ╚═══╝',
-];
-export const LOGO_ART_WIDTH = 52;
-/** Minimum viewport rows / cols each tier needs before it earns its budget. */
-const ART_MIN_VIEWPORT_ROWS = 14;
-/**
- * 4 columns of headroom on purpose: the art renders with `wrap="truncate"`, so
- * at zero headroom anything upstream claiming a single column silently shears
- * the right edge off the `N`. Between `LOGO_ART_WIDTH` and this threshold the
- * opener degrades to `banner`, which is the intended fallback (rename C2).
- */
-const ART_MIN_COLS = LOGO_ART_WIDTH + 4;
-const BANNER_MIN_COLS = 48;
-const BAR_MIN_COLS = 40;
-export function pickHeaderVariant(cols) {
-    return cols >= BAR_MIN_COLS ? 'bar' : 'mini';
-}
-/**
- * Pick the opening wordmark tier.
- *
- * Judged against VIEWPORT rows rather than terminal rows because the wordmark
- * now spends the viewport's budget, not the frame's: the test has to be against
- * the account being charged.
- *
- * Color preferences must not change geometry: a monochrome TUI gets the same
- * wordmark as a colored one when there is room for it.
- */
-export function pickOpenerVariant(viewportRows, cols) {
-    if (viewportRows >= ART_MIN_VIEWPORT_ROWS &&
-        cols >= ART_MIN_COLS) {
-        return 'art';
-    }
-    if (cols >= BANNER_MIN_COLS)
-        return 'banner';
-    return 'none';
-}
-/** Rotate the gradient stops by one per row so the block reads as a diagonal sheen. */
-function shiftStops(stops, row) {
-    if (stops.length === 0)
-        return stops;
-    const at = row % stops.length;
-    return [...stops.slice(at), ...stops.slice(0, at)];
-}
-export function Logo({ variant, theme, caps }) {
-    const wordmark = `${theme.symbols.wordmark} AragonAgent`;
-    if (variant === 'none')
-        return null;
-    if (variant === 'art') {
-        return (_jsx(_Fragment, { children: LOGO_ART.map((line, i) => (_jsx(Text, { wrap: "truncate", color: theme.gradient.length > 0 ? undefined : theme.logoShadow, children: gradientLine(line, shiftStops(theme.gradient, i), caps.colorLevel) }, i))) }));
-    }
-    if (variant === 'banner') {
-        return (_jsx(Text, { wrap: "truncate", bold: true, color: theme.gradient.length > 0 ? undefined : theme.primary, children: gradientLine(wordmark, theme.gradient, caps.colorLevel) }));
-    }
-    return (_jsx(Text, { bold: true, color: theme.primary, children: wordmark }));
-}

package/dist/ui/Markdown.d.ts

@@ -1,29 +0,0 @@
-/**
- * Lightweight markdown renderer for Ink (spec §4 / §4.7).
- *
- * Supports: fenced code blocks (syntax-highlighted via cli-highlight, on a left
- * rail with a language tag), six DISTINCT heading weights, horizontal rules,
- * unordered/ordered lists, blockquotes, pipe tables, and inline **bold** /
- * *italic* / `code` / ~~strike~~. Anything else renders as plain text. Still
- * intentionally small — not a CommonMark implementation.
- *
- * The grammar lives in `markdown-blocks.ts`; this file only renders. That was
- * true of the file header long before it was true of the file
- * (tui-render-performance R2): the block grammar used to run here, in the render
- * body, on every frame. Both expensive halves are now memoised on the input
- * string — `parseMarkdownCached` for the AST, `highlightCached` for the ANSI —
- * while theme and glyphs stay render-time, so `/theme` still takes effect
- * immediately (K-5).
- */
-import React from 'react';
-import type { Theme } from './theme.js';
-import type { TermCapabilities } from './capabilities.js';
-interface MarkdownProps {
-    text: string;
-    theme: Theme;
-    caps: TermCapabilities;
-}
-export declare function Markdown({ text, theme, caps }: MarkdownProps): React.ReactElement;
-/** Turn parsed inline spans into Ink `<Text>` nodes. */
-export declare function renderInline(text: string, theme: Theme): React.ReactNode;
-export {};

package/dist/ui/Markdown.js

@@ -1,116 +0,0 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { Box, Text } from 'ink';
-import { pickGlyphs } from './glyphs.js';
-import { railBorderProps } from './layout/Gutter.js';
-import { highlightCached, parseMarkdownCached } from './render-cache.js';
-import { formatTable, isRule, parseHeading, parseInline, } from './markdown-blocks.js';
-/** Width of the `---` rule. Fixed so it cannot force a wrap on narrow frames. */
-const RULE_WIDTH = 24;
-export function Markdown({ text, theme, caps }) {
-    const glyphs = pickGlyphs(caps);
-    const blocks = parseMarkdownCached(text);
-    return (_jsx(Box, { flexDirection: "column", children: blocks.map((block, i) => renderBlock(block, i, theme, glyphs)) }));
-}
-function renderBlock(block, key, theme, glyphs) {
-    switch (block.kind) {
-        case 'code':
-            return (_jsx(CodeBlock, { code: block.code, lang: block.lang, theme: theme, glyphs: glyphs }, `b${key}`));
-        case 'table': {
-            // Glyphs are injected rather than hardcoded: this module is inside the
-            // ASCII-only scan, and the pure parser defaults to ASCII `|` / `-`.
-            const formatted = formatTable(block.rows, block.align, {
-                separator: glyphs.railVertical,
-                rule: glyphs.hrule,
-            });
-            return (_jsx(Box, { flexDirection: "column", children: formatted.map((row, r) => (_jsx(Text, { wrap: "truncate", bold: r === 0, color: tableRowColor(r, theme), children: row }, r))) }, `b${key}`));
-        }
-        default:
-            return _jsx(InlineLine, { line: block.text, theme: theme, glyphs: glyphs }, `b${key}`);
-    }
-}
-/**
- * Table row 0 is the header (bold + accent); row 1 is the divider drawn under it.
- *
- * The divider must stay distinguishable at colour level 0, where bold is dropped
- * to nothing, so it is MUTED and never bold: in `--no-color` the `----` run is
- * itself the signal, and in a coloured tier the weight difference separates the
- * header from the rule beneath it.
- */
-function tableRowColor(index, theme) {
-    if (index === 0)
-        return theme.accent;
-    if (index === 1)
-        return theme.muted;
-    return undefined;
-}
-/**
- * Fenced code. The round border is gone (§4.3): nested inside a tool card it
- * produced a box inside a box and squeezed an 80-column terminal down to 74
- * usable columns. A left rail plus the language tag conveys the same "this is
- * code" boundary for 1 column and 0 rows.
- *
- * The language tag is a muted TITLE, not a body row: it used to carry a chip
- * background and one padding space either side of the text, so it rendered as
- * `  |  ts` above code rows that start at `| export ...` — a body line that
- * happened to be the language. It keeps its own row on purpose: the height
- * estimator (`virtual-window.estimateEntryRows`) counts RAW markdown lines and
- * has no code-block branch, so the fence line must still occupy exactly 1 row.
- */
-function CodeBlock({ code, lang, theme, glyphs, }) {
-    const rendered = highlightCached(code, lang);
-    return (_jsxs(Box, { flexDirection: "column", flexShrink: 0, paddingLeft: 1, ...railBorderProps(glyphs.railVertical, theme.border), children: [lang.length > 0 && (_jsx(Text, { bold: true, color: theme.muted, children: lang })), _jsx(Text, { children: rendered })] }));
-}
-/** Six heading levels used to render identically; now they carry three weights. */
-function headingStyle(level, theme) {
-    if (level <= 2)
-        return { color: theme.primary };
-    if (level === 3)
-        return { color: theme.accent };
-    return { color: theme.assistant };
-}
-function InlineLine({ line, theme, glyphs, }) {
-    const heading = parseHeading(line);
-    if (heading) {
-        const style = headingStyle(heading.level, theme);
-        if (heading.level === 1) {
-            return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { bold: true, color: style.color, children: heading.text }), _jsx(Text, { color: theme.border, children: glyphs.hrule.repeat(RULE_WIDTH) })] }));
-        }
-        return (_jsx(Text, { bold: true, color: style.color, children: heading.text }));
-    }
-    if (isRule(line)) {
-        return _jsx(Text, { color: theme.border, children: glyphs.hrule.repeat(RULE_WIDTH) });
-    }
-    const quote = /^>\s?(.*)$/.exec(line);
-    if (quote) {
-        return (_jsxs(Text, { color: theme.muted, italic: true, children: [glyphs.railVertical, " ", renderInline(quote[1] ?? '', theme)] }));
-    }
-    const bullet = /^(\s*)([-*+])\s+(.*)$/.exec(line);
-    if (bullet) {
-        return (_jsxs(Text, { children: [bullet[1], _jsxs(Text, { color: theme.accent, children: [glyphs.bullet, " "] }), renderInline(bullet[3] ?? '', theme)] }));
-    }
-    const ordered = /^(\s*)(\d+)\.\s+(.*)$/.exec(line);
-    if (ordered) {
-        return (_jsxs(Text, { children: [ordered[1], _jsxs(Text, { color: theme.accent, children: [ordered[2], ". "] }), renderInline(ordered[3] ?? '', theme)] }));
-    }
-    return _jsx(Text, { children: renderInline(line, theme) });
-}
-/** Turn parsed inline spans into Ink `<Text>` nodes. */
-export function renderInline(text, theme) {
-    const spans = parseInline(text);
-    if (spans.length === 0)
-        return text;
-    return spans.map((span, i) => {
-        switch (span.kind) {
-            case 'code':
-                return (_jsx(Text, { color: theme.code, children: span.text }, `i${i}`));
-            case 'bold':
-                return (_jsx(Text, { bold: true, children: span.text }, `i${i}`));
-            case 'italic':
-                return (_jsx(Text, { italic: true, children: span.text }, `i${i}`));
-            case 'strike':
-                return (_jsx(Text, { strikethrough: true, children: span.text }, `i${i}`));
-            default:
-                return span.text;
-        }
-    });
-}

package/dist/ui/PromptCaret.d.ts

@@ -1,11 +0,0 @@
-import React from 'react';
-export interface PromptCaretProps {
-    text: string;
-    active: boolean;
-    reducedMotion: boolean;
-    colorLevel: 0 | 1 | 2 | 3;
-    color?: string;
-    resetKey: object;
-}
-/** The only blinking state belongs to this leaf, never to the editor. */
-export declare function PromptCaret({ text, active, reducedMotion, colorLevel, color, resetKey, }: PromptCaretProps): React.ReactElement;

package/dist/ui/PromptCaret.js

@@ -1,31 +0,0 @@
-import { jsx as _jsx } from "react/jsx-runtime";
-import { useLayoutEffect, useState } from 'react';
-import { Text } from 'ink';
-import { displayWidth } from './composer-rows.js';
-function monochromeMarker(text) {
-    // Ink's output grid advances for combining marks, even though they have no
-    // terminal width. Retain them in both phases so its cell count stays stable.
-    const replace = (marker) => Array.from(text, (point) => {
-        const width = displayWidth(point);
-        return width > 0 ? marker.repeat(width) : point;
-    }).join('');
-    const underline = replace('_');
-    return underline === text ? replace('^') : underline;
-}
-/** The only blinking state belongs to this leaf, never to the editor. */
-export function PromptCaret({ text, active, reducedMotion, colorLevel, color, resetKey, }) {
-    const [visible, setVisible] = useState(true);
-    useLayoutEffect(() => {
-        setVisible(true);
-        if (!active || reducedMotion)
-            return;
-        const timer = setInterval(() => setVisible((previous) => !previous), 500);
-        return () => clearInterval(timer);
-    }, [resetKey, active, reducedMotion]);
-    const bright = active && (reducedMotion || visible);
-    let content = text;
-    if (bright && colorLevel === 0) {
-        content = monochromeMarker(text);
-    }
-    return _jsx(Text, { color: color, inverse: bright && colorLevel > 0, children: content });
-}