@aragon-agent/cli 0.6.8 → 0.6.9

package/dist/ui/layout/OverlayFrame.js

@@ -1,28 +1,4 @@
 import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
-/**
- * OverlayFrame (spec §4.4) — the shared shell for all four overlays.
- *
- * TWO CONTENT MODES, and the distinction is load-bearing:
- *
- *  - mode A (`rows`): the caller hands over an array of elements that are each
- *    exactly one row and `wrap="truncate"`. The frame slices them and OWNS the
- *    scroll keys. Used by Help and Settings.
- *
- *  - mode B (`children`): the content manages itself. The frame draws the title,
- *    the border and the footer, and touches NOTHING else — no slicing, no
- *    arrow-key handling, no position indicator.
- *
- * Mode B exists because of `ink-select-input`: it already windows itself via
- * `limit` and registers its own `useInput` with `isFocused` defaulting to true.
- * Ink dispatches a key to EVERY mounted input handler, so a frame that also
- * claimed the arrow keys would move the model picker's selection twice per press
- * — breaking a feature that already works. Slicing it by element would be worse
- * still, since it is a single component rather than a list of rows.
- *
- * `maxRows` may be `Infinity` (the inline render path, which has no fixed frame
- * and therefore no height to fit): the frame then renders everything and shows
- * no position indicator.
- */
 import { useEffect } from 'react';
 import { Box, Text } from 'ink';
 import { pickGlyphs } from '../glyphs.js';

package/dist/ui/layout/ScrollViewport.d.ts

