@tiens.nguyen/gonext-local-worker 1.0.195 → 1.0.196

package/gonext-repl.mjs

@@ -36,7 +36,9 @@ 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 blue = (s) => `\x1b[34m${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 CLEAR_LINE = "\r\x1b[K"; // carriage-return + erase-to-end-of-line
 
 // The worker's "still thinking" heartbeat lines look like "Caffeinating… (90s)" — we
@@ -45,7 +47,7 @@ const CLEAR_LINE = "\r\x1b[K"; // carriage-return + erase-to-end-of-line
 const isHeartbeatLine = (line) => /…\s?\(\d+s\)\s*$/.test(line);
 const isFenceLine = (line) => line.trim() === "~~~";
 // The model's raw Python code blob is delimited by <code>/</code> lines. We don't print
-// the tag lines themselves, but the code IN BETWEEN prints in a distinct color (blue)
+// the tag lines themselves, but the code IN BETWEEN prints in a distinct grey (codeColor)
 // instead of dim prose, so it visually separates from the "Thought:" reasoning.
 const isCodeOpenLine = (line) => line.trim() === "<code>";
 const isCodeCloseLine = (line) => line.trim() === "</code>";
@@ -127,16 +129,26 @@ if (!workerKey || !apiBase) {
 // readline stops managing the line/cursor itself; the OS's own canonical-mode terminal
 // still echoes keystrokes normally, and 'line' events fire exactly the same.
 const rl = createInterface({ input: process.stdin, output: process.stdout, terminal: false });
+// Side effect of terminal:false above: readline no longer intercepts arrow keys for
+// command-history recall, so pressing ↑/↓/→/← (or Home/End/Delete) sends the RAW escape
+// bytes straight through as literal input — the OS's own canonical line discipline
+// doesn't understand them either, so they get echoed and end up IN the submitted line
+// once Enter is pressed (seen live: a task sent to the model started with a literal
+// "\x1b[A" from an accidental up-arrow press). Strip CSI escape sequences (ESC '[' …
+// final-byte) from every submitted line so stray arrow-key presses can't corrupt task
+// text sent to the model.
+const stripAnsiEscapes = (s) => String(s ?? "").replace(/\x1b\[[0-9;]*[A-Za-z~]/g, "");
 const _lineQueue = [];
 let _lineWaiter = null;
 let _stdinClosed = false;
 rl.on("line", (l) => {
+  const clean = stripAnsiEscapes(l);
   if (_lineWaiter) {
     const w = _lineWaiter;
     _lineWaiter = null;
-    w(l);
+    w(clean);
   } else {
-    _lineQueue.push(l);
+    _lineQueue.push(clean);
   }
 });
 rl.on("close", () => {
@@ -359,8 +371,8 @@ async function runAgentTurn(history) {
   // Split newly-arrived text into lines: heartbeats + ~~~ fences + the post-tool-call step
   // summary ("tool(...) | → result", redundant with the daemon's own terminal) are
   // swallowed; the model's <code>/</code> TAG lines are hidden but the code body between
-  // them prints in blue (not dim, so it stands out from "Thought:" prose); blank lines
-  // keep spacing; everything else commits dim to scrollback.
+  // them prints in a distinct grey (not dim, so it stands out from "Thought:" prose);
+  // blank lines keep spacing; everything else commits dim to scrollback.
   let inCode = 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
@@ -400,7 +412,7 @@ async function runAgentTurn(history) {
         if (isCodeCloseLine(line)) { inCode = false; lastContentAt = Date.now(); continue; }
         if (line.trim() === "") { lastContentAt = Date.now(); continue; } // skip blank lines in code
         onContent();
-        process.stdout.write(blue(line) + "\n");
+        process.stdout.write(codeColor(line) + "\n");
         lastWasBlank = false;
         continue;
       }

package/gonext_agent_chat.py

@@ -297,6 +297,15 @@ _EMAIL_CONFIRM = re.compile(
     re.IGNORECASE,
 )
 
+# A bare "continue"-style nudge — matched WHOLE-MESSAGE (anchored) so it only fires on a
+# short, unambiguous continuation cue, never a longer sentence that happens to contain
+# one of these words. See _continuation_pending().
+_CONTINUE_CUE = re.compile(
+    r"^(please\s+)?(continue|keep\s+going|go\s+on|resume|carry\s+on|try\s+again)"
+    r"[\s.!?]*$",
+    re.IGNORECASE,
+)
+
 
 def _email_allowed(addr, allow):
     """True if addr matches an allow-list entry — an exact address or a bare domain."""
@@ -2220,6 +2229,29 @@ def run_agent_chat(cfg):
         return bool(_EMAIL_AVAILABLE and _EMAIL_CONFIRM.search(latest_user_text or "")
                     and _prior_email_preview())
 
+    def _prior_turn_was_interrupted() -> bool:
+        """True if the immediately preceding assistant turn is one of OUR OWN
+        interrupted-investigation markers (the honest degrade-fallback note, or the
+        max-steps 'ran out of steps' note) — i.e. a genuine tool-use attempt started but
+        didn't finish, as opposed to a normal completed answer."""
+        for m in reversed(messages[:last_user_idx]):
+            if m.get("role") == "assistant":
+                c = m.get("content") or ""
+                return ("ran out of steps before finishing" in c
+                        or "couldn't finish the full investigation" in c)
+        return False
+
+    def _continuation_pending() -> bool:
+        """A bare 'continue'/'keep going' after an interrupted investigation must reach
+        the AGENT, not plain chat — plain chat has zero tool access and can never
+        actually continue a stalled grep_repo/read_file_lines investigation, which is
+        exactly the reported bug: 'continue' silently degraded to a tool-less reply that
+        could only apologize, never resume. Gated tightly (short continuation phrase +
+        genuinely-interrupted prior turn) so it doesn't misfire on an unrelated 'continue'
+        after a normal, already-complete answer."""
+        return bool(_CONTINUE_CUE.match((latest_user_text or "").strip())
+                    and _prior_turn_was_interrupted())
+
     # Route: does this task need HTTP tool use? A trivial greeting/thank-you/"who are you"
     # is caught LOCALLY (no model classifier call, no tool preamble) → straight to a fast
     # small-prompt reply. Otherwise ask the model classifier.
@@ -2236,6 +2268,13 @@ def run_agent_chat(cfg):
         _log("router → YES (email confirm pending)")
         _emit({"type": "step", "text": "→ Agent mode (email confirm)"})
         needs_agent = True
+    # A bare "continue" after WE reported an interrupted investigation must reach the
+    # agent too — plain chat has zero tool access, so it can only apologize again, never
+    # actually resume the grep_repo/read_file_lines work (the reported bug).
+    if not needs_agent and _continuation_pending():
+        _log("router → YES (continuation of an interrupted investigation)")
+        _emit({"type": "step", "text": "→ Agent mode (continuing)"})
+        needs_agent = True
 
     if not needs_agent:
         _log("router: plain chat (no HTTP needed)")

package/package.json

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