@xingjisoft/neutrino 0.1.6 → 0.1.7

package/README.md

@@ -15,7 +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** — as soon as the model finishes a reply, that round collapses into one summary line (prompt, answer preview, message count) in both the terminal and the browser. Click it to read the complete round again; short exchanges stay open, because hiding two lines helps nobody. 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.
+- **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.
@@ -212,8 +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), folds every finished turn into one summary line that opens
-on a click, 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
@@ -335,7 +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 finished turns fold in both UIs and keep every message
+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/screens/chat.js

@@ -16,10 +16,12 @@ import { SessionCheckpoint } from "../persistence.js";
 import { writeCrashLog } from "../terminal/restore.js";
 const TOOLS = getToolDefinitions();
 /**
- * A finished turn only folds into a one-line summary when hiding it saves real
- * space: four or more visible 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.
+ * 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;
@@ -966,15 +968,21 @@ export class ChatScreen extends Screen {
         return this.messages.length;
     }
     /**
-     * A finished turn is only worth folding when it hides something substantial.
-     * Whether it is folded right now is a separate question (`expandedTurns`).
+     * 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++;
@@ -983,6 +991,42 @@ export class ChatScreen extends Screen {
         }
         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);
@@ -996,12 +1040,11 @@ export class ChatScreen extends Screen {
         return map;
     }
     /**
-     * The first line of the first message in `role` (the last one with `last`).
-     * Only one line: the preview is a signpost, and the full text is a click away.
+     * 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, last = false) {
-        const slice = this.messages.slice(start, end);
-        for (const m of last ? slice.reverse() : slice) {
+    turnPreview(start, end, role) {
+        for (const m of this.messages.slice(start, end)) {
             if (m.role !== role)
                 continue;
             const line = sanitizeText(m.content)
@@ -1031,16 +1074,11 @@ export class ChatScreen extends Screen {
         }
         const you = `You: ${this.turnPreview(start, end, "user") || "(no text)"}`;
         add({ spans: [{ text: ellipsize(`▸ ${you}`, width), style: { fg: C.amber, bold: true } }] }, -1, start);
-        const reply = this.turnPreview(start, end, "assistant", true);
-        const meta = `${count} message${count === 1 ? "" : "s"} folded`;
-        add({
-            spans: [
-                {
-                    text: ellipsize(`  ${meta}${reply ? ` · Neutrino: ${reply}` : ""} — click to expand`, width),
-                    style: { fg: C.dim },
-                },
-            ],
-        }, -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) {
@@ -1215,6 +1253,8 @@ export class ChatScreen extends Screen {
         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++) {
@@ -1229,18 +1269,21 @@ export class ChatScreen extends Screen {
                 archived = context !== null && recordIndex < context.end;
                 recordIndex++;
             }
-            // A foldable turn always shows its control line first; its messages then
-            // render normally when the reader has opened it.
+            // 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) || (turn >= 0 && !this.expandedTurns.has(turn))) {
-                // Hidden, by the collapsed "Earlier conversation" fold or by the turn's
-                // own fold. 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 ((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 } }] });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xingjisoft/neutrino",
-  "version": "0.1.6",
+  "version": "0.1.7",
   "description": "XINGJI Neutrino - a CLI coding agent in the terminal.",
   "type": "module",
   "license": "Apache-2.0",

package/web/README.md

@@ -5,9 +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, with every
-  finished turn folded into one summary line that opens on a click (the turn
-  being answered stays open, and a paused turn is not folded either);
+- 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

package/web/app.js

@@ -1,5 +1,5 @@
 import { createSettingsUI } from "./settings.js";
-import { turnFolds, turnPreview, turnRanges } from "./turns.js";
+import { turnAnswerIndex, turnFolds, turnPreview, turnRanges } from "./turns.js";
 
 // Neutrino web UI — a dependency-free single page app.
 //
@@ -886,10 +886,10 @@ function renderMessageList(messages, streaming, options) {
     });
     el.messages.appendChild(details);
   }
-  // Render the tail one turn at a time: a turn the agent has finished folds into
-  // a summary line, a running one stays open. The turn in flight is the last one,
-  // so `active` decides its state; a turn cut in half by the compressed prefix is
-  // rendered as plain messages instead.
+  // Render the tail one turn at a time: a finished turn folds its work behind a
+  // summary line and keeps its reply; a running one stays fully open. The turn in
+  // flight is the last one, so `active` decides its state; a turn cut in half by
+  // the compressed prefix is rendered as plain messages instead.
   const turns = turnRanges(original);
   const running = options?.active && turns.length > 0 ? turns[turns.length - 1].start : -1;
   for (const turn of turns) {
@@ -958,17 +958,24 @@ function renderMessage(message, index) {
 }
 
 /**
- * A finished turn, folded to one summary line. The messages are rendered on
- * first open and dropped again on close, so a long transcript costs nothing
- * until the reader asks for it. Nothing is lost either way: this is presentation
- * only, and the saved transcript always holds every message.
+ * A finished turn: its work folded behind one control line, its reply always on
+ * screen below it. The folded messages are rendered on first open and dropped
+ * again on close, so a long transcript costs nothing until the reader asks for
+ * it. Nothing is lost either way: this is presentation only, and the saved
+ * transcript always holds every message.
  */
 function renderTurnFold(start, messages) {
+  // The reply is never folded away, so a turn renders as a group: the fold (the
+  // prompt line plus the work it hides) and, right below it, the answer itself.
+  const reply = turnAnswerIndex(messages);
+  const group = document.createElement("div");
+  group.className = "turn-group";
+
   const details = document.createElement("details");
   details.className = "turn";
   details.open = state.openTurns.has(start);
 
-  const count = messages.length;
+  const hidden = reply < 0 ? messages.length : messages.length - 1;
   const summary = document.createElement("summary");
   const chevron = document.createElement("span");
   chevron.className = "turn-chevron";
@@ -978,9 +985,7 @@ function renderTurnFold(start, messages) {
   you.textContent = `You: ${truncate(turnPreview(messages, "user"), 110)}`;
   const meta = document.createElement("span");
   meta.className = "turn-meta";
-  meta.textContent =
-    `${count} message${count === 1 ? "" : "s"} · ` +
-    truncate(turnPreview(messages, "assistant", true), 90);
+  meta.textContent = `${hidden} of ${messages.length} message${messages.length === 1 ? "" : "s"} folded`;
   // The hint cannot live in the static text: it says the opposite once open.
   const hint = document.createElement("span");
   hint.className = "turn-hint";
@@ -989,6 +994,7 @@ function renderTurnFold(start, messages) {
   summary.appendChild(you);
   summary.appendChild(meta);
   details.appendChild(summary);
+  group.appendChild(details);
 
   const syncHint = () => {
     hint.textContent = details.open ? " — click to collapse" : " — click to expand";
@@ -1000,7 +1006,10 @@ function renderTurnFold(start, messages) {
   details.appendChild(body);
   const populate = () => {
     if (body.childNodes.length) return;
-    messages.forEach((message, offset) => body.appendChild(renderMessage(message, start + offset)));
+    messages.forEach((message, offset) => {
+      if (offset === reply) return; // the answer is never inside the fold
+      body.appendChild(renderMessage(message, start + offset));
+    });
   };
   if (details.open) populate();
   details.addEventListener("toggle", () => {
@@ -1015,7 +1024,10 @@ function renderTurnFold(start, messages) {
     }
     syncHint();
   });
-  return details;
+  // The answer comes with the fold, so a finished exchange ends on its reply
+  // even while the work that produced it stays hidden.
+  if (reply >= 0) group.appendChild(renderMessage(messages[reply], start + reply));
+  return group;
 }
 
 function firstUserMessage(messages) {

package/web/style.css

@@ -597,12 +597,17 @@ button {
   margin-bottom: 18px;
 }
 
-/* A finished turn: one summary line, the whole round one click away. */
+/* A finished turn: its work behind one control line, its reply always below. */
+.turn-group {
+  display: flex;
+  flex-direction: column;
+}
+
 .turn {
   border: 1px dashed var(--border-soft);
   border-radius: var(--radius);
   padding: 8px 12px;
-  margin-bottom: 18px;
+  margin-bottom: 14px;
 }
 
 .turn > summary {

package/web/turns.js

@@ -2,8 +2,9 @@
 //
 // A conversation is a sequence of turns: each one starts at a user message and
 // runs until the next one. Once the agent has finished a turn, the browser folds
-// it into a single summary line so scrolling back stays manageable, while the
-// complete transcript is still rendered on demand (click the summary).
+// away the work it took — the prompt body, the thinking and the tool calls — and
+// keeps the final reply on screen, so a finished exchange always ends on its
+// answer. The complete round is still one click away.
 //
 // The thresholds mirror TURN_FOLD_MIN_BLOCKS / TURN_FOLD_MIN_CHARS in
 // src/screens/chat.ts, so the terminal and the browser fold the same turns.
@@ -22,25 +23,38 @@ export function turnRanges(messages) {
   return turns;
 }
 
-/** True when folding this turn saves more room than it costs. */
+/** Index of the turn's reply — its last assistant message (-1 when it has none). */
+export function turnAnswerIndex(messages) {
+  for (let i = messages.length - 1; i >= 0; i--) {
+    if (messages[i].role === "assistant") return i;
+  }
+  return -1;
+}
+
+/**
+ * True when folding the work behind this turn saves more room than it costs.
+ * The reply is never folded away, so it is not counted: a long answer on its own
+ * must never collapse the turn that carries it.
+ */
 export function turnFolds(messages) {
+  const reply = turnAnswerIndex(messages);
   let blocks = 0;
   let chars = 0;
-  for (const message of messages) {
-    if (message.role !== "user" && message.role !== "assistant") continue;
+  messages.forEach((message, index) => {
+    if (index === reply) return;
+    if (message.role !== "user" && message.role !== "assistant") return;
     blocks++;
     chars += String(message.content ?? "").length;
-  }
+  });
   return blocks >= TURN_FOLD_MIN_BLOCKS || chars >= TURN_FOLD_MIN_CHARS;
 }
 
 /**
- * The first line of the first (or, with `last`, the last) message in `role`.
- * One line only: the preview is a signpost, the full text is a click away.
+ * The first line of the first message in `role`. One line only: the header is a
+ * signpost, and the full text is one click away.
  */
-export function turnPreview(messages, role, last = false) {
-  const ordered = last ? [...messages].reverse() : messages;
-  for (const message of ordered) {
+export function turnPreview(messages, role) {
+  for (const message of messages) {
     if (message.role !== role) continue;
     const line = String(message.content ?? "")
       .split(/\r?\n/)