@aragon-agent/cli 0.6.1 → 0.6.3

package/dist/ui/PromptInput.d.ts

@@ -21,6 +21,7 @@
 import React from 'react';
 import type { Theme } from './theme.js';
 import type { TermCapabilities } from './capabilities.js';
+import { pickGlyphs } from './glyphs.js';
 import { type EditIntent } from '../input/keymap.js';
 import { type Suggestion } from './AutocompletePopup.js';
 import type { AgentMode } from '../agent/agent-mode.js';
@@ -65,7 +66,39 @@ interface PromptInputProps {
     };
     /** Fires only when the draft flips empty ⇄ non-empty, for the border color. */
     onDraftChange?: (hasDraft: boolean) => void;
+    /**
+     * Rows of newer output hidden BELOW the viewport — `ScrollViewport`'s offset
+     * (tui-selection-and-scroll-follow §4.2 / G7).
+     *
+     * Rendered as a right-aligned chip ON THE INPUT ROW, INSIDE THE BORDER, which
+     * is what the requirement asks for (输入框内部) and what makes the hint cost
+     * zero rows. It used to take the viewport's own last row, which spent a line of
+     * the user's content exactly when the transcript was longest AND fed the number
+     * back into its own derivation (§3.3).
+     *
+     * IT IS STATE, NOT A HINT. It deliberately ignores `showHint` / `hintsEnabled`
+     * — those govern the teaching row BELOW the box, which fades with experience
+     * and is dropped on a short terminal. "You are 12 rows behind the newest
+     * output" must survive both (T-23).
+     *
+     * Only meaningful in full-screen mode, so it renders only when `bordered` is
+     * set: inline mode has no self-drawn viewport and this is always 0 there.
+     */
+    scrolledLines?: number;
 }
