@tiens.nguyen/gonext-local-worker 1.0.202 → 1.0.203

package/gonext-repl.mjs

@@ -106,6 +106,9 @@ const THINKING_WORDS = (() => {
 })();
 const pickWord = () =>
   THINKING_WORDS[Math.floor(Math.random() * THINKING_WORDS.length)] || "Thinking";
+// Rotating half-circle = an in-progress ("blinking") bullet for the step being worked on.
+const SPINNER = ["◐", "◓", "◑", "◒"];
+const BULLET = "●"; // a completed action
 
 // ---------- flags ----------
 const argv = process.argv.slice(2);
@@ -406,17 +409,17 @@ async function runAgentTurn(history) {
   // until a full line is known, or we'd risk showing part of something we meant to hide.
   let plainReplyFlow = false;
 
-  // --- Live "thinking…" ticker ---------------------------------------------------
-  // Between visible tokens (prompt-eval / awaiting the first token) we show ONE in-place
-  // status line that counts UP every second — "Percolating thinking… (7s)" — so the wait
-  // feels alive. When output resumes we stamp a dim "✔ completed thought (Ns)" and let the
-  // tokens stream. The worker's own 45s heartbeat lines (and ~~~ fences) are swallowed;
-  // this local 1-second ticker owns the progress display.
+  // --- Live in-progress ("blinking") bullet -------------------------------------------
+  // The agent's raw Thought/code stream is SUPPRESSED (see the ~~~-fence handling in
+  // consume) — the terminal shows only a clean list of action bullets. While a step is
+  // being thought about / run, we show ONE in-place blinking bullet that counts up —
+  // "◐ working… (7s)" — instead of dumping the model's rambling reasoning and stamping a
+  // "✔ completed thought" on every token-stream micro-pause (the reported clutter).
   const QUIET_MS = 700; // stream idle this long ⇒ we're waiting on the model
   let lastContentAt = Date.now();
   let thinking = false;
   let thinkingSince = 0;
-  let thinkWord = pickWord();
+  let almostDone = false; // set from the worker's "…almost completed thinking…" heartbeat
   const thinkSecs = () => Math.max(1, Math.round((Date.now() - thinkingSince) / 1000));
 
   const clearStatus = () => {
@@ -427,52 +430,25 @@ async function runAgentTurn(history) {
     if (!following || followAborted || !jobRunning) return;
     if (Date.now() - lastContentAt < QUIET_MS) return; // tokens still flowing
     // A plain-reply answer streams onto a line with NO trailing newline until it's fully
-    // done — if the model pauses mid-sentence (normal token-generation jitter) and we're
-    // already partway through that open line, CLEAR_LINE can only erase the terminal's
-    // CURRENT visual row, not the whole logical line once it's wrapped — overwriting the
-    // ticker there corrupts the visible answer text mid-word. Stay silent once any of
-    // THIS line has already been shown; the next completed line (fresh, empty) is safe.
+    // done — overwriting the ticker there corrupts the visible answer mid-word. Stay
+    // silent once any of THIS line has already been shown (see carryFlushedLen).
     if (plainReplyFlow && carryFlushedLen > 0) return;
-    // Count from when the stream actually went quiet, so the seconds reflect the true
-    // wait for the first token (1s, 2s, 3s…) rather than from the first tick.
-    if (!thinking) { thinking = true; thinkingSince = lastContentAt; thinkWord = pickWord(); }
+    // Count from when the stream went quiet, so the seconds reflect the true wait.
+    if (!thinking) { thinking = true; thinkingSince = lastContentAt; }
     const secs = thinkSecs();
-    if (secs % 12 === 0) thinkWord = pickWord(); // rotate the word on long waits
-    process.stdout.write(CLEAR_LINE + yellow(`${thinkWord} thinking… (${secs}s)`));
+    const glyph = SPINNER[secs % SPINNER.length];       // rotates → reads as "in progress"
+    const label = almostDone ? "almost done" : "working";
+    process.stdout.write(CLEAR_LINE + yellow(`${glyph} ${label}… (${secs}s)`));
     statusShown = true;
   };
   const ticker = setInterval(tick, 1000);
 
-  // Close out a "thinking…" phase right before real output prints. A model streams in
-  // small bursts with natural micro-pauses between them (token batching, network jitter);
-  // each pause >700ms would otherwise stamp its OWN "✔ completed thought" line, stacking
-  // many near-duplicates through a single Thought/code generation. `stampIfThinking()` —
-  // called ONLY at the <code> tag transition, where nothing prints right after it — HOLDS
-  // the stamp as the current status line (like the ticker): a later completion overwrites
-  // it in place instead of stacking a new line. `onContent()` — called immediately before
-  // any real content prints — always COMMITS whatever is pending (a fresh stamp or a held
-  // one) with a trailing newline first, so content never lands on the same line as a stamp.
-  let pendingStamp = false;
-  const stampIfThinking = () => {
-    if (thinking) {
-      process.stdout.write(CLEAR_LINE + dim(`✔ completed thought (${thinkSecs()}s)`));
-      thinking = false;
-      statusShown = true;
-      pendingStamp = true;
-    }
-    lastContentAt = Date.now();
-  };
+  // Called right before any real (bullet/edit-card/answer) content prints: drop the
+  // blinking-bullet status line so content lands cleanly on its own line. No "completed
+  // thought" stamp — each finished action prints its own solid ● bullet instead.
   const onContent = () => {
-    if (thinking) {
-      process.stdout.write(CLEAR_LINE + dim(`✔ completed thought (${thinkSecs()}s)`) + "\n");
-      thinking = false;
-    } else if (pendingStamp) {
-      process.stdout.write("\n"); // commit the held stamp; content prints right after
-    } else {
-      clearStatus();
-    }
-    pendingStamp = false;
-    statusShown = false;
+    clearStatus();
+    if (thinking) { process.stdout.write(CLEAR_LINE); thinking = false; }
     lastContentAt = Date.now();
   };
 
@@ -483,6 +459,12 @@ async function runAgentTurn(history) {
   // blank lines keep spacing; everything else commits dim to scrollback.
   let inCode = false;
   let inEditCard = false; // inside a colored edit-card block (see isEditCardHeader)
+  // The worker wraps the raw model token stream (Thought prose + code) in ~~~ fences;
+  // the concrete ACTION events (tool steps, edit cards) are emitted OUTSIDE them. We
+  // suppress everything IN a fence — the rambling Thought and redundant raw code (the
+  // edit card already shows real changes) — and render the out-of-fence actions as
+  // bullets. This is the whole "action bullets only" declutter (task #41).
+  let inStreamFence = false;
   let lastWasBlank = true; // suppresses a leading blank line and collapses repeats
   // Chars of the CURRENT trailing (newline-less) `carry` line already flushed live — lets
   // a long plain-reply answer stream character-by-character instead of waiting for a "\n"
@@ -496,7 +478,20 @@ async function runAgentTurn(history) {
       carry = carry.slice(nl + 1);
       const alreadyFlushed = carryFlushedLen;
       carryFlushedLen = 0; // reset — `carry` now starts a fresh pending line
-      if (isHeartbeatLine(line) || isFenceLine(line)) continue; // swallow, no trace
+      if (isHeartbeatLine(line)) {
+        // Heartbeats are swallowed (the local ticker drives the display), but they
+        // still carry ONE bit we want: once the worker's word is "…almost completed
+        // thinking…", this model call is past prompt-eval and producing output — flip
+        // the local ticker to the same wording. A plain random-word heartbeat means
+        // we're back to waiting (a fresh step's prompt-eval), so clear the flag.
+        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;
       if (isToolStepSummary(line)) { lastContentAt = Date.now(); continue; } // swallow
       if (isRoutingLine(line)) {
         // Replace the whole routing play-by-play with ONE friendly line, shown once
@@ -547,7 +542,8 @@ async function runAgentTurn(history) {
         if (openM) {
           // Enter code mode (or stay in it on a duplicate tag). Anything glued after
           // the tag on the same line is code — print it, minus a glued close tag.
-          stampIfThinking(); // hold/refresh the stamp; the code body commits it below
+          // (Reached only for a stray <code> OUTSIDE a ~~~ fence; in-fence code is
+          // suppressed above. Kept as a safety net.)
           inCode = true;
           let rest = t.slice(openM[0].length).trim();
           if (CODE_CLOSE_RE.test(rest)) {
@@ -598,12 +594,18 @@ async function runAgentTurn(history) {
         continue;
       }
       if (alreadyFlushed === 0) onContent();
-      // Plain-reply content IS the answer (not background narration) — print it in the
-      // terminal's default color, not dim, and remember it's already visible so the
-      // caller doesn't print the same text again once the turn completes.
-      const paint = plainReplyFlow ? (s) => s : dim;
-      process.stdout.write(paint(line.slice(alreadyFlushed)) + "\n");
-      if (plainReplyFlow) answerShownLive = true;
+      if (plainReplyFlow) {
+        // Plain-reply content IS the answer — print it in the default color and remember
+        // it's visible so the caller doesn't reprint it once the turn completes.
+        process.stdout.write(line.slice(alreadyFlushed) + "\n");
+        answerShownLive = true;
+      } else {
+        // Agent flow: with the raw Thought/code stream suppressed above, the only lines
+        // that reach here are the worker's out-of-fence ACTION events ("Running → npx…",
+        // "Searching code → import (11 hits)", "Server up → …", "Composing answer…").
+        // Render each as ONE solid bullet — the clean, summarized action list (task #41).
+        process.stdout.write(green(BULLET) + " " + line.trim() + "\n");
+      }
       lastWasBlank = false;
     }
     // Plain-reply answers often have NO internal newline at all (a short one-sentence

package/gonext_agent_chat.py

@@ -42,6 +42,13 @@ _REAL_STDOUT = sys.stdout
 # a random one is picked per tick so the wait feels alive instead of a fixed string.
 _THINKING_WORDS: list = []
 
+# Shown INSTEAD of a random word once the model's first token arrives (prompt-eval done,
+# tokens now flowing) — the long silent wait is over and output is being produced, so the
+# status flips from "still thinking" to "almost done". Ends with "…" so the REPL/web can
+# append "(Ns)". The REPL detects the word "almost" in a heartbeat line to switch its own
+# local ticker to the same wording (see gonext-repl.mjs).
+_STATUS_ALMOST_DONE = "…almost completed thinking…"
+
 
 def _thinking_word() -> str:
     """A random playful status word (e.g. 'Caffeinating'). Falls back to a small
@@ -3390,8 +3397,15 @@ def run_agent_chat(cfg):
                 nonlocal first_token_at
                 if first_token_at is None:
                     first_token_at = time.monotonic()
-                    _log(f"streamed generate: FIRST token after {first_token_at - t0:.1f}s "
+                    elapsed = first_token_at - t0
+                    _log(f"streamed generate: FIRST token after {elapsed:.1f}s "
                          "(prompt-eval done; tokens now flowing)")
+                    # Flip the status from "still thinking" to "almost done" the instant
+                    # the wait ends — the heartbeat below keeps it there for the rest of
+                    # this call (self._first_token_seen), and this one-shot emit shows it
+                    # immediately (before the next 45s heartbeat would).
+                    self._first_token_seen = True
+                    _emit({"type": "step", "text": f"{_STATUS_ALMOST_DONE} ({elapsed:.0f}s)"})
                     # Separate this step's live thinking from the previous step summary.
                     _emit({"type": "stream", "text": "\n"})
 
@@ -3531,16 +3545,21 @@ def run_agent_chat(cfg):
             # 31B on a remote Ollama box) can take minutes on prompt-eval before the
             # first byte — emit a keepalive step every 45s until the call returns.
             hb_stop = threading.Event()
+            # Reset per call: True once this call's first token arrives (set in
+            # _mark_first), read by the heartbeat below to switch its wording.
+            self._first_token_seen = False
 
             def _heartbeat():
                 waited = 0
                 while not hb_stop.wait(45):
                     waited += 45
-                    # A random playful word each tick (e.g. "Caffeinating… (90s)") instead
-                    # of a fixed "still working" line — a large or cold-loading model can
-                    # legitimately take a few minutes on prompt-eval.
-                    _emit({"type": "step",
-                           "text": f"{_thinking_word()}… ({waited}s)"})
+                    # Before the first token: a random playful word ("Caffeinating… (90s)")
+                    # — a large/cold model can take minutes on prompt-eval. After the first
+                    # token: "…almost completed thinking… (Ns)", since output is now flowing
+                    # and the call is in its finishing phase, not stuck waiting.
+                    word = (_STATUS_ALMOST_DONE if getattr(self, "_first_token_seen", False)
+                            else f"{_thinking_word()}…")
+                    _emit({"type": "step", "text": f"{word} ({waited}s)"})
                     _log(f"heartbeat: model call in flight {waited}s")
 
             hb = threading.Thread(target=_heartbeat, daemon=True)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tiens.nguyen/gonext-local-worker",
-  "version": "1.0.202",
+  "version": "1.0.203",
   "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",