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

package/gonext-repl.mjs

@@ -43,11 +43,11 @@ const cyan = (s) => `\x1b[36m${s}\x1b[0m`;
 const green = (s) => `\x1b[32m${s}\x1b[0m`;
 const red = (s) => `\x1b[31m${s}\x1b[0m`;
 const yellow = (s) => `\x1b[33m${s}\x1b[0m`;
+const white = (s) => `\x1b[37m${s}\x1b[0m`;
 // ANSI 90 ("bright black") — a reliable neutral grey across terminal themes, unlike
 // code 34 (blue) which many dark-theme palettes render as purple/indigo instead.
 const codeColor = (s) => `\x1b[90m${s}\x1b[0m`;
 const bold = (s) => `\x1b[1m${s}\x1b[0m`;
-const CLEAR_LINE = "\r\x1b[K"; // carriage-return + erase-to-end-of-line
 
 // The worker's "still thinking" heartbeat lines look like "Caffeinating… (90s)" — we
 // SWALLOW them from the terminal (the local ticker below drives progress instead), and
@@ -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);
@@ -397,7 +400,6 @@ async function runAgentTurn(history) {
   let warnedPending = false;
   let jobRunning = false; // only tick "thinking…" once the worker has claimed the job
   let answerShownLive = false; // plain-reply content already printed — don't re-print it
-  let routingAnnounced = false; // one friendly line replaces the whole routing play-by-play
   // True once we've SPECIFICALLY seen "→ Chat reply" (the plain-reply/trivial-chat
   // branch), as opposed to "→ Agent mode…" (the tool-use branch). Only the plain-reply
   // path streams its answer via answer_stream with NO heartbeat/tool-summary/code lines
@@ -406,73 +408,64 @@ 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 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)
   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
+  // under it. Cursor sits at the end of line 2, so clearing = wipe line 2, move up, wipe
+  // line 1, leaving the cursor back at the status's origin for a redraw or real content.
   const clearStatus = () => {
-    if (statusShown) { process.stdout.write(CLEAR_LINE); statusShown = false; }
+    if (!statusShown) return;
+    process.stdout.write("\r\x1b[K\x1b[1A\r\x1b[K");
+    statusShown = false;
   };
 
   const tick = () => {
     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.
+    // Count from when this phase went quiet, so the seconds reflect the current wait/run.
     if (!thinking) { thinking = true; thinkingSince = lastContentAt; thinkWord = pickWord(); }
     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"
+    // 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.
+    const primary = runningCmd
+      ? `Running ${runningCmd}`
+      : 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();
+    process.stdout.write(
+      yellow(`${glyph} ${fit(primary)}… (${secs}s)`) + "\n" + dim(`  ${thinkWord}…`)
+    );
     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
+  // status lines so content lands cleanly, and end the current phase (so the next phase's
+  // seconds count fresh, and any running command is considered finished).
   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();
+    thinking = false;
+    runningCmd = null;
     lastContentAt = Date.now();
   };
 
@@ -483,6 +476,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,20 +495,26 @@ 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
-        // per turn — the raw labels are implementation detail (visible in the daemon's
-        // own terminal if you need them).
+        // Swallow the router's play-by-play entirely — the blinking-bullet ticker (which
+        // already shows the playful word + seconds) is the single in-progress indicator,
+        // so a separate static "Booting the big brain…" line here would just duplicate it.
         if (line.trim() === "→ Chat reply") plainReplyFlow = true;
-        if (!routingAnnounced) {
-          routingAnnounced = true;
-          onContent();
-          process.stdout.write(dim(`${pickWord()}…`) + "\n");
-          lastWasBlank = false;
-        }
-        lastContentAt = Date.now();
         continue;
       }
       // Edit card (a file change made by the agent's edit tools) — rendered as a
@@ -547,7 +552,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)) {
@@ -597,13 +603,26 @@ async function runAgentTurn(history) {
         }
         continue;
       }
+      // Agent flow: a "Running → <cmd>" is the START of a command — show it as the live
+      // in-progress status (the blinking bullet names it) rather than a solid bullet; its
+      // completion ("Command passed/failed → …" / "Server up → …") prints the done bullet.
+      // So the pair collapses to: "◑ Running <cmd>…" while it runs, then "● <result>".
+      if (!plainReplyFlow) {
+        const mRun = /^Running → (.+)$/.exec(line.trim());
+        if (mRun) { runningCmd = mRun[1]; thinking = false; lastContentAt = Date.now(); 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 {
+        // The remaining out-of-fence ACTION events ("Command passed → …", "Searching code
+        // → …", "Server up → …", "Composing answer…") each print as ONE solid bullet —
+        // the clean, summarized action list (task #41).
+        process.stdout.write(white(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.204",
   "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",