+export interface ScrollChip {
+    text: string;
+    /** FIXED width, so the number gaining a digit cannot re-wrap the draft (P2-4). */
+    cells: number;
+}
+/**
+ * Build the chip, or `null` when the viewport is pinned to the newest output.
+ *
+ * Every glyph comes from `pickGlyphs` and none from a literal (I-5): on a legacy
+ * console this renders `v12` rather than mojibake, and `glyphs.test.ts`'s static
+ * scan fails the build if that rule is broken here.
+ */
+export declare function scrollChip(scrolledLines: number, cols: number, glyphs: ReturnType<typeof pickGlyphs>): ScrollChip | null;
 /** Apply an edit intent as a pure buffer/cursor transform. */
 export declare function applyEdit(buffer: string, cursor: number, intent: EditIntent): {
     buffer: string;
@@ -94,5 +127,5 @@ export declare function fileTokenAt(buffer: string, cursor: number): {
     end: number;
     query: string;
 } | null;
-export declare function PromptInput({ isActive, running, history, commands, cwd, theme, caps, popupMaxRows, agentMode, onSubmit, onHelp, bordered, onDraftChange, }: PromptInputProps): React.ReactElement;
+export declare function PromptInput({ isActive, running, history, commands, cwd, theme, caps, popupMaxRows, agentMode, onSubmit, onHelp, bordered, onDraftChange, scrolledLines, }: PromptInputProps): React.ReactElement;
 export {};

package/dist/ui/PromptInput.js

@@ -20,13 +20,49 @@ import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
  * rather than from a key.
  */
 import { useEffect, useReducer, useRef, useState } from 'react';
-import { Box, Text, useInput } from 'ink';
+import { Box, Text, useInput, useStdout } from 'ink';
 import { glob as tinyGlob } from 'tinyglobby';
 import { pickGlyphs } from './glyphs.js';
 import { recognize } from '../input/keymap.js';
 import { AutocompletePopup } from './AutocompletePopup.js';
 import { editorReducer, INITIAL_EDITOR_STATE } from './editor-reducer.js';
 // ---------------------------------------------------------------------------
+// The scroll chip (§4.2)
+// ---------------------------------------------------------------------------
+/** Below this the full sentence does not fit beside a draft; the chip goes terse. */
+const CHIP_FULL_MIN_COLS = 64;
+/**
+ * Ceiling on the number the chip prints, so `chipCells` is a CONSTANT per branch
+ * rather than a function of how far behind the user is (P2-4). Past it the chip
+ * reads `999+`.
+ */
+const CHIP_MAX_N = 999;
+/** `↓ 999+ new lines · PgDn` — the widest form the full branch can produce. */
+const CHIP_FULL_CELLS = 24;
+/** `↓999+` — the widest form the terse branch can produce. */
+const CHIP_TERSE_CELLS = 6;
+/**
+ * Build the chip, or `null` when the viewport is pinned to the newest output.
+ *
+ * Every glyph comes from `pickGlyphs` and none from a literal (I-5): on a legacy
+ * console this renders `v12` rather than mojibake, and `glyphs.test.ts`'s static
+ * scan fails the build if that rule is broken here.
+ */
+export function scrollChip(scrolledLines, cols, glyphs) {
+    if (!Number.isFinite(scrolledLines) || scrolledLines <= 0)
+        return null;
+    const n = Math.floor(scrolledLines);
+    const shown = n > CHIP_MAX_N ? `${CHIP_MAX_N}+` : String(n);
+    if (cols < CHIP_FULL_MIN_COLS) {
+        return { text: `${glyphs.arrowDown}${shown}`, cells: CHIP_TERSE_CELLS };
+    }
+    const noun = n === 1 ? 'line' : 'lines';
+    return {
+        text: `${glyphs.arrowDown} ${shown} new ${noun} ${glyphs.midDot} PgDn`,
+        cells: CHIP_FULL_CELLS,
+    };
+}
+// ---------------------------------------------------------------------------
 // Pure editing helpers (unit-tested in input.test.ts)
 // ---------------------------------------------------------------------------
 const isSpace = (ch) => !!ch && /\s/.test(ch);
@@ -138,7 +174,8 @@ function isControlSeq(input) {
 // ---------------------------------------------------------------------------
 // Component
 // ---------------------------------------------------------------------------
-export function PromptInput({ isActive, running, history, commands, cwd, theme, caps, popupMaxRows, agentMode, onSubmit, onHelp, bordered, onDraftChange, }) {
+export function PromptInput({ isActive, running, history, commands, cwd, theme, caps, popupMaxRows, agentMode, onSubmit, onHelp, bordered, onDraftChange, scrolledLines = 0, }) {
+    const { stdout } = useStdout();
     const [editor, dispatch] = useReducer(editorReducer, INITIAL_EDITOR_STATE);
     const { buffer, cursor, historyIndex, dismissed, sel } = editor;
     const [fileMatches, setFileMatches] = useState([]);
@@ -358,7 +395,21 @@ export function PromptInput({ isActive, running, history, commands, cwd, theme,
             ? `Describe what you want to build; I'll research and plan it first${glyphs.ellipsis}`
             : `Send a message (/ for commands, @ for files)${glyphs.ellipsis}`;
     const lines = renderWithCursor(buffer, cursor, isActive);
-    const inputRow = (_jsxs(Box, { flexDirection: "row", children: [_jsxs(Text, { color: markerColor, bold: true, children: [marker, ' '] }), _jsx(Box, { flexDirection: "column", children: buffer.length === 0 ? (_jsx(Text, { color: theme.muted, children: placeholder })) : (lines.map((line, i) => _jsx(Text, { children: line }, i))) })] }));
+    // Full-screen only: inline mode has no self-drawn viewport, so `scrolledLines`
+    // is always 0 there and the branch is unreachable rather than merely unused.
+    // The guard is explicit so it stays that way.
+    const chip = bordered ? scrollChip(scrolledLines, stdout?.columns ?? 80, glyphs) : null;
+    const inputRow = (_jsxs(Box, { flexDirection: "row", children: [_jsxs(Text, { color: markerColor, bold: true, children: [marker, ' '] }), _jsx(Box, { flexDirection: "column", flexGrow: 1, flexShrink: 1, children: buffer.length === 0 ? (_jsx(Text, { color: theme.muted, children: placeholder })) : (lines.map((line, i) => _jsx(Text, { children: line }, i))) }), chip && (
+            // `alignSelf="flex-start"` pins the chip to the FIRST row of a multi-line
+            // draft. Yoga's default `stretch` sizes this box to the full height of the
+            // editor; it renders on the top row either way today, and relying on that
+            // is how a later `justifyContent` edit moves it without failing anything.
+            //
+            // `width={chip.cells}` is a FIXED cell, not the chip's natural width
+            // (P2-4). The chip is the only thing on this row whose width changes while
+            // the user is typing — `↓ 9` becomes `↓ 10` becomes `↓ 100` — and every
+            // change would otherwise re-wrap a draft that fills the line.
+            _jsx(Box, { flexShrink: 0, alignSelf: "flex-start", marginLeft: 1, width: chip.cells, justifyContent: "flex-end", children: _jsx(Text, { wrap: "truncate", color: theme.hintFg ?? theme.muted, children: chip.text }) }))] }));
     return (_jsxs(Box, { flexDirection: "column", flexShrink: 0, children: [popupItems.length > 0 && (_jsx(AutocompletePopup, { items: popupItems, selected: clampedSel, theme: theme, caps: caps, maxRows: popupMaxRows })), bordered ? (_jsx(Box, { flexDirection: "column", flexShrink: 0, borderStyle: glyphs.boxStyle, borderColor: bordered.color, paddingX: 1, children: inputRow })) : (inputRow)] }));
 }
 /** Split the buffer into lines and render an inverse cursor at `cursor`. */

package/dist/ui/StatusBar.d.ts

@@ -138,6 +138,46 @@ interface StatusBarProps {
     fastActive?: {
         inFlight: boolean;
     };
+    /**
+     * Live context compaction (context-auto-compaction §6.2), or absent when it is
+     * off for this session — in which case an ordinary session's bar is unchanged.
+     *
+     * RIGHT CLUSTER, next to `fast` and `eco`, and it DEGRADES below
+     * `COMPACTION_LIMITS.statusCompactCols`. The `teamActive` / `ecoRung` /
+     * `fastActive` treatment rather than the `agentMode` one, for the reason the
+     * note on `agentMode` gives: the mode must never be unreportable, whereas
+     * compaction has a fuller home in `/compact status` — the GUARANTEED reporting
+     * surface (§6.5) — and a chip on a 60-column terminal costs the context gauge
+     * more than it says.
+     *
+     * `inFlight` renders `compacting`, so a summarization that is taking a while is
+     * visible on this row without a spinner competing with the activity line's.
+     */
+    compactionActive?: {
+        inFlight: boolean;
+    };
+    /**
+     * Where the gauge turns amber and red (§6.2).
+     *
+     * ABSENT means today's hardcoded `{ warn: 60, high: 85 }`, so a session with
+     * compaction off renders a byte-identical bar. When present these are
+     * `warnThreshold * 100` and `threshold * 100`, which is what makes the colour
+     * the user sees agree with the number the trigger fires on.
+     */
+    gaugeMarks?: {
+        warn: number;
+        high: number;
+    };
+    /**
+     * Whether `contextTokens` is a DERIVED figure rather than a measured one.
+     *
+     * It WIDENS THE EXISTING `~`, it does not add a second marker. Today that
+     * prefix means "the window is a guess" (`contextWindowKnown`); with compaction
+     * it also has to mean "the occupancy is a guess", because the bar is written
+     * from an estimate for one turn after every compaction so it can fall
+     * immediately (§6.2 / AC-5).
+     */
+    contextEstimated?: boolean;
 }
 export declare function StatusBar(props: StatusBarProps): React.ReactElement;
 export {};

package/dist/ui/StatusBar.js

@@ -6,6 +6,7 @@ import { buildGauge } from './gauge.js';
 import { MODE_LABEL } from '../agent/agent-mode.js';
 import { formatRetryChip } from '../agent/retry-view.js';
 import { FAST_LIMITS } from '../fast/limits.js';
+import { COMPACTION_LIMITS } from '../compaction/limits.js';
 import { TEAM_LIMITS } from '../team/limits.js';
 import { TODO_LIMITS } from '../todo/limits.js';
 /** Below this the `eco` chip costs the context gauge more than it is worth. */
@@ -29,14 +30,22 @@ function redrawChar(nonce) {
     return nonce % 2 === 0 ? ' ' : NBSP;
 }
 export function StatusBar(props) {
-    const { model, provider, usageTotal, contextTokens, contextWindow, contextWindowKnown, status, elapsedMs, thinkingLevel, tokPerSec, theme, caps, scrolledLines = 0, redrawNonce = 0, agentMode = 'build', pendingAgentMode = null, teamActive, todoActive, retryActive, ecoRung = 0, fastActive, } = props;
+    const { model, provider, usageTotal, contextTokens, contextWindow, contextWindowKnown, status, elapsedMs, thinkingLevel, tokPerSec, theme, caps, scrolledLines = 0, redrawNonce = 0, agentMode = 'build', pendingAgentMode = null, teamActive, todoActive, retryActive, ecoRung = 0, fastActive, compactionActive, gaugeMarks, contextEstimated = false, } = props;
     const { stdout } = useStdout();
     const cols = stdout?.columns ?? 80;
     const running = status === 'running';
     const glyphs = pickGlyphs(caps);
     const pct = contextWindow > 0 ? Math.min(100, Math.round((contextTokens / contextWindow) * 100)) : 0;
-    const gauge = buildGauge(pct, cols < 72 ? 8 : 12, theme, caps);
-    const pctLabel = `${contextWindowKnown ? '' : '~'}${gauge.pct}%`;
+    // `gaugeMarks` is spread rather than passed as `undefined`, so a session with
+    // compaction off takes `buildGauge`'s own default and the bar is byte-identical
+    // to the pre-feature build.
+    const gauge = gaugeMarks
+        ? buildGauge(pct, cols < 72 ? 8 : 12, theme, caps, gaugeMarks)
+        : buildGauge(pct, cols < 72 ? 8 : 12, theme, caps);
+    // ONE `~` FOR TWO KINDS OF APPROXIMATION (§6.2). A second marker would be a
+    // second thing to explain for a distinction the user does not act on
+    // differently: either way the number is a guess.
+    const pctLabel = `${contextWindowKnown && !contextEstimated ? '' : '~'}${gauge.pct}%`;
     const tokens = `${formatTokens(usageTotal.inputTokens)}${glyphs.arrowUp} ${formatTokens(usageTotal.outputTokens)}${glyphs.arrowDown}`;
     const statusGlyph = running ? theme.symbols.toolRunning : theme.symbols.toolPending;
     // Nothing at all in build mode with nothing pending: the default posture is
@@ -57,5 +66,5 @@ export function StatusBar(props) {
                                 ? `agents ${teamActive.running}/${teamActive.total}`
                                 : `[${teamActive.running}]`] })), retryActive && (_jsxs(Text, { color: theme.noticeWarn, bold: true, children: ['  ', formatRetryChip(retryActive, cols)] })), todoActive && (_jsxs(Text, { color: theme.accent, children: ['  ', cols >= TODO_LIMITS.statusCompactCols
                                 ? `todo ${todoActive.done}/${todoActive.total}`
-                                : `[${todoActive.done}/${todoActive.total}]`] })), cols >= 60 && (_jsxs(Text, { color: theme.muted, children: ['  ', provider, ":", model] })), thinkingLevel !== 'off' && cols >= 72 && (_jsxs(Text, { color: theme.accent, children: ["  think:", thinkingLevel] }))] }), _jsxs(Box, { flexDirection: "row", children: [fastActive && cols >= FAST_LIMITS.statusCompactCols && (_jsxs(Text, { color: theme.muted, children: ["fast", fastActive.inFlight ? '*' : '', '  '] })), ecoRung > 0 && cols >= ECO_MIN_COLS && (_jsxs(Text, { color: theme.muted, children: ["eco", '  '] })), scrolledLines > 0 && (_jsxs(Text, { color: theme.noticeWarn, children: [glyphs.arrowUp, scrolledLines, '  '] })), cols >= 60 && (_jsxs(Text, { children: [_jsx(Text, { color: theme.muted, children: "[" }), _jsx(Text, { color: gauge.fillColor, children: gauge.filled }), _jsx(Text, { color: gauge.trackColor, children: gauge.empty }), _jsx(Text, { color: theme.muted, children: "] " })] })), _jsx(Text, { color: theme.muted, children: pctLabel }), cols >= 72 && _jsxs(Text, { color: theme.muted, children: ["  ", tokens] }), _jsxs(Text, { color: theme.muted, children: ["  ", formatCost(usageTotal.costUsd)] }), running && (_jsxs(Text, { color: theme.muted, children: [tokPerSec > 0 && cols >= 72 ? `  ${tokPerSec} tok/s` : '', "  ", formatDuration(elapsedMs)] }))] })] }));
+                                : `[${todoActive.done}/${todoActive.total}]`] })), cols >= 60 && (_jsxs(Text, { color: theme.muted, children: ['  ', provider, ":", model] })), thinkingLevel !== 'off' && cols >= 72 && (_jsxs(Text, { color: theme.accent, children: ["  think:", thinkingLevel] }))] }), _jsxs(Box, { flexDirection: "row", children: [compactionActive && cols >= COMPACTION_LIMITS.statusCompactCols && (_jsxs(Text, { color: compactionActive.inFlight ? theme.accent : theme.muted, children: [compactionActive.inFlight ? 'compacting' : 'compact', '  '] })), fastActive && cols >= FAST_LIMITS.statusCompactCols && (_jsxs(Text, { color: theme.muted, children: ["fast", fastActive.inFlight ? '*' : '', '  '] })), ecoRung > 0 && cols >= ECO_MIN_COLS && (_jsxs(Text, { color: theme.muted, children: ["eco", '  '] })), scrolledLines > 0 && (_jsxs(Text, { color: theme.noticeWarn, children: [glyphs.arrowUp, scrolledLines, '  '] })), cols >= 60 && (_jsxs(Text, { children: [_jsx(Text, { color: theme.muted, children: "[" }), _jsx(Text, { color: gauge.fillColor, children: gauge.filled }), _jsx(Text, { color: gauge.trackColor, children: gauge.empty }), _jsx(Text, { color: theme.muted, children: "] " })] })), _jsx(Text, { color: theme.muted, children: pctLabel }), cols >= 72 && _jsxs(Text, { color: theme.muted, children: ["  ", tokens] }), _jsxs(Text, { color: theme.muted, children: ["  ", formatCost(usageTotal.costUsd)] }), running && (_jsxs(Text, { color: theme.muted, children: [tokPerSec > 0 && cols >= 72 ? `  ${tokPerSec} tok/s` : '', "  ", formatDuration(elapsedMs)] }))] })] }));
 }

