@aragon-agent/cli 0.6.8 → 0.6.10

package/dist/ui/overlays/QuestionOverlay.js

@@ -20,6 +20,7 @@ import { Box, Text, useInput } from 'ink';
 import { pickGlyphs } from '../glyphs.js';
 import { OverlayFrame } from '../layout/OverlayFrame.js';
 import { stripPasteFrames } from '../paste-frames.js';
+import { stripEnterFrames } from '../enter-frames.js';
 /** Which option index each question starts on: the recommended one. */
 function initialCursors(questions) {
     return questions.map((q) => Math.max(0, q.options.findIndex((o) => o.recommended)));
@@ -125,8 +126,12 @@ export function QuestionOverlay({ questions, maxRows, cols, theme, caps, onSubmi
             // `stripPasteFrames`, NOT `input` (I-12 / P0-2) -- the same broadcast
             // hazard `SettingsScreen` documents at length: a framed paste appended
             // verbatim stores NULs that render as nothing.
-            if (input && !key.ctrl && !key.meta && !key.tab)
-                setDraft(draft + stripPasteFrames(input));
+            // `stripEnterFrames` rides inside it for the newline frame a
+            // Shift+Enter broadcasts (tui-shift-enter-copy-queue 3.5): same hazard,
+            // same fix, and this order is the one that leaves no NUL in the draft.
+            if (input && !key.ctrl && !key.meta && !key.tab) {
+                setDraft(draft + stripPasteFrames(stripEnterFrames(input)));
+            }
             return;
         }
         // phase === 'choosing'

package/dist/ui/overlays/SettingsScreen.js

@@ -16,6 +16,7 @@ import { LOG_LEVEL_NAMES } from '../../logging/levels.js';
 import { pickGlyphs } from '../glyphs.js';
 import { OverlayFrame } from '../layout/OverlayFrame.js';
 import { stripPasteFrames } from '../paste-frames.js';
+import { stripEnterFrames } from '../enter-frames.js';
 const SHOW_THINKING_OPTIONS = ['off', 'on'];
 const LIVE_OUTPUT_OPTIONS = ['off', 'on'];
 const FAST_ENABLED_OPTIONS = ['off', 'on'];
@@ -302,7 +303,13 @@ export function SettingsScreen({ initial, apiKeys, maxRows, cols, scrollOffset,
             // `controller.setApiKey()`. The user is told the settings were saved and
             // every request afterwards fails to authenticate with nothing on screen to
             // explain it. Pasting IS how a key enters this process.
-            const text = stripPasteFrames(input);
+            // `stripEnterFrames` INSIDE (tui-shift-enter-copy-queue 3.5): the same
+            // broadcast carries the newline frame a Shift+Enter produced, and this
+            // composition order is the one that leaves no NUL in the field -- the
+            // outer paste strip removes the frame's newline for a single-line field
+            // exactly as it removes a bare Ctrl+J today, while the reverse order
+            // would leak the frame's letter as visible text.
+            const text = stripPasteFrames(stripEnterFrames(input));
             if (text.length === 0)
                 return;
             setValues((prev) => ({ ...prev, [field.key]: String(prev[field.key]) + text }));

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/selection/selection-controller.d.ts

@@ -1,8 +1,8 @@
 /**
  * The selection controller (tui-selection-and-scroll-follow §4.4). NON-REACT: it
- * owns the mouse lifecycle, the 16 ms drag coalescer, the `decorate` hook and the
- * copy-on-release, and it reaches the React tree only through the two callbacks
- * `App` registers on mount.
+ * owns the mouse lifecycle, the 16 ms drag coalescer, the `decorate` hook and
+ * the released-selection state Ctrl+C consumes, and it reaches the React tree
+ * only through the callbacks `App` registers on mount.
  *
  * WHY IT IS NOT A COMPONENT (D-6). A React re-render per motion report goes
  * through the render governor and the whole component tree; the frame pipeline
@@ -28,9 +28,9 @@
  *    than by a staleness check that can be wrong.
  */
 import type { MouseSource } from '../../input/stdin-filter.js';
+import type { CopyVia } from '../clipboard.js';
 import type { Theme } from '../theme.js';
 import type { TermCapabilities } from '../capabilities.js';
-import type { CopyVia } from '../clipboard.js';
 /**
  * How long a nominally-held button may sit MOTIONLESS before the watchdog lets
  * go of it (I-11). Reset by every motion report, so it only fires when the
@@ -49,9 +49,6 @@ export interface SelectionControllerOptions {
     repaint: () => boolean;
     /** `App`'s `redrawNonce`, for the invalidated case (§4.4.3). */
     requestRedraw: () => void;
-    copy: (text: string) => CopyVia;
-    /** Toast sink, registered by `App` on mount (§6.3). */
-    onCopied: (via: CopyVia, lines: number, chars: number) => void;
     theme: () => Theme;
     caps: TermCapabilities;
     /** Terminal width, for the right edge of a multi-row highlight. */
@@ -64,6 +61,25 @@ export interface SelectionControllerOptions {
 export interface SelectionController {
     /** Feed to `createFrameDiffer({ decorate })`. Mirrors, then paints. */
     decorate(lines: string[]): string[];
+    /**
+     * Whether a RELEASED, non-empty selection is waiting for Ctrl+C
+     * (tui-shift-enter-copy-queue 4.2). Dragging does not count: the gesture
+     * is not finished, and a copy key pressed mid-drag must fall through to
+     * whatever it meant before this feature.
+     */
+    hasPendingSelection(): boolean;
+    /**
+     * Take the pending selection: returns its text and line count, and clears
+     * the highlight, the settled state and the hold. `null` when nothing is
+     * pending. The caller owns the copy itself (`copyText` is the single
+     * clipboard path) and MUST take BEFORE copying: OSC 52 writes through
+     * `writeForeign`, the differ invalidates, and its `onInvalidate` clears
+     * this controller -- taking first makes that clear a no-op (4.3 / R7).
+     */
+    takeSelection(): {
+        text: string;
+        lines: number;
+    } | null;
     /** Subscribe to `hold` transitions; `App` mirrors this into React state. */
     onHoldChange(listener: (hold: boolean) => void): () => void;
     /** Called by `App` for key / resize / overlay / clear, and by `onInvalidate`. */

package/dist/ui/selection/selection-controller.js

@@ -1,8 +1,8 @@
 /**
  * The selection controller (tui-selection-and-scroll-follow §4.4). NON-REACT: it
- * owns the mouse lifecycle, the 16 ms drag coalescer, the `decorate` hook and the
- * copy-on-release, and it reaches the React tree only through the two callbacks
- * `App` registers on mount.
+ * owns the mouse lifecycle, the 16 ms drag coalescer, the `decorate` hook and
+ * the released-selection state Ctrl+C consumes, and it reaches the React tree
+ * only through the callbacks `App` registers on mount.
  *
  * WHY IT IS NOT A COMPONENT (D-6). A React re-render per motion report goes
  * through the render governor and the whole component tree; the frame pipeline
@@ -57,6 +57,10 @@ export function createSelectionController(options) {
     let enabled = true;
     let sel = null;
     let dragging = false;
+    /** A released, non-empty selection is waiting for Ctrl+C (4.2.1). */
+    let settled = false;
+    /** Mirror of the last `hold` emitted, so exits can be conditional. */
+    let holdActive = false;
     let pendingFocus = null;
     let flushTimer = null;
     let holdWatchdog = null;
@@ -64,6 +68,7 @@ export function createSelectionController(options) {
     /** Guards `decorate` against being re-entered from inside a repaint. */
     let painting = false;
     const emitHold = (hold) => {
+        holdActive = hold;
         for (const listener of [...holdListeners])
             listener(hold);
     };
@@ -121,15 +126,18 @@ export function createSelectionController(options) {
         // Nothing to undo: no timers, no repaint, no redraw. This is what keeps
         // `onInvalidate` — which fires on every resize and every foreign write —
         // free for a session that has never selected anything.
-        if (sel === null && !dragging && pendingFocus === null)
+        if (sel === null && !dragging && pendingFocus === null && !settled)
             return;
-        const wasDragging = dragging;
         sel = null;
         dragging = false;
+        settled = false;
         pendingFocus = null;
         clearFlushTimer();
         clearWatchdog();
-        if (wasDragging)
+        // `holdActive`, not `wasDragging`: since tui-shift-enter-copy-queue a
+        // RELEASED selection also holds the viewport (4.2.3), so this is the
+        // exit for two states, not one.
+        if (holdActive)
             emitHold(false);
         paint(false);
     };
@@ -150,26 +158,38 @@ export function createSelectionController(options) {
         paint(true);
     };
     const finishSelection = () => {
-        if (!sel)
+        if (!sel) {
+            emitHold(false);
             return;
+        }
         const normal = normalize(sel);
         if (isEmpty(normal)) {
-            // A plain click. It must never leave a one-cell highlight behind, and it
-            // must never clobber the clipboard.
+            // A plain click. It must never leave a one-cell highlight behind, and
+            // it must never clobber the clipboard.
             sel = null;
+            settled = false;
+            emitHold(false);
             paint(false);
             return;
         }
-        const text = selectedText(mirror.plain, normal);
-        if (text.length === 0) {
+        if (selectedText(mirror.plain, normal).length === 0) {
+            // Geometry without content (blank cells): nothing honest to promise a
+            // later Ctrl+C, so this is the same no-op a click is.
             sel = null;
+            settled = false;
+            emitHold(false);
             paint(false);
             return;
         }
-        const via = options.copy(text);
-        options.onCopied(via, text.split('\n').length, text.length);
-        // The highlight STAYS after a release: it is the receipt for what was taken,
-        // and it goes away on the next thing that moves the rows (I-9).
+        // RELEASED AND NON-EMPTY: the highlight STAYS and so does the hold
+        // (4.2.1 / 4.2.3). The highlight is the promise of what Ctrl+C will
+        // copy -- not a receipt for a copy that already happened -- and the
+        // hold keeps the rows under it frozen until that promise resolves,
+        // which is what lets "what you see is what you get" survive a
+        // streaming run. The watchdog is NOT re-armed: the release already
+        // happened, and the frozen state has explicit exits (Ctrl+C, any other
+        // key, resize, overlay, /mouse off).
+        settled = true;
         paint(true);
     };
     const onMouse = (event) => {
@@ -222,7 +242,9 @@ export function createSelectionController(options) {
         clearFlushTimer();
         clearWatchdog();
         dragging = false;
-        emitHold(false);
+        // `finishSelection` decides the hold: a non-empty release KEEPS it
+        // (4.2.3) so the pending selection cannot be pushed off screen; every
+        // empty path releases it there.
         finishSelection();
     };
     const unsubscribe = options.source.subscribe(onMouse);
@@ -258,6 +280,32 @@ export function createSelectionController(options) {
             holdListeners.add(listener);
             return () => holdListeners.delete(listener);
         },
+        hasPendingSelection() {
+            return settled && sel !== null;
+        },
+        takeSelection() {
+            if (!settled || sel === null)
+                return null;
+            const normal = normalize(sel);
+            const text = selectedText(mirror.plain, normal);
+            // CONSUMED BEFORE THE CALLER COPIES (4.3 / R7). The copy writes OSC
+            // 52 through `writeForeign`; the differ treats that as a foreign
+            // write and invalidates, and `onInvalidate` clears this controller on
+            // the next macrotask. Clearing first makes that callback a no-op;
+            // copying first would let it erase the held viewport state a tick
+            // after the copy -- the "copy flashes the screen" regression.
+            sel = null;
+            settled = false;
+            pendingFocus = null;
+            clearFlushTimer();
+            clearWatchdog();
+            if (holdActive)
+                emitHold(false);
+            paint(false);
+            if (text.length === 0)
+                return null;
+            return { text, lines: text.split('\n').length };
+        },
         clear,
         setEnabled(next) {
             if (enabled === next)
@@ -270,6 +318,10 @@ export function createSelectionController(options) {
             if (disposed)
                 return;
             disposed = true;
+            // 4.2.3: a pending selection holds the viewport; teardown must let go
+            // of it explicitly, exactly like `clear()` does.
+            if (holdActive)
+                emitHold(false);
             unsubscribe();
             clearFlushTimer();
             clearWatchdog();

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

@@ -22,8 +22,12 @@ import type { ViewAction } from '../agent/reducer.js';
  *
  * `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.
+ * `2` = the Ctrl+C-to-copy text (tui-shift-enter-copy-queue 4.4): releasing
+ * no longer copies, and every user who learned the old gesture -- which is
+ * every user who has a version recorded at all -- has to be told the new
+ * one, once.
  */
-export declare const MOUSE_NOTICE_VERSION = 1;
+export declare const MOUSE_NOTICE_VERSION = 2;
 /**
  * The revision of the text below that a user must have seen for this notice to
  * stay quiet (`state.json::vtInputNoticeVersion`, `0` when absent).
@@ -40,53 +44,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 +90,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

@@ -26,8 +26,12 @@ import { getLogger } from '../logging/logger.js';
  *
  * `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.
+ * `2` = the Ctrl+C-to-copy text (tui-shift-enter-copy-queue 4.4): releasing
+ * no longer copies, and every user who learned the old gesture -- which is
+ * every user who has a version recorded at all -- has to be told the new
+ * one, once.
  */
-export const MOUSE_NOTICE_VERSION = 1;
+export const MOUSE_NOTICE_VERSION = 2;
 /**
  * The one-shot mouse notice (tui-selection-and-scroll-follow §5.2 row 29).
  *
@@ -47,8 +51,8 @@ function mouseNoticeText(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.');
+    return ('Mouse wheel scrolls the transcript; drag to select, then Ctrl+C to copy. ' +
+        '/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
@@ -80,61 +84,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 +153,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 +163,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.10",
   "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.22",
     "chalk": "^5.6.2",
     "cli-highlight": "^2.0.0",
     "commander": "^12.1.0",