@tiens.nguyen/gonext-local-worker 1.0.313 → 1.0.314

package/gonext-repl.mjs

@@ -948,6 +948,11 @@ let cancelRequested = false; // a cancel POST has been sent for the current turn
 let approvalActive = false;
 let approvalSel = 0; // 0 = Yes (default highlighted), 1 = No
 let approvalResolve = null;
+// The active turn's live-status wiper (its local clearStatus), or null between turns. A
+// picker calls this before drawing so the "Almost done…/thought/token" block is gone
+// first — otherwise the 120ms ticker keeps redrawing that block on top of the picker and
+// its relative-cursor math lands on the wrong rows (duplicated/interleaved options).
+let clearActiveStatus = null;
 function drawApprovalOptions(redraw) {
   // Two option lines, redrawn in place. On redraw the cursor sits one row below "No";
   // step up 2 rows, clear+rewrite both, landing back where we started.
@@ -986,6 +991,10 @@ const MAXSTEP_PREFIX = "__MAXSTEP__::";
 const TIMEOUT_PREFIX = "__TIMEOUT__::";
 const COMPACT_PREFIX = "__COMPACT__::";
 async function approvalPrompt(command) {
+  // Wipe the live "thinking" status block BEFORE any picker draws, and stop the ticker from
+  // redrawing it (the tick early-returns while a picker is active) — otherwise the block
+  // reappears under the options and corrupts the layout.
+  if (clearActiveStatus) clearActiveStatus();
   // Context-compaction prompt (task #87 rec#3): the running context got large. Ask whether
   // to aggressively compact older steps. No answer in 30s = No (keep full detail — the safe
   // default; the always-on auto-trim still bounds things).
@@ -1463,10 +1472,11 @@ async function runAgentTurn(history) {
     process.stdout.write(seq);
     statusShown = false;
   };
+  clearActiveStatus = clearStatus; // let pickers wipe this turn's status block before they draw
 
   const tick = () => {
     if (!following || followAborted || !jobRunning) return;
-    if (approvalActive) return; // a Yes/No picker owns the screen — don't draw over it
+    if (approvalActive || listPickerActive) return; // a picker owns the screen — don't draw over it
     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 — overwriting the ticker there corrupts the visible answer mid-word. Stay
@@ -2009,6 +2019,7 @@ async function runAgentTurn(history) {
   } finally {
     clearInterval(ticker);
     clearStatus();
+    clearActiveStatus = null; // no turn owns the status wiper between turns
     // Task #96: stop mouse-reporting the moment the turn ends (also on cancel/error — this
     // finally always runs), and detach the click parser, so the user's shell selection is
     // never captured between turns.

package/gonext_agent_chat.py

@@ -5071,20 +5071,40 @@ def run_agent_chat(cfg):
             """Recover a <code>…</code> tool call that a reasoning model placed in the
             REASONING channel instead of the visible message (task #111). No-op when the
             visible content already has a usable code block, or when there is no reasoning
-            text (e.g. Ollama with reasoning_effort='none') — so the Ollama path is unchanged."""
+            text (e.g. Ollama with reasoning_effort='none') — so the Ollama path is unchanged.
+
+            Kimi K3 @ Moonshot splits its output two ways when it fails: (a) the full
+            <code>…</code> block lands in reasoning and only prose leaks to content; or
+            (b) the OPENER + code land in reasoning while the CLOSING </code> leaks into
+            content (seen live: content = 'Thought: …contains.</code>'). Handle both."""
             _pair = r"<code[^>]*>[\s\S]*?</code>"
             if re.search(_pair, content or "", re.I):
-                return content  # already parseable
-            if not (reasoning or "").strip():
+                return content  # content already has a usable block — never override it
+            reasoning = reasoning or ""
+            if not reasoning.strip():
                 return content  # nothing to recover from (Ollama / non-reasoning model)
-            # Take the LAST code block in the combined stream (reasoning usually holds it).
-            combined = (reasoning or "") + "\n" + (content or "")
+            code = None
+            # (a) Prefer a COMPLETE block already inside reasoning (the model drafts the
+            # whole tool call there) — take the LAST one, ignoring any stray </code> in content.
             last = None
-            for last in re.finditer(r"<code[^>]*>([\s\S]*?)</code>", combined, re.I):
+            for last in re.finditer(r"<code[^>]*>([\s\S]*?)</code>", reasoning, re.I):
                 pass
-            if not last:
+            if last:
+                code = last.group(1)
+            else:
+                # (b) Opener + code in reasoning, closer leaked to content → take everything
+                # after the LAST opener in reasoning (its </code> is the one now in content).
+                m = None
+                for m in re.finditer(r"<code[^>]*>([\s\S]*)$", reasoning, re.I):
+                    pass
+                if m:
+                    code = m.group(1)
+            if code is None:
                 return content
-            code = (last.group(1) or "").strip()
+            # A leaked 'Thought:' line (or a stray </code>) can ride along after the code —
+            # cut it so only the executable snippet remains.
+            code = re.split(r"\n\s*Thought\s*:\s", code, maxsplit=1)[0]
+            code = re.sub(r"</?code[^>]*>", "", code, flags=re.I).strip()
             if not code:
                 return content
             # Keep the visible Thought prose (strip any stray/unbalanced code tags), then

package/package.json

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