@aragon-agent/cli 0.6.47 → 0.6.48

package/dist/tools/terminal-output.js

@@ -1,201 +0,0 @@
-/**
- * Raw child-process output to terminal-safe rows (agent-activity-presentation-live
- * L2 / §3.2).
- *
- * NOTHING ELSE IN THIS TREE STRIPS ANSI (E-13). `renderBash` hands each line to
- * `<Text>` unmodified (`ui/entries/ToolPreview.tsx:180`), and that survives only
- * because the settled preview is printed ONCE, after the command has stopped
- * writing. Redraw the same text every frame while the child is still emitting
- * `\r`-rewritten progress bars and `\x1b[A` cursor moves and it stops being
- * survivable: the terminal honours cursor motion Ink does not know it emitted,
- * and `wrappedRows` measures escape bytes as if they were columns.
- *
- * So this module is the boundary. It runs ONCE, inside the store's `append`
- * (§3.1.1), and every reader downstream is already safe.
- *
- * Pure, ASCII-only, React-free, Ink-free, and TOTAL: `sanitizeChunk` never
- * throws, for any input including lone surrogates, NUL bytes, a chunk consisting
- * solely of `\x1b`, and a 4 MB chunk containing no `\n` at all.
- *
- * D-27 — IT STRIPS, IT DOES NOT INTERPRET. Keeping colour would mean validating
- * it (an unterminated SGR leaks its attribute into the rest of the frame), and
- * interpreting cursor motion would mean owning a screen buffer. Neither is a
- * presentation round's job.
- */
-import { stripControlSequences } from '../input/control-sequences.js';
-/** Columns a live row may occupy before it is clipped. */
-export const LIVE_ROW_MAX_CHARS = 200;
-/** Tab stop width, matching every terminal's default. */
-export const TAB_WIDTH = 8;
-/**
- * The in-progress line's ceiling before it is flushed as a row (§3.2 step 7).
- *
- * AFTER STEP 4 THIS IS A RARE PATH RATHER THAN THE PROGRESS-BAR PATH (D-33). A
- * `\r`-rewritten bar collapses to one row however many times it is redrawn, so
- * reaching 400 characters with no `\n` requires a line that is genuinely that
- * long -- `cat` on a minified bundle. Without the bound the carry is an
- * unbounded accumulator.
- */
-export const CARRY_MAX_CHARS = LIVE_ROW_MAX_CHARS * 2;
-/**
- * Appended to a row clipped at `LIVE_ROW_MAX_CHARS`.
- *
- * SPELLED HERE RATHER THAN IMPORTED from `agent/reducer.ts`, the rule
- * `patch.ts:95-103` already states for the identical string: `tools/` keeps no
- * runtime dependency on the view model for three characters, and
- * `terminal-output.test.ts` asserts the spellings are equal so the pair cannot
- * drift silently.
- */
-export const TRUNCATION_MARK = '...';
-/**
- * How far back a trailing incomplete escape may start.
- *
- * A chunk can split mid-escape, and the next chunk completes it -- so the tail
- * of an unfinished sequence must survive in the carry rather than being stripped
- * down to its visible remainder (`\x1b[` would otherwise render as a bare `[`).
- * The lookback is bounded because an "escape" that has run for 64 characters
- * without a final byte is not an escape, it is a byte that happened to be 0x1b,
- * and holding it forever would pin the carry.
- */
-const MAX_PARTIAL_ESCAPE = 64;
-/** C1, plus every C0 control except `\t` `\n` `\r`. */
-const CONTROLS = /[\x00-\x08\x0b\x0c\x0e-\x1f\x7f-\x9f]/g;
-/**
- * Remove every escape sequence and control byte except `\t` `\n` `\r`.
- *
- * SEQUENCE SYNTAX HAS ONE OWNER (`input/control-sequences.ts`); this function
- * adds only the control-byte sweep a DISPLAY row wants. Both call sites in this
- * module already cut an unfinished escape off into the carry before calling it
- * (`partialEscapeStart`), so the shared one-shot rule for a truncated sequence
- * is exactly what they need -- and it fixes AC-24's failure in place: the old
- * two-byte rule consumed the `\x1b[` of an unfinished CSI and left the
- * PARAMETERS behind, so `\x1b[31m` split across chunks rendered as `red 3`.
- *
- * Exported for the tests, and used by `toDisplayRow` as the second line of
- * defence over a carry that ends mid-escape.
- */
-export function stripAnsi(text) {
-    return stripControlSequences(text).replace(CONTROLS, '');
-}
-/**
- * Index at which a trailing INCOMPLETE escape begins, or `-1`.
- *
- * Only the last `\x1b` can be incomplete: anything before it is either a
- * complete sequence (the regexes above consume it) or a stray byte the control
- * strip removes.
- */
-function partialEscapeStart(text) {
-    const at = text.lastIndexOf('\x1b');
-    if (at === -1 || text.length - at > MAX_PARTIAL_ESCAPE)
-        return -1;
-    const rest = text.slice(at);
-    // A lone ESC at the very end: the next chunk decides what it is.
-    if (rest.length === 1)
-        return at;
-    // An opened CSI/OSC is incomplete exactly when its own regex does not match
-    // from here -- `\x1b[1;3` has no final byte yet, `\x1b]0;title` no terminator.
-    if (rest[1] === '[')
-        return /^\x1b\[[0-?]*[ -/]*[@-~]/.test(rest) ? -1 : at;
-    if (rest[1] === ']')
-        return /^\x1b\][\s\S]*?(?:\x07|\x1b\\)/.test(rest) ? -1 : at;
-    // Any other two-byte form is already complete.
-    return -1;
-}
-/**
- * Apply `\r` as the LINE REWRITE it is (§3.2 step 4 / D-33).
- *
- * A piece containing `\r` is a sequence of overwrites, so the later segment
- * replaces the earlier one's PREFIX and anything the earlier one had beyond it
- * survives -- which is what a real terminal shows, and what keeps R-6's classic
- * `\r`-only tooling from losing content. A thousand progress-bar rewrites
- * collapse to one row holding the final state.
- */
-export function applyCarriageReturns(piece) {
-    if (piece.indexOf('\r') === -1)
-        return piece;
-    return piece.split('\r').reduce((acc, s) => s + acc.slice(s.length), '');
-}
-/** Expand tabs to the next multiple of `TAB_WIDTH`. */
-export function expandTabs(row) {
-    if (row.indexOf('\t') === -1)
-        return row;
-    let out = '';
-    for (let i = 0; i < row.length; i += 1) {
-        const ch = row[i];
-        if (ch === '\t')
-            out += ' '.repeat(TAB_WIDTH - (out.length % TAB_WIDTH));
-        else
-            out += ch;
-    }
-    return out;
-}
-/** Clip a row at `LIVE_ROW_MAX_CHARS`, marking the cut. */
-export function clipRow(row) {
-    return row.length <= LIVE_ROW_MAX_CHARS
-        ? row
-        : `${row.slice(0, LIVE_ROW_MAX_CHARS)}${TRUNCATION_MARK}`;
-}
-/**
- * The carry as a RENDERED row: the held-back incomplete escape removed, then
- * stripped and clipped.
- *
- * THE PARTIAL MUST BE CUT OFF, NOT STRIPPED (AC-24). `stripAnsi` alone is not
- * enough and fails in the visible direction: its two-byte rule consumes the
- * `\x1b[` of an unfinished CSI and leaves the PARAMETERS behind, so a chunk that
- * split inside `\x1b[31m` renders as `red 3`. The bytes are held for the next
- * chunk to complete; until then they are not text.
- */
-export function toDisplayRow(carry) {
-    const at = partialEscapeStart(carry);
-    return clipRow(stripAnsi(at === -1 ? carry : carry.slice(0, at)));
-}
-/**
- * Tab expansion is column arithmetic, so it cannot be done after the clip -- but
- * it also need not run over four megabytes to decide the first 200 columns.
- * Every character occupies at least one column, so a `CARRY_MAX_CHARS` prefix
- * covers every column the clip can keep.
- */
-function expandTabsForDisplay(piece) {
-    return piece.length <= CARRY_MAX_CHARS
-        ? expandTabs(piece)
-        : expandTabs(piece.slice(0, CARRY_MAX_CHARS));
-}
-/**
- * Turn a raw chunk into complete rows plus the in-progress line.
- *
- * The order of the steps IS the specification (§3.2), and step 4's "every piece,
- * THE INCOMPLETE TAIL INCLUDED" is the whole of P0-1: a progress bar emits no
- * `\n` for its entire run, so a rule that collapsed only completed lines would
- * never run for npm, pip, curl, docker or any other `\r` writer -- the tail
- * would stay empty, `showLive` false, and the card the single `running` row this
- * round exists to replace.
- */
-export function sanitizeChunk(carry, chunk) {
-    const text = (typeof carry === 'string' ? carry : '') + (typeof chunk === 'string' ? chunk : '');
-    if (text.length === 0)
-        return { rows: [], carry: '' };
-    // 1-2. Concatenate and strip, holding back an escape the next chunk finishes.
-    const partialAt = partialEscapeStart(text);
-    const held = partialAt === -1 ? '' : text.slice(partialAt);
-    const clean = stripAnsi(partialAt === -1 ? text : text.slice(0, partialAt));
-    // 3. Split: the first n-1 pieces are complete rows, the last is the tail.
-    const pieces = clean.split('\n');
-    const rows = [];
-    for (let i = 0; i < pieces.length - 1; i += 1) {
-        // 4-6. Collapse, expand, clip.
-        rows.push(clipRow(expandTabsForDisplay(applyCarriageReturns(pieces[i]))));
-    }
-    const rawTail = applyCarriageReturns(pieces[pieces.length - 1]);
-    const tail = expandTabsForDisplay(rawTail);
-    // 7. Bound the carry. The held escape survives the flush: it belongs to the
-    // NEXT row, and dropping it here would corrupt the sequence it opened.
-    //
-    // BOTH LENGTHS ARE TESTED, and testing only the expanded one is the bug:
-    // `expandTabsForDisplay` truncates its input at `CARRY_MAX_CHARS`, so a
-    // megabyte-long line would sit at exactly the bound forever and never flush.
-    if (rawTail.length > CARRY_MAX_CHARS || tail.length > CARRY_MAX_CHARS) {
-        rows.push(clipRow(tail));
-        return { rows, carry: held };
-    }
-    return { rows, carry: tail + held };
-}

