@aragon-agent/cli 0.6.28 → 0.6.31

package/dist/config/ui-state.d.ts

@@ -84,6 +84,12 @@ export interface UiState {
      * older file, which is the behaviour wanted here anyway.
      */
     vtInputNoticeVersion: number;
+    /**
+     * Which revision of the "scrolling now uses your terminal" notice this user has
+     * been shown (`0` = none; tui-native-terminal-scroll D12). A scalar beside the
+     * others for the same reasons the two above record, and NOT a schema bump.
+     */
+    scrollModeNoticeVersion: number;
 }
 /** Read the state, caching it for the life of the process. Never throws. */
 export declare function loadUiState(): UiState;
@@ -98,6 +104,9 @@ export declare function setMouseNoticeVersion(version: number): void;
 /** `0` on a file written before the field existed — see the field's comment. */
 export declare function getVtInputNoticeVersion(): number;
 export declare function setVtInputNoticeVersion(version: number): void;
+/** `0` on a file written before the field existed. */
+export declare function getScrollModeNoticeVersion(): number;
+export declare function setScrollModeNoticeVersion(version: number): void;
 /**
  * Migration-only: fill in fields that are still at their default, and never
  * overwrite a value already here. A second import — after a half-finished

package/dist/config/ui-state.js

@@ -37,6 +37,7 @@ const DEFAULT_UI_STATE = {
     mouseNoticeSeen: false,
     mouseNoticeVersion: 0,
     vtInputNoticeVersion: 0,
+    scrollModeNoticeVersion: 0,
 };
 let memory = null;
 /** Non-negative integer or `fallback`; shared by both numeric fields. */