package/dist/ui/TeamPanel.js

@@ -88,7 +88,13 @@ export function activityLine(run, cols) {
                     ? 'waiting for mail'
                     : 'tool';
         case 'done':
-            return `done  ${run.turns} turns`;
+            // `compacted N` ON THE SETTLED ROW ONLY (hardening §3.4.4 / W3). A running
+            // row is already competing for `activityBudget(cols)` with the child's own
+            // prose, and a marker that displaces what the child is DOING right now
+            // buys nothing - the dispatch report carries the same fact for good.
+            return run.compactions
+                ? `done  ${run.turns} turns  compacted ${run.compactions}`
+                : `done  ${run.turns} turns`;
         case 'failed':
             return 'failed';
         case 'aborted':

package/dist/ui/Transcript.d.ts

@@ -31,6 +31,7 @@ import type { TermCapabilities } from './capabilities.js';
 import { type DensityMode } from './density.js';
 import type { Entry } from '../agent/reducer.js';
 import type { RenderMode } from './layout/frame.js';
+import { type TailSink } from './layout/follow-state.js';
 import type { HeightStore } from './use-height-store.js';
 /**
  * Largest prefix length P such that `entries[0..P)` are all terminal, none is
@@ -119,7 +120,7 @@ export declare const EntryView: React.MemoExoticComponent<typeof EntryViewImpl>;
  * `selectWindow`, and the two spacers are what keep the scroll maths honest
  * while they are absent.
  */
-export declare function TranscriptList({ entries, expandedToolIds, thinkingVisible, reducedMotion, density, mode, nowSec, theme, caps, windowSize, cols, heights, mountedSink, }: TranscriptProps & {
+export declare function TranscriptList({ entries, expandedToolIds, thinkingVisible, reducedMotion, density, mode, nowSec, theme, caps, windowSize, cols, heights, mountedSink, tailSink, }: TranscriptProps & {
     windowSize: number;
     /** The viewport's own width — narrower than the terminal when the rail is up. */
     cols: number;
@@ -132,6 +133,25 @@ export declare function TranscriptList({ entries, expandedToolIds, thinkingVisib
     mountedSink?: {
         current: number;
     };
+    /**
+     * Rows appended AT THE TAIL, published for `ScrollViewport`'s Rule A
+     * (tui-selection-and-scroll-follow §4.3.1a). THIS IS P0-1's FIX.
+     *
+     * It lives here because this is the only place that holds the per-entry height
+     * table, and therefore the only place that can tell "the agent produced output"
+     * apart from "an entry above changed height" or "the horizon dropped an entry
+     * off the front". Reacting to `measureElement(inner).height` instead conflates
+     * all three, breaks `virtual-window.ts`'s invariant V-4, and closes an
+     * offset → mounted-set → measured-height → offset loop.
+     *
+     * A REF WRITTEN DURING RENDER, exactly as `mountedSink` above is and for the
+     * same reason: a `setState` here would make observing the tail cost a render.
+     * If this sink ever needs more than that — a `setState`, or the geometry
+     * context — STOP AND RE-REVIEW: the loop above is open again, and the correct
+     * response is full entry anchoring (D-13's rejected alternative), not a larger
+     * sink.
+     */
+    tailSink?: TailSink;
 }): React.ReactElement;
 export declare function Transcript({ entries, expandedToolIds, thinkingVisible, reducedMotion, density, mode, nowSec, theme, caps, }: TranscriptProps): React.ReactElement;
 export {};

package/dist/ui/Transcript.js

@@ -39,9 +39,11 @@ import { TeamCard, teamCardColor } from './entries/TeamCard.js';
 import { TodoCard, todoCardColor } from './entries/TodoCard.js';
 import { RetryCard, retryCardColor } from './entries/RetryCard.js';
 import { FastCard, fastCardColor } from './entries/FastCard.js';
+import { CompactionCard, compactionCardColor } from './entries/CompactionCard.js';
 import { MeasuredEntry } from './layout/MeasuredEntry.js';
 import { useViewportGeometry } from './layout/viewport-geometry.js';
 import { estimateEntryRows, heightKey, selectWindow, VIRTUAL_LIMITS, } from './layout/virtual-window.js';
+import { advanceTailRows } from './layout/follow-state.js';
 import { useTerminalSize } from './layout/useTerminalSize.js';
 /** Keep the last K entries in the live region so a mutating tail stays hot. */
 const LIVE_TAIL = 1;
@@ -99,6 +101,12 @@ export function computeSettledCount(entries, expandedToolIds) {
         // other half.
         if (e.kind === 'fast' && e.live)
             break;
+        // Nor is a compaction card whose call is still open: it is rewritten once,
+        // when the engine reports its verdict, and `<Static>` cannot un-print what it
+        // has already drawn (C-8). `session/persist.ts` forces `live: false` on load,
+        // which is the other half.
+        if (e.kind === 'compaction' && e.live)
+            break;
         count = i + 1;
     }
     return count;
@@ -111,7 +119,14 @@ export function computeSettledCount(entries, expandedToolIds) {
  * comparator, on every frame, forever.
  */
 function nowSecFor(entry, nowSec) {
-    return entry.kind === 'tool' && entry.status === 'running' ? nowSec : undefined;
+    if (entry.kind === 'tool' && entry.status === 'running')
+        return nowSec;
+    // THE LIVE COMPACTION CARD IS THE SECOND CONSUMER (hardening W5). It is at most
+    // ONE entry in the whole transcript, and it settles - so the memo boundary this
+    // function protects is unchanged for every other card, forever.
+    if (entry.kind === 'compaction' && entry.live)
+        return nowSec;
+    return undefined;
 }
 function noticeColor(level, theme) {
     if (level === 'error')
@@ -185,6 +200,14 @@ function EntryViewImpl({ entry, prev, expanded, thinkingVisible, reducedMotion,
                 reducedMotion: reducedMotion, theme: theme, caps: caps }));
         case 'fast':
             return frame(entry.status === 'failed' ? glyphs.toolError : glyphs.teamAgent, fastCardColor(entry.status, theme), _jsx(FastCard, { reviewIndex: entry.reviewIndex, model: entry.model, status: entry.status, text: entry.text, detail: entry.detail, turn: entry.turn, durationMs: entry.durationMs, live: entry.live, reducedMotion: reducedMotion, theme: theme, caps: caps }));
+        case 'compaction':
+            return frame(entry.applied || entry.live ? glyphs.compaction : glyphs.toolError, compactionCardColor(entry, theme), _jsx(CompactionCard, { index: entry.index, trigger: entry.trigger, mode: entry.mode, applied: entry.applied, reason: entry.reason, messagesBefore: entry.messagesBefore, messagesAfter: entry.messagesAfter, tokensBefore: entry.tokensBefore, tokensAfter: entry.tokensAfter, summary: entry.summary, model: entry.model, durationMs: entry.durationMs, tailRelief: entry.tailRelief, 
+                // ONLY WHILE LIVE, and only when the clock has ticked at least once:
+                // `nowSec` is `undefined` until then, and a settled card must keep
+                // rendering `durationMs` rather than a figure that would drift.
+                elapsedMs: entry.live && nowSec !== undefined && entry.startedAt !== undefined
+                    ? Math.max(0, nowSec * 1000 - entry.startedAt)
+                    : undefined, live: entry.live, expanded: expanded, reducedMotion: reducedMotion, theme: theme, caps: caps }));
         case 'notice':
             return frame(noticeSymbol(entry.level, theme), noticeColor(entry.level, theme), _jsx(Text, { color: noticeColor(entry.level, theme), children: entry.text }));
         default:
@@ -248,7 +271,7 @@ export const EntryView = React.memo(EntryViewImpl, (a, b) => {
  * `selectWindow`, and the two spacers are what keep the scroll maths honest
  * while they are absent.
  */
-export function TranscriptList({ entries, expandedToolIds, thinkingVisible, reducedMotion, density, mode, nowSec, theme, caps, windowSize, cols, heights, mountedSink, }) {
+export function TranscriptList({ entries, expandedToolIds, thinkingVisible, reducedMotion, density, mode, nowSec, theme, caps, windowSize, cols, heights, mountedSink, tailSink, }) {
     const size = Math.max(1, Math.floor(windowSize));
     const visible = entries.length > size ? entries.slice(-size) : entries;
     const collapsed = entries.length - visible.length;
@@ -291,6 +314,13 @@ export function TranscriptList({ entries, expandedToolIds, thinkingVisible, redu
     const slice = visible.slice(selection.startIndex, selection.endIndex);
     if (mountedSink)
         mountedSink.current = slice.length;
+    // One more pass over the array `selectWindow` has already walked, reading the
+    // SAME height table and never the geometry context (§4.3.1a). `visible` is
+    // what is drawn, so its last entry is the tail; entries the horizon dropped are
+    // not "removed rows" and must not register as one.
+    if (tailSink) {
+        tailSink.current = advanceTailRows(tailSink.current, visible.map((entry) => entry.id), heightOf);
+    }
     return (_jsxs(Box, { flexDirection: "column", flexShrink: 0, children: [collapsed > 0 && (_jsxs(Text, { wrap: "truncate", color: theme.hintFg ?? theme.muted, children: [glyphs.ellipsis, " ", collapsed, " earlier ", collapsed === 1 ? 'entry' : 'entries', " collapsed (/save exports the full session)"] })), selection.leadingRows > 0 && (_jsx(Box, { flexShrink: 0, height: selection.leadingRows })), slice.map((entry, i) => {
                 const index = selection.startIndex + i;
                 return (_jsx(MeasuredEntry, { heightKey: keyOf(entry), onMeasure: report, children: _jsx(EntryView, { entry: entry, prev: index > 0 ? visible[index - 1] : undefined, expanded: !!expandedToolIds[entry.id], thinkingVisible: thinkingVisible, reducedMotion: reducedMotion, density: density, mode: mode, nowSec: nowSecFor(entry, nowSec), theme: theme, caps: caps }) }, entry.id));

package/dist/ui/clipboard.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Clipboard (tui-selection-and-scroll-follow §4.4.5) — the SINGLE clipboard path
+ * for the package. `/copy` and the selection release both come through here.
+ *
+ * Two mechanisms, both attempted, and the return value names the better one so
+ * the toast can say what was SENT rather than claiming a success neither one can
+ * confirm:
+ *
+ *  1. **OSC 52.** It reaches the clipboard of the machine the USER is sitting
+ *     at, which is the only correct target over SSH, and it is the only mechanism
+ *     that works with no helper binary installed. `/copy` gained SSH support the
+ *     moment it moved onto this module.
+ *  2. **The platform binary** (`clip` / `pbcopy` / `xclip`), moved here unchanged
+ *     from `commands/builtins.ts`, for the local case and for terminals that
+ *     ignore OSC 52 (tmux without `set -g set-clipboard on`, R-7).
+ *
+ * IT TAKES A WRITE *DOOR*, NOT A STREAM, and that is P1-6 rather than taste. In
+ * full-screen mode stdout is a `Proxy` in front of the frame differ; an
+ * unrecognised chunk there takes `passThrough(true)`, which increments
+ * `fallbacks` and — on the first one — raises `onFirstFallback`, wired to
+ * `console.warn(FRAME_FALLBACK_NOTICE)`. Sending OSC 52 through the proxy would
+ * therefore print a diagnostic at a user who did nothing wrong the first time
+ * they copied anything, and would permanently corrupt a counter documented to
+ * mean "something wrote to stdout behind Ink's back". The caller supplies
+ * `writeForeign` instead, and this module cannot pick the wrong door.
+ */
+export type CopyVia = 'osc52' | 'native' | 'none';
+/**
+ * Ceiling on an OSC 52 payload, in bytes of the ORIGINAL text.
+ *
+ * xterm's default limit is around 100 000 BASE64 characters and tmux / screen
+ * are stricter, so 56 000 source bytes (~74 700 base64) stays inside all three
+ * with room to spare. Past it the sequence is skipped rather than truncated: a
+ * terminal that drops an over-long OSC 52 leaves the clipboard holding whatever
+ * was there before, and half a selection is worse than none.
+ */
+export declare const MAX_OSC52_BYTES = 56000;
+/** `\x1b]52;c;<base64>\x07` — `c` is the CLIPBOARD selection, not PRIMARY. */
+export declare function osc52(text: string): string;
+/**
+ * Put `text` on the clipboard and report the best mechanism that was reached.
+ *
+ * `write` is the foreign-write door (see the module header). Omit it and OSC 52
+ * is skipped entirely, which is the correct behaviour for a caller that has no
+ * terminal to write to.
+ *
+ * NEITHER MECHANISM IS DETECTABLE. `spawn` returning without throwing does not
+ * mean `xclip` exists, and an OSC 52 sequence a terminal ignores is
+ * indistinguishable from one it honours. The return value therefore names what
+ * was ATTEMPTED, and every caller's user-facing text is worded accordingly.
+ */
+export declare function copyText(text: string, write?: (chunk: string) => void): CopyVia;

package/dist/ui/clipboard.js

@@ -0,0 +1,91 @@
+/**
+ * Clipboard (tui-selection-and-scroll-follow §4.4.5) — the SINGLE clipboard path
+ * for the package. `/copy` and the selection release both come through here.
+ *
+ * Two mechanisms, both attempted, and the return value names the better one so
+ * the toast can say what was SENT rather than claiming a success neither one can
+ * confirm:
+ *
+ *  1. **OSC 52.** It reaches the clipboard of the machine the USER is sitting
+ *     at, which is the only correct target over SSH, and it is the only mechanism
+ *     that works with no helper binary installed. `/copy` gained SSH support the
+ *     moment it moved onto this module.
+ *  2. **The platform binary** (`clip` / `pbcopy` / `xclip`), moved here unchanged
+ *     from `commands/builtins.ts`, for the local case and for terminals that
+ *     ignore OSC 52 (tmux without `set -g set-clipboard on`, R-7).
+ *
+ * IT TAKES A WRITE *DOOR*, NOT A STREAM, and that is P1-6 rather than taste. In
+ * full-screen mode stdout is a `Proxy` in front of the frame differ; an
+ * unrecognised chunk there takes `passThrough(true)`, which increments
+ * `fallbacks` and — on the first one — raises `onFirstFallback`, wired to
+ * `console.warn(FRAME_FALLBACK_NOTICE)`. Sending OSC 52 through the proxy would
+ * therefore print a diagnostic at a user who did nothing wrong the first time
+ * they copied anything, and would permanently corrupt a counter documented to
+ * mean "something wrote to stdout behind Ink's back". The caller supplies
+ * `writeForeign` instead, and this module cannot pick the wrong door.
+ */
+import { spawn } from 'node:child_process';
+import process from 'node:process';
+/**
+ * Ceiling on an OSC 52 payload, in bytes of the ORIGINAL text.
+ *
+ * xterm's default limit is around 100 000 BASE64 characters and tmux / screen
+ * are stricter, so 56 000 source bytes (~74 700 base64) stays inside all three
+ * with room to spare. Past it the sequence is skipped rather than truncated: a
+ * terminal that drops an over-long OSC 52 leaves the clipboard holding whatever
+ * was there before, and half a selection is worse than none.
+ */
+export const MAX_OSC52_BYTES = 56_000;
+/** `\x1b]52;c;<base64>\x07` — `c` is the CLIPBOARD selection, not PRIMARY. */
+export function osc52(text) {
+    return `\x1b]52;c;${Buffer.from(text, 'utf-8').toString('base64')}\x07`;
+}
+/** Best-effort clipboard copy via the platform's clipboard CLI. */
+function copyNative(text) {
+    const cmd = process.platform === 'win32'
+        ? { file: 'clip', args: [] }
+        : process.platform === 'darwin'
+            ? { file: 'pbcopy', args: [] }
+            : { file: 'xclip', args: ['-selection', 'clipboard'] };
+    try {
+        const child = spawn(cmd.file, cmd.args, { stdio: ['pipe', 'ignore', 'ignore'] });
+        child.on('error', () => {
+            /* swallow — clipboard is best-effort, and a missing xclip is ordinary */
+        });
+        child.stdin?.end(text);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Put `text` on the clipboard and report the best mechanism that was reached.
+ *
+ * `write` is the foreign-write door (see the module header). Omit it and OSC 52
+ * is skipped entirely, which is the correct behaviour for a caller that has no
+ * terminal to write to.
+ *
+ * NEITHER MECHANISM IS DETECTABLE. `spawn` returning without throwing does not
+ * mean `xclip` exists, and an OSC 52 sequence a terminal ignores is
+ * indistinguishable from one it honours. The return value therefore names what
+ * was ATTEMPTED, and every caller's user-facing text is worded accordingly.
+ */
+export function copyText(text, write) {
+    if (text.length === 0)
+        return 'none';
+    let sentOsc52 = false;
+    if (write && Buffer.byteLength(text, 'utf-8') <= MAX_OSC52_BYTES) {
+        try {
+            write(osc52(text));
+            sentOsc52 = true;
+        }
+        catch {
+            // A closed or broken stdout must never turn a copy into a crash.
+        }
+    }
+    const sentNative = copyNative(text);
+    if (sentOsc52)
+        return 'osc52';
+    return sentNative ? 'native' : 'none';
+}

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 {};