package/dist/tools/tool-output-store.d.ts

@@ -1,68 +0,0 @@
-/**
- * The CLI-local side channel a running tool's output travels on
- * (agent-activity-presentation-live L1 / §3.1.1).
- *
- * It mirrors `file-change-store.ts` in shape and in its documented reasoning,
- * with ONE deliberate difference: it is PEEK-AND-CLEAR, not take-once, because a
- * running command is read many times and consumed once.
- *
- * Four properties, each load-bearing, each with the failure it prevents:
- *
- *  - **Owner-scoped.** The key is `${owner}:${toolCallId}`, for D-13's reason
- *    unchanged: only `'lead'` is written this round, but subagents build their
- *    tools from the same factory, and a child's tool-call id must never be able
- *    to paint a lead's card.
- *  - **Sanitised on write.** `append` calls `sanitizeChunk` BEFORE storing, so
- *    the store's contract is "terminal-safe rows" and no consumer can forget.
- *  - **Bounded twice.** `LIVE_TAIL_ROWS` per call and `TOOL_OUTPUT_STORE_CAP`
- *    calls. A command emitting 400 MB to stdout costs a fixed number of retained
- *    rows: the per-call bound is what makes the DISPLAY bounded, the cap is what
- *    makes a session that never settles a call bounded.
- *  - **Cleared at settle, not at read.** The authoritative result arrives with
- *    `tool_execution_end`; from that instant the tail is superseded and must be
- *    released. Clearing there keeps the store's size a function of CONCURRENT
- *    calls rather than of total calls.
- */
-/**
- * ROWS retained per tool call.
- *
- * THIS AND THE CAP BELOW ARE DELIBERATELY DIFFERENT NUMBERS (P2-8). They bound
- * unrelated things -- rows inside one call, and calls inside one session -- and
- * a shared literal is how a later edit collapses two bounds into one.
- */
-export declare const LIVE_TAIL_ROWS = 8;
-/** CONCURRENT CALLS retained before the oldest is evicted. */
-export declare const TOOL_OUTPUT_STORE_CAP = 16;
-/**
- * Silence after which the card stops claiming progress and says so (§3.3.4).
- *
- * It lives here rather than in `ToolCard` because it is the STORE's notion of
- * "quiet": the card reads it so there is no second copy to drift.
- */
-export declare const STALL_AFTER_MS = 10000;
-export interface ToolOutputStore {
-    /**
-     * Append a raw chunk. Sanitises (§3.2), then returns the display tail: the
-     * last `LIVE_TAIL_ROWS` of `[...completedRows, carry]`, `carry` last and
-     * included only when non-empty.
-     */
-    append(owner: string, toolCallId: string, chunk: string): readonly string[];
-    /** Current tail, or `undefined`. Does NOT remove. Test-facing (P2-2). */
-    peek(owner: string, toolCallId: string): readonly string[] | undefined;
-    /** Drop the entry -- called at `tool_execution_end`. */
-    clear(owner: string, toolCallId: string): void;
-    size(): number;
-}
-/**
- * What the controller's fourth CLI-local emitter carries (§3.1.3).
- *
- * `rows` IS THE WHOLE TAIL, not an increment, and that is what lets
- * `mergeDeltas` keep only the last one per `toolCallId` (D-30). It is frozen, so
- * a listener cannot mutate the array a later listener will see.
- */
-export interface ToolOutputEvent {
-    toolCallId: string;
-    rows: readonly string[];
-}
-export type ToolOutputListener = (event: ToolOutputEvent) => void;
-export declare function createToolOutputStore(cap?: number): ToolOutputStore;

