@xingjisoft/neutrino 0.1.5 → 0.1.7

package/dist/screens/chat.js

@@ -15,6 +15,16 @@ import { hub, liveApprovalDetails } from "../web/hub.js";
 import { SessionCheckpoint } from "../persistence.js";
 import { writeCrashLog } from "../terminal/restore.js";
 const TOOLS = getToolDefinitions();
+/**
+ * A finished turn folds its *work* away — the prompt body, the thinking and the
+ * tool calls — and never its final reply, which always stays on screen. Doing
+ * that is only worth a click when the work is substantial: four or more blocks,
+ * or roughly six wrapped lines of text. Short exchanges stay readable without a
+ * click. `web/turns.js` applies the same rule in the browser, so both UIs fold
+ * exactly the same turns.
+ */
+export const TURN_FOLD_MIN_BLOCKS = 4;
+export const TURN_FOLD_MIN_CHARS = 600;
 function parseArgs(s) {
     if (!s || !s.trim())
         return {};
@@ -80,6 +90,19 @@ export class ChatScreen extends Screen {
     toolLineIndex = [];
     /** Terminal row -> tool message index, rebuilt each render for hit-testing. */
     toolRows = new Map();
+    // ---- collapsible turns ----
+    /** First message index of every turn whose reply has finished. A transcript
+     *  loaded from disk starts finished: reopening history reviews past work. */
+    finishedTurns = new Set();
+    /** Turns the reader opened; a finished turn stays folded unless listed here. */
+    expandedTurns = new Set();
+    /** First message index of the turn being answered right now, if any. */
+    activeTurnStart = null;
+    /** For each built line, the folded turn it belongs to (-1 = none). Only the
+     *  header lines carry it, so clicks inside a tool block still target the tool. */
+    turnLineIndex = [];
+    /** Terminal row -> folded turn start, rebuilt each render for hit-testing. */
+    turnRows = new Map();
     // ---- web bridge ----
     liveKey = null;
     liveDir = process.cwd();
@@ -120,6 +143,9 @@ export class ChatScreen extends Screen {
         for (const m of this.loadedMessages ?? []) {
             this.messages.push(m);
         }
+        // Everything already on disk was answered, so history opens compact.
+        for (const start of this.userMessageIndexes())
+            this.finishedTurns.add(start);
         this.context = normalizeContext(this.loadedContext, this.messages.filter((m) => m.role !== "system").length);
         this.liveDir = this.loadedCwd ?? process.cwd();
         this.checkpoint.register();
@@ -429,6 +455,9 @@ export class ChatScreen extends Screen {
             const sysText = this.messages[0] && this.messages[0].role === "system" ? this.messages[0].content : "";
             this.messages = [{ role: "system", content: sysText }];
             this.expandedTools.clear();
+            this.finishedTurns.clear();
+            this.expandedTurns.clear();
+            this.activeTurnStart = null;
             this.streamingContent = null;
             this.scrollTop = 0;
             this.followBottom = true;
@@ -504,6 +533,11 @@ export class ChatScreen extends Screen {
                 this.app.render();
                 return;
             }
+            const turn = this.turnRows.get(ev.y);
+            if (turn !== undefined) {
+                this.toggleTurn(turn);
+                return;
+            }
             const tool = this.toolRows.get(ev.y);
             if (tool !== undefined) {
                 this.toggleTool(tool);
@@ -582,6 +616,14 @@ export class ChatScreen extends Screen {
         this.startTurn();
     }
     startTurn() {
+        // Sending closes every earlier turn, including one left unfinished by
+        // ESC ESC: it is folded from here on, but never while it is still paused.
+        const starts = this.userMessageIndexes();
+        const active = starts.length > 0 ? starts[starts.length - 1] : null;
+        for (const start of starts)
+            if (start !== active)
+                this.finishedTurns.add(start);
+        this.activeTurnStart = active;
         const turnMessages = this.messages.slice();
         const approvalContext = captureApprovalContext(turnMessages);
         this.busy = true;
@@ -687,7 +729,7 @@ export class ChatScreen extends Screen {
                         this.messages.push({ role: "assistant", content });
                     this.streamingContent = null;
                     this.app.render();
-                    this.onTurnFinished();
+                    this.onTurnFinished(false);
                     return;
                 }
                 const toolCalls = client.toolCalls;
@@ -769,7 +811,14 @@ export class ChatScreen extends Screen {
             this.onTurnFinished();
         }
     }
-    onTurnFinished() {
+    /**
+     * Ends the turn. `finished` is false when the turn was cut short (ESC ESC,
+     * Ctrl+C): a paused turn is not a completed one and stays open for reading.
+     */
+    onTurnFinished(finished = true) {
+        if (finished && this.activeTurnStart !== null)
+            this.finishedTurns.add(this.activeTurnStart);
+        this.activeTurnStart = null;
         this.busy = false;
         this.paused = false;
         this.app.state.isThinking = false;
@@ -900,6 +949,147 @@ export class ChatScreen extends Screen {
             deny: { x: denyX, y: by, w: deny.length },
         };
     }
+    // ---- turn folding ----------------------------------------------------
+    /** First message index of every turn: a turn starts at a user message and
+     *  ends where the next one begins. */
+    userMessageIndexes() {
+        const starts = [];
+        for (let i = 0; i < this.messages.length; i++) {
+            if (this.messages[i].role === "user")
+                starts.push(i);
+        }
+        return starts;
+    }
+    turnEnd(start) {
+        for (let i = start + 1; i < this.messages.length; i++) {
+            if (this.messages[i].role === "user")
+                return i;
+        }
+        return this.messages.length;
+    }
+    /**
+     * A finished turn is only worth folding when the work it hides is substantial.
+     * Whether it is folded right now is a separate question (`expandedTurns`), and
+     * its reply is never part of what it hides.
+     */
+    turnHides(start, end) {
+        if (!this.finishedTurns.has(start))
+            return false;
+        const answer = this.turnAnswer(start, end);
+        let blocks = 0;
+        let chars = 0;
+        for (let i = start; i < end; i++) {
+            // The reply stays on screen, so it is neither hidden content nor a reason
+            // to fold: a long answer alone must never collapse its own turn.
+            if (i === answer)
+                continue;
+            const m = this.messages[i];
+            if (m.role === "user" || m.role === "assistant") {
+                blocks++;
+                chars += m.content.length;
+            }
+        }
+        return blocks >= TURN_FOLD_MIN_BLOCKS || chars >= TURN_FOLD_MIN_CHARS;
+    }
+    /**
+     * The index of the turn's reply: its last assistant message. A fold hides the
+     * work that led to the answer, so this message is always rendered.
+     */
+    turnAnswer(start, end) {
+        for (let i = end - 1; i > start; i--) {
+            if (this.messages[i].role === "assistant")
+                return i;
+        }
+        return -1;
+    }
+    /** For every message, the reply of the turn it belongs to (-1 = none). */
+    turnAnswers() {
+        const answers = new Array(this.messages.length).fill(-1);
+        let start = -1;
+        let answer = -1;
+        const close = (end) => {
+            if (start < 0 || answer < 0)
+                return;
+            for (let i = start; i < end; i++)
+                answers[i] = answer;
+        };
+        for (let i = 0; i < this.messages.length; i++) {
+            const role = this.messages[i].role;
+            if (role === "user") {
+                close(i);
+                start = i;
+                answer = -1;
+            }
+            else if (role === "assistant") {
+                answer = i;
+            }
+        }
+        close(this.messages.length);
+        return answers;
+    }
+    /** For every message, the first index of the turn folding it (-1 = none). */
+    turnMap() {
+        const map = new Array(this.messages.length).fill(-1);
+        for (const start of this.userMessageIndexes()) {
+            const end = this.turnEnd(start);
+            if (!this.turnHides(start, end))
+                continue;
+            for (let i = start; i < end; i++)
+                map[i] = start;
+        }
+        return map;
+    }
+    /**
+     * The first line of the first message in `role`. Only one line: the header is
+     * a signpost, and the full text is one click away.
+     */
+    turnPreview(start, end, role) {
+        for (const m of this.messages.slice(start, end)) {
+            if (m.role !== role)
+                continue;
+            const line = sanitizeText(m.content)
+                .split("\n")
+                .map((part) => part.trim())
+                .find((part) => part.length > 0);
+            if (line)
+                return line;
+        }
+        return "";
+    }
+    /** The header standing in for a folded turn, or the way back into one. */
+    pushTurnHeader(start, end, width, add) {
+        const count = end - start;
+        if (this.expandedTurns.has(start)) {
+            // Open: the messages below say everything, so the line is only the way
+            // back. Reserve the room the hint needs so a narrow terminal keeps it.
+            const hint = " — click to collapse";
+            const label = `▾ ${count} message${count === 1 ? "" : "s"}`;
+            add({
+                spans: [
+                    { text: ellipsize(label, Math.max(10, width - displayWidth(hint))), style: { fg: C.dim, bold: true } },
+                    { text: hint, style: { fg: C.dim } },
+                ],
+            }, -1, start);
+            return;
+        }
+        const you = `You: ${this.turnPreview(start, end, "user") || "(no text)"}`;
+        add({ spans: [{ text: ellipsize(`▸ ${you}`, width), style: { fg: C.amber, bold: true } }] }, -1, start);
+        // The prompt and the reply sit either side of the work this fold hides, so
+        // the control line goes between them and the answer stays on screen below.
+        const hidden = this.turnAnswer(start, end) < 0 ? count : count - 1;
+        const meta = `${hidden} of ${count} message${count === 1 ? "" : "s"} folded`;
+        add({ spans: [{ text: ellipsize(`  ${meta} — click to expand`, width), style: { fg: C.dim } }] }, -1, start);
+    }
+    /** Fold or unfold one turn. */
+    toggleTurn(start) {
+        if (this.expandedTurns.has(start))
+            this.expandedTurns.delete(start);
+        else
+            this.expandedTurns.add(start);
+        // Expanding pushes the rest of the log down, so do not snap to the bottom.
+        this.followBottom = false;
+        this.app.render();
+    }
     /** Expand/collapse the tool block belonging to message `index`. */
     toggleTool(index) {
         if (this.expandedTools.has(index))
@@ -1044,9 +1234,13 @@ export class ChatScreen extends Screen {
         // Parallel map from rendered line -> owning tool message index (-1 = none),
         // used to turn a click on any line of a tool block into an expand/collapse.
         const toolLineIndex = [];
-        const add = (line, tool = -1) => {
+        // Same idea for a folded turn. Only its header lines point at the turn, so
+        // the messages of an expanded turn keep their own click targets.
+        const turnLineIndex = [];
+        const add = (line, tool = -1, turn = -1) => {
             lines.push(line);
             toolLineIndex.push(tool);
+            turnLineIndex.push(turn);
         };
         const pushText = (text, style, tool = -1) => {
             for (const ln of wrapText(text, width))
@@ -1057,10 +1251,15 @@ export class ChatScreen extends Screen {
                 add(ln);
         };
         const context = normalizeContext(this.context, this.messages.filter((m) => m.role !== "system").length);
+        // Which turn owns each message: [] -> first index of that turn, -1 = none.
+        const turns = this.turnMap();
+        // Per message, the reply of its turn: a folded turn always renders that one.
+        const answers = this.turnAnswers();
         this.contextLines.clear();
         let recordIndex = 0;
         for (let mi = 0; mi < this.messages.length; mi++) {
             const m = this.messages[mi];
+            const turn = m.role === "system" ? -1 : turns[mi];
             let archived = false;
             if (m.role !== "system") {
                 if (recordIndex === 0 && context) {
@@ -1069,12 +1268,23 @@ export class ChatScreen extends Screen {
                 }
                 archived = context !== null && recordIndex < context.end;
                 recordIndex++;
-                if (archived && !this.expandedContext)
-                    continue;
             }
+            // A foldable turn always shows its control lines first; its work then
+            // renders when the reader has opened it, and its reply always does.
+            if (m.role !== "system" && turn === mi && !(archived && !this.expandedContext)) {
+                this.pushTurnHeader(mi, this.turnEnd(mi), width, add);
+            }
+            const folded = turn >= 0 && !this.expandedTurns.has(turn);
+            const reply = folded && answers[mi] === mi;
             if (m.role === "system") {
                 pushText(sanitizeText(m.content), { fg: C.dim });
             }
+            else if ((archived && !this.expandedContext) || (folded && !reply)) {
+                // Hidden: by the collapsed "Earlier conversation" fold, or by the turn's
+                // own fold, which hides the prompt body and the work but never the
+                // reply. Either way the message stays in the transcript, on disk and in
+                // the request; the header above says how to get it back on screen.
+            }
             else if (m.role === "user") {
                 add({ spans: [{ text: "You:", style: { fg: C.accent, bold: true } }] });
                 pushMarkdown(sanitizeText(m.content), { fg: C.user });
@@ -1141,6 +1351,7 @@ export class ChatScreen extends Screen {
             pushMarkdown(sanitizeText(this.streamingContent), { fg: C.assistant });
         }
         this.toolLineIndex = toolLineIndex;
+        this.turnLineIndex = turnLineIndex;
         return lines;
     }
     render(buf) {
@@ -1166,7 +1377,7 @@ export class ChatScreen extends Screen {
             statusStyle = { fg: C.amber, bold: true };
         }
         else if (this.busy) {
-            status = "Streaming... press ESC ESC to pause";
+            status = "Streaming... press Ctrl+C or ESC ESC to pause";
             statusStyle = { fg: C.dim };
         }
         if (status && this.approvalToggleY(h) !== 1)
@@ -1195,6 +1406,7 @@ export class ChatScreen extends Screen {
         // click can expand/collapse it (see the onMouse handler).
         this.toolRows.clear();
         this.contextRows.clear();
+        this.turnRows.clear();
         for (let y = logTop; y <= logBottom; y++) {
             const li = this.scrollTop + (y - logTop);
             if (li >= lines.length)
@@ -1202,6 +1414,9 @@ export class ChatScreen extends Screen {
             const tool = this.toolLineIndex[li];
             if (tool !== undefined && tool >= 0)
                 this.toolRows.set(y, tool);
+            const turn = this.turnLineIndex[li];
+            if (turn !== undefined && turn >= 0)
+                this.turnRows.set(y, turn);
             if (this.contextLines.has(li))
                 this.contextRows.add(y);
             drawSpans(buf, 2, y, lines[li].spans, Math.max(4, w - 4));
@@ -1222,7 +1437,7 @@ export class ChatScreen extends Screen {
             placeholder: "Type a message...",
         });
         const hintY = h - 1;
-        const hints = "Enter send · ESC ESC pause · Ctrl+A approval · Ctrl+B menu · Ctrl+L clear · drag to copy";
+        const hints = "Enter send · Ctrl+C pause · ESC ESC pause · Ctrl+A approval · Ctrl+B menu · Ctrl+L clear · drag to copy";
         const hintW = displayWidth(hints);
         const hintX = Math.max(0, w - 1 - hintW);
         const pathAvail = Math.max(0, hintX - 2);

package/dist/selection.js

@@ -6,6 +6,12 @@ export function normalizeSelection(sel) {
         return { start: a, end: b };
     return { start: b, end: a };
 }
+/** Order the two ends of a line-space selection into reading order. */
+export function orderLinePoints(a, b) {
+    if (a.line < b.line || (a.line === b.line && a.x <= b.x))
+        return { start: a, end: b };
+    return { start: b, end: a };
+}
 /**
  * Index of the last cell on a row that holds real content, or -1 when the row
  * has none. UI chrome (a scrollbar) and blank cells are ignored, so a highlight
@@ -87,3 +93,57 @@ export function selectionText(buf, sel) {
         lines.pop();
     return lines.join("\n");
 }
+/**
+ * One buffer row as column-indexed text: `cells[x]` is what column `x` holds,
+ * or `""` for a cell that never copies (UI chrome, and the tail of a
+ * double-width glyph).
+ *
+ * Keeping the column index is the point: it lets a row be sliced by column
+ * later, after the frame it came from is long gone. A drag that scrolls the log
+ * needs exactly that, because the rows it started on leave the screen while the
+ * selection keeps growing.
+ */
+export function rowCells(buf, y) {
+    const row = buf.cells[y];
+    if (!row)
+        return [];
+    const cells = new Array(row.length);
+    for (let x = 0; x < row.length; x++) {
+        const cell = row[x];
+        cells[x] = !cell || cell.chrome || cell.ch === "" ? "" : cell.ch;
+    }
+    return cells;
+}
+/**
+ * Extract the text of a selection expressed in content lines (`rowSelectionText`
+ * is to `selectionText` what `LinePoint` is to `Point`).
+ *
+ * `getRow` supplies the cells of a line — from the current frame while the line
+ * is on screen, from the snapshot taken during the drag once it has scrolled
+ * away, or `null` for a line that was never captured. Trailing blanks and edge
+ * blank lines are trimmed exactly like `selectionText`, so both paths produce
+ * the same text for a selection that fits on one screen.
+ */
+export function rowSelectionText(getRow, start, end) {
+    const lines = [];
+    for (let line = start.line; line <= end.line; line++) {
+        const row = getRow(line);
+        if (!row) {
+            // Never captured (a line that scrolled past without being drawn). Keep
+            // the line count honest instead of glueing its neighbours together.
+            lines.push("");
+            continue;
+        }
+        const x0 = line === start.line ? Math.max(0, start.x) : 0;
+        const x1 = line === end.line ? Math.min(row.length - 1, end.x) : row.length - 1;
+        let text = "";
+        for (let x = x0; x <= x1; x++)
+            text += row[x] ?? "";
+        lines.push(text.replace(/[ \t]+$/, ""));
+    }
+    while (lines.length > 0 && lines[0] === "")
+        lines.shift();
+    while (lines.length > 0 && lines[lines.length - 1] === "")
+        lines.pop();
+    return lines.join("\n");
+}

package/dist/terminal/input.js

@@ -194,6 +194,24 @@ export class InputReader {
     finishCsi() {
         const s = this.csiBuf;
         const final = s[s.length - 1];
+        // CSI-u (kitty) and xterm modifyOtherKeys preserve Ctrl+Shift separately.
+        const extended = final === "u"
+            ? /^(\d+)(?::[\d:]*)?(?:;(\d+)(?::(\d+))?)?(?:;[\d:]*)?u$/.exec(s)
+            : /^27;(\d+);(\d+)~$/.exec(s);
+        if (extended) {
+            const code = Number(extended[final === "u" ? 1 : 2]);
+            const modifiers = Number(extended[final === "u" ? 2 : 1] ?? 1) - 1;
+            // Ignore key-up reports: releasing C must not count as another press.
+            if (final === "u" && extended[3] === "3")
+                return;
+            if (code < 0 || code > 0x10ffff || (code >= 0xd800 && code <= 0xdfff))
+                return;
+            const char = String.fromCodePoint(code);
+            const special = { 13: "return", 9: "tab", 27: "escape", 127: "backspace" };
+            const ctrl = (modifiers & 4) !== 0;
+            this.emitKey(special[code] ?? (ctrl ? char.toLowerCase() : char), ctrl, (modifiers & 2) !== 0, (modifiers & 1) !== 0, char, "\x1b[" + s);
+            return;
+        }
         if (final === "A")
             this.emitKey("up", false, false, false, "\x1b[A");
         else if (final === "B")
@@ -272,7 +290,7 @@ export class InputReader {
             this.emitMouse({ type: "click", x, y, button });
         }
     }
-    emitKey(name, ctrl, meta, shift, char) {
+    emitKey(name, ctrl, meta, shift, char, sequence = char) {
         if (!this.handler)
             return;
         this.handler({
@@ -283,7 +301,7 @@ export class InputReader {
                 meta,
                 shift,
                 char,
-                sequence: char,
+                sequence,
             },
         });
     }

package/dist/terminal/renderer.js

@@ -50,13 +50,20 @@ export class Renderer {
     prevH = 0;
     out = process.stdout;
     /**
-     * The most recent frame and the rows that were force-repainted for it. Kept
-     * so `repaint()` can re-emit the exact same frame — without re-running the
+     * The most recent frame, kept so `repaint()` can re-emit it without re-running the
      * screen's (potentially expensive) render — to heal any drift the terminal
      * introduced behind our back.
      */
     lastBuf = null;
-    lastForce = [];
+    blocked = false;
+    pendingForce = new Set();
+    drainHandler = () => {
+        this.blocked = false;
+        const forceRows = [...this.pendingForce];
+        this.pendingForce.clear();
+        if (!this.disposed && this.lastBuf)
+            this.draw(this.lastBuf, forceRows);
+    };
     init() {
         // Tell the crash guard the terminal is ours *before* touching it, so a
         // crash that skips dispose() can still undo every switch below.
@@ -65,11 +72,14 @@ export class Renderer {
         this.write("\x1b[?25l"); // hide cursor
         this.write("\x1b[?1000h\x1b[?1002h\x1b[?1003h\x1b[?1006h\x1b[?1015h"); // mouse tracking (incl. any-event for hover)
         this.write("\x1b[?2004h"); // bracketed paste (so pastes can be told apart from typing)
+        this.write("\x1b[>4;2m\x1b[>1u"); // xterm/kitty modified keys, including Ctrl+Shift+C
     }
     dispose() {
         if (this.disposed)
             return;
         this.disposed = true;
+        this.out.removeListener?.("drain", this.drainHandler);
+        this.pendingForce.clear();
         // stdout.write may still be queued when App.quit calls process.exit.
         // Use the same synchronous teardown as the crash/exit guard.
         restoreTerminalSync();
@@ -82,7 +92,6 @@ export class Renderer {
      */
     render(buf, forceRows = []) {
         this.lastBuf = buf;
-        this.lastForce = forceRows;
         this.draw(buf, forceRows);
     }
     /**
@@ -110,6 +119,13 @@ export class Renderer {
         this.write("\x07".repeat(count));
     }
     draw(buf, forceRows) {
+        if (this.disposed)
+            return;
+        if (this.blocked) {
+            for (const y of forceRows)
+                this.pendingForce.add(y);
+            return;
+        }
         const w = buf.width;
         const h = buf.height;
         if (w !== this.prevW || h !== this.prevH) {
@@ -127,8 +143,12 @@ export class Renderer {
                 this.prevSig[y] = sig;
             }
         }
-        if (out)
-            this.write(out);
+        if (out && !this.write(out) && typeof this.out.once === "function") {
+            // The stream already accepted this frame. Wait for it to drain, then
+            // diff straight to the latest frame instead of queueing old mouse moves.
+            this.blocked = true;
+            this.out.once("drain", this.drainHandler);
+        }
     }
     renderRow(y, row) {
         // Move to the row, reset attributes and erase the whole line first. The
@@ -158,13 +178,14 @@ export class Renderer {
     }
     write(chunk) {
         if (this.disposed || this.out.destroyed || this.out.writableEnded)
-            return;
+            return true;
         try {
-            this.out.write(chunk);
+            return this.out.write(chunk) !== false;
         }
         catch {
             // A terminal that vanished (closed window, dying conhost) must not take
             // the whole session down with it.
+            return true;
         }
     }
 }

package/dist/terminal/restore.js

@@ -12,7 +12,8 @@ const NEUTRINO_DIR = path.join(os.homedir(), ".neutrino");
  * half-configured terminal. Order matters: `?1049l` must come last or the
  * remaining writes would land on the main screen.
  */
-export const TUI_TEARDOWN = "\x1b[?2004l" + // bracketed paste off
+export const TUI_TEARDOWN = "\x1b[<u\x1b[>4m" + // restore kitty keyboard flags and xterm modified keys
+    "\x1b[?2004l" + // bracketed paste off
     "\x1b[?1000l\x1b[?1002l\x1b[?1003l\x1b[?1006l\x1b[?1015l" + // mouse tracking off
     "\x1b[?25h" + // cursor visible
     "\x1b[0m" + // default attributes
@@ -121,7 +122,7 @@ export function installCrashGuard() {
         }
     });
     // These signals otherwise bypass Node's exit hook, including Ctrl+Break on
-    // Windows. SIGINT/SIGTERM are handled by App.quit (or the web server).
+    // Windows. The app handles SIGINT as an interrupt and SIGTERM as a quit.
     process.on("SIGHUP", () => process.exit(129));
     process.on("SIGBREAK", () => process.exit(149));
     const fatal = (kind, err) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xingjisoft/neutrino",
-  "version": "0.1.5",
+  "version": "0.1.7",
   "description": "XINGJI Neutrino - a CLI coding agent in the terminal.",
   "type": "module",
   "license": "Apache-2.0",
@@ -18,7 +18,7 @@
   },
   "scripts": {
     "build": "tsc -p tsconfig.json",
-    "test": "npm run build && node scripts/test-paste.mjs && node scripts/test-mouse.mjs && node scripts/test-cursor.mjs && node scripts/test-selection.mjs && node scripts/test-copy.mjs && node scripts/test-scrollbar.mjs && node scripts/test-render.mjs && node scripts/test-drift.mjs && node scripts/test-sanitize.mjs && node scripts/test-markdown.mjs && node scripts/test-wrap.mjs && node scripts/test-fetch.mjs && node scripts/test-compact.mjs && node scripts/test-history-fold.mjs && node scripts/test-web-history.mjs && node scripts/test-web-settings.mjs && node scripts/test-tools.mjs && node scripts/test-approval.mjs && node scripts/test-approval-review.mjs && node scripts/test-approval-ui.mjs && node scripts/test-web-approval-details.mjs && node scripts/test-approval-mode.mjs && node scripts/test-approval-context.mjs && node scripts/test-settings-render.mjs && node scripts/test-approval-flow.mjs && node scripts/test-web.mjs && node scripts/test-web-settings-http.mjs && node scripts/test-web-auth.mjs && node scripts/test-web-auth-ui.mjs && node scripts/test-terminal-lifecycle.mjs && node scripts/test-persistence.mjs && node scripts/test-resilience.mjs && node scripts/test-approval-timeout.mjs && node scripts/test-approval-hardening.mjs && node scripts/test-approval-extreme.mjs && node scripts/test-approval-reason.mjs",
+    "test": "npm run build && node scripts/test-paste.mjs && node scripts/test-mouse.mjs && node scripts/test-cursor.mjs && node scripts/test-selection.mjs && node scripts/test-drag-scroll.mjs && node scripts/test-selection-performance.mjs && node scripts/test-copy.mjs && node scripts/test-scrollbar.mjs && node scripts/test-render.mjs && node scripts/test-drift.mjs && node scripts/test-sanitize.mjs && node scripts/test-markdown.mjs && node scripts/test-wrap.mjs && node scripts/test-fetch.mjs && node scripts/test-compact.mjs && node scripts/test-history-fold.mjs && node scripts/test-web-history.mjs && node scripts/test-turn-fold.mjs && node scripts/test-web-settings.mjs && node scripts/test-tools.mjs && node scripts/test-approval.mjs && node scripts/test-approval-review.mjs && node scripts/test-approval-ui.mjs && node scripts/test-web-approval-details.mjs && node scripts/test-approval-mode.mjs && node scripts/test-approval-context.mjs && node scripts/test-settings-render.mjs && node scripts/test-approval-flow.mjs && node scripts/test-web.mjs && node scripts/test-web-settings-http.mjs && node scripts/test-web-auth.mjs && node scripts/test-web-auth-ui.mjs && node scripts/test-interrupt.mjs && node scripts/test-terminal-lifecycle.mjs && node scripts/test-persistence.mjs && node scripts/test-resilience.mjs && node scripts/test-approval-timeout.mjs && node scripts/test-approval-hardening.mjs && node scripts/test-approval-extreme.mjs && node scripts/test-approval-reason.mjs",
     "prepare": "npm run build",
     "web": "node dist/bin.js web"
   },

package/web/README.md

@@ -5,7 +5,9 @@ a port you choose. It lets you:
 
 - browse every saved conversation grouped by working directory (like Codex),
   with only the five latest transcripts per path shown and the rest collapsed;
-- watch a running terminal conversation stream in real time;
+- watch a running terminal conversation stream in real time: the work behind every
+  finished turn folds into one line that opens on a click, while the reply itself
+  stays on screen (the turn being answered is open, and a pause is not a fold);
 - switch the provider, model and intensity for the next turn;
 - edit defaults, context compression and approval settings in a Settings dialog;
 - drive the running conversation: pause / resume the current turn and send new