@tiens.nguyen/gonext-local-worker 1.0.260 → 1.0.262

package/gonext-repl.mjs

@@ -383,6 +383,30 @@ rl.on("close", () => {
     w(null);
   }
 });
+// Mouse click-to-expand (task #96): while a turn runs we turn ON xterm button tracking so a
+// click on the live "thinking" status can expand it (see runAgentTurn). Trade-off the user
+// accepted: with tracking on, the terminal's own drag-to-select/copy is captured by us — the
+// user holds Option/Shift to select text meanwhile. ?1000 = report button press+release only
+// (no motion, so we don't flood on mouse-move); ?1006 = SGR extended coords (no 223-col cap).
+const MOUSE_ON = "\x1b[?1000h\x1b[?1006h";
+const MOUSE_OFF = "\x1b[?1000l\x1b[?1006l";
+let _mouseEnabled = false;
+const enableMouse = () => {
+  if (_mouseEnabled || !process.stdin.isTTY) return;
+  process.stdout.write(MOUSE_ON);
+  _mouseEnabled = true;
+};
+const disableMouse = () => {
+  if (!_mouseEnabled) return;
+  process.stdout.write(MOUSE_OFF);
+  _mouseEnabled = false;
+};
+// Safety net: never leave the user's terminal in mouse-reporting mode (would break their
+// shell's selection) if we exit ungracefully.
+process.on("exit", disableMouse);
+// SGR mouse report: ESC [ < btn ; col ; row (M=press, m=release). A left-button PRESS is
+// btn low-2-bits 0 with the wheel bit (64) clear.
+const MOUSE_RE = /\x1b\[<(\d+);(\d+);(\d+)([Mm])/g;
 const nextLine = () =>
   _lineQueue.length > 0
     ? Promise.resolve(_lineQueue.shift())
@@ -1025,13 +1049,20 @@ const normalizeThought = (buf) => {
   const t = String(buf || "");
   const ci = t.search(/<code[\s>]/i);
   const head = ci >= 0 ? t.slice(0, ci) : t;
-  // 1) a genuine Thought prose line (before the code) — only if it isn't itself code.
+  // 1) a genuine Thought prose line (before the code) — only if it isn't itself code AND
+  //    reads like an actual clause. A streaming token boundary can leave the first
+  //    non-empty line as a single bare word (e.g. "string", when the model is rambling
+  //    about "multi-line strings"); shown alone on the blinking line it's meaningless and,
+  //    because liveThought only updates on a truthy value, it can FREEZE there through a
+  //    long silent prompt-eval ("string… (777s)"). Require ≥2 words and a little length so
+  //    a lone fragment falls through to the tool label / "Thinking…" instead.
   const prose = head
     .replace(/^\s*Thought:\s*/i, "")
     .split(/\n/)
     .map((x) => x.trim())
     .find(Boolean);
-  if (prose && !_thoughtLooksCodey(prose)) return prose.slice(0, 100);
+  const proseIsClause = !!prose && prose.length >= 6 && prose.trim().split(/\s+/).length >= 2;
+  if (proseIsClause && !_thoughtLooksCodey(prose)) return prose.slice(0, 100);
   // 2) otherwise name the tool being called (from the code part).
   const codePart = ci >= 0 ? t.slice(ci) : t;
   const m = /(?:<code>\s*)?\b([a-z_]\w*)\s*\(\s*(?:path\s*=\s*)?["']?([^"'\n,)]*)/i.exec(codePart);
@@ -1040,6 +1071,52 @@ const normalizeThought = (buf) => {
   return "";
 };
 
+// The FULLER thought (task #96): the same Thought prose normalizeThought summarizes, but
+// NOT clipped to one clause/100 chars — collapsed to a single spaced string and capped so
+// the expanded (mouse-click) view has a few lines to show. Returns "" when the live line is
+// only a tool label (nothing extra to expand). Bounded by fenceThought's own 400-char cap.
+const thoughtFull = (buf) => {
+  const t = String(buf || "");
+  const ci = t.search(/<code[\s>]/i);
+  const head = (ci >= 0 ? t.slice(0, ci) : t)
+    .replace(/^\s*Thought:\s*/i, "")
+    .replace(/\s+/g, " ")
+    .trim();
+  // Only worth expanding when there's a genuine prose clause (same gate as normalizeThought
+  // path 1) — a bare fragment or pure code has nothing meaningful to unfold.
+  const first = head.split(/\s+/).length;
+  if (head.length < 6 || first < 2 || _thoughtLooksCodey(head)) return "";
+  return head.slice(0, 400);
+};
+
+// Word-wrap a plain (ANSI-free) string into at most `maxLines` lines of width ≤ `width`,
+// appending an ellipsis to the last line when text was dropped (task #96 expand view).
+const wrapThought = (s, width, maxLines) => {
+  const words = String(s || "").split(/\s+/).filter(Boolean);
+  const lines = [];
+  let cur = "";
+  let truncated = false;
+  for (let i = 0; i < words.length; i++) {
+    const w = words[i];
+    const next = cur ? cur + " " + w : w;
+    if (next.length <= width) {
+      cur = next;
+    } else {
+      if (cur) lines.push(cur);
+      cur = w;
+      if (lines.length >= maxLines) { truncated = true; cur = ""; break; }
+    }
+  }
+  if (cur && lines.length < maxLines) lines.push(cur);
+  else if (cur) truncated = true;
+  if (truncated && lines.length) {
+    const last = lines[maxLines - 1] ?? lines[lines.length - 1];
+    const room = Math.max(1, width - 1);
+    lines[lines.length - 1] = (last.length > room ? last.slice(0, room) : last).replace(/\s+$/, "") + "…";
+  }
+  return lines;
+};
+
 async function runAgentTurn(history) {
   const res = await fetch(`${apiBase}/api/worker/agent-ask`, {
     method: "POST",
@@ -1083,6 +1160,7 @@ async function runAgentTurn(history) {
   let lastApprovalId = null; // the last command-approval request we've already answered
   let carry = ""; // trailing partial content line held until its newline arrives
   let statusShown = false; // a transient status line is currently on screen
+  let statusLines = 2; // how many rows the status block currently occupies (grows when expanded)
   let warnedPending = false;
   // Transient poll failures (a network blip or a 5xx like the API's momentary "Worker
   // key lookup failed." — a cold Mongo connection, NOT a bad key) must NOT kill a
@@ -1117,6 +1195,7 @@ async function runAgentTurn(history) {
   // "◐ 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
+  const STALE_THOUGHT_MS = 25000; // no new tokens this long ⇒ the current Thought clause is stale (#95 A)
   let lastContentAt = Date.now();
   let thinking = false;
   let thinkingSince = 0;
@@ -1130,14 +1209,21 @@ async function runAgentTurn(history) {
   // random word. `fenceThought` accumulates the raw in-fence text for the current step.
   let liveThought = "";
   let fenceThought = "";
+  // Task #96: the FULLER version of the current thought (for the click-to-expand view) and
+  // whether the user has clicked to expand it. Both reset when the step's Thought changes.
+  let fullLiveThought = "";
+  let thoughtExpanded = false;
   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.
+  // The status is normally TWO in-place lines — the in-progress action, then the playful
+  // word under it — but grows by a few grey lines when the thought is expanded (task #96).
+  // Cursor sits at the end of the LAST line, so clearing = wipe it, then move-up-and-wipe
+  // for each line above, leaving the cursor back at the status's origin for a redraw.
   const clearStatus = () => {
     if (!statusShown) return;
-    process.stdout.write("\r\x1b[K\x1b[1A\r\x1b[K");
+    let seq = "\r\x1b[K";
+    for (let i = 1; i < statusLines; i++) seq += "\x1b[1A\r\x1b[K";
+    process.stdout.write(seq);
     statusShown = false;
   };
 
@@ -1154,6 +1240,13 @@ async function runAgentTurn(history) {
       thinking = true; thinkingSince = lastContentAt; thinkWord = pickWord(); lastWordBucket = 0;
     }
     const now = Date.now();
+    // Age out a stale Thought clause: if the model has produced NO new stream content for a
+    // while (e.g. a 150s+ silent prompt-eval on a huge context), the last clause is no longer
+    // "what it's doing now" — drop it so the line falls back to the playful word / "Thinking…"
+    // instead of freezing on an old thought while the timer climbs ("string… (777s)", #95 A).
+    if (liveThought && now - lastContentAt > STALE_THOUGHT_MS) {
+      liveThought = ""; fullLiveThought = ""; thoughtExpanded = false; // #96: nothing to expand once stale
+    }
     const secs = thinkSecs();
     // Rotate the playful word once per 12s window (guarded so the fast ticker doesn't
     // re-roll it many times within the same second).
@@ -1185,16 +1278,58 @@ async function runAgentTurn(history) {
     const tokLabel =
       dim(` · ${fmtTokens(latestCodeTokens)} tok`) +
       orange(` · ${fmtTokens(sessionMaxCodeTokens)} max`);
-    process.stdout.write(
+    let out =
       `${green(BULLET)} ${green(`${fit(primary)}… (${secs}s)`)}` +
-        "\n" + `  ${color256(wc, `${glyph} ${thinkWord}…`)}${tokLabel}`
-    );
+      "\n" + `  ${color256(wc, `${glyph} ${thinkWord}…`)}${tokLabel}`;
+    let drawn = 2;
+    // Task #96: when the user has clicked the thought line, unfold the fuller thought below
+    // it as up to 4 wrapped GREY lines (dim). Only when there's genuinely more to show than
+    // the truncated primary (a live command / bare "Thinking" has nothing to expand).
+    if (thoughtExpanded && fullLiveThought && !runningCmd) {
+      const wrapped = wrapThought(fullLiveThought, max, 4);
+      for (const wl of wrapped) { out += "\n  " + dim(wl); drawn++; }
+    }
+    process.stdout.write(out);
+    statusLines = drawn;
     statusShown = true;
   };
   // 120ms so the spinner animates smoothly (the frame math above uses the wall clock, so
   // seconds still tick once/sec). Only redraws when the model has gone quiet >QUIET_MS.
   const ticker = setInterval(tick, 120);
 
+  // --- Click-to-expand the thinking line (task #96) --------------------------------------
+  // A left-click on the live status block toggles the fuller thought (3-4 grey lines). The
+  // status block sits at the bottom of the viewport (new output keeps scrolling it there),
+  // so we hit-test the click row against the bottom `statusLines` rows. We enable xterm
+  // mouse reporting only for the duration of the turn and always turn it back off in the
+  // finally + on process exit, so the user's shell is never left in mouse-capture mode.
+  const onStatusClick = (row) => {
+    if (!statusShown) return;
+    const rows = process.stdout.rows || 24;
+    const top = rows - statusLines + 1; // 1-based viewport row of the first status line
+    if (row < top || row > rows) return; // click landed outside the status block
+    // Only meaningful when there IS a fuller thought to reveal; otherwise ignore the click
+    // so we don't flicker an empty expand.
+    if (!thoughtExpanded && !(fullLiveThought && !runningCmd)) return;
+    thoughtExpanded = !thoughtExpanded;
+    clearStatus(); // next tick (≤120ms) redraws at the new size; keeps cursor math correct
+  };
+  const onMouseData = (chunk) => {
+    if (!following) return;
+    const s = chunk.toString("latin1");
+    if (s.indexOf("\x1b[<") === -1) return; // fast reject: no SGR mouse report in this chunk
+    MOUSE_RE.lastIndex = 0;
+    let m;
+    while ((m = MOUSE_RE.exec(s))) {
+      const btn = parseInt(m[1], 10);
+      const row = parseInt(m[3], 10);
+      const isPress = m[4] === "M";
+      if (isPress && (btn & 0b11) === 0 && (btn & 64) === 0) onStatusClick(row); // left press
+    }
+  };
+  if (process.stdin.isTTY) process.stdin.on("data", onMouseData);
+  enableMouse();
+
   // 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).
@@ -1206,6 +1341,8 @@ async function runAgentTurn(history) {
     // next step's blinking line starts from "Thinking", not last step's stale clause.
     liveThought = "";
     fenceThought = "";
+    fullLiveThought = "";       // #96: the fuller thought is spent too…
+    thoughtExpanded = false;    // …and each new thinking phase starts collapsed.
     lastContentAt = Date.now();
   };
 
@@ -1264,6 +1401,7 @@ async function runAgentTurn(history) {
           fenceThought += line + "\n";
           const th = normalizeThought(fenceThought);
           if (th) liveThought = th;
+          fullLiveThought = thoughtFull(fenceThought); // #96: keep the fuller thought for expand
         }
         continue;
       }
@@ -1403,6 +1541,7 @@ async function runAgentTurn(history) {
     if (inStreamFence && fenceThought.length < 400) {
       const th = normalizeThought(fenceThought + carry);
       if (th) liveThought = th;
+      fullLiveThought = thoughtFull(fenceThought + carry); // #96: fuller thought for expand
     }
     // 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.
@@ -1561,6 +1700,11 @@ async function runAgentTurn(history) {
   } finally {
     clearInterval(ticker);
     clearStatus();
+    // 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.
+    disableMouse();
+    if (process.stdin.isTTY) process.stdin.removeListener("data", onMouseData);
     following = false;
     currentJobId = null;
     // Drop anything typed (but not submitted) during the turn — echo was muted, so it's

package/gonext_agent_chat.py

@@ -1077,6 +1077,35 @@ def _plain_reply(messages: list, base_url: str, api_key: str, model_id: str,
     raise RuntimeError(f"couldn't get a response ({_clip(str(last_err), 160)})")
 
 
+# A model-server call can fail for two very different reasons, and they deserve
+# different handling:
+#   • the BACKEND is unavailable — an nginx 502/503/504 (the upstream Ollama/MLX box is
+#     down, restarting, still loading the weights, or overloaded past the proxy's read
+#     timeout), or the socket refused/timed out. These are INFRA outages: retrying a bit
+#     harder can ride out a blip, and if it persists the honest thing is to SAY the
+#     coding backend is down — never to hallucinate a generic answer as if we succeeded.
+#   • a genuine model/agent error — worth the plain-reply degrade.
+# `str(e)` for a proxy error is the raw nginx HTML ("<html>…502 Bad Gateway…"), so match
+# on the status text/codes and the common connection-failure phrases.
+def _is_backend_unavailable(err) -> bool:
+    s = str(err or "").lower()
+    return (
+        "502 bad gateway" in s
+        or "503 service" in s
+        or "504 gateway" in s
+        or "bad gateway" in s
+        or "gateway time-out" in s
+        or "gateway timeout" in s
+        or "connection refused" in s
+        or "connection reset" in s
+        or "connection aborted" in s
+        or "failed to establish a new connection" in s
+        or "max retries exceeded" in s
+        or "read timed out" in s
+        or "timed out" in s
+    )
+
+
 def _synthesize_document(gathered: list, task: str, base_url: str, api_key: str,
                          model_id: str) -> str:
     """Turn raw gathered research observations into ONE clean, organized document body
@@ -1179,11 +1208,19 @@ def _normalize_code_tags(text: str) -> str:
     return fixed
 
 
-def _escape_raw_newlines_in_strings(code: str) -> str:
+def _escape_raw_newlines_in_strings(code: str, defuse_tags: bool = False) -> str:
     """Turn RAW newlines/tabs that sit INSIDE a single/double-quoted string literal into
     \\n/\\t escapes. Triple-quoted strings, comments, and everything outside a string are
     copied verbatim. A tiny hand-rolled scanner (the code doesn't parse, so ast/tokenize
-    can't help). Used only by _repair_unterminated_string below."""
+    can't help). Used by _repair_unterminated_string below.
+
+    defuse_tags: also rewrite a literal <code>/</code> that appears INSIDE a string literal
+    (e.g. the file content the model is writing legitimately contains React's default
+    "Edit <code>src/App.js</code>") to <co\\x64e>/</co\\x64e>. The `\\x64` is Python's hex
+    escape for 'd', so at RUNTIME the string is still exactly "<code>"/"</code>" — but the
+    literal source no longer contains the token smolagents uses as its code-block delimiter,
+    so its parser can't mis-close the block on content. Only touches tags inside strings;
+    the real closing </code> lives OUTSIDE any string and is left intact."""
     out = []
     i, n = 0, len(code)
     quote = None      # the delimiter of the string we're inside, or None
@@ -1196,7 +1233,10 @@ def _escape_raw_newlines_in_strings(code: str) -> str:
                 end = code.find(three, i + 3)
                 if end == -1:
                     out.append(code[i:]); break
-                out.append(code[i:end + 3]); i = end + 3; continue
+                seg = code[i:end + 3]
+                if defuse_tags:
+                    seg = seg.replace("</code>", "</co\\x64e>").replace("<code>", "<co\\x64e>")
+                out.append(seg); i = end + 3; continue
             if ch == "#":                          # comment — copy to end of line
                 j = code.find("\n", i)
                 if j == -1:
@@ -1212,6 +1252,11 @@ def _escape_raw_newlines_in_strings(code: str) -> str:
                 out.append(ch); escaped = True; i += 1; continue
             if ch == quote:
                 out.append(ch); quote = None; i += 1; continue
+            # Defuse a delimiter-colliding tag INSIDE the string (see docstring).
+            if defuse_tags and code.startswith("</code>", i):
+                out.append("</co\\x64e>"); i += 7; continue
+            if defuse_tags and code.startswith("<code>", i):
+                out.append("<co\\x64e>"); i += 6; continue
             out.append({"\n": "\\n", "\r": "\\r", "\t": "\\t"}.get(ch, ch)); i += 1
     return "".join(out)
 
@@ -1242,15 +1287,42 @@ def _repair_unterminated_string(code: str) -> str:
 def _repair_code_block_strings(text: str) -> str:
     """Apply _repair_unterminated_string to the python inside a <code>…</code> block
     (leaving the surrounding Thought prose untouched). No-op when there's no block or the
-    block already parses."""
-    m = re.search(r"<code>([\s\S]*?)</code>", text)
-    if not m:
+    block already parses.
+
+    Two-stage rescue:
+      1. NON-GREEDY span (first <code> → first </code>) + raw-newline escaping — the common
+         case (multi-line file content with unescaped newlines).
+      2. If that still won't compile AND the content itself contains extra </code> tags
+         (the model is writing a file whose CONTENT legitimately has <code>/</code> — e.g.
+         React's default App.js "Edit <code>src/App.js</code>"), the non-greedy match closed
+         the block early on that inner tag → a truncated, unterminatable fragment. Retry with
+         the GREEDY span (first <code> → LAST </code>) and defuse the in-string tags so the
+         only real </code> left is the true closer. This is the fix for the create_file loop
+         where the coder burned minutes/100k+ tokens on 'unterminated string literal'."""
+    om = re.search(r"<code>", text)
+    if not om:
         return text
-    inner = m.group(1)
-    fixed = _repair_unterminated_string(inner)
-    if fixed == inner:
+    open_end = om.end()
+    cm = re.search(r"</code>", text[open_end:])
+    if not cm:
         return text
-    return text[:m.start(1)] + fixed + text[m.end(1):]
+    close_start = open_end + cm.start()
+    inner = text[open_end:close_start]
+    fixed = _repair_unterminated_string(inner)
+    if fixed != inner:
+        return text[:open_end] + fixed + text[close_start:]
+    # Stage 2 — only worth trying when there's MORE than one </code> (extra tags in content).
+    last = text.rfind("</code>")
+    if last <= close_start:
+        return text  # single </code>; nothing a greedy re-read would change
+    greedy = text[open_end:last]
+    sanitized = _escape_raw_newlines_in_strings(greedy, defuse_tags=True)
+    try:
+        compile(sanitized, "<gonext-code>", "exec")
+    except Exception:  # noqa: BLE001
+        return text  # still not parseable — leave it for the loop-breaker / model retry
+    # Rebuild so the FIRST literal </code> is now the true closer (inner ones are defused).
+    return text[:open_end] + sanitized + text[last:]
 
 
 def _strip_think(text: str) -> str:
@@ -4173,6 +4245,12 @@ def run_agent_chat(cfg):
             # Largest SINGLE-request prompt-token count seen this turn (task #84) — the
             # peak context size, not the sum. The REPL keeps a per-workspace max of this.
             self._code_tokens_max = 0
+            # Loop-breaker (#95 B1): how many CONSECUTIVE generations have produced a code
+            # block that STILL won't compile after our repair. A weak coder can get stuck
+            # re-emitting the same unparseable tool call (seen live: create_file with a
+            # multi-line string, ~10 identical retries, 863s/133k tokens). After a few in a
+            # row we stop feeding smolagents an un-runnable block and finish honestly.
+            self._parse_fail_streak = 0
             # stream_agent: request the completion with stream=True and reassemble the
             # deltas into one message. Enabled for Ollama, where a long single-shot
             # (non-stream) generation sends nothing until the very end — a reverse proxy
@@ -4445,9 +4523,16 @@ def run_agent_chat(cfg):
             hb.start()
             last_err = None
             try:
-                for attempt in range(3):
+                # A gateway outage (502/503/504, refused/reset/timeout) is transient infra —
+                # the remote box may just be cold or the proxy briefly down — so give it MORE
+                # attempts and a longer backoff to ride out a blip, instead of the 3 quick
+                # tries a normal error gets. The attempt count is decided per-error: we start
+                # with the generic budget and extend it the moment we see a gateway error.
+                attempt, max_attempts = 0, 3
+                while attempt < max_attempts:
                     try:
                         msg = self._generate_once(*args, **kwargs)
+                        last_err = None
                         break
                     except Exception as e:  # noqa: BLE001
                         emsg = str(e)
@@ -4465,10 +4550,19 @@ def run_agent_chat(cfg):
                                 "names (for Ollama use the tag, e.g. qwen3:14b)."
                             ) from e
                         last_err = e
-                        if attempt < 2:
-                            _log(f"generate transient error (attempt {attempt + 1}/3): {e} — retrying")
-                            time.sleep(1.5 * (attempt + 1))
-                else:
+                        gateway = _is_backend_unavailable(e)
+                        if gateway and max_attempts < 6:
+                            max_attempts = 6  # stretch the budget for a flaky backend
+                        attempt += 1
+                        if attempt < max_attempts:
+                            # Longer, capped backoff for gateway errors (up to ~8s) so a
+                            # cold/loading model has time to come back; short for the rest.
+                            delay = min(8.0, 2.0 * attempt) if gateway else 1.5 * attempt
+                            kind = "gateway/backend unavailable" if gateway else "transient"
+                            _log(f"generate {kind} error (attempt {attempt}/{max_attempts}): "
+                                 f"{_clip(emsg, 160)} — retrying in {delay:.0f}s")
+                            time.sleep(delay)
+                if last_err is not None:
                     raise last_err
             finally:
                 hb_stop.set()
@@ -4532,7 +4626,42 @@ def run_agent_chat(cfg):
                             _log("repaired unterminated string literal in tool-call code")
                         if repaired != content:
                             msg.content = repaired
+                        # Loop-breaker (#95 B1): if the block STILL won't compile after the
+                        # repair, the model is stuck emitting an unparseable tool call. Count
+                        # consecutive failures; after a few, finish honestly rather than burn
+                        # the whole step budget — each retry is a full (often 150s+) model
+                        # call on an ever-growing context. B2's greedy/defuse fix means the
+                        # <code>-in-content collision now compiles here, so this only trips on
+                        # genuinely un-fixable code (e.g. a truncated generation).
+                        _cb = re.search(r"<code>([\s\S]*?)</code>", msg.content or "")
+                        _still_bad = False
+                        if _cb:
+                            try:
+                                compile(_cb.group(1), "<gonext-code>", "exec")
+                            except Exception:  # noqa: BLE001
+                                _still_bad = True
+                        if _still_bad:
+                            self._parse_fail_streak += 1
+                            _log("tool-call code still unparseable after repair "
+                                 f"(streak {self._parse_fail_streak}/3)")
+                            if self._parse_fail_streak >= 3:
+                                _log("parse-fail streak hit limit → ending the turn honestly "
+                                     "instead of looping on an unparseable tool call")
+                                _stuck_msg = (
+                                    "I got stuck on a code-formatting error: my edit to the "
+                                    "file kept failing to parse (a string/escaping issue in the "
+                                    "tool call), so I stopped instead of retrying in a loop. "
+                                    "Any dev server I started is still running. Please try "
+                                    "again, or tell me the specific change to make and I'll "
+                                    "keep it to a small, single-line edit."
+                                )
+                                msg.content = ("<code>\nfinal_answer("
+                                               + repr(_stuck_msg) + ")\n</code>")
+                                self._parse_fail_streak = 0
+                        else:
+                            self._parse_fail_streak = 0
                     else:
+                        self._parse_fail_streak = 0  # a prose turn isn't a parse failure
                         stripped = content.strip()
                         looks_final = (
                             len(stripped) >= 400 or re.search(
@@ -5778,6 +5907,26 @@ def run_agent_chat(cfg):
             _log(f"agent config error (not degrading): {cfg_err}")
             _emit({"type": "final", "text": f"⚠️ {cfg_err}"})
             return
+        # Coding-model BACKEND outage (502/503/504, refused/timeout): the tool-capable
+        # loop never got to run because its code model was unreachable. Do NOT fall through
+        # to _plain_reply — a bare chat model would stream a confident GENERIC how-to (e.g.
+        # "to create a React app, run npx create-react-app…") that looks like a real answer
+        # but did NOTHING the user asked (seen live: "create a reactjs and start it" → the
+        # coder 502'd 3× → generic instructions, no warning). That's worse than an honest
+        # failure: it hides the outage and, being persisted to history, misleads the next
+        # turn. Emit a clear, standalone "backend is down, retry" and stop — the checkpoint
+        # is kept (not cleared) so a later "continue" resumes once the box is back.
+        if _is_backend_unavailable(e):
+            _log(f"agent error (coding-model backend unavailable, NOT degrading): {_clip(str(e), 160)}")
+            _emit({"type": "final", "text": (
+                "⚠️ The coding model backend is currently unavailable (the server returned "
+                "a gateway error / timed out), so I couldn't run the tools to do this. It's "
+                "usually starting up, reloading the model, or briefly overloaded — not a "
+                "problem with your request. Please try again in a moment; if it keeps "
+                "happening, check that the coding model server is up. (I didn't make any "
+                "changes.)"
+            )})
+            return
         # An unexpected failure inside the agent loop should still return a useful
         # answer from the conversation rather than surfacing a raw error to the user —
         # but only when the fallback ACTUALLY has something useful to say.

package/package.json

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