@xingjisoft/neutrino 0.1.5 → 0.1.7

package/README.md

@@ -6,7 +6,7 @@ A CLI coding agent that lives in your terminal. Neutrino gives you an interactiv
 
 - **Interactive terminal UI** — logo screen, chat, model select, history, and settings screens.
 - **Full mouse support** — hover to highlight, click to select/open/position the cursor, wheel to scroll, right-click to go back (like OpenCode).
-- **Select & copy** — drag the mouse over any text (agent output, the input box, menus, …) to select it; releasing the button copies the selection to the clipboard (via OSC 52, with a native fallback).
+- **Select & copy** — drag the mouse over any text (agent output, the input box, menus, …) to select it; releasing the button copies the selection to the clipboard (via OSC 52, with a native fallback). Holding the drag against the top or bottom edge of the log scrolls it, so one selection can run for as long as the whole conversation.
 - **Paste-friendly input** — like OpenCode, a pasted block has its newlines turned into spaces so it stays one line, and only a manually typed `Enter` submits the message.
 - **Faithful log rendering** — text in the chat log keeps its indentation, blank lines and column alignment; when a long tool-output line wraps, continuation lines stay indented instead of snapping back to the left margin.
 - **Scrollable context log** — a vertical scrollbar is drawn on the right edge of the chat (and the agent-conversation viewer) whenever the conversation is taller than the view. Scroll with the wheel, `PgUp`/`PgDn` or `↑`/`↓`, or grab the scrollbar with the mouse and drag it like in a GUI.
@@ -15,6 +15,7 @@ A CLI coding agent that lives in your terminal. Neutrino gives you an interactiv
 - **Streaming responses** — token-by-token output with pause/resume (`ESC ESC`).
 - **Intensity control** — tune `temperature`/`top_p` from `Low` to `Ultra`.
 - **Session history** — messages are saved before a turn starts, streamed replies are checkpointed every second, and tool calls/results are saved immediately. The history screen lists conversations started in the current working directory. Failed saves are shown in the terminal and browser UI.
+- **Auto-folding turns** — once a turn finishes, the work behind the reply (the thinking and the tool calls) folds into one summary line in both the terminal and the browser, while the answer itself always stays on screen. Click the line to read the whole round again; a turn with little to hide, or a long answer on its own, stays open. A turn stopped with `ESC ESC` is paused, not finished, so it stays open. Nothing is dropped: the transcript, the saved session and the model's context keep every message.
 - **Complete conversation history** — context compression keeps every original message and tool result on disk. The earlier portion starts collapsed in the terminal and browser; click **Earlier conversation** to expand it, including in reopened history. Model requests use a separate summary plus recent messages.
 - **Token usage stats** — click the `ⓘ` in the chat header to see prompt/completion/total token counts for the current session.
 - **Agent history browser** — view past sessions from other CLI agents (Claude Code, Codex, OpenCode) directly from the history screen.
@@ -59,10 +60,12 @@ Type a message on the start screen and press `Enter` to begin a new chat.
 | `Ctrl+E` | Open model config |
 | `Ctrl+B` | Back to menu (from chat) |
 | `Ctrl+L` | Clear conversation (from chat) |
-| `Esc Esc` | Pause / resume streaming |
+| `Esc Esc` | Pause / resume streaming (a paused turn stays open: only a finished reply folds) |
 | `Esc` | Clear an active selection |
 | `PgUp` / `PgDn` | Scroll chat history |
-| `Ctrl+C` | Copy the selection, or quit if nothing is selected |
+| `Ctrl+C` | Do nothing while text is selected; otherwise pause the running conversation or show the exit hint at the top |
+| `Ctrl+C` × 3 | Quit after three consecutive presses, no more than 1.5 seconds apart (another key, paste, click or scroll resets the count) |
+| `Ctrl+Shift+C` | Quit immediately (requires the terminal to forward the shortcut) |
 | `Ctrl+A` | Toggle Request Approval / Auto Approval in a conversation |
 | `Y` | Approve the pending request (while the approval card is up) |
 | `N` / `Esc` | Deny the pending request |
