@aragon-agent/cli 0.6.9 → 0.6.10

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/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).

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

package/package.json

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