package/dist/tools/tool-output-store.js

@@ -1,102 +0,0 @@
-/**
- * The CLI-local side channel a running tool's output travels on
- * (agent-activity-presentation-live L1 / §3.1.1).
- *
- * It mirrors `file-change-store.ts` in shape and in its documented reasoning,
- * with ONE deliberate difference: it is PEEK-AND-CLEAR, not take-once, because a
- * running command is read many times and consumed once.
- *
- * Four properties, each load-bearing, each with the failure it prevents:
- *
- *  - **Owner-scoped.** The key is `${owner}:${toolCallId}`, for D-13's reason
- *    unchanged: only `'lead'` is written this round, but subagents build their
- *    tools from the same factory, and a child's tool-call id must never be able
- *    to paint a lead's card.
- *  - **Sanitised on write.** `append` calls `sanitizeChunk` BEFORE storing, so
- *    the store's contract is "terminal-safe rows" and no consumer can forget.
- *  - **Bounded twice.** `LIVE_TAIL_ROWS` per call and `TOOL_OUTPUT_STORE_CAP`
- *    calls. A command emitting 400 MB to stdout costs a fixed number of retained
- *    rows: the per-call bound is what makes the DISPLAY bounded, the cap is what
- *    makes a session that never settles a call bounded.
- *  - **Cleared at settle, not at read.** The authoritative result arrives with
- *    `tool_execution_end`; from that instant the tail is superseded and must be
- *    released. Clearing there keeps the store's size a function of CONCURRENT
- *    calls rather than of total calls.
- */
-import { sanitizeChunk, toDisplayRow } from './terminal-output.js';
-/**
- * ROWS retained per tool call.
- *
- * THIS AND THE CAP BELOW ARE DELIBERATELY DIFFERENT NUMBERS (P2-8). They bound
- * unrelated things -- rows inside one call, and calls inside one session -- and
- * a shared literal is how a later edit collapses two bounds into one.
- */
-export const LIVE_TAIL_ROWS = 8;
-/** CONCURRENT CALLS retained before the oldest is evicted. */
-export const TOOL_OUTPUT_STORE_CAP = 16;
-/**
- * Silence after which the card stops claiming progress and says so (§3.3.4).
- *
- * It lives here rather than in `ToolCard` because it is the STORE's notion of
- * "quiet": the card reads it so there is no second copy to drift.
- */
-export const STALL_AFTER_MS = 10_000;
-const EMPTY = Object.freeze([]);
-export function createToolOutputStore(cap = TOOL_OUTPUT_STORE_CAP) {
-    // A `Map` iterates in insertion order, so the first key IS the oldest.
-    const entries = new Map();
-    const limit = Math.max(1, Math.floor(cap));
-    const keyOf = (owner, toolCallId) => `${owner}:${toolCallId}`;
-    /**
-     * The tail a consumer sees.
-     *
-     * THE IN-PROGRESS LINE IS PART OF IT, and that is the display half of P0-1: a
-     * command whose output is one continuously-rewritten line -- every progress
-     * bar there is -- has NO completed rows until it exits, and a tail built from
-     * completed rows alone would be empty for its entire run.
-     */
-    const tailOf = (slot) => {
-        const live = toDisplayRow(slot.carry);
-        const rows = live.length > 0 ? [...slot.rows, live] : [...slot.rows];
-        return Object.freeze(rows.length > LIVE_TAIL_ROWS ? rows.slice(-LIVE_TAIL_ROWS) : rows);
-    };
-    return {
-        append(owner, toolCallId, chunk) {
-            const key = keyOf(owner, toolCallId);
-            const slot = entries.get(key) ?? { rows: [], carry: '' };
-            // Delete first so an append moves the key to the END of the ring rather
-            // than leaving it at its original age: the cap must evict the least
-            // recently WRITTEN call, not the one that started first.
-            entries.delete(key);
-            entries.set(key, slot);
-            const { rows, carry } = sanitizeChunk(slot.carry, chunk);
-            if (rows.length > 0) {
-                slot.rows.push(...rows);
-                if (slot.rows.length > LIVE_TAIL_ROWS) {
-                    slot.rows.splice(0, slot.rows.length - LIVE_TAIL_ROWS);
-                }
-            }
-            slot.carry = carry;
-            while (entries.size > limit) {
-                const oldest = entries.keys().next();
-                if (oldest.done)
-                    break;
-                entries.delete(oldest.value);
-            }
-            return tailOf(slot);
-        },
-        peek(owner, toolCallId) {
-            const slot = entries.get(keyOf(owner, toolCallId));
-            if (!slot)
-                return undefined;
-            const tail = tailOf(slot);
-            return tail.length > 0 ? tail : EMPTY;
-        },
-        clear(owner, toolCallId) {
-            entries.delete(keyOf(owner, toolCallId));
-        },
-        size() {
-            return entries.size;
-        },
-    };
-}

