@aragon-agent/cli 0.6.10 → 0.6.12

package/dist/ui/enter-frames.d.ts

@@ -1,37 +1,21 @@
-/**
- * Reading Enter frames back out of an Ink `input` string
- * (tui-shift-enter-copy-queue 3.5) -- pure.
- *
- * The stdin filter rewrites a modified Enter into `ENTER_NEWLINE_FRAME` inline,
- * in stream order, exactly the way it frames a paste. This module is the only
- * place that takes those frames apart again, and it handles BOTH newline
- * sources the composer can see in one `input` string:
- *
- *  - `ENTER_NEWLINE_FRAME` -- Shift+Enter / Alt+Enter / CSI-u Enter, translated
- *    by the filter; and
- *  - a bare `\n` -- Ctrl+J, which Ink parses to `name: 'enter'` with
- *    `input === '\n'` and NO `key.return`, so it reaches this branch as an
- *    ordinary (control) character that must still mean "newline".
- *
- * I-12, THE BROADCAST OBLIGATION, APPLIES TO THESE FRAMES TOO. `useInput`
- * re-emits every chunk to every mounted handler, `stripPasteFrames` does not
- * know this frame, and a NUL appended into `SettingsScreen`'s API-key field
- * renders as nothing and silently breaks authentication -- the exact accident
- * class that function's own doc records. `stripEnterFrames` is the equivalent
- * guard for overlays with no paste model of their own.
- */
-import { type FrameSegment } from './paste-frames.js';
+export type ComposerFrame = {
+    kind: 'text';
+    text: string;
+} | {
+    kind: 'paste';
+    text: string;
+} | {
+    kind: 'newline';
+} | {
+    kind: 'submit';
+};
 /** True when this `input` carries at least one Enter frame -- the branch guard. */
 export declare function hasEnterFrame(input: string): boolean;
 /**
- * Split an `input` string into ordered text runs and newline runs.
- *
- * Text-only by construction (paste frames are `mergeWithPasteRuns`'s job), so
- * the paste id never has to exist here -- `PromptInput` allocates ids for paste
- * segments while building the reducer's action, exactly as the paste branch
- * does (P1-5: the reducer stays pure and this stays a function of its input).
+ * Decode paste regions before interpreting CR/LF or newline frames as keys.
+ * Paste IDs remain the caller's responsibility.
  */
-export declare function splitEnterFrames(input: string): FrameSegment[];
+export declare function splitEnterFrames(input: string): ComposerFrame[];
 /**
  * Merge newline runs with the paste frames that share the same `input`.
  *
@@ -48,7 +32,7 @@ export declare function splitEnterFrames(input: string): FrameSegment[];
  * Paste segments carry NO id here (P1-5); the caller assigns one per segment
  * only when it builds the reducer's action.
  */
-export declare function mergeWithPasteRuns(input: string, runs: FrameSegment[]): FrameSegment[];
+export declare function mergeWithPasteRuns(input: string, runs: ComposerFrame[]): ComposerFrame[];
 /**
  * Remove every Enter frame for a consumer that has no newline model of its
  * own, replacing each frame with `'\n'` (tui-shift-enter-copy-queue 3.5, the

package/dist/ui/enter-frames.js

@@ -1,25 +1,3 @@
-/**
- * Reading Enter frames back out of an Ink `input` string
- * (tui-shift-enter-copy-queue 3.5) -- pure.
- *
- * The stdin filter rewrites a modified Enter into `ENTER_NEWLINE_FRAME` inline,
- * in stream order, exactly the way it frames a paste. This module is the only
- * place that takes those frames apart again, and it handles BOTH newline
- * sources the composer can see in one `input` string:
- *
- *  - `ENTER_NEWLINE_FRAME` -- Shift+Enter / Alt+Enter / CSI-u Enter, translated
- *    by the filter; and
- *  - a bare `\n` -- Ctrl+J, which Ink parses to `name: 'enter'` with
- *    `input === '\n'` and NO `key.return`, so it reaches this branch as an
- *    ordinary (control) character that must still mean "newline".
- *
- * I-12, THE BROADCAST OBLIGATION, APPLIES TO THESE FRAMES TOO. `useInput`
- * re-emits every chunk to every mounted handler, `stripPasteFrames` does not
- * know this frame, and a NUL appended into `SettingsScreen`'s API-key field
- * renders as nothing and silently breaks authentication -- the exact accident
- * class that function's own doc records. `stripEnterFrames` is the equivalent
- * guard for overlays with no paste model of their own.
- */
 import { ENTER_NEWLINE_FRAME, PASTE_CLOSE, PASTE_OPEN } from '../input/limits.js';
 import { sanitisePaste } from '../input/paste-parse.js';
 import { sanitiseTyped } from './paste-frames.js';
