@aragon-agent/cli 0.6.2 → 0.6.4

package/dist/ui/composer-rows.js

@@ -0,0 +1,201 @@
+/**
+ * Composer layout (tui-paste-handling section 5.5) -- pure. No Ink, no React.
+ *
+ * THE ONE PLACE THAT MAPS A BUFFER INDEX TO A SCREEN CELL (I-9). The composer
+ * used to hand its buffer to Ink one `<Text>` per logical line and let Yoga wrap
+ * it, which is fine until the draft is taller than the frame: `AppShell` gives
+ * the bottom chrome `flexShrink={0}`, so a tall composer does not grow the frame
+ * -- Yoga takes the rows out of the transcript and `overflow: hidden` clips them
+ * away, while `layout/budget.ts` keeps telling five consumers the composer is
+ * three rows tall. Four hundred presses of `Shift+Enter` do it without pasting
+ * anything.
+ *
+ * So the wrap happens HERE, the row count is a number this module returns, and
+ * `budget.ts` is told that number (I-8).
+ *
+ * HARD WRAP BY DISPLAY COLUMN, NEVER `layout/wrap-rows.ts::wrapToRows` (D-15).
+ * That function is a PROSE wrapper: it splits on `/\s+/` and rejoins with single
+ * spaces, so it destroys indentation and makes the character-index-to-screen-cell
+ * mapping the caret depends on impossible to state, let alone compute.
+ */
+import stringWidth from 'string-width';
+import { tokenSpans } from './paste-tokens.js';
+/**
+ * Columns a TAB advances to.
+ *
+ * TABS ARE EXPANDED TO SPACES FOR DISPLAY ONLY -- the buffer keeps the tab, so
+ * the model receives exactly what was pasted. The alternative is to emit the raw
+ * tab and let the terminal expand it, which puts the terminal's tab stop (8) and
+ * this module's column arithmetic in disagreement: the row would overflow its box
+ * and the terminal would wrap it a second time, which is the corruption the whole
+ * feature exists to remove.
+ */
+const TAB_WIDTH = 4;
+/**
+ * Display width of one code point.
+ *
+ * The ASCII fast path matters: `layoutComposer` runs on every keystroke and a
+ * recalled prompt-history entry can be thousands of characters, so one
+ * `string-width` call per character would be the cost this package spent
+ * `tui-render-performance` removing.
+ */
+function charWidth(ch) {
+    const code = ch.codePointAt(0) ?? 0;
+    if (code >= 0x20 && code < 0x7f)
+        return 1;
+    return stringWidth(ch);
+}
+/** Total display width of a run, using the same table the layout used. */
+export function displayWidth(text) {
+    let w = 0;
+    for (const ch of text)
+        w += charWidth(ch);
+    return w;
+}
+/**
+ * Wrap `buffer` into rows, locate the caret, and select a window of at most
+ * `maxRows` rows that contains it.
+ *
+ * The window is pinned to the BOTTOM -- where the user is typing -- and pulled up
+ * only far enough to keep the caret visible. That is deterministic, which matters
+ * because this function holds no state between calls: a scroll offset would have
+ * to live in the reducer and would then need its own invalidation rules.
+ */
+export function layoutComposer(input) {
+    const { buffer, cursor, active } = input;
+    const cols = Math.max(1, Math.floor(input.cols));
+    const maxRows = input.maxRows >= 1 ? Math.floor(input.maxRows) : 1;
+    const spans = tokenSpans(buffer);
+    let spanIndex = 0;
+    /** Monotonic in `index`, which is why the pointer is safe. */
+    const kindAt = (index) => {
+        while (spanIndex < spans.length && spans[spanIndex].end <= index)
+            spanIndex += 1;
+        const span = spans[spanIndex];
+        return span && index >= span.start && index < span.end ? 'token' : 'text';
+    };
+    const rows = [];
+    let segments = [];
+    let col = 0;
+    let cursorRowAbs = -1;
+    let cursorCol = 0;
+    const breakRow = () => {
+        rows.push({ segments });
+        segments = [];
+        col = 0;
+    };
+    const append = (text, width, kind) => {
+        const last = segments[segments.length - 1];
+        if (last && last.kind === kind)
+            segments[segments.length - 1] = { text: last.text + text, kind };
+        else
+            segments.push({ text, kind });
+        col += width;
+    };
+    const ensureRoom = (width) => {
+        if (col > 0 && col + width > cols)
+            breakRow();
+    };
+    const length = buffer.length;
+    let i = 0;
+    while (i <= length) {
+        const atCursor = active && i === cursor && cursorRowAbs === -1;
+        if (i === length) {
+            if (atCursor) {
+                ensureRoom(1);
+                cursorRowAbs = rows.length;
+                cursorCol = col;
+            }
+            break;
+        }
+        const ch = String.fromCodePoint(buffer.codePointAt(i));
+        if (ch === '\n') {
+            if (atCursor) {
+                cursorRowAbs = rows.length;
+                cursorCol = col;
+            }
+            breakRow();
+            i += 1;
+            continue;
+        }
+        const kind = kindAt(i);
+        if (ch === '\t') {
+            let advance = TAB_WIDTH - (col % TAB_WIDTH);
+            if (col > 0 && col + advance > cols) {
+                breakRow();
+                advance = TAB_WIDTH;
+            }
+            if (atCursor) {
+                cursorRowAbs = rows.length;
+                cursorCol = col;
+            }
+            append(' '.repeat(advance), advance, kind);
+            i += 1;
+            continue;
+        }
+        const width = charWidth(ch);
+        ensureRoom(width);
+        if (atCursor) {
+            cursorRowAbs = rows.length;
+            cursorCol = col;
+        }
+        append(ch, width, kind);
+        i += ch.length;
+    }
+    rows.push({ segments });
+    const totalRows = rows.length;
+    const cap = Math.max(1, Math.min(maxRows, totalRows));
+    let start = Math.max(0, totalRows - cap);
+    if (cursorRowAbs >= 0) {
+        if (cursorRowAbs < start)
+            start = cursorRowAbs;
+        else if (cursorRowAbs >= start + cap)
+            start = Math.min(totalRows - cap, cursorRowAbs - cap + 1);
+    }
+    const windowed = rows.slice(start, start + cap);
+    return {
+        rows: windowed,
+        cursorRow: cursorRowAbs >= 0 ? cursorRowAbs - start : -1,
+        cursorCol,
+        totalRows,
+        hiddenAbove: start,
+        hiddenBelow: totalRows - start - windowed.length,
+    };
+}
+/**
+ * Split one row at a display column so the renderer can draw an inverse caret on
+ * exactly one cell.
+ *
+ * Lives here rather than in the component because it walks the SAME width table
+ * `layoutComposer` walked (I-9): a second, subtly different measurement is how
+ * the caret ends up drawn on a cell that does not hold the character it is on.
+ */
+export function splitRowAtColumn(row, column) {
+    const before = [];
+    const after = [];
+    let at = null;
+    let x = 0;
+    const push = (list, text, kind) => {
+        const last = list[list.length - 1];
+        if (last && last.kind === kind)
+            list[list.length - 1] = { text: last.text + text, kind };
+        else
+            list.push({ text, kind });
+    };
+    for (const segment of row.segments) {
+        if (at !== null) {
+            push(after, segment.text, segment.kind);
+            continue;
+        }
+        for (const ch of segment.text) {
+            if (at === null && x === column) {
+                at = { text: ch, kind: segment.kind };
+            }
+            else {
+                push(at === null ? before : after, ch, segment.kind);
+            }
+            x += charWidth(ch);
+        }
+    }
+    return { before, at, after };
+}

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