package/dist/ui/ActivityLine.d.ts

@@ -1,26 +0,0 @@
-/** Legacy activity presentation. Explicit facts share the global status label mapping.
- * StatusBar owns the application's sole live spinner via the factory below.
- */
-import React from 'react';
-import type { Theme } from './theme.js';
-import type { TermCapabilities } from './capabilities.js';
-import { pickGlyphs } from './glyphs.js';
-import type { RunActivity } from './run-status-row.js';
-/** Shared animation factory; returns null for ASCII or reduced-motion terminals. */
-export declare function liveSpinner(reducedMotion: boolean, caps: TermCapabilities): React.ReactElement | null;
-/** Explicit execution facts outrank compatibility tool names and rotating phrases. */
-export declare function resolveActivityLabel(activity: RunActivity, glyphs: ReturnType<typeof pickGlyphs>): string;
-export interface ActivityLabelProps extends RunActivity {
-    /**
-     * False forces a static glyph. Compatibility phrases still follow reducedMotion.
-     */
-    spinnerLive?: boolean;
-    /** Prefix one space for compatibility line consumers. */
-    leadingSpace?: boolean;
-    theme: Theme;
-    caps: TermCapabilities;
-}
-/** `<spinner> <label>` as ONE truncating `<Text>`; the only place that composes them. */
-export declare function ActivityLabel({ spinnerLive, leadingSpace, theme, caps, ...activity }: ActivityLabelProps): React.ReactElement;
-export type ActivityLineProps = Omit<ActivityLabelProps, 'spinnerLive' | 'leadingSpace'>;
-export declare function ActivityLine(props: ActivityLineProps): React.ReactElement;