@@ -28,10 +6,10 @@ export function hasEnterFrame(input) {
     return input.includes(ENTER_NEWLINE_FRAME);
 }
 /**
- * Split one Enter-frame-free span into ordered text / newline segments.
+ * Split one paste-free span into ordered text, newline and submit intents.
  *
  * Every newline source -- frame or bare `\n` -- yields ONE
- * `{ kind: 'text', text: '\n' }` segment, so the editor's existing `input`
+ * `{ kind: 'newline' }` segment, so the editor's existing `input`
  * action inserts it through the same path typing uses and the draft's row
  * budget applies unchanged. Non-newline text is accumulated and passed through
  * `sanitiseTyped` (I-14): a chunk that carries a frame can also carry the
@@ -51,13 +29,19 @@ function splitEnterSpan(span) {
     while (i < span.length) {
         if (span.startsWith(ENTER_NEWLINE_FRAME, i)) {
             pushText();
-            segments.push({ kind: 'text', text: '\n' });
+            segments.push({ kind: 'newline' });
             i += ENTER_NEWLINE_FRAME.length;
             continue;
         }
+        if (span[i] === '\r') {
+            pushText();
+            segments.push({ kind: 'submit' });
+            i += 1;
+            continue;
+        }
         if (span[i] === '\n') {
             pushText();
-            segments.push({ kind: 'text', text: '\n' });
+            segments.push({ kind: 'newline' });
             i += 1;
             continue;
         }
@@ -68,15 +52,12 @@ function splitEnterSpan(span) {
     return segments;
 }
 /**
- * Split an `input` string into ordered text runs and newline runs.
- *
- * Text-only by construction (paste frames are `mergeWithPasteRuns`'s job), so
- * the paste id never has to exist here -- `PromptInput` allocates ids for paste
- * segments while building the reducer's action, exactly as the paste branch
- * does (P1-5: the reducer stays pure and this stays a function of its input).
+ * Decode paste regions before interpreting CR/LF or newline frames as keys.
+ * Paste IDs remain the caller's responsibility.
  */
 export function splitEnterFrames(input) {
-    return splitEnterSpan(input);
+    return input.includes(PASTE_OPEN)
+        ? mergeWithPasteRuns(input, []) : splitEnterSpan(input);
 }
 /**
  * Merge newline runs with the paste frames that share the same `input`.

package/dist/ui/overlays/HelpOverlay.js

@@ -6,6 +6,7 @@ function keyRows(times) {
     return [
         ['Enter', 'Submit (idle) / queue steering (running); re-pins to the newest output'],
         ['Alt+Enter / Shift+Enter', 'Insert newline'],
+        ['Ctrl+J', 'Newline fallback; /terminal-setup explains Shift+Enter binding'],
         ['Esc', 'Close menu / overlay'],
         ['Esc twice', 'Interrupt run (within 1.5s)'],
         ['Esc again', 'Force-stop after requesting interruption'],
@@ -30,6 +31,12 @@ function keyRows(times) {
         ['Run status row', 'Spinner and queue / interrupt keys, above the input during a run'],
         ['Drag text (left button)', 'Select text on screen; the highlight waits'],
         ['Ctrl+C (with a selection)', 'Copy the pending selection - does not arm exit'],
+        ['Native terminal selection', 'Copy-on-select is controlled by your terminal settings'],
+        ['Queue', 'Waits for a message receipt, not turn start; paused means not running'],
+        ['P>B / B>P', 'A pending mode switch; P=plan, B=build'],
+        ['E2 / E!', 'Esc twice to interrupt / Esc again to force-stop'],
+        ['S+ / T+', 'Services / TODO present; /bg and /todo status show counts'],
+        ['Queue(p) / (+99+)', 'Paused queue / at least 100 additional messages'],
         ['Up / Down', 'Prompt history (empty input)'],
         // Pasting is the one affordance here with no key of its own, so the only
         // place a user can learn what happened to their 218 lines is this row.
@@ -58,6 +65,7 @@ const COMMANDS = [
     ['/resume [file]', 'Load a saved session'],
     ['/copy', 'Copy the last answer to the clipboard (OSC 52, so it works over ssh)'],
     ['/mouse [on|off]', 'Release the mouse to your terminal, or take it back'],
+    ['/terminal-setup', 'Show newline key bindings without changing terminal settings'],
     ['/exit', 'Exit'],
 ];
 const SKILL_ROWS = [

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

@@ -27,9 +27,10 @@
  *    same `decorate` call. What you see is what you get by construction, rather
  *    than by a staleness check that can be wrong.
  */
