@tiens.nguyen/gonext-local-worker 1.0.225 → 1.0.226

package/gonext-repl.mjs

@@ -699,6 +699,21 @@ async function runAgentTurn(history) {
   let thinkWord = pickWord(); // playful word shown UNDER the in-progress line (flavor)
   let almostDone = false; // set from the worker's "…almost completed thinking…" heartbeat
   let runningCmd = null; // the command currently executing (from a "Running → …" event)
+  // The model's CURRENT Thought (task #64): while it streams its reasoning inside the
+  // hidden ~~~ fence, show a one-clause summary on the blinking line so a 300s CPU-bound
+  // step reads as "◑ Adding the nav links to app.component.html… (52s)" instead of a
+  // random word. `fenceThought` accumulates the raw in-fence text for the current step.
+  let liveThought = "";
+  let fenceThought = "";
+  // First non-empty Thought clause: drop the "Thought:" prefix, stop at the <code> block
+  // (we never show code), take the first line, and cap length so it never wraps.
+  const extractThought = (buf) => {
+    let t = String(buf || "");
+    const ci = t.search(/<code[\s>]/i);
+    if (ci >= 0) t = t.slice(0, ci);
+    t = t.replace(/^\s*Thought:\s*/i, "").split(/\n/)[0].trim();
+    return t;
+  };
   const thinkSecs = () => Math.max(1, Math.round((Date.now() - thinkingSince) / 1000));
 
   // The status is TWO in-place lines — the in-progress action, then the playful word
@@ -724,9 +739,12 @@ async function runAgentTurn(history) {
     const glyph = SPINNER[secs % SPINNER.length]; // rotates → reads as "in progress"
     // Line 1 = WHAT is happening now: the running command, else the phase (Thinking /
     // Almost done). Line 2 = the playful word (flavor). Truncate so neither wraps.
+    // Priority: a live command > the model's current Thought clause (task #64, so a
+    // long CPU-bound step reads as what it's actually reasoning about, not "Thinking")
+    // > the "almost done" heartbeat > the bare fallback.
     const primary = runningCmd
       ? `Running ${runningCmd}`
-      : almostDone ? "Almost done" : "Thinking";
+      : liveThought || (almostDone ? "Almost done" : "Thinking");
     const max = Math.max(24, (process.stdout.columns || 80) - 14);
     const fit = (s) => (s.length > max ? s.slice(0, max - 1) + "…" : s);
     clearStatus();
@@ -744,6 +762,10 @@ async function runAgentTurn(history) {
     clearStatus();
     thinking = false;
     runningCmd = null;
+    // A concrete action landed → the Thought that led to it is spent; clear it so the
+    // next step's blinking line starts from "Thinking", not last step's stale clause.
+    liveThought = "";
+    fenceThought = "";
     lastContentAt = Date.now();
   };
 
@@ -782,11 +804,26 @@ async function runAgentTurn(history) {
         almostDone = /almost/i.test(line);
         continue;
       }
-      if (isFenceLine(line)) { inStreamFence = !inStreamFence; continue; }
-      // Inside a ~~~ fence = raw model Thought/code stream → suppressed entirely. Do NOT
-      // bump lastContentAt: while the (now hidden) tokens flow, the blinking bullet keeps
-      // ticking so the user sees the step is still being worked on.
-      if (inStreamFence) continue;
+      // A fence opening starts a fresh step's raw stream → reset the harvested Thought
+      // so the blinking line doesn't carry last step's clause into this one.
+      if (isFenceLine(line)) {
+        inStreamFence = !inStreamFence;
+        if (inStreamFence) fenceThought = "";
+        continue;
+      }
+      // Inside a ~~~ fence = raw model Thought/code stream → suppressed from scrollback. Do
+      // NOT bump lastContentAt: while the (now hidden) tokens flow, the blinking bullet keeps
+      // ticking so the user sees the step is still being worked on. But HARVEST the first
+      // Thought clause for the blinking line (task #64) — up to the <code> block, which is
+      // where the prose ends and the tool call begins (we never surface code here).
+      if (inStreamFence) {
+        if (!/<code[\s>]/i.test(fenceThought)) {
+          fenceThought += line + "\n";
+          const th = extractThought(fenceThought);
+          if (th) liveThought = th;
+        }
+        continue;
+      }
       if (isToolStepSummary(line)) { lastContentAt = Date.now(); continue; } // swallow
       if (isRoutingLine(line)) {
         // Swallow the router's play-by-play entirely — the blinking-bullet ticker (which
@@ -914,6 +951,14 @@ async function runAgentTurn(history) {
       answerShownLive = true;
       lastWasBlank = false;
     }
+    // While in the hidden fence, the model's FIRST Thought line often sits in `carry` with
+    // no newline yet (a long reasoning sentence streams token-by-token) — recompute the
+    // live clause from the partial too, so the blinking line updates mid-sentence instead
+    // of only once the line finally breaks (task #64).
+    if (inStreamFence && !/<code[\s>]/i.test(fenceThought)) {
+      const th = extractThought(fenceThought + carry);
+      if (th) liveThought = th;
+    }
     // A non-empty remainder is a partial CONTENT line (heartbeats always arrive whole with
     // a newline), so tokens are actively flowing — keep the ticker asleep.
     if (carry.trim() !== "") lastContentAt = Date.now();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tiens.nguyen/gonext-local-worker",
-  "version": "1.0.225",
+  "version": "1.0.226",
   "description": "Polls GoNext cloud API for async local LLM jobs and runs them against Ollama/OpenAI-compatible servers on this Mac",
   "type": "module",
   "license": "MIT",