package/dist/ui/ActivityLine.js

@@ -1,51 +0,0 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { Box, Text } from 'ink';
-import Spinner from 'ink-spinner';
-import { pickGlyphs } from './glyphs.js';
-import { pickActivityPhrase } from './activity-phrases.js';
-import { phaseLabels, shortDuration } from './layout/status-layout.js';
-/** Shared animation factory; returns null for ASCII or reduced-motion terminals. */
-export function liveSpinner(reducedMotion, caps) {
-    return caps.unicode && !reducedMotion ? _jsx(Spinner, { type: "dots" }) : null;
-}
-/** Explicit execution facts outrank compatibility tool names and rotating phrases. */
-export function resolveActivityLabel(activity, glyphs) {
-    // A WAIT OUTRANKS EVERYTHING BELOW IT, and sits ABOVE `runningTool` on purpose:
-    // "Running job_wait" names the tool, "Waiting on t3 (up to 30s)" names the
-    // situation. It is placed after the phase/outcome branch because a settled run
-    // must never claim to be waiting for anything.
-    if (activity.phase === undefined && activity.outcome === undefined && activity.wait) {
-        const { jobId, upToSeconds, elapsedSeconds } = activity.wait;
-        return elapsedSeconds !== undefined
-            ? `Waiting on ${jobId} ${shortDuration(elapsedSeconds * 1000)}/${shortDuration(upToSeconds * 1000)}`
-            : `Waiting on ${jobId} (up to ${upToSeconds}s)`;
-    }
-    if (activity.phase !== undefined || activity.activeTool !== undefined || activity.outcome !== undefined) {
-        return phaseLabels({
-            phase: activity.phase ?? (activity.activeTool ? 'tool' : 'idle'),
-            activeTool: activity.activeTool, runOutcome: activity.outcome, compacting: activity.compacting,
-        })[1];
-    }
-    if (activity.compacting)
-        return `Compacting context${glyphs.ellipsis}`;
-    if (activity.runningTool)
-        return `Running ${activity.runningTool}`;
-    // PURE AND DERIVED FROM `(startedAt, now)`, so the sequence does not need to
-    // keep rotating underneath the tool label: when the tool settles the phrase
-    // resumes at the position the clock implies, with no state anywhere.
-    const phrase = pickActivityPhrase(activity.startedAt, activity.startedAt + activity.elapsedMs, !activity.reducedMotion);
-    return `${phrase}${glyphs.ellipsis}`;
-}
-/** `<spinner> <label>` as ONE truncating `<Text>`; the only place that composes them. */
-export function ActivityLabel({ spinnerLive = true, leadingSpace = false, theme, caps, ...activity }) {
-    const glyphs = pickGlyphs(caps);
-    const label = resolveActivityLabel(activity, glyphs);
-    const settled = activity.phase === 'idle' || (activity.phase === undefined
-        && activity.outcome !== undefined && activity.outcome !== 'none' && !activity.activeTool);
-    const spinner = (spinnerLive && (!settled || activity.compacting) ? liveSpinner(activity.reducedMotion, caps) : null) ??
-        glyphs.spinnerStill;
-    return (_jsxs(Text, { wrap: "truncate", color: theme.thinking, children: [leadingSpace ? ' ' : '', spinner, " ", label] }));
-}
-export function ActivityLine(props) {
-    return (_jsx(Box, { flexShrink: 0, children: _jsx(ActivityLabel, { ...props, leadingSpace: true }) }));
-}