+import stripAnsi from 'strip-ansi';
 import { createScreenMirror } from './screen-mirror.js';
 import { paintRow, selectionOpen } from './highlight.js';
-import { isEmpty, normalize, rowSpan, selectedText, } from './selection.js';
+import { isEmpty, normalize, rowSpan, selectedText, sliceColumns, } from './selection.js';
 /**
  * Motion coalescing window. The same 16 ms and the same reasoning as
  * `use-wheel-routing.ts`: this one is in the direct path of a hand gesture, so
@@ -67,10 +68,28 @@ export function createSelectionController(options) {
     let disposed = false;
     /** Guards `decorate` against being re-entered from inside a repaint. */
     let painting = false;
+    let notifiedHold = false;
+    let holdNotificationPending = false;
+    const notifyHold = () => {
+        if (disposed || notifiedHold === holdActive)
+            return;
+        notifiedHold = holdActive;
+        for (const listener of [...holdListeners])
+            listener(holdActive);
+    };
     const emitHold = (hold) => {
         holdActive = hold;
-        for (const listener of [...holdListeners])
-            listener(hold);
+        if (!painting) {
+            notifyHold();
+            return;
+        }
+        if (holdNotificationPending)
+            return;
+        holdNotificationPending = true;
+        queueMicrotask(() => {
+            holdNotificationPending = false;
+            notifyHold();
+        });
     };
     const clearFlushTimer = () => {
         if (!flushTimer)
@@ -97,13 +116,7 @@ export function createSelectionController(options) {
             holdWatchdog = null;
             if (!dragging)
                 return;
-            // Let go of `hold` and the drag; KEEP whatever was selected. The user may
-            // still want to copy it, and throwing it away would turn a terminal quirk
-            // into lost work.
-            dragging = false;
-            pendingFocus = null;
-            clearFlushTimer();
-            emitHold(false);
+            clear();
         }, holdMaxMs);
         holdWatchdog.unref?.();
     };
@@ -122,7 +135,7 @@ export function createSelectionController(options) {
         if (!painted && wanted)
             options.requestRedraw();
     };