@@ -75,7 +78,10 @@ Type a message on the start screen and press `Enter` to begin a new chat.
 | Hover over an item | Highlight / select it in lists and menus |
 | Click an item | Select and confirm (open a screen, load a session, apply a setting…) |
 | Click the input box | Focus it and place the cursor at the clicked position |
+| Click a folded turn | Expand the complete round, or fold it again |
+| Click `⚙ tool` | Expand or collapse a tool call's output |
 | Click and drag | Select text under the rectangle; releasing copies it to the clipboard |
+| Drag onto the first/last row of the log | Scroll the log a line at a time (faster the longer you hold it) and keep growing the selection past the screen |
 | Click the header (left of `ⓘ`) | Open the model selector |
 | Click `ⓘ` (chat header) | Toggle token usage stats |
 | Drag the scrollbar | Grab the thumb on the right edge of the chat/log and drag it to scroll |
@@ -84,6 +90,12 @@ Type a message on the start screen and press `Enter` to begin a new chat.
 
 The selection highlight is drawn over whatever is on screen, so it works uniformly on the chat log, the input box and every menu. Selected text is copied with trailing whitespace trimmed per line (shell-style), so it can be pasted straight back into a terminal. UI chrome (such as the scrollbar) is skipped when copying and highlighting, so a copy never picks up the bar or the padding in front of it.
 
+A drag that scrolls keeps its starting point anchored to the line it began on,
+not to the row it began on: the mark stays on the edge that is scrolling, the
+highlight stops at the log's edge instead of spilling into the header or the
+input box, and the copy includes the lines that scrolled out of view. Scroll back
+and the selection shrinks again; press `Esc` to drop it.
+
 ## Configuration
 
 Settings are stored under `~/.neutrino/`:
@@ -200,7 +212,9 @@ Only sessions that were started in the current working directory are listed, so
 
 Neutrino can mount a small website on a port of your choice. It groups every
 saved conversation by working directory (showing the five newest per path with
-the rest collapsed), streams a running conversation live, and lets you pause or
+the rest collapsed), folds the work of every finished turn into one summary line
+that opens on a click while the reply stays on screen, streams a running
+conversation live, and lets you pause or
 resume it and send new messages from the browser.
 
 A saved transcript opens read-only, because nothing is running for it. Press
@@ -309,6 +323,7 @@ node scripts/test-paste.mjs      # verify pasted newlines are flattened to space
 node scripts/test-mouse.mjs      # verify mouse escape-sequence parsing
 node scripts/test-cursor.mjs     # verify click-to-position-cursor math
 node scripts/test-selection.mjs  # verify selection highlighting & text extraction
+node scripts/test-drag-scroll.mjs # verify drag-select auto-scroll: edge scrolling, cross-screen copy
 node scripts/test-copy.mjs       # verify a copy never includes the scrollbar or trailing padding
 node scripts/test-scrollbar.mjs  # verify the conversation scrollbar size/position and drag maths
 node scripts/test-markdown.mjs   # verify markdown/table rendering (incl. ragged rows)
@@ -321,6 +336,7 @@ node scripts/test-fetch.mjs      # verify streamed requests release aborts and r
 node scripts/test-compact.mjs    # verify context-compression planning
 node scripts/test-history-fold.mjs # verify full-history retention, folding and resume
 node scripts/test-web-history.mjs  # verify browser history disclosures and streaming state
+node scripts/test-turn-fold.mjs    # verify folded turns keep their reply and every message
 node scripts/test-tools.mjs      # verify tool-output folding
 node scripts/test-web.mjs        # verify the web server, API, SSE stream and path-traversal guards
 node scripts/test-web-settings.mjs # verify model switching, persistence, browser controls and defaults

package/dist/app.js