@@ -22,13 +22,41 @@
  *
  * Extracted from the component so it is unit-testable without mounting Ink.
  */
+import { type PasteRecord } from './paste-tokens.js';
 export interface EditorState {
     buffer: string;
     cursor: number;
     historyIndex: number | null;
     dismissed: boolean;
     sel: number;
+    /**
+     * Payloads for the collapse tokens currently in `buffer`
+     * (tui-paste-handling section 5.3).
+     *
+     * Pruned to `referencedIds(buffer)` on EVERY buffer-changing action and
+     * emptied by `clear` (I-7). Without both, a payload outlives the draft that
+     * referenced it, unbounded, for the whole session.
+     */
+    pastes: ReadonlyMap<number, PasteRecord>;
 }
+/**
+ * One run of an `input` chunk that mixed typing and pasting.
+ *
+ * THE `id` IS ALLOCATED BY THE CALLER (P1-5). React may run a reducer more than
+ * once for a single action -- eager evaluation in `dispatchSetState`, base-queue
+ * replay after a bailout, StrictMode -- so a counter read and written inside one
+ * would skip ids and produce two computed states differing in the token TEXT.
+ * `PromptInput` calls `allocatePasteId()` while building these segments, and the
+ * reducer stays a pure function of `(state, action)`.
+ */
+export type InputSegment = {
+    readonly kind: 'text';
+    readonly text: string;
+} | {
+    readonly kind: 'paste';
+    readonly text: string;
+    readonly id: number;
+};
 /**
  * A `type` and not an `interface` because it is a discriminated union — the one
  * documented exception to this package's interface-first convention.
@@ -57,6 +85,15 @@ export type EditorAction = {
     type: 'dismiss';
 } | {
     type: 'clear';
+}
+/**
+ * ONE chunk of stdin, already split into ordered runs. The only new action,
+ * and it is what keeps the one-dispatch-per-key rule true for a chunk that
+ * carried both a paste and the keystrokes beside it.
+ */
+ | {
+    type: 'input';
+    segments: InputSegment[];
 };
 export declare const INITIAL_EDITOR_STATE: EditorState;
 export declare function editorReducer(state: EditorState, action: EditorAction): EditorState;