@@ -27,6 +27,9 @@ export interface ScrollViewportProps {
     scrollbar?: ScrollbarBridge;
     composerRef?: React.RefObject<DOMElement>;
     onComposerVisibilityChange?: (visible: boolean) => void;
+    /** The run status row above the input box (tui-scrollbar-edge-and-run-row). */
+    activityRef?: React.RefObject<DOMElement>;
+    onActivityVisibilityChange?: (visible: boolean) => void;
     theme: Theme;
     caps: TermCapabilities;
     children: React.ReactNode;

package/dist/ui/layout/ScrollViewport.js

@@ -8,17 +8,23 @@ import { reduceFollow, shouldArmResume } from './follow-state.js';
 import { thumbRange } from './scroll-indicator.js';
 import { ScrollIndicator } from './ScrollIndicator.js';
 import { buildDocumentLayout } from './document-layout.js';
-function composerVisible(composer, clip) {
-    if (!composer || !clip)
+/**
+ * Whether `element` lies fully inside `clip`. A missing element (not mounted) or
+ * clip reports `true`, so a caller that consumes the answer must first know the
+ * element is actually mounted. Rows are one line tall, so "partially visible"
+ * cannot occur for the run status row.
+ */
+function elementVisible(element, clip) {
+    if (!element || !clip)
         return true;
     let top = 0;
-    let current = composer;
+    let current = element;
     while (current && current !== clip) {
         top += current.yogaNode?.getComputedTop() ?? 0;
         current = current.parentNode;
     }
     return current === clip && top >= 0 &&
-        top + measureElement(composer).height <= measureElement(clip).height;
+        top + measureElement(element).height <= measureElement(clip).height;
 }
 /** One offset for messages, padding and editor; hidden trees keep their local state. */
 export function ScrollViewport(props) {
@@ -45,6 +51,7 @@ export function ScrollViewport(props) {
     const lastPin = useRef(props.pinToBottomNonce);
     const lastReset = useRef(props.resetKey);
     const lastVisible = useRef();
+    const lastActivityVisible = useRef();
     const previousActive = useRef(active);
     const geometryRevision = useRef(0);
     const geometryBounds = useRef('');
@@ -186,11 +193,16 @@ export function ScrollViewport(props) {
                 thumb: thumbRange(viewport, content, next, true), revision: geometryRevision.current };
             scrollbar.onGeometry?.();
         }
-        const visible = composerVisible(props.composerRef?.current ?? null, clipRef.current);
+        const visible = elementVisible(props.composerRef?.current ?? null, clipRef.current);
         if (lastVisible.current !== visible) {
             lastVisible.current = visible;
             props.onComposerVisibilityChange?.(visible);
         }
+        const activityVisible = elementVisible(props.activityRef?.current ?? null, clipRef.current);
+        if (lastActivityVisible.current !== activityVisible) {
+            lastActivityVisible.current = activityVisible;
+            props.onActivityVisibilityChange?.(activityVisible);
+        }
     });
     const shiftUp = Math.max(0, metrics.content - metrics.viewport - offset);
     useEffect(() => { props.onScrolledLinesChange?.(offset); }, [offset, props.onScrolledLinesChange]);

package/dist/ui/layout/frame.d.ts

@@ -4,7 +4,6 @@
  * Two pure functions with zero React dependency so the load-bearing invariant
  * I-1 (`frameHeight(r) < r`) can be pinned by a unit test rather than by hope.
  */
-export type RenderMode = 'fullscreen' | 'inline';
 /** Below this many rows a full-screen frame has no usable viewport left. */
 export declare const MIN_FULLSCREEN_ROWS = 12;
 /** Below this many columns the chrome (composer + status bar) cannot line-wrap sanely. */
@@ -35,24 +34,3 @@ export declare const FALLBACK_COLS = 80;
  * terminal is strictly better than a per-frame full-screen repaint.
  */
 export declare function frameHeight(rows: number | undefined): number;
-interface StdoutLike {
-    isTTY?: boolean;
-    rows?: number;
-    columns?: number;
-}
-/**
- * Decide the render mode once, at startup (never re-decided at run time —
- * entering/leaving the alt-screen mid-session is a state machine we do not want).
- *
- * Order is semantics, not style:
- *  1. an explicit opt-out always wins (users can always get v0.2.0 back);
- *  2. `isTTY` is the one gate `--fullscreen` cannot override — writing ANSI into
- *     a pipe or a redirected file is a contract violation, whereas a heuristic
- *     misfire only costs polish;
- *  3. the explicit force comes next so it can beat the heuristics below;
- *  4. heuristics (TERM/CI/size), all overridable by `--fullscreen`.
- */
-export declare function decideRenderMode(flags: {
-    fullscreen?: boolean;
-}, env: Record<string, string | undefined>, stdout: StdoutLike | undefined): RenderMode;
-export {};

package/dist/ui/layout/frame.js

@@ -37,39 +37,3 @@ export function frameHeight(rows) {
     const r = rows && rows > 0 ? rows : FALLBACK_ROWS;
     return Math.max(0, r - 1);
 }
-/** `CI=` / `CI=0` / `CI=false` are not CI; anything else non-empty is. */
-function isTruthyEnv(value) {
-    if (value === undefined)
-        return false;
-    const v = value.trim().toLowerCase();
-    return v.length > 0 && v !== '0' && v !== 'false';
-}
-/**
- * Decide the render mode once, at startup (never re-decided at run time —
- * entering/leaving the alt-screen mid-session is a state machine we do not want).
- *
- * Order is semantics, not style:
- *  1. an explicit opt-out always wins (users can always get v0.2.0 back);
- *  2. `isTTY` is the one gate `--fullscreen` cannot override — writing ANSI into
- *     a pipe or a redirected file is a contract violation, whereas a heuristic
- *     misfire only costs polish;
- *  3. the explicit force comes next so it can beat the heuristics below;
- *  4. heuristics (TERM/CI/size), all overridable by `--fullscreen`.
- */
-export function decideRenderMode(flags, env, stdout) {
-    if (flags.fullscreen === false)
-        return 'inline';
-    if (!stdout?.isTTY)
-        return 'inline';
-    if (flags.fullscreen === true)
-        return 'fullscreen';
-    if (env.TERM === 'dumb')
-        return 'inline';
-    if (isTruthyEnv(env.CI))
-        return 'inline';
-    if ((stdout.rows ?? 0) < MIN_FULLSCREEN_ROWS)
-        return 'inline';
-    if ((stdout.columns ?? 0) < MIN_FULLSCREEN_COLS)
-        return 'inline';
-    return 'fullscreen';
-}

package/dist/ui/layout/todo-layout.d.ts

@@ -1,6 +1,4 @@
-import type { RenderMode } from './frame.js';
 export interface TodoRailLayoutInput {
-    mode: RenderMode;
     cols: number;
     panelEnabled: boolean;
     overlayOpen: boolean;
@@ -12,7 +10,7 @@ export interface TodoRailLayoutInput {
 }
 export interface TodoRailLayout {
     visible: boolean;
-    reason: 'visible' | 'inline' | 'disabled' | 'overlay' | 'empty' | 'narrow' | 'short';
+    reason: 'visible' | 'disabled' | 'overlay' | 'empty' | 'narrow' | 'short';
     width: number;
     rows: number;
     contentCols: number;

package/dist/ui/layout/todo-layout.js

@@ -11,15 +11,14 @@ export function buildTodoRailLayout(input) {
     const popupMaxHeight = Math.max(0, budget - teamRows - TODO_LIMITS.panelMinRows
         - nonNegativeInt(input.composerBaseRows ?? 0));
     const popupRows = popupMaxHeight < 3 ? 0 : Math.min(nonNegativeInt(input.popupRows), popupMaxHeight);
-    const rows = input.mode === 'fullscreen' ? budget : budget - teamRows - popupRows;
+    const rows = budget;
     const width = todoRailWidth(cols);
-    const reason = input.mode !== 'fullscreen' ? 'inline'
-        : !input.panelEnabled ? 'disabled'
-            : input.overlayOpen ? 'overlay'
-                : nonNegativeInt(input.itemCount) === 0 ? 'empty'
-                    : width === 0 ? 'narrow'
-                        : rows < TODO_LIMITS.panelMinRows ? 'short'
-                            : 'visible';
+    const reason = !input.panelEnabled ? 'disabled'
+        : input.overlayOpen ? 'overlay'
+            : nonNegativeInt(input.itemCount) === 0 ? 'empty'
+                : width === 0 ? 'narrow'
+                    : rows < TODO_LIMITS.panelMinRows ? 'short'
+                        : 'visible';
     const visible = reason === 'visible';
     return { visible, reason, width, rows, contentCols: cols - (visible ? width : 0), popupMaxHeight };
 }

package/dist/ui/layout/viewport-geometry.d.ts

@@ -21,7 +21,7 @@ export interface ViewportGeometry {
 }
 /**
  * The default is the UNMEASURED geometry, and consumers must treat it as such:
- * a `TranscriptList` rendered outside a `ScrollViewport` (inline mode, and every
+ * a `TranscriptList` rendered outside a `ScrollViewport` (including
  * test that mounts it bare) sees `viewportRows: 0`, which `selectWindow` reads
  * as "first frame" and answers by pinning the live tail.
  */

package/dist/ui/layout/viewport-geometry.js

@@ -13,7 +13,7 @@
 import { createContext, useContext } from 'react';
 /**
  * The default is the UNMEASURED geometry, and consumers must treat it as such:
- * a `TranscriptList` rendered outside a `ScrollViewport` (inline mode, and every
+ * a `TranscriptList` rendered outside a `ScrollViewport` (including
  * test that mounts it bare) sees `viewportRows: 0`, which `selectWindow` reads
  * as "first frame" and answers by pinning the live tail.
  */

package/dist/ui/live-clamp.d.ts

@@ -1,32 +1,4 @@
-/**
- * Live-region clamp for INLINE render mode (tui-render-performance L5 / R6).
- *
- * Inline mode has no fixed frame, so nothing kept its live (non-`<Static>`)
- * region shorter than the terminal. When one live entry grew taller than
- * `stdout.rows`, Ink took the branch at `ink.js:118-123`:
- *
- *     if (outputHeight >= this.options.stdout.rows) {
- *       stdout.write(clearTerminal + this.fullStaticOutput + output);
- *     }
- *
- * `fullStaticOutput` accumulates EVERY `<Static>` frame of the whole session and
- * is never trimmed, so once that branch is taken it is taken on every subsequent
- * frame — bypassing both the `output !== lastOutput` dedupe and `throttledLog` —
- * and the terminal receives the entire session history thirty times a second.
- * That is a genuine hard freeze, and it is reachable today by any inline user
- * (`--no-fullscreen`, `TERM=dumb`, CI, a short or narrow terminal) whose model
- * writes a long answer.
- *
- * I-L5-1 — keeping the live region strictly below `stdout.rows` makes that
- * branch UNREACHABLE, which is the inline analogue of `frame.ts`'s
- * `frameHeight(r) < r` and deserves the same standing. We cannot bound Ink's
- * `fullStaticOutput` growth (it is private and append-only); preventing the
- * branch that WRITES it is the entire mitigation, and nothing about the memory
- * it holds is fixed by this module.
- *
- * Nothing is lost, only deferred: when the entry settles it moves into
- * `<Static>` and is printed in full.
- */
+/** Keep the newest thinking lines visible while an assistant entry streams. */
 export interface LiveClamp {
     text: string;
     /** Rows dropped off the FRONT. `0` means the text was returned untouched. */

package/dist/ui/live-clamp.js

@@ -1,32 +1,4 @@
-/**
- * Live-region clamp for INLINE render mode (tui-render-performance L5 / R6).
- *
- * Inline mode has no fixed frame, so nothing kept its live (non-`<Static>`)
- * region shorter than the terminal. When one live entry grew taller than
- * `stdout.rows`, Ink took the branch at `ink.js:118-123`:
- *
- *     if (outputHeight >= this.options.stdout.rows) {
- *       stdout.write(clearTerminal + this.fullStaticOutput + output);
- *     }
- *
- * `fullStaticOutput` accumulates EVERY `<Static>` frame of the whole session and
- * is never trimmed, so once that branch is taken it is taken on every subsequent
- * frame — bypassing both the `output !== lastOutput` dedupe and `throttledLog` —
- * and the terminal receives the entire session history thirty times a second.
- * That is a genuine hard freeze, and it is reachable today by any inline user
- * (`--no-fullscreen`, `TERM=dumb`, CI, a short or narrow terminal) whose model
- * writes a long answer.
- *
- * I-L5-1 — keeping the live region strictly below `stdout.rows` makes that
- * branch UNREACHABLE, which is the inline analogue of `frame.ts`'s
- * `frameHeight(r) < r` and deserves the same standing. We cannot bound Ink's
- * `fullStaticOutput` growth (it is private and append-only); preventing the
- * branch that WRITES it is the entire mitigation, and nothing about the memory
- * it holds is fixed by this module.
- *
- * Nothing is lost, only deferred: when the entry settles it moves into
- * `<Static>` and is printed in full.
- */
+/** Keep the newest thinking lines visible while an assistant entry streams. */
 /**
  * Keep the LAST `maxRows` rows of `text`; report how many were dropped.
  *

package/dist/ui/overlays/HelpOverlay.js

@@ -27,6 +27,7 @@ function keyRows(times) {
         // a key, so it has to be named somewhere they can look it up. The one-shot
         // startup notice is the other place, and it scrolls away.
         ['Drag right edge', 'Scroll messages and input together; type to return'],
+        ['Run status row', 'Spinner and steer / interrupt keys, above the input during a run'],
         ['Drag text (left button)', 'Select text on screen; releasing copies it'],
         ['Up / Down', 'Prompt history (empty input)'],
         // Pasting is the one affordance here with no key of its own, so the only

package/dist/ui/run-status-row.d.ts

@@ -0,0 +1,61 @@
+/**
+ * The run status row's width plan (tui-scrollbar-edge-and-run-row §3.3.3).
+ *
+ * While a run is in flight, ONE row above the input box carries the spinner, the
+ * phrase and the `steer / interrupt / exit` hint clauses, and `planRunRow` decides
+ * what survives when the line is too narrow. It is a pure function with no React
+ * and no I/O so the whole ladder can be tested as arithmetic.
+ *
+ * THE ALLOCATION IS PER CLAUSE, NOT PER STRING, and that is the whole point.
+ * The idle hint row this one replaces owned the full line width and ended in
+ * `wrap="truncate"`; handing the label half the line and truncating the joined
+ * hint would cut `interrupt` to `inter...` at 38 columns - a regression of the
+ * "running hint is NEVER abbreviated" rule `Composer.hintText` documents. So:
+ *
+ *  - clauses are dropped WHOLE, from the tail (`exit`, then `stop N`), and
+ *  - `steer` and `interrupt` (REQUIRED_CLAUSES) are never dropped or cut mid-word
+ *    while the row is enabled, and
+ *  - the only thing allowed to end in an ellipsis is the label.
+ */
+/** Everything the label needs, kept in one shape so there is one place that names it. */
+export interface RunActivity {
+    /** Epoch ms the current run began - the phrase sequence's seed. */
+    startedAt: number;
+    /** `Date.now() - startedAt`, already computed by App's 200 ms ticker. */
+    elapsedMs: number;
+    /** The RAW config flag, never the widened one (single-spinner D-5). */
+    reducedMotion: boolean;
+    /** The tool currently in flight, if any. */
+    runningTool?: string;
+    /** A context compaction is in flight; outranks the tool name and the phrase. */
+    compacting?: boolean;
+}
+export interface RunRowPlanInput {
+    /** Width of the row's container (the composer's content columns). */
+    cols: number;
+    /** Spinner + space + label, in display columns (the label's natural width). */
+    labelCols: number;
+    /** Display width of each hint clause, most urgent first. */
+    hintClauseCols: readonly number[];
+    /** Display width of the separator between clauses (` · ` or ` - `). */
+    separatorCols: number;
+    /** Display width of the right-aligned mode chip; 0 = no chip. */
+    chipCols: number;
+}
+export interface RunRowPlan {
+    /** Columns the label may occupy; below its natural width it is ellipsized. */
+    labelCols: number;
+    /** How many leading clauses to show; 0 = none (defensive tier only). */
+    hintClauses: number;
+    /** Whether the chip fits after everything else. */
+    chip: boolean;
+}
+/** One leading space, matching the idle hint row's `'  '` indent. */
+export declare const RUN_ROW_LEAD = 1;
+/** Narrowest the label may be squeezed before a clause is dropped instead. */
+export declare const RUN_ROW_MIN_LABEL_COLS = 10;
+/** `steer` and `interrupt`: always whole while the row is enabled. */
+export declare const RUN_ROW_REQUIRED_CLAUSES = 2;
+/** Space kept between the last clause and the chip. */
+export declare const RUN_ROW_CHIP_GAP = 2;
+export declare function planRunRow(input: RunRowPlanInput): RunRowPlan;

package/dist/ui/run-status-row.js

@@ -0,0 +1,70 @@
+/**
+ * The run status row's width plan (tui-scrollbar-edge-and-run-row §3.3.3).
+ *
+ * While a run is in flight, ONE row above the input box carries the spinner, the
+ * phrase and the `steer / interrupt / exit` hint clauses, and `planRunRow` decides
+ * what survives when the line is too narrow. It is a pure function with no React
+ * and no I/O so the whole ladder can be tested as arithmetic.
+ *
+ * THE ALLOCATION IS PER CLAUSE, NOT PER STRING, and that is the whole point.
+ * The idle hint row this one replaces owned the full line width and ended in
+ * `wrap="truncate"`; handing the label half the line and truncating the joined
+ * hint would cut `interrupt` to `inter...` at 38 columns - a regression of the
+ * "running hint is NEVER abbreviated" rule `Composer.hintText` documents. So:
+ *
+ *  - clauses are dropped WHOLE, from the tail (`exit`, then `stop N`), and
+ *  - `steer` and `interrupt` (REQUIRED_CLAUSES) are never dropped or cut mid-word
+ *    while the row is enabled, and
+ *  - the only thing allowed to end in an ellipsis is the label.
+ */
+/** One leading space, matching the idle hint row's `'  '` indent. */
+export const RUN_ROW_LEAD = 1;
+/** Narrowest the label may be squeezed before a clause is dropped instead. */
+export const RUN_ROW_MIN_LABEL_COLS = 10;
+/** `steer` and `interrupt`: always whole while the row is enabled. */
+export const RUN_ROW_REQUIRED_CLAUSES = 2;
+/** Space kept between the last clause and the chip. */
+export const RUN_ROW_CHIP_GAP = 2;
+/** Non-finite or negative widths collapse to 0 so no input can make the plan throw. */
+function width(value) {
+    return Number.isFinite(value) && value > 0 ? Math.floor(value) : 0;
+}
+/** Width of the first `count` clauses joined by `separator`. */
+function clausesWidth(clauses, count, separator) {
+    if (count <= 0)
+        return 0;
+    let total = separator * (count - 1);
+    for (let i = 0; i < count; i += 1)
+        total += clauses[i] ?? 0;
+    return total;
+}
+export function planRunRow(input) {
+    const inner = Math.max(0, width(input.cols) - RUN_ROW_LEAD);
+    const natural = width(input.labelCols);
+    const separator = width(input.separatorCols);
+    const chipCols = width(input.chipCols);
+    const clauses = input.hintClauseCols.map(width);
+    const total = clauses.length;
+    const labelOnly = {
+        labelCols: Math.min(natural, inner), hintClauses: 0, chip: false,
+    };
+    if (total < RUN_ROW_REQUIRED_CLAUSES)
+        return labelOnly;
+    // Tier 1: everything fits; the chip is the first thing to go.
+    const everything = natural + separator + clausesWidth(clauses, total, separator);
+    if (everything <= inner) {
+        const chip = chipCols > 0 && everything + RUN_ROW_CHIP_GAP + chipCols <= inner;
+        return { labelCols: natural, hintClauses: total, chip };
+    }
+    // Tier 2: drop clauses from the tail, but never below the required two; only the
+    // label may be squeezed (down to its minimum) to make the remaining clauses fit.
+    for (let kept = total - 1; kept >= RUN_ROW_REQUIRED_CLAUSES; kept -= 1) {
+        const available = inner - separator - clausesWidth(clauses, kept, separator);
+        if (available >= RUN_ROW_MIN_LABEL_COLS) {
+            return { labelCols: Math.min(natural, available), hintClauses: kept, chip: false };
+        }
+    }
+    // Tier 3 (defensive, below ~40 columns): the label alone. The status bar's own
+    // `Esc x2 interrupt` carries the urgent hint at this width.
+    return labelOnly;
+}

package/dist/ui/transcript-text.d.ts

@@ -1,11 +1,3 @@
-/**
- * Plain-text session rendering (spec §4.4). Pure, colorless, ANSI-free, so the
- * exit replay can be piped, diffed, or pasted into an issue.
- *
- * Used only by the full-screen exit replay: inline mode already left the real
- * transcript in the terminal's native scrollback, and replaying there would
- * simply print everything twice.
- */
 import type { Entry, UsageTotal } from '../agent/reducer.js';
 import type { Glyphs } from './glyphs.js';
 export interface TranscriptTextOptions {

package/dist/ui/transcript-text.js

@@ -1,11 +1,3 @@
-/**
- * Plain-text session rendering (spec §4.4). Pure, colorless, ANSI-free, so the
- * exit replay can be piped, diffed, or pasted into an issue.
- *
- * Used only by the full-screen exit replay: inline mode already left the real
- * transcript in the terminal's native scrollback, and replaying there would
- * simply print everything twice.
- */
 import { formatCost, formatDuration, formatTokens, promptTokensOf } from '../agent/usage.js';
 import { formatRetryLine } from '../agent/retry-view.js';
 const DEFAULT_MAX_ENTRIES = 200;

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

@@ -40,53 +40,7 @@ export declare const MOUSE_NOTICE_VERSION = 1;
  * that offered only `/plan`, recorded back when this was a boolean.
  */
 export declare const VT_INPUT_NOTICE_VERSION = 1;
-/**
- * The `shift-tab-and-mouse-wheel-dead-on-some-terminals` notice (F1'). Shown at
- * most once per `VT_INPUT_NOTICE_VERSION`, and only on a Windows console that
- * cannot deliver either input — see `ui/win-vt-input.ts` for why that is a
- * property of the Node version rather than of the terminal.
- *
- * IT NAMES WHAT THE KEY DOES NOW, not merely that it is unavailable, and that
- * is the load-bearing half of the text. `Shift+Tab` on these machines is not
- * inert: the modifier is lost inside libuv, so Ink sees an ordinary `Tab` and
- * the `/` palette or an `@` popup completes its selection over the user's
- * draft. A user told only "this key does not work" keeps pressing it and keeps
- * losing text without ever connecting the two.
- *
- * THE FALLBACK KEY COMES BEFORE `/plan` IN BOTH BRANCHES, and it is named from
- * `MODE_TOGGLE_KEYS` rather than spelled out, so the four consumers of that
- * constant cannot drift apart. This notice is the last one of them to be wired
- * up, and it is also the only channel that reaches the affected user without
- * being asked to: the composer hint does not exist at all in inline mode and is
- * switched off by a short terminal or `hints: false` in full-screen, and
- * `/help` has to be typed by someone whose current belief is "the key does
- * nothing" rather than "I should read the help". Ordering follows cost — one
- * keystroke before four and a return.
- *
- * `Shift+Up` / `Shift+Down` is the scroll workaround named here because it is
- * the only one PROVEN to survive: both Node versions emit `\x1b[1;2A` for it,
- * byte for byte, in the probe data. `PgUp` / `PgDn` is expected to work too but
- * was never injected, so it is left out rather than promised.
- *
- * THE WHEEL HALF IS FULL-SCREEN ONLY, and dropping it inline is not a detail.
- * `Shift+Tab` is broken in both modes — the modifier dies inside libuv, well
- * below anything this app chooses — but the wheel is only ours to lose in
- * full-screen: inline never asks the console to report it (`mode` is a conjunct
- * of `cli.tsx::wantMouse`), so the wheel goes on scrolling the terminal's own
- * scrollback exactly as it always has. And `Shift+Up` / `Shift+Down` are handled
- * inside `App`'s `if (fullscreen)` branch, so recommending them inline names a
- * key that does nothing. Telling an inline user their working wheel is dead and
- * then handing them an inert workaround is the same failure this notice exists
- * to end — advice about a mode that is not running — merely pointed the other
- * way.
- *
- * EXPORTED FOR ITS TEST, unlike the two notices above it. Asserting this text
- * through a rendered frame does not work: the transcript wraps a notice at two
- * columns wider than it displays it, so any phrase landing on a wrap boundary
- * loses a character or two on the way to `lastFrame()` and the assertion fails
- * for a reason that has nothing to do with the text.
- */
-export declare function vtInputDeadNotice(nodeVersion: string, fullscreen: boolean): string;
+export declare function vtInputDeadNotice(nodeVersion: string): string;
 /**
  * `{ requested, resolved }` when the raise happened, `undefined` otherwise —
  * i.e. `cfg.transcriptRetainRequested` and `cfg.transcriptRetain`.
@@ -132,16 +86,6 @@ export interface MouseNoticeOptions {
 export interface VtInputNoticeOptions {
     /** `process.versions.node`, quoted back so the user can act on it. */
     nodeVersion: string;
-    /**
-     * Whether this run owns the alternate screen, i.e. `App`'s own `fullscreen`.
-     *
-     * Selects which half of the text applies: inline keeps the wheel and loses the
-     * full-screen scroll keys, so it is told about `Shift+Tab` and nothing else
-     * (see `vtInputDeadNotice`). Taken from the caller rather than re-derived here
-     * for the same reason the version is — one source, no chance of the notice and
-     * the renderer disagreeing about which mode is running.
-     */
-    fullscreen: boolean;
     /**
      * Record that `VT_INPUT_NOTICE_VERSION` was shown (`state.json`). Called once,
      * after dispatch — and it must write that constant, not `true`: the gate

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

@@ -80,61 +80,11 @@ function retainRaisedNotice(requested, resolved) {
  * that offered only `/plan`, recorded back when this was a boolean.
  */
 export const VT_INPUT_NOTICE_VERSION = 1;
-/**
- * The `shift-tab-and-mouse-wheel-dead-on-some-terminals` notice (F1'). Shown at
- * most once per `VT_INPUT_NOTICE_VERSION`, and only on a Windows console that
- * cannot deliver either input — see `ui/win-vt-input.ts` for why that is a
- * property of the Node version rather than of the terminal.
- *
- * IT NAMES WHAT THE KEY DOES NOW, not merely that it is unavailable, and that
- * is the load-bearing half of the text. `Shift+Tab` on these machines is not
- * inert: the modifier is lost inside libuv, so Ink sees an ordinary `Tab` and
- * the `/` palette or an `@` popup completes its selection over the user's
- * draft. A user told only "this key does not work" keeps pressing it and keeps
- * losing text without ever connecting the two.
- *
- * THE FALLBACK KEY COMES BEFORE `/plan` IN BOTH BRANCHES, and it is named from
- * `MODE_TOGGLE_KEYS` rather than spelled out, so the four consumers of that
- * constant cannot drift apart. This notice is the last one of them to be wired
- * up, and it is also the only channel that reaches the affected user without
- * being asked to: the composer hint does not exist at all in inline mode and is
- * switched off by a short terminal or `hints: false` in full-screen, and
- * `/help` has to be typed by someone whose current belief is "the key does
- * nothing" rather than "I should read the help". Ordering follows cost — one
- * keystroke before four and a return.
- *
- * `Shift+Up` / `Shift+Down` is the scroll workaround named here because it is
- * the only one PROVEN to survive: both Node versions emit `\x1b[1;2A` for it,
- * byte for byte, in the probe data. `PgUp` / `PgDn` is expected to work too but
- * was never injected, so it is left out rather than promised.
- *
- * THE WHEEL HALF IS FULL-SCREEN ONLY, and dropping it inline is not a detail.
- * `Shift+Tab` is broken in both modes — the modifier dies inside libuv, well
- * below anything this app chooses — but the wheel is only ours to lose in
- * full-screen: inline never asks the console to report it (`mode` is a conjunct
- * of `cli.tsx::wantMouse`), so the wheel goes on scrolling the terminal's own
- * scrollback exactly as it always has. And `Shift+Up` / `Shift+Down` are handled
- * inside `App`'s `if (fullscreen)` branch, so recommending them inline names a
- * key that does nothing. Telling an inline user their working wheel is dead and
- * then handing them an inert workaround is the same failure this notice exists
- * to end — advice about a mode that is not running — merely pointed the other
- * way.
- *
- * EXPORTED FOR ITS TEST, unlike the two notices above it. Asserting this text
- * through a rendered frame does not work: the transcript wraps a notice at two
- * columns wider than it displays it, so any phrase landing on a wrap boundary
- * loses a character or two on the way to `lastFrame()` and the assertion fails
- * for a reason that has nothing to do with the text.
- */
-export function vtInputDeadNotice(nodeVersion, fullscreen) {
+export function vtInputDeadNotice(nodeVersion) {
     const cause = `Node ${nodeVersion} on Windows does not turn on the console's VT input mode, so `;
     const cost = 'it will not switch mode, and with the / palette or an @ popup open it completes that ' +
         'instead, overwriting your draft. ';
     const toggle = `Press ${MODE_TOGGLE_KEYS.fallback} to switch mode instead (or /plan)`;
-    if (!fullscreen) {
-        return (`${cause}Shift+Tab never arrives: it comes through as a PLAIN TAB - ${cost}` +
-            `${toggle}. Node 22.17.0+ (or 24.2.0+) restores it.`);
-    }
     return (`${cause}two keys never arrive: the wheel sends nothing at all, and Shift+Tab arrives ` +
         `as a PLAIN TAB - ${cost}${toggle}, and Shift+Up / Shift+Down to scroll. ` +
         'Node 22.17.0+ (or 24.2.0+) restores both.');
@@ -199,7 +149,6 @@ export function useStartupNotices(dispatch, mouseNotice, retainNotice, vtInputNo
     const vtNoticeRef = useRef(vtInputNotice);
     vtNoticeRef.current = vtInputNotice;
     const vtNodeVersion = vtInputNotice?.nodeVersion;
-    const vtFullscreen = vtInputNotice?.fullscreen ?? false;
     const vtNoticeShown = useRef(false);
     useEffect(() => {
         if (vtNodeVersion === undefined || vtNoticeShown.current)
@@ -210,10 +159,10 @@ export function useStartupNotices(dispatch, mouseNotice, retainNotice, vtInputNo
         dispatch({
             type: 'notice',
             level: 'warn',
-            text: vtInputDeadNotice(vtNodeVersion, vtFullscreen),
+            text: vtInputDeadNotice(vtNodeVersion),
         });
         vtNoticeRef.current?.onSeen();
-    }, [vtNodeVersion, vtFullscreen, dispatch]);
+    }, [vtNodeVersion, dispatch]);
     // A `warn` notice rather than a toast: it is about a value the user typed, so
     // it belongs in the transcript where it can be scrolled back to, not in a row
     // that expires. DEPENDS ON THE TWO SCALARS, never on the options object —

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

@@ -32,7 +32,7 @@ export declare const OVERLAY_PAGE = 8;
 export interface WheelRoutingOptions {
     isPointerCaptured?: () => boolean;
     isActive?: () => boolean;
-    /** Absent when mouse support is off, in inline mode, or on a non-TTY. */
+    /** Absent when mouse support is off, or on a non-TTY. */
     mouseSource?: MouseSource;
     /** Read at EVENT time for the routing branch, and again at FLUSH time (P1-3). */
     getOverlay: () => Overlay | null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aragon-agent/cli",
-  "version": "0.6.8",
+  "version": "0.6.9",
   "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.20",
+    "@aragon-agent/core": "^0.2.21",
     "chalk": "^5.6.2",
     "cli-highlight": "^2.0.0",
     "commander": "^12.1.0",