-    const clear = () => {
+    const clearState = () => {
         // 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.
@@ -139,7 +152,12 @@ export function createSelectionController(options) {
         // exit for two states, not one.
         if (holdActive)
             emitHold(false);
-        paint(false);
+    };
+    const clear = () => {
+        const hadSelection = sel !== null || holdActive;
+        clearState();
+        if (hadSelection)
+            paint(false);
     };
     const cellOf = (event) => {
         // SGR reports are 1-based, frame line `i` is terminal row `i + 1`. A report
@@ -200,8 +218,7 @@ export function createSelectionController(options) {
             // a selection — N1 already declines auto-scroll-while-dragging. The notch
             // then scrolls normally, because the wheel router is a separate subscriber
             // on the same channel.
-            if (dragging)
-                clear();
+            clear();
             return;
         }
         if (event.kind === 'press') {
@@ -213,6 +230,7 @@ export function createSelectionController(options) {
                 return;
             }
             const cell = cellOf(event);
+            settled = false;
             sel = { anchor: cell, focus: cell };
             pendingFocus = null;
             clearFlushTimer();
@@ -248,16 +266,35 @@ export function createSelectionController(options) {
         finishSelection();
     };
     const unsubscribe = options.source.subscribe(onMouse);
+    const selectedCellsChanged = (lines) => {
+        if (!settled || !sel)
+            return false;
+        const normal = normalize(sel);
+        for (let row = normal.start.row; row <= normal.end.row; row += 1) {
+            const span = rowSpan(normal, row);
+            if (!span)
+                continue;
+            const before = sliceColumns(stripAnsi(mirror.raw[row] ?? ''), span.from, span.to);
+            const after = sliceColumns(stripAnsi(lines[row] ?? ''), span.from, span.to);
+            if (before !== after)
+                return true;
+        }
+        return false;
+    };
     return {
         decorate(lines) {
-            mirror.set(lines);
-            if (painting || sel === null)
-                return lines;
-            const normal = normalize(sel);
-            if (isEmpty(normal))
+            if (painting || disposed)
                 return lines;
             painting = true;
             try {
+                if (selectedCellsChanged(lines))
+                    clearState();
+                mirror.set(lines);
+                if (sel === null)
+                    return lines;
+                const normal = normalize(sel);
+                if (isEmpty(normal))
+                    return lines;
                 const open = selectionOpen(options.theme(), options.caps);
                 const cols = Math.max(1, options.cols());
                 const out = lines.slice();
@@ -317,11 +354,11 @@ export function createSelectionController(options) {
         dispose() {
             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);
+            disposed = true;
             unsubscribe();
             clearFlushTimer();
             clearWatchdog();

package/dist/ui/transcript-text.js

@@ -73,6 +73,8 @@ function serviceTextGlyph(status, exitCode, glyphs) {
 }
 function renderEntry(entry, glyphs) {
     switch (entry.kind) {
+        case 'queued':
+            return block('Queued but never sent:', entry.text);
         case 'user':
             return block(glyphs.user, entry.text);
         case 'assistant': {
@@ -211,20 +213,26 @@ export function renderTranscriptText(entries, opts) {
         lines.push(`${g.ellipsis} ${dropped} earlier ${dropped === 1 ? 'entry' : 'entries'} dropped by ` +
             `transcriptRetain ${g.midDot} raise it or /save sooner`);
     }
-    if (entries.length > max && max > 1) {
-        const head = Math.ceil(max / 2);
-        const tail = max - head;
-        const omitted = entries.length - max;
-        for (const entry of entries.slice(0, head))
-            lines.push(...renderEntry(entry, g));
-        lines.push(`${g.ellipsis} ${omitted} entries omitted ${g.midDot} use /save before exiting`);
-        for (const entry of entries.slice(entries.length - tail)) {
+    const historyCount = entries.filter((entry) => entry.kind !== 'queued').length;
+    const omitted = max > 1 ? Math.max(0, historyCount - max) : 0;
+    const head = Math.ceil(max / 2);
+    const tailStart = historyCount - (max - head);
+    let historyIndex = 0;
+    let reported = false;
+    for (const entry of entries) {
+        if (entry.kind === 'queued') {
             lines.push(...renderEntry(entry, g));
+            continue;
         }
-    }
-    else {
-        for (const entry of entries)
-            lines.push(...renderEntry(entry, g));
+        const index = historyIndex++;
+        if (omitted > 0 && index >= head && index < tailStart) {
+            if (!reported) {
+                lines.push(`${g.ellipsis} ${omitted} entries omitted ${g.midDot} use /save before exiting`);
+                reported = true;
+            }
+            continue;
+        }
+        lines.push(...renderEntry(entry, g));
     }
     return `${lines.join('\n')}\n`;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aragon-agent/cli",
-  "version": "0.6.10",
+  "version": "0.6.12",
   "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.22",
+    "@aragon-agent/core": "^0.2.24",
     "chalk": "^5.6.2",
     "cli-highlight": "^2.0.0",
     "commander": "^12.1.0",