package/dist/ui/editor-reducer.js

@@ -22,12 +22,15 @@
  *
  * Extracted from the component so it is unit-testable without mounting Ink.
  */
+import { expandRangeOverTokens, formatPasteToken, makePasteRecord, referencedIds, shouldCollapse, snapOutOfToken, } from './paste-tokens.js';
+const NO_PASTES = new Map();
 export const INITIAL_EDITOR_STATE = {
     buffer: '',
     cursor: 0,
     historyIndex: null,
     dismissed: false,
     sel: 0,
+    pastes: NO_PASTES,
 };
 /**
  * The three flags `resetDraftFlags()` used to clear with three separate
@@ -40,26 +43,99 @@ export const INITIAL_EDITOR_STATE = {
  * (the candidate list is about to be recomputed).
  */
 const DRAFT_FLAGS = { historyIndex: null, dismissed: false, sel: 0 };
+/**
+ * Drop payloads the buffer no longer references (I-7).
+ *
+ * A WRAPPER, NOT A LINE IN ONE BRANCH (P1-6). v1 of the design pruned only inside
+ * `input`, which leaves `replace` (the action behind `Ctrl+U` / `Ctrl+K` /
+ * `Ctrl+W` and every `applyEdit`), `backspace` and `recall` able to delete a token
+ * without releasing its payload. A rule the body contradicts is worse than no
+ * rule, because the next reader trusts the invariant.
+ *
+ * `moveCursor`, `select` and `dismiss` do not change the buffer and are left
+ * alone, which keeps their "return the same object so React bails out" property.
+ */
+function withPrune(next) {
+    if (next.pastes.size === 0)
+        return next;
+    const live = referencedIds(next.buffer);
+    // EVERY held id is tested, rather than `live.size === next.pastes.size`.
+    // Equal counts do not mean equal sets: `referencedIds` reads the BUFFER, which
+    // can name an id this map never held — a user who types `[Pasted text #99 +2
+    // lines]` by hand, or edits the number inside a real token. One such id
+    // balances out one deleted token and the cheap check then returns early with a
+    // payload the buffer no longer references, which is the leak I-7 forbids.
+    let stale = false;
+    for (const id of next.pastes.keys()) {
+        if (!live.has(id)) {
+            stale = true;
+            break;
+        }
+    }
+    if (!stale)
+        return next;
+    const kept = new Map();
+    for (const [id, record] of next.pastes)
+        if (live.has(id))
+            kept.set(id, record);
+    return { ...next, pastes: kept };
+}
 export function editorReducer(state, action) {
     switch (action.type) {
-        case 'insert':
-            return {
+        case 'insert': {
+            // D-8: typing can never land INSIDE a token. A no-op on a buffer with no
+            // tokens, which is every buffer until the first collapse.
+            const cursor = snapOutOfToken(state.buffer, state.cursor);
+            return withPrune({
                 ...state,
                 ...DRAFT_FLAGS,
-                buffer: state.buffer.slice(0, state.cursor) + action.text + state.buffer.slice(state.cursor),
-                cursor: state.cursor + action.text.length,
-            };
+                buffer: state.buffer.slice(0, cursor) + action.text + state.buffer.slice(cursor),
+                cursor: cursor + action.text.length,
+            });
+        }
         case 'replace':
-            return { ...state, ...DRAFT_FLAGS, buffer: action.buffer, cursor: action.cursor };
+            return withPrune({
+                ...state,
+                ...DRAFT_FLAGS,
+                buffer: action.buffer,
+                cursor: action.cursor,
+            });
         case 'backspace': {
             if (state.cursor <= 0)
                 return state;
-            return {
+            // G5: one `Backspace` immediately after `...lines]` removes the whole
+            // token and releases its payload, in ONE dispatch.
+            const range = expandRangeOverTokens(state.buffer, state.cursor - 1, state.cursor);
+            return withPrune({
+                ...state,
+                ...DRAFT_FLAGS,
+                buffer: state.buffer.slice(0, range.from) + state.buffer.slice(range.to),
+                cursor: range.from,
+            });
+        }
+        case 'input': {
+            let buffer = state.buffer;
+            let cursor = snapOutOfToken(buffer, state.cursor);
+            let pastes = null;
+            for (const segment of action.segments) {
+                const collapse = segment.kind === 'paste' && shouldCollapse(segment.text);
+                let text = segment.text;
+                if (collapse) {
+                    const record = makePasteRecord(segment.id, segment.text);
+                    text = formatPasteToken(record);
+                    pastes = pastes ?? new Map(state.pastes);
+                    pastes.set(record.id, record);
+                }
+                buffer = buffer.slice(0, cursor) + text + buffer.slice(cursor);
+                cursor += text.length;
+            }
+            return withPrune({
                 ...state,
                 ...DRAFT_FLAGS,
-                buffer: state.buffer.slice(0, state.cursor - 1) + state.buffer.slice(state.cursor),
-                cursor: state.cursor - 1,
-            };
+                buffer,
+                cursor,
+                ...(pastes ? { pastes } : {}),
+            });
         }
         case 'moveCursor':
             // NO DRAFT-FLAG RESET. Moving the caret is not an edit: clearing
@@ -74,12 +150,12 @@ export function editorReducer(state, action) {
             // an Esc-dismissed popup that reopened when the user stepped through their
             // history would be a behaviour change smuggled in by a refactor whose whole
             // claim is that input semantics are identical (K-7).
-            return {
+            return withPrune({
                 ...state,
                 buffer: action.buffer,
                 cursor: action.cursor,
                 historyIndex: action.historyIndex,
-            };
+            });
         case 'select':
             return state.sel === action.sel ? state : { ...state, sel: action.sel };
         case 'dismiss':

package/dist/ui/entries/CompactionCard.d.ts

@@ -0,0 +1,75 @@
+/**
+ * CompactionCard — one context compaction in the transcript
+ * (context-auto-compaction §6.3).
+ *
+ * ASCII ONLY: every glyph comes from `pickGlyphs`, INCLUDING THE ARROW. The mock
+ * in the design shows `112 -> 9 messages`; that arrow is `glyphs.arrowRight`, the
+ * one `StatusBar` already uses, not a literal — `ui/` is inside
+ * `glyphs.test.ts::inScope`, so a literal here fails the scan (P2-7).
+ *
+ * EXPANDABLE, UNLIKE `FastCard`. A critique is already clamped to
+ * `fast.reviewMaxChars` before it reaches its card, so there is nothing hidden
+ * for Ctrl+O to reveal; a summary is up to `summaryMaxChars` and there genuinely
+ * is more to see. That is why `App`'s Ctrl+O predicate had to learn about this
+ * kind — without it the card renders a hint that does nothing and expands an
+ * older tool card instead (C-15 / P1-8 / AC-21).
+ *
+ * EVERY STRING DESCRIBES THE HISTORY, NEVER THE SCREEN (§6.4 / P2-9). `/clear`
+ * empties the transcript view but not `messages`, so this card can legitimately
+ * report "112 -> 9 messages" with nine visible rows above it. Nothing here says
+ * "above" or "earlier in this transcript".
+ */
+import React from 'react';
+import type { Theme } from '../theme.js';
+import type { TermCapabilities } from '../capabilities.js';
+import type { CompactionMode, CompactionUiTrigger } from '../../compaction/types.js';
+export interface CompactionCardProps {
+    index: number;
+    trigger: CompactionUiTrigger;
+    mode: CompactionMode;
+    applied: boolean;
+    reason?: string;
+    messagesBefore: number;
+    messagesAfter: number;
+    tokensBefore: number;
+    tokensAfter: number;
+    summary?: string;
+    model: string;
+    durationMs?: number;
+    /**
+     * Wall-clock since the card opened, LIVE ONLY
+     * (context-auto-compaction-hardening §3.6 / W5).
+     *
+     * Rendered in the position `durationMs` occupies once settled, so the number
+     * does not move when the card settles. Only the single live card receives it,
+     * so exactly one memoized card re-renders per second.
+     */
+    elapsedMs?: number;
+    /** Set when tail relief clipped the retained turns (W2). */
+    tailRelief?: {
+        messages: number;
+        charsRemoved: number;
+    };
+    live: boolean;
+    expanded?: boolean;
+    reducedMotion?: boolean;
+    theme: Theme;
+    caps: TermCapabilities;
+}
+/**
+ * The card's colour.
+ *
+ * `truncated` is a WARNING rather than the accent, because it is a real and
+ * bounded data loss the user is entitled to notice; `applied: false` is an error
+ * because the run is still at the occupancy that triggered it.
+ */
+export declare function compactionCardColor(props: Pick<CompactionCardProps, 'live' | 'applied' | 'mode'>, theme: Theme): string | undefined;
+declare function CompactionCardImpl(props: CompactionCardProps): React.ReactElement;
+/**
+ * `React.memo` with the DEFAULT comparator (tui-render-performance L2 / R3).
+ * `mapEntry` already preserves object identity for untouched entries, so the
+ * props below are stable references on a settled card, and `theme` / `caps` are
+ * `useMemo`d in `App.tsx` (I-L2-1).
+ */
+export declare const CompactionCard: React.MemoExoticComponent<typeof CompactionCardImpl>;
+export {};

package/dist/ui/entries/CompactionCard.js

@@ -0,0 +1,158 @@
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * CompactionCard — one context compaction in the transcript
+ * (context-auto-compaction §6.3).
+ *
+ * ASCII ONLY: every glyph comes from `pickGlyphs`, INCLUDING THE ARROW. The mock
+ * in the design shows `112 -> 9 messages`; that arrow is `glyphs.arrowRight`, the
+ * one `StatusBar` already uses, not a literal — `ui/` is inside
+ * `glyphs.test.ts::inScope`, so a literal here fails the scan (P2-7).
+ *
+ * EXPANDABLE, UNLIKE `FastCard`. A critique is already clamped to
+ * `fast.reviewMaxChars` before it reaches its card, so there is nothing hidden
+ * for Ctrl+O to reveal; a summary is up to `summaryMaxChars` and there genuinely
+ * is more to see. That is why `App`'s Ctrl+O predicate had to learn about this
+ * kind — without it the card renders a hint that does nothing and expands an
+ * older tool card instead (C-15 / P1-8 / AC-21).
+ *
+ * EVERY STRING DESCRIBES THE HISTORY, NEVER THE SCREEN (§6.4 / P2-9). `/clear`
+ * empties the transcript view but not `messages`, so this card can legitimately
+ * report "112 -> 9 messages" with nine visible rows above it. Nothing here says
+ * "above" or "earlier in this transcript".
+ */
+import React from 'react';
+import { Box, Text } from 'ink';
+import Spinner from 'ink-spinner';
+import { pickGlyphs } from '../glyphs.js';
+import { railBorderProps } from '../layout/Gutter.js';
+import { formatDuration, formatTokens } from '../../agent/usage.js';
+import { COMPACTION_LIMITS } from '../../compaction/limits.js';
+/**
+ * The card's colour.
+ *
+ * `truncated` is a WARNING rather than the accent, because it is a real and
+ * bounded data loss the user is entitled to notice; `applied: false` is an error
+ * because the run is still at the occupancy that triggered it.
+ */
+export function compactionCardColor(props, theme) {
+    if (props.live)
+        return theme.toolRunning;
+    if (!props.applied)
+        return theme.toolError;
+    if (props.mode === 'truncated' || props.mode === 'relieved')
+        return theme.noticeWarn;
+    return theme.accent;
+}
+/** The one-line summary of what the compaction did, or why it did not. */
+function headline(props, arrow, dot) {
+    const { index, live } = props;
+    // The model is `''` when no summarizer resolves (no key for the provider), and
+    // the separator has to go with it — a headline ending in a dangling `  -  `
+    // reads as a rendering fault rather than as the missing model it is.
+    if (live) {
+        // ELAPSED IN THE SAME POSITION `durationMs` TAKES ONCE SETTLED, so the number
+        // does not jump across the line when the card settles. Between second 0 and
+        // second 45 this was the only changing information on the card, and there was
+        // none.
+        const elapsed = props.elapsedMs === undefined ? '' : `${dot}${formatDuration(props.elapsedMs)}`;
+        return props.model
+            ? `compacting context #${index}${dot}${props.model}${elapsed}`
+            : `compacting context #${index}${elapsed}`;
+    }
+    if (!props.applied) {
+        const why = props.reason ? `: ${props.reason}` : '';
+        return `context not compacted #${index}${why}`;
+    }
+    const messages = `${props.messagesBefore} ${arrow} ${props.messagesAfter} messages`;
+    const tokens = `${formatTokens(props.tokensBefore)} ${arrow} ${formatTokens(props.tokensAfter)} tokens`;
+    const duration = props.durationMs === undefined ? '' : `${dot}${formatDuration(props.durationMs)}`;
+    return `context compacted${dot}${messages}${dot}${tokens}${duration}`;
+}
+/**
+ * The muted second line: how it was done, and with what.
+ *
+ * THE LIVE BRANCH NAMES THE ESCAPE (§3.6 / E-10). `AgentController.abort()` has
+ * always called `this.compaction?.abort()` before `agent.abort()`, so Esc has
+ * always cancelled an in-flight summarization - and no surface has ever said so
+ * during the forty-five seconds it matters. The hint goes with the model for the
+ * same reason the separator does: with no summarizer resolved there is no call to
+ * cancel.
+ *
+ * THE `relieved` BRANCH COMES BEFORE `truncated`, AND IT EXISTS BECAUSE THE
+ * `summarized` LINE WOULD OTHERWISE LIE. Relief drops no messages, so the
+ * fall-through would render "summarized 0 messages with <model>" for a
+ * compaction in which no model was called - in the rare, alarming case the user
+ * most needs to read correctly.
+ */
+function detailLine(props) {
+    if (props.live) {
+        if (!props.model)
+            return '';
+        return `summarizing with ${props.model} - esc to cancel`;
+    }
+    if (!props.applied)
+        return props.mode === 'none' && !props.reason ? 'nothing was changed' : '';
+    const dropped = Math.max(0, props.messagesBefore - props.messagesAfter);
+    if (props.mode === 'relieved') {
+        const n = props.tailRelief?.messages ?? 0;
+        return `clipped ${n} tool ${n === 1 ? 'result' : 'results'} in the retained turns - nothing could be dropped`;
+    }
+    if (props.mode === 'truncated') {
+        return `dropped ${dropped} messages WITHOUT a summary - summarization failed`;
+    }
+    const via = props.trigger === 'overflow' ? ' after a context overflow' : '';
+    return `summarized ${dropped} messages with ${props.model}${via}`;
+}
+/**
+ * The relief disclosure, on a settled card that ALSO summarized.
+ *
+ * A BOUNDED, ANNOUNCED DATA LOSS THE USER IS ENTITLED TO NOTICE, in the same
+ * voice §6.4's honesty rules use for `truncated`. Suppressed on the `relieved`
+ * card, where `detailLine` has already said it and a second line would be the
+ * same sentence twice.
+ */
+function reliefLine(props) {
+    if (props.live || !props.applied || !props.tailRelief || props.mode === 'relieved')
+        return '';
+    const n = props.tailRelief.messages;
+    return (`clipped ${n} tool ${n === 1 ? 'result' : 'results'} in the retained turns ` +
+        `(${formatTokens(props.tailRelief.charsRemoved)} characters) - ` +
+        'the recent turns alone exceeded the window');
+}
+/**
+ * Split the summary into rows.
+ *
+ * A ROW budget, not a character one: `summaryMaxChars` already bounded the text,
+ * and this only decides how much of it the COLLAPSED card shows. Ink wraps the
+ * rest.
+ */
+function summaryRows(text, expanded) {
+    const lines = text.split('\n').filter((l) => l.trim().length > 0);
+    return expanded ? lines : lines.slice(0, COMPACTION_LIMITS.cardTextRows);
+}
+function CompactionCardImpl(props) {
+    const { live, summary, expanded, reducedMotion, theme, caps } = props;
+    const glyphs = pickGlyphs(caps);
+    const color = compactionCardColor(props, theme);
+    const dot = `  ${glyphs.midDot}  `;
+    const head = headline(props, glyphs.arrowRight, dot);
+    const detail = detailLine(props);
+    const relief = reliefLine(props);
+    const rows = summary ? summaryRows(summary, expanded === true) : [];
+    const totalRows = summary ? summary.split('\n').filter((l) => l.trim().length > 0).length : 0;
+    const hidden = Math.max(0, totalRows - rows.length);
+    // COLOUR TRACKS `live`, MOTION TRACKS `animate` — one headline, two separate
+    // decisions, and the split is the one `FastCard` records at length: `App`
+    // widens `reducedMotion` to "this frame does not animate here" for the whole of
+    // every run, and folding the two together would grey out every live card for
+    // the whole run, losing the status colour along with the motion.
+    const animate = live && reducedMotion !== true && caps.unicode;
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { flexDirection: "row", children: [_jsx(Text, { color: theme.accent, bold: true, children: "compact" }), _jsxs(Text, { color: live ? color : theme.muted, wrap: "truncate", children: ['  ', animate ? (_jsxs(_Fragment, { children: [_jsx(Spinner, { type: "dots" }), ' '] })) : live ? (`${glyphs.spinnerStill} `) : (''), head] })] }), detail.length > 0 && (_jsx(Box, { flexDirection: "column", flexShrink: 0, paddingLeft: 1, children: _jsx(Text, { color: color, wrap: "truncate", children: detail }) })), relief.length > 0 && (_jsx(Box, { flexDirection: "column", flexShrink: 0, paddingLeft: 1, children: _jsx(Text, { color: theme.noticeWarn, children: relief }) })), rows.length > 0 && (_jsxs(Box, { flexDirection: "column", flexShrink: 0, paddingLeft: 1, ...railBorderProps(glyphs.railVertical, theme.border), children: [rows.map((line, index) => (_jsx(Text, { color: theme.primary, children: line }, index))), hidden > 0 && (_jsxs(Text, { color: theme.muted, children: [glyphs.railEnd, " +", hidden, " more lines (ctrl+o to expand)"] })), hidden === 0 && expanded === true && totalRows > COMPACTION_LIMITS.cardTextRows && (_jsxs(Text, { color: theme.muted, children: [glyphs.railEnd, " ctrl+o to collapse"] }))] }))] }));
+}
+/**
+ * `React.memo` with the DEFAULT comparator (tui-render-performance L2 / R3).
+ * `mapEntry` already preserves object identity for untouched entries, so the
+ * props below are stable references on a settled card, and `theme` / `caps` are
+ * `useMemo`d in `App.tsx` (I-L2-1).
+ */
+export const CompactionCard = React.memo(CompactionCardImpl);