package/dist/ui/AutocompletePopup.d.ts

@@ -1,23 +0,0 @@
-/**
- * Autocomplete popup (spec §3.6). A shared bordered suggestion menu used by both
- * the slash-command palette and `@file` completion. Presentational only — the
- * suggestion list, selection index, and key handling live in `PromptInput`.
- */
-import React from 'react';
-import type { Theme } from './theme.js';
-import type { TermCapabilities } from './capabilities.js';
-import { type AutocompleteLayout } from './layout/autocomplete.js';
-export interface Suggestion {
-    label: string;
-    hint?: string;
-}
-interface AutocompletePopupProps {
-    items: Suggestion[];
-    selected: number;
-    theme: Theme;
-    caps: TermCapabilities;
-    maxRows?: number;
-    layout?: AutocompleteLayout;
-}
-export declare function AutocompletePopup({ items, selected, theme, caps, maxRows, layout, }: AutocompletePopupProps): React.ReactElement | null;
-export {};

package/dist/ui/AutocompletePopup.js

@@ -1,17 +0,0 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { Box, Text } from 'ink';
-import { pickGlyphs } from './glyphs.js';
-import { buildAutocompleteLayout } from './layout/autocomplete.js';
-export function AutocompletePopup({ items, selected, theme, caps, maxRows, layout, }) {
-    const projection = layout ?? buildAutocompleteLayout({ itemCount: items.length, selected, maxRows });
-    if (projection.rowCount === 0)
-        return null;
-    const glyphs = pickGlyphs(caps);
-    const { start: windowStart, count, moreBelow, showMore } = projection;
-    const visible = items.slice(windowStart, windowStart + count);
-    return (_jsxs(Box, { flexDirection: "column", flexShrink: 0, borderStyle: glyphs.boxStyle, borderColor: theme.border, paddingX: 1, children: [visible.map((item, i) => {
-                const idx = windowStart + i;
-                const active = idx === selected;
-                return (_jsxs(Text, { inverse: active, wrap: "truncate", children: [_jsx(Text, { color: active ? theme.accent : theme.muted, children: active ? `${glyphs.caret} ` : '  ' }), _jsx(Text, { color: active ? undefined : theme.primary, children: item.label.replace(/\s+/g, ' ') }), item.hint ? _jsxs(Text, { color: theme.muted, children: ["  ", item.hint.replace(/\s+/g, ' ')] }) : null] }, idx));
-            }), showMore && _jsxs(Text, { wrap: "truncate", color: theme.muted, children: ["  +", moreBelow, " more"] })] }));
-}

