@aragon-agent/cli 0.6.2 → 0.6.4

package/dist/ui/selection/selection.js

@@ -0,0 +1,223 @@
+/**
+ * The selection model (tui-selection-and-scroll-follow §4.4.4). PURE — no React,
+ * no I/O, no terminal.
+ *
+ * Coordinates are SCREEN CELLS, 0-based: frame line `i` is terminal row `i + 1`
+ * and column `x - 1`, so an SGR report at `(x, y)` becomes `{ row: y - 1, col: x
+ * - 1 }`. Screen coordinates are only sound while the rows hold still, and
+ * holding them still is Stage 2's job — `press` sets `hold`, which anchors the
+ * content and suspends the resume timer, so the transcript is frozen for the
+ * duration of a drag (D-7).
+ *
+ * ═══════════════════════════════════════════════════════════════════════════
+ * I-12 — `sliceColumns` IS THE ONE COLUMN→CHARACTER MAPPING IN THIS FEATURE,
+ * and `stringWidth` is its only width oracle.
+ *
+ * The painter and the extractor are handed the SAME half-open column range by
+ * `rowSpan`. If they turn that range into characters by different rules, the
+ * copied text is not the highlighted text — silently, which is the one failure
+ * mode I-4 exists to name. That is not hypothetical: `slice-ansi` advances its
+ * cursor by `isFullWidth ? 2 : character.length`, i.e. display columns for CJK
+ * but UTF-16 CODE UNITS for everything else, so a combining mark costs it a
+ * column that occupies none and an astral code point costs two; and the obvious
+ * `String.slice` for the extractor is code units throughout. Two mappings from
+ * one range agree on ASCII and diverge on exactly the rows a user is most likely
+ * to want to copy.
+ *
+ * So both call the function below, which walks GRAPHEME CLUSTERS and charges
+ * each one `stringWidth(cluster)` columns. What is hand-rolled here is only the
+ * column arithmetic — the width table is still `string-width`'s, and the escape
+ * bookkeeping is `slice-ansi`'s idea re-indexed (R-13).
+ * ═══════════════════════════════════════════════════════════════════════════
+ */
+import stringWidth from 'string-width';
+export function normalize(sel) {
+    const { anchor, focus } = sel;
+    const anchorFirst = anchor.row < focus.row || (anchor.row === focus.row && anchor.col <= focus.col);
+    return anchorFirst ? { start: anchor, end: focus } : { start: focus, end: anchor };
+}
+export function isEmpty(sel) {
+    return sel.start.row === sel.end.row && sel.start.col === sel.end.col;
+}
+/**
+ * The half-open column range to highlight on `row`, or `null` when the row is
+ * outside the selection.
+ *
+ * LINEAR, NOT RECTANGULAR — what every terminal does: the first row runs from
+ * `start.col` to end of line, whole middle rows are taken entirely, and the last
+ * row stops at `end.col`. `Infinity` means "to the end of the line"; the painter
+ * clamps it to the terminal width so a multi-row selection gets a straight right
+ * edge, and the extractor treats it as "no upper bound".
+ */
+export function rowSpan(sel, row) {
+    const { start, end } = sel;
+    if (row < start.row || row > end.row)
+        return null;
+    if (start.row === end.row) {
+        return end.col > start.col ? { from: start.col, to: end.col } : null;
+    }
+    if (row === start.row)
+        return { from: start.col, to: Number.POSITIVE_INFINITY };
+    if (row === end.row)
+        return end.col > 0 ? { from: 0, to: end.col } : null;
+    return { from: 0, to: Number.POSITIVE_INFINITY };
+}
+/**
+ * The text a release would put on the clipboard.
+ *
+ * `plainRows` are the mirror's ANSI-STRIPPED rows — the same rows the highlight
+ * was painted over, which is what makes I-4 hold by construction rather than by
+ * a staleness check that can be wrong.
+ */
+export function selectedText(plainRows, sel) {
+    const out = [];
+    for (let row = sel.start.row; row <= sel.end.row; row += 1) {
+        const span = rowSpan(sel, row);
+        if (!span)
+            continue;
+        const line = plainRows[row] ?? '';
+        const to = Number.isFinite(span.to) ? span.to : undefined;
+        out.push(sliceColumns(line, span.from, to).trimEnd());
+    }
+    return out.join('\n');
+}
+// ---------------------------------------------------------------------------
+// sliceColumns — the one mapping (I-12)
+// ---------------------------------------------------------------------------
+/**
+ * CSI / OSC sequences. They occupy ZERO columns and are copied through so a
+ * slice keeps the styling of the text around it.
+ */
+const ANSI_RE = /\x1b(?:\[[0-9;:?]*[ -/]*[@-~]|\][^\x07\x1b]*(?:\x07|\x1b\\)|[@-Z\\-_])/g;
+/** SGR "all attributes off" — everything carried before it is cancelled. */
+const SGR_RESET_RE = /^\x1b\[0?m$/;
+const segmenter = typeof Intl !== 'undefined' && typeof Intl.Segmenter === 'function'
+    ? new Intl.Segmenter(undefined, { granularity: 'grapheme' })
+    : null;
+/**
+ * Width cache. `stringWidth` re-segments and re-classifies on every call, and a
+ * repaint slices every row of the selection; the key space is the set of
+ * grapheme clusters on screen, which is tiny and bounded by the frame.
+ */
+const widthCache = new Map();
+const WIDTH_CACHE_MAX = 4096;
+function clusterWidth(cluster) {
+    const hit = widthCache.get(cluster);
+    if (hit !== undefined)
+        return hit;
+    const w = stringWidth(cluster);
+    // A plain ceiling with a wholesale drop, like `virtual-window.ts`'s height
+    // cache: an LRU here would cost more bookkeeping than the values are worth.
+    if (widthCache.size >= WIDTH_CACHE_MAX)
+        widthCache.clear();
+    widthCache.set(cluster, w);
+    return w;
+}
+/** Split into ANSI sequences and grapheme clusters, in order. */
+function tokenize(text) {
+    const tokens = [];
+    ANSI_RE.lastIndex = 0;
+    let last = 0;
+    let m;
+    const pushPlain = (chunk) => {
+        if (chunk.length === 0)
+            return;
+        if (segmenter) {
+            for (const { segment } of segmenter.segment(chunk))
+                tokens.push({ text: segment, ansi: false });
+            return;
+        }
+        // No `Intl.Segmenter`: code points are a strictly worse but never wrong
+        // approximation — a combining mark becomes its own zero-width token, which
+        // the walk below already handles.
+        for (const cp of chunk)
+            tokens.push({ text: cp, ansi: false });
+    };
+    while ((m = ANSI_RE.exec(text)) !== null) {
+        pushPlain(text.slice(last, m.index));
+        tokens.push({ text: m[0], ansi: true });
+        last = m.index + m[0].length;
+    }
+    pushPlain(text.slice(last));
+    return tokens;
+}
+/**
+ * Slice `text` by SCREEN COLUMNS, half-open `[from, to)`.
+ *
+ * Three properties are load-bearing:
+ *
+ *  - **Escape codes opened before `from` are carried into the result.** Without
+ *    it the painter's tail — `sliceColumns(line, to)` — would lose the colour
+ *    `Markdown` and `cli-highlight` gave it, on every row a selection touches.
+ *  - **A wide cluster straddling either boundary becomes spaces for the part
+ *    that is inside.** That keeps the arithmetic EXACT in columns, which is the
+ *    whole point of I-12: half a CJK glyph is not a character, and inventing one
+ *    would put the painter and the extractor back out of step.
+ *  - **`to` is optional and means "to the end of the line".**
+ */
+export function sliceColumns(text, from, to) {
+    const start = Math.max(0, Math.floor(from));
+    const end = to === undefined || !Number.isFinite(to) ? Number.POSITIVE_INFINITY : Math.floor(to);
+    if (end <= start)
+        return '';
+    let carried = '';
+    let out = '';
+    let col = 0;
+    let started = false;
+    const open = () => {
+        if (started)
+            return;
+        started = true;
+        out += carried;
+    };
+    for (const token of tokenize(text)) {
+        if (token.ansi) {
+            if (started)
+                out += token.text;
+            else {
+                if (SGR_RESET_RE.test(token.text))
+                    carried = '';
+                carried += token.text;
+            }
+            continue;
+        }
+        if (col >= end)
+            break;
+        const w = clusterWidth(token.text);
+        if (w === 0) {
+            // A zero-width cluster attaches to the cell before it, so it belongs to the
+            // slice only when that cell is already inside.
+            if (started)
+                out += token.text;
+            continue;
+        }
+        const cellEnd = col + w;
+        if (cellEnd <= start) {
+            col = cellEnd;
+            continue;
+        }
+        open();
+        if (col < start) {
+            // Straddles the LEFT boundary: only `cellEnd - start` columns are ours.
+            out += ' '.repeat(Math.min(cellEnd, end) - start);
+        }
+        else if (cellEnd > end) {
+            // Straddles the RIGHT boundary.
+            out += ' '.repeat(end - col);
+        }
+        else {
+            out += token.text;
+        }
+        col = cellEnd;
+    }
+    return out;
+}
+/** Display width in columns, using the same oracle `sliceColumns` charges with. */
+export function columnsOf(text) {
+    let total = 0;
+    for (const token of tokenize(text)) {
+        if (!token.ansi)
+            total += clusterWidth(token.text);
+    }
+    return total;
+}

package/dist/ui/stdout-frame-writer.d.ts

@@ -35,6 +35,39 @@ export interface FrameWriterHandle {
     stdout: NodeJS.WriteStream;
     /** Hand this to `setFrameStatsProvider`. */
     stats(): FrameWriterStats;
+    /**
+     * Re-paint the last frame through the differ's `decorate` hook — how a
+     * selection drag reaches the screen without a React commit.
+     *
+     * Returns whether anything was written. `false` means the differ had nothing
+     * safe to do (no cache, or a geometry stand-down), which is the caller's cue to
+     * fall back to `App`'s `redrawNonce`.
+     *
+     * I-3 / I-13 — IT WRITES TO THE REAL STREAM, NEVER THROUGH THE PROXY. Through
+     * the proxy the payload would be handed to `transform`, which would not
+     * recognise it and would `invalidate()`, turning every drag frame into a full
+     * repaint — the flicker `tui-input-flicker-fix` removed. It is also not a
+     * fallback and not a frame, so it touches neither counter.
+     */
+    repaint(): boolean;
+    /**
+     * Write bytes that are ours but are not a frame — today, the OSC 52 clipboard
+     * sequence (§4.4.5).
+     *
+     * The differ is invalidated first, because absolute addressing is only valid
+     * while nothing else writes to stdout, and one full repaint after a copy is the
+     * correct price.
+     *
+     * IT IS NOT A FALLBACK (P1-6 / I-13), and that is the whole reason this door
+     * exists rather than the caller reaching for `stdout.write`. `transform` cannot
+     * recognise an OSC 52 chunk, so through the proxy it would take
+     * `passThrough(true)` — which increments `fallbacks` and, on the first one,
+     * raises `onFirstFallback`, wired to `console.warn(FRAME_FALLBACK_NOTICE)`.
+     * The first copy of every session would print a diagnostic at a user who did
+     * nothing wrong, and `fallbacks` — documented to mean "something wrote to
+     * stdout behind Ink's back" — would stop being true for the rest of the run.
+     */
+    writeForeign(text: string): void;
     /** Removes the `'resize'` subscription of I-8. Idempotent. */
     dispose(): void;
 }

package/dist/ui/stdout-frame-writer.js

@@ -92,6 +92,21 @@ export function wrapStdoutForFrames(stdout, differ) {
     return {
         stdout: proxy,
         stats: () => differ.stats(),
+        repaint() {
+            if (disposed)
+                return false;
+            const payload = differ.repaint();
+            if (payload.length === 0)
+                return false;
+            writeReal(payload);
+            return true;
+        },
+        writeForeign(text) {
+            differ.invalidate();
+            if (disposed || text.length === 0)
+                return;
+            writeReal(text);
+        },
         dispose() {
             if (disposed)
                 return;

package/dist/ui/theme.d.ts

@@ -50,6 +50,17 @@ export interface Theme {
     hintFg: Color;
     /** Single-color wordmark fallback below ansi-256. */
     logoShadow: Color;
+    /**
+     * Drag-selection highlight (tui-selection-and-scroll-follow §4.4.4).
+     *
+     * Degraded like every other colour here, which means that below ansi-256 these
+     * are chalk colour NAMES rather than hex triples. `highlight.ts` tests for a
+     * hex shape and falls back to plain reverse video otherwise — the fallback a
+     * terminal that shallow would render anyway, and what the emulator's own
+     * selection looks like.
+     */
+    selectionBg: Color;
+    selectionFg: Color;
     gradient: string[];
     gauge: {
         track: Color;

package/dist/ui/theme.js

@@ -101,6 +101,8 @@ export function getTheme(name, caps) {
         idleBorder: d(palette.idleBorder),
         hintFg: d(palette.hintFg),
         logoShadow: d(palette.logoShadow),
+        selectionBg: d(palette.selectionBg),
+        selectionFg: d(palette.selectionFg),
         gradient: level >= 2 ? [...palette.gradient] : [],
         gauge: {
             track: d(palette.gauge.track),

package/dist/ui/transcript-text.js

@@ -51,6 +51,34 @@ function safeParse(raw) {
         return null;
     }
 }
+/**
+ * The replay's glyph for a service, MIRRORING `ServiceCard::serviceGlyph`.
+ *
+ * The two ladders have to agree, and the cheap-looking shortcut here — "ready or
+ * running is a tick, everything else is an error" — disagrees on the two states
+ * a user reaches ON PURPOSE: a service they stopped with `Ctrl+C`, and one that
+ * exited cleanly. Marking either as a failure in the record the user is left
+ * with after the alternate screen is torn down is a lie about their own action.
+ *
+ * Duplicated rather than imported, as every other case in this file duplicates
+ * its card's ladder: this module is deliberately free of React and ink, and
+ * `serviceGlyph` lives in a `.tsx`.
+ */
+function serviceTextGlyph(status, exitCode, glyphs) {
+    switch (status) {
+        case 'ready':
+            return glyphs.toolDone;
+        case 'running':
+            return glyphs.toolRunning;
+        case 'starting':
+        case 'stopped':
+            return glyphs.toolPending;
+        case 'exited':
+            return exitCode === 0 ? glyphs.toolDone : glyphs.toolError;
+        default:
+            return glyphs.toolError;
+    }
+}
 function renderEntry(entry, glyphs) {
     switch (entry.kind) {
         case 'user':
@@ -111,6 +139,50 @@ function renderEntry(entry, glyphs) {
             const detail = entry.detail ? `: ${entry.detail}` : '';
             return [`${head} ${entry.status}${detail}`];
         }
+        case 'compaction': {
+            // A compaction is real spend AND a real, permanent loss of history, and an
+            // exported transcript that omitted it would be unaccountable for both —
+            // the argument the `team`, `retry` and `fast` cases above each make in
+            // their own words. It matters most here: this is the one entry kind whose
+            // presence explains why the messages the reader is looking for are gone.
+            const glyph = entry.applied ? glyphs.compaction : glyphs.toolError;
+            const duration = entry.durationMs === undefined ? '' : ` (${entry.durationMs}ms)`;
+            if (!entry.applied) {
+                const why = entry.reason ? `: ${entry.reason}` : '';
+                return [`${TOOL_INDENT}${glyph} context not compacted #${entry.index}${why}`];
+            }
+            const head = `${TOOL_INDENT}${glyph} context compacted #${entry.index} ` +
+                `${entry.messagesBefore} ${glyphs.arrowRight} ${entry.messagesAfter} messages, ` +
+                `${entry.tokensBefore} ${glyphs.arrowRight} ${entry.tokensAfter} tokens ` +
+                `[${entry.mode}] ${entry.model}${duration}`;
+            if (!entry.summary)
+                return [head];
+            return [
+                head,
+                ...entry.summary.split('\n').map((l) => `${TOOL_INDENT}${CONTINUATION_INDENT}${l}`),
+            ];
+        }
+        case 'service': {
+            // A service the agent started is real work with a real outcome, and an
+            // exported transcript that omitted it would be unaccountable for both —
+            // the argument the `team`, `retry`, `fast` and `compaction` cases above
+            // each make in their own words. It matters more here than for any of them:
+            // this replay is the user's ONLY record once the alternate screen is torn
+            // down (`cli.tsx`'s exit snapshot), and a service card dropped from it
+            // takes the URL the agent reported with it. This file's
+            // `default: return []` means the addition is a CHOICE rather than a
+            // compile requirement, which is exactly why it is easy to leave out
+            // (P0-3).
+            const glyph = serviceTextGlyph(entry.status, entry.exitCode, glyphs);
+            const where = entry.url ? ` ${entry.url}` : '';
+            const code = entry.exitCode === null || entry.exitCode === undefined
+                ? ''
+                : ` (exit code ${entry.exitCode})`;
+            return [
+                `${TOOL_INDENT}${glyph} service ${entry.serviceId} ${entry.command} ` +
+                    `${entry.status}${where}${code}`.trimEnd(),
+            ];
+        }
         case 'notice': {
             const glyph = entry.level === 'error'
                 ? glyphs.error

package/dist/ui/use-startup-notices.d.ts

@@ -12,6 +12,18 @@
  * not otherwise see — rather than belonging to the view.
  */
 import type { ViewAction } from '../agent/reducer.js';
+/**
+ * The revision of the mouse notice a user must have seen for it to stay quiet
+ * (`state.json::mouseNoticeVersion`, `0` when absent).
+ *
+ * BUMP IT WHENEVER THE ADVICE CHANGES, never for a rewording that leaves the
+ * recommended actions alone — the same rule `VT_INPUT_NOTICE_VERSION` below
+ * carries, and for the same reason.
+ *
+ * `1` = the first text that names DRAG-SELECT and `/mouse`. `0` = the 0.6.2 text
+ * that taught the Shift bypass, recorded back when this was a boolean.
+ */
+export declare const MOUSE_NOTICE_VERSION = 1;
 /**
  * The revision of the text below that a user must have seen for this notice to
  * stay quiet (`state.json::vtInputNoticeVersion`, `0` when absent).
@@ -100,7 +112,21 @@ export interface MouseNoticeOptions {
      * re-deriving either one here would put them back out of step.
      */
     enabled: boolean;
-    /** Record that it was shown (`state.json`). Called once, after dispatch. */
+    /**
+     * Whether DRAG-SELECT is running too, i.e. the resolved `mouseSelect`.
+     *
+     * A SECOND FLAG RATHER THAN AN INFERENCE, for the reason the field above
+     * records about its own two halves: "the mouse is captured" and "dragging
+     * selects text" are not the same claim, and a session that turned drag-select
+     * off must not be handed advice about a mode that is not running.
+     */
+    selectEnabled: boolean;
+    /**
+     * Record that `MOUSE_NOTICE_VERSION` was shown (`state.json`). Called once,
+     * after dispatch — and it must write that constant, not `true`: the gate
+     * compares against it, so a caller storing anything else either replays the
+     * notice forever or silences a future revision of the text.
+     */
     onSeen: () => void;
 }
 export interface VtInputNoticeOptions {

package/dist/ui/use-startup-notices.js

@@ -14,18 +14,42 @@
 import { useEffect, useRef } from 'react';
 import { MODE_TOGGLE_KEYS } from '../agent/agent-mode.js';
 import { readConfigFile } from '../config/store.js';
-import { getMouseNoticeSeen, getVtInputNoticeVersion } from '../config/ui-state.js';
+import { getMouseNoticeVersion, getVtInputNoticeVersion } from '../config/ui-state.js';
 import { getLogger } from '../logging/logger.js';
 /**
- * The §6.1 notice (mouse-wheel-region-routing). Shown at most once, ever.
+ * The revision of the mouse notice a user must have seen for it to stay quiet
+ * (`state.json::mouseNoticeVersion`, `0` when absent).
  *
- * R-3 is the only part of wheel region routing that reaches users who never
- * scroll, and it REMOVES a gesture — drag to select — that is used more often
- * than the one being added. A README is consulted only after the belief
- * "aragon broke copy/paste" has already formed.
+ * BUMP IT WHENEVER THE ADVICE CHANGES, never for a rewording that leaves the
+ * recommended actions alone — the same rule `VT_INPUT_NOTICE_VERSION` below
+ * carries, and for the same reason.
+ *
+ * `1` = the first text that names DRAG-SELECT and `/mouse`. `0` = the 0.6.2 text
+ * that taught the Shift bypass, recorded back when this was a boolean.
  */
-const MOUSE_SELECTION_NOTICE = 'Mouse wheel scrolls the transcript. Hold Shift to select text, ' +
-    'or turn it off with `aragon config set mouse false`.';
+export const MOUSE_NOTICE_VERSION = 1;
+/**
+ * The one-shot mouse notice (tui-selection-and-scroll-follow §5.2 row 29).
+ *
+ * IT NO LONGER TEACHES THE SHIFT WORKAROUND. That text was a workaround told
+ * once, in a line that scrolls away, naming a key that is not portable — Shift
+ * on xterm / VTE / Windows Terminal, Fn on macOS Terminal, a preference
+ * elsewhere — and it collided with our own Shift+wheel binding. The user report
+ * this feature exists for is the evidence that it was not enough (D-1).
+ *
+ * TWO TEXTS, because a `mouseSelect: false` session must not be told about a
+ * gesture that is not running — the same rule the vt-input notice follows below,
+ * and the reason `MouseNoticeOptions` carries the flag rather than this module
+ * re-deriving it.
+ */
+function mouseNoticeText(selectEnabled) {
+    if (!selectEnabled) {
+        return ('Mouse wheel scrolls the transcript. Drag-select is off (mouseSelect); ' +
+            '/mouse off hands the mouse back to your terminal for this session.');
+    }
+    return ('Mouse wheel scrolls the transcript, and dragging selects text - releasing ' +
+        'copies it. /mouse off hands the mouse back to your terminal for this session.');
+}
 /**
  * The §5.1 notice (tui-render-performance). Shown once per run, and only when
  * the user's own `transcriptRetain` was below `transcriptWindow`.
@@ -142,16 +166,24 @@ export function useStartupNotices(dispatch, mouseNotice, retainNotice, vtInputNo
     const noticeRef = useRef(mouseNotice);
     noticeRef.current = mouseNotice;
     const mouseEnabled = mouseNotice?.enabled ?? false;
+    const mouseSelectEnabled = mouseNotice?.selectEnabled ?? false;
     const mouseNoticeShown = useRef(false);
     useEffect(() => {
         if (!mouseEnabled || mouseNoticeShown.current)
             return;
-        if (getMouseNoticeSeen())
+        // A VERSION, NOT THE OLD BOOLEAN (P1-8 / AC-16). The audience for the
+        // corrected text is exactly the set of users who already have
+        // `mouseNoticeSeen: true` on disk from the text it replaces, so reading that
+        // flag would make this change inert for everyone it is for.
+        //
+        // `>=`, not `!==`: a state file written by a NEWER build (a downgrade, or a
+        // shared home directory) has already told this user everything below.
+        if (getMouseNoticeVersion() >= MOUSE_NOTICE_VERSION)
             return;
         mouseNoticeShown.current = true;
-        dispatch({ type: 'notice', level: 'info', text: MOUSE_SELECTION_NOTICE });
+        dispatch({ type: 'notice', level: 'info', text: mouseNoticeText(mouseSelectEnabled) });
         noticeRef.current?.onSeen();
-    }, [mouseEnabled, dispatch]);
+    }, [mouseEnabled, mouseSelectEnabled, dispatch]);
     // The R-1 notice. `warn`, not `info`: unlike the one above it reports a
     // capability the user was promised and does not have, plus a key that is
     // actively editing their draft.

package/dist/ui/use-wheel-routing.d.ts

@@ -20,7 +20,7 @@
  * the wheel spins: one gesture, one `setState`, one render.
  */
 import type { Overlay } from '../agent/reducer.js';
-import type { MouseSource } from '../input/stdin-mouse-filter.js';
+import type { MouseSource } from '../input/stdin-filter.js';
 import type { ScrollIntent } from './layout/scroll.js';
 /**
  * Rows a PgUp/PgDn — and a Shift+wheel notch — moves inside a controlled

package/dist/ui/use-wheel-routing.js

@@ -84,6 +84,14 @@ export function useWheelRouting(options) {
         }
     }, [flush]);
     const route = useCallback((event) => {
+        // The channel now carries press / drag / release as well
+        // (tui-selection-and-scroll-follow §4.4.2). ONE LINE, AT THE TOP, and the
+        // rest of this module is untouched: widening the single channel rather
+        // than adding a second is what keeps arrival order intact between a wheel
+        // notch and a button, and each subscriber ignoring what it does not own is
+        // the price of that.
+        if (event.kind !== 'wheel')
+            return;
         const current = optionsRef.current;
         const overlay = current.getOverlay();
         // THE OVERLAY BRANCH IS EVALUATED FIRST AND RETURNS FOR EVERY OVERLAY IT

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aragon-agent/cli",
-  "version": "0.6.2",
+  "version": "0.6.4",
   "description": "AragonAgent CLI — a Claude-Code / Codex-style interactive terminal UI (TUI) on top of the @aragon-agent/core engine. Installable and runnable via npm / npx.",
   "license": "MIT",
   "author": "AragonAgent contributors",
@@ -56,7 +56,7 @@
     "prepublishOnly": "npm run build"
   },
   "dependencies": {
-    "@aragon-agent/core": "^0.2.14",
+    "@aragon-agent/core": "^0.2.16",
     "chalk": "^5.6.2",
     "cli-highlight": "^2.0.0",
     "commander": "^12.1.0",
@@ -67,6 +67,8 @@
     "ink-select-input": "^6.0.0",
     "ink-spinner": "^5.0.0",
     "react": "^18.3.1",
+    "string-width": "^7.2.0",
+    "strip-ansi": "^7.1.0",
     "tinyglobby": "^0.2.17"
   },
   "devDependencies": {

package/dist/input/stdin-mouse-filter.d.ts

@@ -1,42 +0,0 @@
-/**
- * Stdin mouse filter (mouse-wheel-region-routing §4.2 / §5.2).
- *
- * WHY A WRAPPER AND NOT A SECOND LISTENER. Ink 5.2.1 owns stdin in a way that
- * forbids a second reader: `components/App.js` calls `setEncoding('utf8')`,
- * `ref()`, `setRawMode(true)`, subscribes to `'readable'` and drains with
- * `read()`. Attaching our own `'data'` listener to the same `process.stdin`
- * would switch the stream into flowing mode and RACE Ink's `read()` for chunks
- * — some keystrokes would reach Ink, some would not, non-deterministically
- * (D-3). So the filter REPLACES the stream Ink is given: it reads the real
- * stdin, strips every mouse report, and writes the remainder into a
- * `PassThrough` that carries the surface Ink requires.
- *
- * ORDERING IS AN INVARIANT, NOT A CONVENTION (I-8). The caller must build this
- * filter BEFORE anything writes `\x1b[?1000h`. Reporting enabled while Ink
- * still holds the raw stream does not degrade the feature — it types
- * `[<0;12;5M` into the user's message on every click, which is strictly worse
- * than the bug this feature fixes. `cli.tsx::runInteractive` is the only caller
- * and passes `filter !== null` to `enterAltScreen`.
- */
-import { type WheelEvent } from './mouse-events.js';
-export interface MouseSource {
-    /** Returns an unsubscribe function. Multiple subscribers are allowed. */
-    subscribe(listener: (event: WheelEvent) => void): () => void;
-}
-export interface MouseFilter {
-    /** Hand this to Ink: `render(<App/>, { stdin: filter.stdin })`. */
-    readonly stdin: NodeJS.ReadStream;
-    readonly source: MouseSource;
-    /** Idempotent. Detaches from the real stdin and clears the flush timer (I-7). */
-    dispose(): void;
-}
-export declare function createMouseFilter(real: NodeJS.ReadStream): MouseFilter;
-/**
- * Build a filter, or `null` if construction throws.
- *
- * The `null` return is the whole point (P0-1): `enterAltScreen` derives whether
- * to enable mouse reporting from `filter !== null`, so a construction failure
- * degrades to "the wheel is inert" — a supported, tested rung of the fail-safe
- * ladder — rather than leaving reporting on with no filter in front of Ink.
- */
-export declare function tryCreateMouseFilter(real: NodeJS.ReadStream, onError?: (reason: string) => void): MouseFilter | null;