@@ -6,7 +6,7 @@ import { installCrashGuard, writeCrashLog } from "./terminal/restore.js";
 import { defaultState } from "./state.js";
 import { loadConfig, saveConfig } from "./config.js";
 import { C } from "./colors.js";
-import { applySelection, selectionText } from "./selection.js";
+import { applySelection, orderLinePoints, rowCells, rowSelectionText, selectionText, } from "./selection.js";
 import { offsetFromThumbTop, scrollbarGeometry } from "./ui.js";
 import { copyToClipboard } from "./clipboard.js";
 import { ChatScreen } from "./screens/chat.js";
@@ -18,10 +18,19 @@ import { StartScreen } from "./screens/start.js";
 import { startWebServer } from "./web/server.js";
 const CURSOR_BLINK_MS = 530;
 const TOAST_MS = 1600;
+const INTERRUPT_WINDOW_MS = 1500;
+const SELECTION_FRAME_MS = 16;
+const EXIT_HINT = "press ctrl+shift+c or press ctrl+c 3 times to exit";
 // How often the whole frame is re-emitted as a safety net, so terminal-side
 // drift (ConPTY reflow, stray scroll) can never leave any row stale for long.
 // Re-emitting the cached frame is a no-op when nothing drifted.
 const REPAINT_MS = 2000;