package/dist/ui/BottomStatusRow.d.ts

@@ -1,10 +0,0 @@
-/** Renders an already allocated detail row; it never chooses visibility or animation. */
-import React from 'react';
-import type { Theme } from './theme.js';
-import type { StatusLinePlan } from './layout/status-layout.js';
-export interface BottomStatusRowProps {
-    plan: StatusLinePlan;
-    columns: number;
-    theme: Theme;
-}
-export declare function BottomStatusRow({ plan, columns, theme }: BottomStatusRowProps): React.ReactElement;

package/dist/ui/BottomStatusRow.js

@@ -1,9 +0,0 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-/** Renders an already allocated detail row; it never chooses visibility or animation. */
-import React from 'react';
-import { Box, Text } from 'ink';
-export function BottomStatusRow({ plan, columns, theme }) {
-    const tones = { normal: theme.primary, muted: theme.muted, warning: theme.noticeWarn, error: theme.noticeError,
-        accent: theme.accent, govern: theme.governAccent };
-    return _jsxs(Box, { height: 1, width: columns, flexShrink: 0, overflow: "hidden", children: [_jsx(Box, { width: 1, flexShrink: 0, children: _jsx(Text, { children: " " }) }), plan.fields.map((field, index) => _jsxs(React.Fragment, { children: [index > 0 && _jsx(Box, { width: plan.separatorCells, flexShrink: 0, children: _jsx(Text, { color: theme.muted, children: plan.separator }) }), _jsx(Box, { width: field.cells, flexShrink: 0, children: _jsx(Text, { wrap: "truncate", color: tones[field.tone], children: field.text }) })] }, field.id))] });
-}

package/dist/ui/Composer.d.ts