@@ -69,6 +70,7 @@ function readFromDisk() {
                 : DEFAULT_UI_STATE.mouseNoticeSeen,
             mouseNoticeVersion: coerceCount(parsed.mouseNoticeVersion, DEFAULT_UI_STATE.mouseNoticeVersion),
             vtInputNoticeVersion: coerceCount(parsed.vtInputNoticeVersion, DEFAULT_UI_STATE.vtInputNoticeVersion),
+            scrollModeNoticeVersion: coerceCount(parsed.scrollModeNoticeVersion, DEFAULT_UI_STATE.scrollModeNoticeVersion),
         };
     }
     catch {
@@ -142,6 +144,13 @@ export function getVtInputNoticeVersion() {
 export function setVtInputNoticeVersion(version) {
     update({ vtInputNoticeVersion: version });
 }
+/** `0` on a file written before the field existed. */
+export function getScrollModeNoticeVersion() {
+    return loadUiState().scrollModeNoticeVersion;
+}
+export function setScrollModeNoticeVersion(version) {
+    update({ scrollModeNoticeVersion: version });
+}
 /**
  * Migration-only: fill in fields that are still at their default, and never
  * overwrite a value already here. A second import — after a half-finished

package/dist/input/limits.d.ts

@@ -39,6 +39,26 @@ export declare const PASTE_BURST_MS = 15;
  * which is the rule `MAX_PENDING_MOUSE_CHARS` already encodes for mouse reports.
  */
 export declare const PASTE_ASSEMBLY_MAX_MS = 2000;
+/**
+ * How long a paste-marker head that was ALREADY released to the pass-through as
+ * ordinary text may still be recognised as the head of a marker (defect 2: the
+ * torn-marker rescue in `stdin-filter.ts`).
+ *
+ * STRUCTURAL, NOT POLICY: no config key exposes it, because it bounds what the
+ * byte stream can physically do -- a marker split across two reads -- and not
+ * what a user prefers. What it does NOT do is delay a keystroke: the 12 ms
+ * pending-flush window in `stdin-filter.ts` still releases a lone ESC exactly as
+ * before, and this window only governs whether that release may be spliced back
+ * in front of the next chunk so an assembled marker is consumed, not typed.
+ *
+ * THE FALSE POSITIVE IS THE TRADE-OFF, AND IT IS ACCEPTED. Firing the rescue
+ * wrongly needs the user to press Esc and then TYPE the literal characters
+ * `[200~` or `[201~` inside this window -- a sequence no keyboard produces, and
+ * at worst five characters of lost typing. Paying that buys a fix for visible
+ * `[200~` / `[201~` garbage in the draft, which is the failure the whole paste
+ * feature exists to prevent.
+ */
+export declare const PASTE_MARKER_RESCAN_TTL_MS = 250;
 /**
  * The inline frame the filter writes into the stream Ink reads (D-3 / I-5).
  *

package/dist/input/limits.js

@@ -39,6 +39,26 @@ export const PASTE_BURST_MS = 15;
  * which is the rule `MAX_PENDING_MOUSE_CHARS` already encodes for mouse reports.
  */
 export const PASTE_ASSEMBLY_MAX_MS = 2_000;
+/**
+ * How long a paste-marker head that was ALREADY released to the pass-through as
+ * ordinary text may still be recognised as the head of a marker (defect 2: the
+ * torn-marker rescue in `stdin-filter.ts`).
+ *
+ * STRUCTURAL, NOT POLICY: no config key exposes it, because it bounds what the
+ * byte stream can physically do -- a marker split across two reads -- and not
+ * what a user prefers. What it does NOT do is delay a keystroke: the 12 ms
+ * pending-flush window in `stdin-filter.ts` still releases a lone ESC exactly as
+ * before, and this window only governs whether that release may be spliced back
+ * in front of the next chunk so an assembled marker is consumed, not typed.
+ *
+ * THE FALSE POSITIVE IS THE TRADE-OFF, AND IT IS ACCEPTED. Firing the rescue
+ * wrongly needs the user to press Esc and then TYPE the literal characters
+ * `[200~` or `[201~` inside this window -- a sequence no keyboard produces, and
+ * at worst five characters of lost typing. Paying that buys a fix for visible
+ * `[200~` / `[201~` garbage in the draft, which is the failure the whole paste
+ * feature exists to prevent.
+ */
+export const PASTE_MARKER_RESCAN_TTL_MS = 250;
 /**
  * The inline frame the filter writes into the stream Ink reads (D-3 / I-5).
  *

package/dist/input/stdin-filter.js

@@ -33,8 +33,8 @@
  */
 import { PassThrough } from 'node:stream';
 import { MAX_PENDING_MOUSE_CHARS, splitMouseEvents, isMousePrefix, } from './mouse-events.js';
-import { ENTER_NEWLINE_FRAME, INDEX_KEY_FRAME, PASTE_ASSEMBLY_MAX_MS, PASTE_BURST_MS, PASTE_CLOSE, PASTE_MAX_BYTES, PASTE_OPEN, formatPasteSize, } from './limits.js';
-import { PASTE_BEGIN_MARK, PASTE_END_MARK, classifyChunk, sanitisePaste, trailingPastePrefixLength, } from './paste-parse.js';
+import { ENTER_NEWLINE_FRAME, INDEX_KEY_FRAME, PASTE_ASSEMBLY_MAX_MS, PASTE_BURST_MS, PASTE_CLOSE, PASTE_MARKER_RESCAN_TTL_MS, PASTE_MAX_BYTES, PASTE_OPEN, formatPasteSize, } from './limits.js';
+import { PASTE_BEGIN_MARK, PASTE_END_MARK, classifyChunk, isPastePrefix, sanitisePaste, trailingPastePrefixLength, } from './paste-parse.js';
 import { hasPasteOnlySequence } from './control-sequences.js';
 import { splitEnterSequences, trailingEnterPrefixLength } from './enter-sequences.js';
 import { splitCsiUKeys, trailingCsiUPrefixLength, translateCsiUKey } from './csiu-keys.js';
@@ -97,6 +97,23 @@ export function createStdinFilter(real, features, bridge, onWarn) {
     let paste = { kind: 'idle' };
     let discardBracketed = false;
     let outputBatch = null;
+    /**
+     * A marker head that has ALREADY been released to Ink, kept for one more
+     * chunk (defect 2: the torn-marker rescue in `onData`).
+     *
+     * WHY IT EXISTS. `flushPending` releases a lone ESC after 12 ms because the
+     * Esc key must not be held hostage. When the split point lands inside a paste
+     * marker -- `ESC` in one read and `[200~hello` in the next, which is ordinary
+     * for a Windows console, SSH or tmux under load -- `feed` can no longer find
+     * the marker and `[200~` is typed into the draft. Nothing downstream can undo
+     * that: the marker has to be recognised BEFORE its bytes become text.
+     *
+     * WHAT IT CANNOT DO, STATED HONESTLY. The released ESC has already reached Ink
+     * as an Esc key press and this filter cannot retract a write. The rescue
+     * guarantees the marker CHARACTERS never become draft text; it does NOT undo
+     * that keypress (an armed interrupt gesture, a dismissed popup).
+     */
+    let rescuedPrefix = null;
     const writeInput = (text) => {
         if (disposed || outputBatch?.refused)
             return;
@@ -417,6 +434,18 @@ export function createStdinFilter(real, features, bridge, onWarn) {
             rest = rest.slice(first + PASTE_BEGIN_MARK.length);
         }
     };
+    /**
+     * Hand a held tail to the ordinary text path, remembering it when it could
+     * still be the head of a paste marker.
+     *
+     * THE TAIL IS RELEASED EXACTLY AS BEFORE. Remembering it costs no latency: a
+     * real Esc keypress still reaches Ink after `PENDING_FLUSH_MS`, and the
+     * remembered head is only ever consulted for the NEXT chunk.
+     */
+    const flushTailAsText = (text) => {
+        rescuedPrefix = isPastePrefix(text) ? { text, at: Date.now() } : null;
+        handleOutsidePaste(text, false);
+    };
     const flushPending = () => {
         flushTimer = clearTimer(flushTimer);
         if (pending.length === 0 || disposed)
@@ -425,20 +454,54 @@ export function createStdinFilter(real, features, bridge, onWarn) {
         pending = '';
         // A tail that never completed is ordinary text; it goes through the same
         // scan so a burst already open keeps coalescing it.
-        handleOutsidePaste(text, false);
+        flushTailAsText(text);
+    };
+    /**
+     * One-shot rescue of a marker whose ESC was already flushed as text.
+     *
+     * Returns the string `feed` should scan -- the remembered head followed by
+     * this chunk -- when the chunk COMPLETES that head into a whole marker, and
+     * `null` otherwise. On `null` the chunk travels the normal path: the head has
+     * already been emitted, so re-feeding it would type its bytes twice, and
+     * holding the chunk instead would swallow characters the user really typed.
+     *
+     * STARTS WITH, NOT CONTAINS. A marker completed at the junction starts at
+     * index 0 of the joined text; one starting anywhere later lies wholly inside
+     * `chunk` (the head holds an ESC at index 0 and nothing else that could begin
+     * a marker), and `feed` finds that on its own. Only the junction case needs
+     * re-scanning, and it is the only case where prepending cannot duplicate a
+     * byte that Ink has already seen.
+     *
+     * ONE-SHOT BY CONSTRUCTION: the remembered head is cleared here on every call,
+     * whether or not the rescue fired, so at most one chunk is ever re-scanned
+     * against it and no stale head can outlive its `PASTE_MARKER_RESCAN_TTL_MS`.
+     */
+    const takeRescuedPrefix = (carried, chunk) => {
+        const rescue = rescuedPrefix;
+        rescuedPrefix = null;
+        if (rescue === null || carried.length > 0 || !features.paste)
+            return null;
+        if (Date.now() - rescue.at > PASTE_MARKER_RESCAN_TTL_MS)
+            return null;
+        const joined = rescue.text + chunk;
+        const completes = joined.startsWith(PASTE_BEGIN_MARK) || joined.startsWith(PASTE_END_MARK);
+        return completes ? joined : null;
     };
     const onData = (chunk) => {
         if (disposed || finished)
             return;
         flushTimer = clearTimer(flushTimer);
         const decoded = typeof chunk === 'string' ? chunk : chunk.toString('utf8');
+        // Stripped on BOTH paths, because a NUL in a payload must never be able to
+        // forge a `PASTE_OPEN` frame boundary.
+        const cleaned = decoded.replace(/\u0000/g, '');
         const carried = pending;
         pending = '';
         // A rejected paste must not leave earlier text or a later Enter executable.
         const batch = { chunks: [], refused: false };
         outputBatch = batch;
         try {
-            feed(carried + decoded.replace(/\u0000/g, ''));
+            feed(takeRescuedPrefix(carried, cleaned) ?? (carried + cleaned));
         }
         finally {
             outputBatch = null;
@@ -468,7 +531,7 @@ export function createStdinFilter(real, features, bridge, onWarn) {
             // input: past the ceiling the tail becomes ordinary text.
             const text = pending;
             pending = '';
-            handleOutsidePaste(text, false);
+            flushTailAsText(text);
             return;
         }
         flushTimer = arm(flushPending, PENDING_FLUSH_MS);

package/dist/ui/App.d.ts

@@ -10,6 +10,8 @@ import type { AgentController } from '../agent/controller.js';
 import type { ConfirmRequest } from '../tools/index.js';
 import { type Entry, type Overlay, type ToastLevel } from '../agent/reducer.js';
 import type { UpdateBridge } from '../update/types.js';
+import { type ScrollbackBridge } from './scrollback/use-scrollback-view.js';
+import type { ScrollMode } from '../config/schema.js';
 import type { MouseSource } from '../input/stdin-filter.js';
 import { type PasteBridge } from '../input/limits.js';
 import type { CheckpointResult } from '../session/checkpoint.js';
@@ -86,6 +88,14 @@ export interface AppProps {
      */
     pasteBridge?: PasteBridge;
     terminal?: TerminalBridge;
+    /**
+     * `'native'` prints settled conversation into the terminal's own scrollback and
+     * renders only a bounded live region (tui-native-terminal-scroll). DEFAULTS TO
+     * `'app'` so every existing render test and call site is untouched (I-S9).
+     */
+    scrollMode?: ScrollMode;
+    /** The writer / feed channel `cli.tsx` shares with the tree; required for `'native'`. */
+    scrollback?: ScrollbackBridge;
     /**
      * The transcript to seed the first frame with, from a resumed session
      * (tui-session-id-resume 3.12).
@@ -148,4 +158,4 @@ export interface TerminalBridge {
     writeForeign?: (text: string) => void;
     selection?: SelectionBridge;
 }
-export declare function App({ controller, version, initialOverlay, initialPrompt, confirmBridge, humanInputBridge, mouseSource, vtInputWarning, updateBridge, pasteBridge, terminal, initialEntries, session, sessionBridge, sessionNotice, }: AppProps): React.ReactElement;
+export declare function App({ controller, version, initialOverlay, initialPrompt, confirmBridge, humanInputBridge, mouseSource, vtInputWarning, updateBridge, pasteBridge, terminal, scrollMode, scrollback, initialEntries, session, sessionBridge, sessionNotice, }: AppProps): React.ReactElement;