+// Auto-scrolling while drag-selecting: parked on the first/last row of the log,
+// the pointer scrolls it one line per tick, a few lines per tick once it has
+// been held for a while.
+const DRAG_SCROLL_MS = 60;
+const DRAG_SCROLL_RAMP = 8;
+const DRAG_SCROLL_MAX_ROWS = 3;
 export class App {
     state = defaultState();
     width;
@@ -36,12 +45,18 @@ export class App {
     toastTimer = null;
     repaintTimer = null;
     toast = "";
+    toastPosition = "bottom";
+    interruptCount = 0;
+    lastInterruptTime = 0;
     // Consecutive failed renders. A screen that cannot draw itself is fatal;
     // a single bad frame is not.
     renderFailures = 0;
     // Most recently rendered frame. Kept so a selection can be turned back into
     // text without having to re-run the screen's render.
     lastBuffer = null;
+    // Cache the screen without selection so dragging never reflows the history.
+    contentBuffer = null;
+    selectionTimer = null;
     // Mouse selection bookkeeping. `pressed` is true between a left-button press
     // and its release; `pressStart` is where the press landed, used as the anchor
     // once the pointer starts moving (i.e. once it becomes a drag). A plain click
@@ -51,6 +66,28 @@ export class App {
     // Active scrollbar drag: how many rows below the thumb's top the press
     // landed, so the thumb stays under the pointer as it moves.
     barDrag = null;
+    // Auto-scroll during a drag-select. `dragScrollDir` is where the pointer is
+    // parked (-1 top edge, 1 bottom edge, 0 neither) and `dragScrollTicks` counts
+    // how long it has been there, which speeds the scroll up.
+    dragScrollTimer = null;
+    dragScrollDir = 0;
+    dragScrollTicks = 0;
+    // Latest pointer position, so a scroll tick can keep the mark pinned to the
+    // edge the pointer is parked on.
+    pointer = { x: 0, y: 0 };
+    // True once a drag has scrolled the log. The anchor is then in *content*
+    // coordinates: it points at the line the drag started on, which may well be
+    // off screen by now.
+    dragScrolled = false;
+    // True when the drag started inside the scrollable log, i.e. when its anchor
+    // is log content that is allowed to scroll away.
+    anchorInLog = false;
+    // Rows covered by the current drag, keyed by content line, so text that
+    // scrolled out of the viewport still ends up in the copy.
+    selRows = new Map();
+    // Scroll offset the anchor was last reconciled with, so a log that moves on
+    // its own (streamed output, a resize) can still carry the anchor along.
+    selOffset = null;
     resizeHandler = () => this.onResize();
     webHandle = null;
     constructor() {
@@ -100,7 +137,7 @@ export class App {
         this.renderer.init();
         this.input.start((ev) => this.handleEvent(ev));
         process.stdout.on("resize", this.resizeHandler);
-        process.on("SIGINT", () => this.quit());
+        process.on("SIGINT", () => this.handleInterrupt());
         process.on("SIGTERM", () => this.quit());
         this.sizeTimer = setInterval(() => {
             if (this.syncSize())
@@ -131,9 +168,19 @@ export class App {
         screen?.onDeactivate();
         this.render();
     }
-    render() {
+    render(selectionOnly = false) {
+        if (this.selectionTimer) {
+            clearTimeout(this.selectionTimer);
+            this.selectionTimer = null;
+        }
         try {
-            this.renderFrame();
+            if (selectionOnly && this.contentBuffer
+                && this.contentBuffer.width === this.width && this.contentBuffer.height === this.height) {
+                this.renderBuffer(this.contentBuffer);
+            }
+            else {
+                this.renderFrame();
+            }
             this.renderFailures = 0;
         }
         catch (err) {
@@ -175,19 +222,240 @@ export class App {
         this.updateCursorBlink();
         const buf = new Buffer(this.width, this.height);
         this.top?.render(buf);
-        this.lastBuffer = buf;
+        this.contentBuffer = buf;
+        this.renderBuffer(buf, this.top?.alwaysRepaintRows() ?? []);
+    }
+    renderBuffer(content, forceRows = []) {
+        // Snapshot the rows a drag has covered *before* painting: once a scroll
+        // pushes them off screen this is the only copy of their text left.
+        this.captureSelectionRows(content);
         // The selection overlay is painted over the finished frame, so it works on
         // every screen (chat log, input box, menus, …) without each having to know
         // about selection at all.
-        if (this.state.selection)
-            applySelection(buf, this.state.selection);
+        let buf = content;
+        if (this.state.selection) {
+            buf = new Buffer(content.width, content.height);
+            buf.cells = content.cells.map((row) => row.map((cell) => ({ ...cell })));
+            applySelection(buf, this.displaySelection(this.state.selection, content.width));
+        }
         this.drawToast(buf);
-        this.renderer.render(buf, this.top?.alwaysRepaintRows() ?? []);
+        this.lastBuffer = buf;
+        this.renderer.render(buf, forceRows);
+    }
+    /**
+     * The selection as it should be *painted*.
+     *
+     * An end that scrolled out of the log is drawn from the log's own edge: the
+     * rows it points at are off screen, and highlighting the header or the input
+     * box instead would claim those were selected.
+     */
+    displaySelection(sel, width) {
+        const bar = this.top?.scrollbar();
+        if (!bar || !this.anchorInLog)
+            return sel;
+        if (sel.anchor.y < bar.top)
+            return { anchor: { x: 0, y: bar.top }, cursor: sel.cursor };
+        if (sel.anchor.y > bar.bottom) {
+            return { anchor: { x: width - 1, y: bar.bottom }, cursor: sel.cursor };
+        }
+        return sel;
+    }
+    /**
+     * Remember the log rows the current drag covers.
+     *
+     * Runs on every frame, because a row can only be captured while it is still
+     * on screen — after the scroll carries it away, its text is gone.
+     */
+    captureSelectionRows(content) {
+        const sel = this.state.selection;
+        if (!sel || !this.pressed)
+            return;
+        const bar = this.top?.scrollbar();
+        if (!bar)
+            return;
+        // Anything else that moved the log — a streamed reply following the bottom,
+        // a resize — has to carry the anchor with it. Without this the anchor keeps
+        // its screen row while different text scrolls under it, and the copy
+        // silently covers the wrong lines.
+        if (this.selOffset === null) {
+            this.selOffset = bar.offset;
+        }
+        else if (bar.offset !== this.selOffset) {
+            const drift = bar.offset - this.selOffset;
+            this.selOffset = bar.offset;
+            if (this.anchorInLog) {
+                this.state.selection = {
+                    anchor: { x: sel.anchor.x, y: sel.anchor.y - drift },
+                    cursor: sel.cursor,
+                };
+            }
+        }
+        const ends = this.lineSelection(bar);
+        if (!ends)
+            return;
+        for (let y = bar.top; y <= bar.bottom && y < content.height; y++) {
+            const line = bar.offset + (y - bar.top);
+            if (line < ends.start.line || line > ends.end.line)
+                continue;
+            this.selRows.set(line, rowCells(content, y));
+        }
+    }
+    /**
+     * The current selection expressed in content lines instead of screen rows.
+     *
+     * Rows under the pointer map straight through the log's scroll offset, and
+     * rows outside the log get keys of their own (negative above it, past `total`
+     * below it) so a drag that starts on the header or runs into the input box
+     * still copies what is actually drawn there. The anchor is the exception: once
+     * it belongs to the log it follows its text out of the viewport, which is what
+     * lets a selection outlive the frame it started in.
+     */
+    lineSelection(bar) {
+        const sel = this.state.selection;
+        if (!sel)
+            return null;
+        const screenLine = (y) => {
+            if (y < bar.top)
+                return y - bar.top;
+            if (y > bar.bottom)
+                return bar.total + (y - bar.bottom) - 1;
+            return bar.offset + (y - bar.top);
+        };
+        const anchorLine = this.anchorInLog
+            ? bar.offset + (sel.anchor.y - bar.top)
+            : screenLine(sel.anchor.y);
+        return orderLinePoints({ line: anchorLine, x: sel.anchor.x }, { line: screenLine(sel.cursor.y), x: sel.cursor.x });
+    }
+    /**
+     * Text covered by the current selection, including the rows a drag scrolled
+     * out of the viewport.
+     */
+    selectionToText() {
+        const buf = this.lastBuffer;
+        const sel = this.state.selection;
+        if (!buf || !sel)
+            return "";
+        const bar = this.top?.scrollbar();
+        const ends = bar ? this.lineSelection(bar) : null;
+        // Nothing can scroll, so the frame holds the whole selection.
+        if (!bar || !ends)
+            return selectionText(buf, sel);
+        const getRow = (line) => {
+            // Rows above/below the log are drawn at a fixed screen row.
+            if (line < 0) {
+                const y = line + bar.top;
+                return y >= 0 && y < buf.height ? rowCells(buf, y) : null;
+            }
+            if (line >= bar.total) {
+                const y = bar.bottom + (line - bar.total) + 1;
+                return y >= 0 && y < buf.height ? rowCells(buf, y) : null;
+            }
+            // A log line: read the frame while it is on screen and the drag's snapshot
+            // once it has scrolled away.
+            const y = bar.top + (line - bar.offset);
+            if (y >= bar.top && y <= bar.bottom && y < buf.height)
+                return rowCells(buf, y);
+            return this.selRows.get(line) ?? null;
+        };
+        return rowSelectionText(getRow, ends.start, ends.end);
+    }
+    /** Where the mark sits, clamped into the log while a drag is scrolling it. */
+    cursorAt(x, y) {
+        const bar = this.top?.scrollbar();
+        if (!bar || !this.dragScrolled)
+            return { x, y };
+        return { x, y: Math.max(bar.top, Math.min(y, bar.bottom)) };
+    }
+    /**
+     * Start or stop the auto-scroll that runs while a drag sits on an edge of the
+     * log. Only a real drag scrolls: a press that never moved selects nothing, so
+     * clicking on the last row stays a plain click.
+     */
+    updateDragScroll() {
+        const bar = this.top?.scrollbar();
+        const dir = !bar || !this.state.selection
+            ? 0
+            : this.pointer.y <= bar.top
+                ? -1
+                : this.pointer.y >= bar.bottom
+                    ? 1
+                    : 0;
+        if (dir === this.dragScrollDir)
+            return;
+        this.stopDragScroll();
+        if (dir === 0)
+            return;
+        this.dragScrollDir = dir;
+        this.dragScrollTicks = 0;
+        // Reveal the first line at once: waiting a whole tick for it would make the
+        // edge feel dead. The tick schedules the ones that follow.
+        this.dragScrollTick();
+    }
+    /**
+     * One auto-scroll step: move the log a line (a few lines, the longer the
+     * pointer is held there) and grow the selection with it.
+     */
+    dragScrollTick() {
+        const sel = this.state.selection;
+        const bar = this.top?.scrollbar();
+        if (!this.pressed || !sel || !bar || this.dragScrollDir === 0) {
+            this.stopDragScroll();
+            return;
+        }
+        const maxOffset = Math.max(0, bar.total - bar.viewport);
+        const rows = Math.min(DRAG_SCROLL_MAX_ROWS, 1 + Math.floor(this.dragScrollTicks / DRAG_SCROLL_RAMP));
+        const target = Math.max(0, Math.min(bar.offset + this.dragScrollDir * rows, maxOffset));
+        const delta = target - bar.offset;
+        if (delta === 0) {
+            // The end of the log: nothing left to reveal in that direction.
+            this.stopDragScroll();
+            return;
+        }
+        this.dragScrollTicks++;
+        this.dragScrolled = true;
+        // The content moved by `delta` rows, so the anchor moves with it to stay on
+        // the line the drag started from. The mark stays under the pointer — that
+        // difference is what makes the selection grow instead of sliding along.
+        const anchor = this.anchorInLog ? { x: sel.anchor.x, y: sel.anchor.y - delta } : sel.anchor;
+        this.state.selection = { anchor, cursor: this.cursorAt(this.pointer.x, this.pointer.y) };
+        // This scroll is already accounted for; the frame that follows must not
+        // treat it as drift and move the anchor a second time.
+        this.selOffset = target;
+        // scrollTo re-renders, so the new offset, the highlight and the snapshot of
+        // the rows leaving the screen all land in a single paint.
+        bar.scrollTo(target);
+        // The next step is scheduled only now that this frame is drawn: laying out a
+        // very long log can take longer than one tick, and a fixed interval would
+        // queue ticks faster than they can be served.
+        if (this.dragScrollTimer)
+            clearTimeout(this.dragScrollTimer);
+        this.dragScrollTimer = setTimeout(() => this.dragScrollTick(), DRAG_SCROLL_MS);
+    }
+    stopDragScroll() {
+        if (this.dragScrollTimer) {
+            clearTimeout(this.dragScrollTimer);
+            this.dragScrollTimer = null;
+        }
+        this.dragScrollDir = 0;
+        this.dragScrollTicks = 0;
+    }
+    /** Drop everything remembered about a drag; a new gesture starts clean. */
+    resetDragTracking() {
+        this.stopDragScroll();
+        this.dragScrolled = false;
+        this.anchorInLog = false;
+        this.selOffset = null;
+        this.selRows.clear();
+    }
+    scheduleSelectionRender() {
+        if (!this.selectionTimer) {
+            this.selectionTimer = setTimeout(() => this.render(true), SELECTION_FRAME_MS);
+        }
     }
     drawToast(buf) {
         if (!this.toast)
             return;
-        const y = buf.height - 1;
+        const y = this.toastPosition === "top" ? 0 : buf.height - 1;
         buf.fillRect(0, y, buf.width, 1, { bg: C.black });
         buf.centerText(y, ` ${this.toast} `, { fg: C.black, bg: C.accent, bold: true });
     }
@@ -220,6 +488,10 @@ export class App {
         }
     }
     dispatchEvent(ev) {
+        const interrupt = ev.type === "key" && ev.key.ctrl && ev.key.name === "c";
+        if (!interrupt && (ev.type !== "mouse" || ev.event.type === "click" || ev.event.type === "wheel")) {
+            this.interruptCount = 0;
+        }
         if (ev.type === "paste") {
             // Pasted text arrives with its newlines already flattened to spaces, so
             // it is inserted into the input instead of being submitted.
@@ -230,6 +502,11 @@ export class App {
         }
         if (ev.type === "key") {
             const k = ev.key;
+            // Leave an active drag/selection untouched by the terminal copy shortcut.
+            if (k.ctrl && k.name === "c" && !k.shift && this.state.selection) {
+                this.interruptCount = 0;
+                return;
+            }
             // Any keystroke ends a pending mouse gesture (in case a release was lost).
             this.resetMouse();
             if (k.ctrl && k.name === "q") {
@@ -237,13 +514,10 @@ export class App {
                 return;
             }
             if (k.ctrl && k.name === "c") {
-                // Ctrl+C copies the selection when there is one, otherwise it quits —
-                // the usual terminal convention.
-                if (this.state.selection) {
-                    this.copySelection();
-                    return;
-                }
-                this.quit();
+                if (k.shift)
+                    this.quit();
+                else
+                    this.handleInterrupt();
                 return;
             }
             if (k.name === "escape" && this.state.selection) {
@@ -265,6 +539,9 @@ export class App {
     handleMouse(ev) {
         if (ev.type === "click") {
             this.wakeCursor();
+            // A new gesture starts clean: no auto-scroll left over from the previous
+            // drag, and no rows remembered from it.
+            this.resetDragTracking();
             // A left-press on the scrollbar starts a thumb drag rather than a text
             // selection or a click on the screen behind it.
             if (ev.button === 0) {
@@ -289,6 +566,13 @@ export class App {
             }
             this.pressed = true;
             this.pressStart = { x: ev.x, y: ev.y };
+            this.pointer = { x: ev.x, y: ev.y };
+            // A press inside the log starts a selection whose top is log content, so
+            // it may scroll away with the text (see dragScrollTick). Its offset is the
+            // baseline the anchor is reconciled against on every later frame.
+            const bar = this.top?.scrollbar();
+            this.anchorInLog = !!bar && ev.y >= bar.top && ev.y <= bar.bottom;
+            this.selOffset = bar ? bar.offset : null;
             if (this.state.selection) {
                 this.state.selection = null;
                 this.render();
@@ -299,6 +583,7 @@ export class App {
             return;
         }
         if (ev.type === "move") {
+            this.pointer = { x: ev.x, y: ev.y };
             // A release can be lost (the pointer left the window, the terminal did
             // not report button-up, …). Motion with no button held means the gesture
             // is over, so drop any stale press/drag instead of letting a bare hover
@@ -307,6 +592,7 @@ export class App {
                 this.pressed = false;
                 this.pressStart = null;
                 this.barDrag = null;
+                this.resetDragTracking();
             }
             if (this.barDrag) {
                 const bar = this.top?.scrollbar();
@@ -319,28 +605,50 @@ export class App {
             }
             if (this.pressed && this.pressStart) {
                 const s = this.pressStart;
-                if (ev.x !== s.x || ev.y !== s.y) {
+                const sel = this.state.selection;
+                // A drag that already scrolled the log keeps the anchor it has: it has
+                // moved into content coordinates and no longer equals the press cell.
+                const anchor = this.dragScrolled && sel ? sel.anchor : s;
+                const cursor = this.cursorAt(ev.x, ev.y);
+                if ((cursor.x !== anchor.x || cursor.y !== anchor.y || sel)
+                    && (!sel || cursor.x !== sel.cursor.x || cursor.y !== sel.cursor.y)) {
                     // The pointer left the press cell, so this is a drag: grow/shrink the
                     // selection instead of forwarding a hover to the screen.
-                    this.state.selection = { anchor: s, cursor: { x: ev.x, y: ev.y } };
-                    this.render();
+                    this.state.selection = { anchor, cursor };
+                    this.scheduleSelectionRender();
                 }
+                // Sitting on the first/last row of the log scrolls it, so a selection
+                // can run past the visible screen.
+                this.updateDragScroll();
                 return;
             }
             this.top?.onMouse(ev);
             return;
         }
         if (ev.type === "release") {
+            this.pointer = { x: ev.x, y: ev.y };
+            this.stopDragScroll();
+            // A release can arrive before the queued frame (or the final move).
+            if (this.pressed && this.pressStart && this.state.selection) {
+                // The anchor goes back to the press cell — unless the drag scrolled the
+                // log, in which case it belongs to the line it was dropped on and has
+                // drifted away from that cell on purpose.
+                const anchor = this.dragScrolled ? this.state.selection.anchor : this.pressStart;
+                this.state.selection = { anchor, cursor: this.cursorAt(ev.x, ev.y) };
+            }
+            if (this.selectionTimer)
+                this.render(true);
             const sel = this.state.selection;
             this.pressed = false;
             this.pressStart = null;
             this.barDrag = null;
             if (sel) {
                 if (this.lastBuffer) {
-                    const text = selectionText(this.lastBuffer, sel);
+                    const text = this.selectionToText();
                     if (text.trim().length > 0) {
                         copyToClipboard(text);
                         this.showToast(`Copied ${text.length} char${text.length === 1 ? "" : "s"}`);
+                        this.selRows.clear();
                         return;
                     }
                 }
@@ -349,6 +657,7 @@ export class App {
             return;
         }
         if (ev.type === "wheel") {
+            this.resetDragTracking();
             if (this.state.selection)
                 this.state.selection = null;
             this.top?.onMouse(ev);
@@ -358,16 +667,29 @@ export class App {
         this.pressed = false;
         this.pressStart = null;
         this.barDrag = null;
+        this.resetDragTracking();
     }
-    copySelection() {
-        const sel = this.state.selection;
-        if (!sel || !this.lastBuffer)
+    handleInterrupt() {
+        if (this.state.selection) {
+            this.interruptCount = 0;
+            return;
+        }
+        const now = Date.now();
+        this.interruptCount = now - this.lastInterruptTime <= INTERRUPT_WINDOW_MS
+            ? this.interruptCount + 1 : 1;
+        this.lastInterruptTime = now;
+        if (this.interruptCount >= 3) {
+            this.quit();
             return;
-        const text = selectionText(this.lastBuffer, sel);
-        if (text.trim().length === 0)
+        }
+        // A model/settings overlay can sit above the current conversation.
+        const chat = [...this.screens].reverse().find((screen) => screen instanceof ChatScreen);
+        const meta = chat instanceof ChatScreen ? chat.liveMeta() : null;
+        if (chat instanceof ChatScreen && meta?.busy && !meta.paused) {
+            chat.livePause();
             return;
-        copyToClipboard(text);
-        this.showToast(`Copied ${text.length} char${text.length === 1 ? "" : "s"}`);
+        }
+        this.showToast(EXIT_HINT, "top");
     }
     // Public so screens can surface transient status (e.g. "reviewing 3/3").
     /**
@@ -387,8 +709,9 @@ export class App {
         }
         this.renderer.bell(kind === "approval" ? 2 : 1);
     }
-    showToast(text) {
+    showToast(text, position = "bottom") {
         this.toast = text;
+        this.toastPosition = position;
         if (this.toastTimer)
             clearTimeout(this.toastTimer);
         this.toastTimer = setTimeout(() => {
@@ -479,6 +802,13 @@ export class App {
             clearTimeout(this.toastTimer);
             this.toastTimer = null;
         }
+        if (this.selectionTimer) {
+            clearTimeout(this.selectionTimer);
+            this.selectionTimer = null;
+        }
+        // An auto-scroll timer outliving the app would keep firing into a disposed
+        // renderer.
+        this.stopDragScroll();
         // Disable mouse reporting before input returns to cooked/echo mode.
         this.renderer.dispose();
         try {