@@ -1,115 +0,0 @@
-/** Input border and draft shell. Global action hints and activity live below the viewport. */
-import React from 'react';
-import { type DOMElement } from 'ink';
-import type { Theme } from './theme.js';
-import type { TermCapabilities } from './capabilities.js';
-import { pickGlyphs } from './glyphs.js';
-import type { ComposerSubmitResult } from './composer-input.js';
-import { type CommandOption, type DraftFill } from './PromptInput.js';
-import type { RunActivity } from './run-status-row.js';
-import { type AgentMode } from '../agent/agent-mode.js';
-/** Legacy caller shape retained for source compatibility; Composer no longer mounts it. */
-export interface RunRowProps {
-    activity: RunActivity;
-    /** The row is in the viewport with no overlay: draw the animated spinner. */
-    live: boolean;
-    /** Measured by `ScrollViewport` to learn whether the row has scrolled away. */
-    rowRef?: React.RefObject<DOMElement>;
-}
-export interface ComposerProps {
-    /** Compatibility prop; activity is now rendered by the global StatusBar. */
-    runRow?: RunRowProps | null;
-    cols?: number;
-    terminalRows?: number;
-    statusExpanded?: boolean;
-    deleteDisambiguated?: boolean;
-    onCompletionContextChange?: (context: 'none' | 'slash' | 'file') => void;
-    cursorVisible?: boolean;
-    onInteraction?: () => void;
-    measureRef?: React.RefObject<DOMElement>;
-    /** False while an overlay owns the keyboard (the input is visually blurred). */
-    isActive: boolean;
-    reducedMotion?: boolean;
-    onEscape?: () => void;
-    onEscapeDismiss?: () => void;
-    running: boolean;
-    history: string[];
-    commands: CommandOption[];
-    cwd: string;
-    /** Dropped on short terminals to buy back a row (§5.4). */
-    showHint: boolean;
-    /** Compatibility prop; submission count no longer hides essential actions. */
-    submitCount: number;
-    /** Compatibility prop; App owns secondary teaching-hint visibility. */
-    hintsEnabled: boolean;
-    /** Mirror of the controller's effective mode; drives the border. */
-    agentMode: AgentMode;
-    /**
-     * The adopted posture (governance-mode 10.2). A governed one paints the idle/draft
-     * border in `governAccent`, the same slot PLAN uses `accent` for. Absent = the
-     * pre-governance border logic, unchanged.
-     */
-    posture?: string;
-    /** Compatibility prop; the global action row names the effective mode key. */
-    modeToggleKey?: string;
-    popupMaxRows?: number;
-    popupMaxHeight?: number;
-    onPopupRowsChange?: (rows: number) => void;
-    /** Compatibility prop; history position is displayed by Header. */
-    scrolledLines?: number;
-    /** Compatibility prop; the global status and action rows show live services. */
-    services?: number;
-    /**
-     * The composer's DRAFT row count, forwarded upward (tui-paste-handling
-     * section 5.5).
-     *
-     * `hasDraft` stays here, because the border reacts to it and routing that
-     * through `App` would re-render the transcript on the first keystroke of every
-     * message. The row count is the opposite case: `layout/budget.ts` needs it, so
-     * it has to reach `App` — and it changes on a line break rather than on a
-     * character, which is what keeps the re-render rate the same (R-6).
-     */
-    onDraftRows?: (rows: number) => void;
-    /**
-     * Draft PRESENCE, forwarded upward for the Ctrl+C ladder
-     * (ctrl-c-clear-draft-exit). App stores it in a ref only - no state,
-     * so the transcript does not re-render on the first keystroke of a
-     * message (the same cost the comment above documents).
-     */
-    onDraftPresence?: (hasDraft: boolean) => void;
-    /**
-     * Downward half of the same channel: ticks when App asks the editor
-     * to clear the draft (Ctrl+C x2 while drafting). Passed through to
-     * PromptInput unchanged.
-     */
-    draftClearNonce?: number;
-    /** Downward half of the fill channel; forwarded to `PromptInput` unchanged. */
-    draftFill?: DraftFill;
-    /** `prompts.insertMode`, forwarded unchanged. */
-    insertMode?: 'insert' | 'replace';
-    /** Paste refusals from `PromptInput`, routed to `App`'s notice dispatch. */
-    onNotice?: (level: 'warn' | 'error', text: string) => void;
-    theme: Theme;
-    caps: TermCapabilities;
-    onSubmit: (text: string) => ComposerSubmitResult;
-    onHelp?: () => void;
-}
-/** Legacy helper retained for consumers and contract tests; not rendered by Composer. */
-export declare function runningHintClauses(opts: {
-    glyphs: ReturnType<typeof pickGlyphs>;
-    services: number;
-}): string[];
-/** Compatibility formatter. Product hints use interaction-hints.ts. */
-declare function hintText(opts: {
-    running: boolean;
-    submitCount: number;
-    glyphs: ReturnType<typeof pickGlyphs>;
-    mode: AgentMode;
-    toggleKey: string;
-    /** Live background services; 0 leaves both rows byte-identical to today's. */
-    services: number;
-}): string;
-/** Compatibility export for existing hint contract tests. */
-export declare const hintTextForTest: typeof hintText;
-export declare 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, }: ComposerProps): React.ReactElement;
-export {};