@tiens.nguyen/gonext-local-worker 1.0.244 → 1.0.247

package/gonext-local-worker.mjs

@@ -1879,6 +1879,9 @@ async function runAgentChatJob(job) {
       // REPL's "I can show a picker" signal (else python keeps hard-blocking, as on web).
       jobId,
       interactiveApproval: payload?.interactiveApproval === true,
+      // Session opt-in (task #80): auto-extend past the step budget without re-prompting
+      // (the REPL sets this once the user picks "yes, don't ask again").
+      alwaysExtendOnMaxStep: payload?.alwaysExtendOnMaxStep === true,
       // Auto-test mode (/test-auto): the agent verifies its work and fixes until it passes.
       autoTest: payload?.autoTest === true,
       // Deploy target chosen via the terminal /server picker (task #69). Host/user only.

package/gonext-repl.mjs

@@ -778,8 +778,25 @@ function onApprovalKey(key) {
 // Show the picker and resolve to the user's choice. Non-TTY (piped) can't pick → deny
 // (safe). Auto-denies after ~170s so an absent user never hangs the turn (and stays
 // under the python side's 180s wait); Enter is instant since Yes is preselected.
-function approvalPrompt(command) {
-  return new Promise((resolve) => {
+// The command carries a "__MAXSTEP__::<message>" sentinel when it's the step-budget
+// continue prompt (task #80) rather than a risky-command approval. That case shows a
+// 3-option picker (Yes / Yes-don't-ask-again / No); a normal command shows Yes/No.
+// Returns { allow, dontAsk } — dontAsk is only ever true for the max-step "don't ask
+// again this session" choice (the caller then stops sending the prompt).
+const MAXSTEP_PREFIX = "__MAXSTEP__::";
+async function approvalPrompt(command) {
+  const isMax = command.startsWith(MAXSTEP_PREFIX);
+  if (isMax) {
+    const label = command.slice(MAXSTEP_PREFIX.length);
+    if (!process.stdin.isTTY) return { allow: false, dontAsk: false };
+    process.stdout.write("\n" + yellow("⏭ " + label) + "\n");
+    const idx = await pickFromList(
+      ["Yes, keep going", "Yes, and don't ask again this session", "No, stop here"],
+      0
+    );
+    return { allow: idx === 0 || idx === 1, dontAsk: idx === 1 };
+  }
+  const allow = await new Promise((resolve) => {
     if (!process.stdin.isTTY) {
       process.stdout.write(dim(`\n(approval needed for: ${command} — no interactive terminal, skipping)\n`));
       resolve(false);
@@ -799,6 +816,7 @@ function approvalPrompt(command) {
       orig(v);
     };
   });
+  return { allow, dontAsk: false };
 }
 // Generic arrow-key list picker (↑/↓ + Enter) — used by /server so you navigate instead
 // of typing a number. Same mechanism as the Yes/No approval picker above, generalized to
@@ -860,6 +878,10 @@ let sessionCodingModel = "";
 // and fixes → re-tests until it passes before finishing. Default off; remembered per
 // folder in the session file; sent to /agent-ask as autoTest so python drives the loop.
 let sessionTestAuto = false;
+// Step-budget opt-out (task #80): set once the user picks "yes, don't ask again" at a
+// max-step prompt. Session-scoped (not persisted per folder); sent to /agent-ask each turn
+// so the agent auto-extends past the step budget without prompting again.
+let alwaysExtendOnMaxStep = false;
 // Deploy target chosen via /server (task #69): {name, host, user} or null. Session-scoped;
 // sent to /agent-ask as deployServer so the agent deploys to this host with KEY auth.
 let selectedServer = null;
@@ -965,6 +987,9 @@ async function runAgentTurn(history) {
       // The terminal can show a Yes/No picker → the agent PAUSES on a risky command and
       // asks instead of hard-blocking it (interactive command-approval gate).
       interactiveApproval: true,
+      // Step-budget opt-out (task #80): once the user chose "don't ask again", auto-extend
+      // past the step budget without prompting.
+      ...(alwaysExtendOnMaxStep ? { alwaysExtendOnMaxStep: true } : {}),
       // Auto-test mode (/test-auto): the agent verifies its work and fixes until it passes.
       ...(sessionTestAuto ? { autoTest: true } : {}),
       // Deploy target chosen via /server — host/user only (no secret), for key-auth deploys.
@@ -1409,7 +1434,13 @@ async function runAgentTurn(history) {
       ) {
         lastApprovalId = job.pendingApproval.id;
         clearStatus();
-        const allow = await approvalPrompt(job.pendingApproval.command || "");
+        const { allow, dontAsk } = await approvalPrompt(job.pendingApproval.command || "");
+        // "Yes, don't ask again this session" (max-step prompt only): remember it so every
+        // later turn sends alwaysExtendOnMaxStep and the agent auto-extends silently (#80).
+        if (dontAsk) {
+          alwaysExtendOnMaxStep = true;
+          process.stdout.write(dim("  (won't ask again about the step budget this session)\n"));
+        }
         try {
           await fetch(`${apiBase}/api/worker/jobs/${jobId}/approval`, {
             method: "POST",

package/gonext_agent_chat.py

@@ -2340,7 +2340,10 @@ def _ws_request_approval(api_base, worker_key, job_id, command, reason):
     except Exception as e:  # noqa: BLE001
         _log(f"approval-request failed: {e} — treating as deny")
         return False
-    _emit({"type": "step", "text": f"Awaiting your approval to run: {command[:70]}"})
+    if command.startswith("__MAXSTEP__::"):
+        _emit({"type": "step", "text": "Awaiting your choice: continue past the step budget?"})
+    else:
+        _emit({"type": "step", "text": f"Awaiting your approval to run: {command[:70]}"})
     deadline = _t.time() + 180  # 3 min; absent user → deny (never auto-run something risky)
     while _t.time() < deadline:
         _t.sleep(1.2)
@@ -3181,19 +3184,26 @@ def run_agent_chat(cfg):
     # flakes, prove the test ran, cap retries) so it converges instead of chasing green.
     _auto_test_block = (
         "\nAUTO-TEST MODE (ON): after you CHANGE code you MUST verify it before "
-        "final_answer — never finish on an untested change. Use the CHEAPEST check that "
-        "proves the change, climbing only as needed:\n"
-        "  1. grep_repo the edited file to confirm the change landed (and the old code is gone).\n"
-        "  2. build / typecheck (e.g. run_command('npm run build') / 'tsc --noEmit' / 'go build').\n"
-        "  3. run the project's tests (npm test / pytest / …) if they exist.\n"
-        "  4. if it's a running app, start it and curl/fetch_url it, then check the response "
+        "final_answer — never finish on an untested change. Climb the CHEAPEST check that "
+        "proves the change, only as far as needed:\n"
+        "  1. grep_repo the edited file to confirm the change landed (old code gone).\n"
+        "  2. STATIC (cheapest — nothing runs): typecheck + lint. run_command('tsc --noEmit' "
+        "/ 'mypy' / 'go vet'; 'eslint' / 'ruff'). Fix errors here first.\n"
+        "  3. build / compile if the project does (npm run build / go build).\n"
+        "  4. run the project's tests (npm test / pytest / …) if they exist — prefer the "
+        "SINGLE test/file covering your change for speed (e.g. pytest path::test_x).\n"
+        "  5. if it's a running app, start it and curl/fetch_url it, then check the response "
         "contains what the change should produce.\n"
-        "DECIDE what 'passes' BEFORE you fix — do NOT weaken the check to make it green. If a "
-        "check FAILS: read the error, make ONE fix, then RE-TEST the SAME way. If it passes only "
-        "after re-running with no change, it was flaky — stop, don't keep editing. Give up after "
-        "3 fix attempts on the same failure and final_answer honestly what still fails. Confirm a "
-        "test actually exercised the change (e.g. the asserted text was really present), not an "
-        "empty/no-op pass.\n"
+        "FIXING A BUG → write a MINIMAL test that reproduces it and run it FIRST: it must FAIL "
+        "(red) BEFORE your fix and PASS (green) after. A test that passes before you change "
+        "anything proves nothing. Keep it with the project's other tests.\n"
+        "Before final_answer, run_command('git diff') (or 'git status' if not a git repo) to "
+        "review EVERYTHING you changed — only what you intended, no stray edits or debug prints.\n"
+        "DECIDE what 'passes' BEFORE you fix — do NOT weaken the check to make it green. On a "
+        "FAIL: read the error, make ONE fix, RE-TEST the SAME way. Passes only after a no-change "
+        "re-run = flaky, stop editing. Give up after 3 fix attempts on the same failure and "
+        "final_answer honestly what still fails. Confirm a test actually exercised the change "
+        "(the asserted behavior really ran), not an empty/no-op pass.\n"
         if (_auto_test and _WS_AVAILABLE) else ""
     )
     # Deploy target (/server): when the user picked one, tell the agent to deploy THERE
@@ -3383,6 +3393,54 @@ def run_agent_chat(cfg):
     # still deterministically deliver (e.g. render a partial PDF) instead of dead-ending.
     _gathered: list = []
 
+    # --- Loop / no-progress guards (task #79) -------------------------------------------
+    # Weak coders thrash on a debug loop: rewrite a file to a previously-tried version,
+    # re-hit a broken endpoint, and re-read unchanged files — burning the whole step
+    # budget without new information. These caches let the tools detect and refuse that.
+    _file_writes: dict = {}   # realpath -> {content hashes already written this run}
+    _url_5xx: dict = {}       # localhost url -> how many 5xx it has returned
+    _reads: dict = {}         # realpath -> (mtime, identical-read count)
+
+    def _server_log_tail_for_url(url: str) -> str:
+        """If `url` is a localhost server we started via run_command, return the tail of
+        its run-log — the REAL error. A 5xx returns only an HTML error page; the actual
+        stack trace lives in the server's stdout log (task #79)."""
+        try:
+            import os as _os
+            from urllib.parse import urlparse
+            p = urlparse(url)
+            if p.hostname not in ("localhost", "127.0.0.1", "0.0.0.0", "::1"):
+                return ""
+            for s in _ws_load_servers():
+                if p.port and p.port in (s.get("ports") or []):
+                    logp = s.get("log") or ""
+                    if logp and _os.path.isfile(logp):
+                        with open(logp, "r", encoding="utf-8", errors="replace") as fh:
+                            return _ws_distill_output(fh.read())[-1500:]
+            return ""
+        except Exception:  # noqa: BLE001
+            return ""
+
+    def _read_repeat_block(rp: str) -> str:
+        """Refuse a 3rd+ identical read of an UNCHANGED file (a common step-waster)."""
+        try:
+            import os as _os
+            mt = _os.path.getmtime(rp)
+        except OSError:
+            return ""
+        prev = _reads.get(rp)
+        if prev and prev[0] == mt:
+            cnt = prev[1] + 1
+            _reads[rp] = (mt, cnt)
+            if cnt >= 3:
+                import os as _os2
+                return (f"You've already read {_os2.path.basename(rp)} {cnt} times and it "
+                        "hasn't changed. Stop re-reading it — act on what it says, or "
+                        "call final_answer.")
+            return ""
+        _reads[rp] = (mt, 1)
+        return ""
+
     def _dedup(tool_name: str, arg: str, next_hint: str):
         """Return (is_repeat, message). On a repeat, message steers the model forward."""
         key = _norm_query(arg) if tool_name == "web_search" else (arg or "").strip().lower()
@@ -3452,6 +3510,23 @@ def run_agent_chat(cfg):
         # Append a success tag to 2xx JSON responses so the model stops and calls final_answer.
         elif result and result.startswith("HTTP 2"):
             result = result + "\n[SUCCESS — call final_answer(response) now, do not parse or retry]"
+        # A 5xx from a localhost dev server (task #79): the HTML error page hides the real
+        # cause. Surface the SERVER'S OWN LOG (the actual stack trace) so the model fixes
+        # the specific error instead of guessing/oscillating — and hard-stop after a few
+        # repeats so it can't burn the whole budget re-hitting a broken endpoint.
+        _m5 = re.match(r"HTTP\s+(5\d\d)", result or "")
+        if _m5:
+            _url_5xx[url] = _url_5xx.get(url, 0) + 1
+            _tail = _server_log_tail_for_url(url)
+            if _tail:
+                result = (result + f"\n[SERVER ERROR LOG — the real cause of the "
+                          f"{_m5.group(1)} (fix THIS, don't guess):\n{_tail}\n]")
+            if _url_5xx[url] >= 3:
+                result = result + (
+                    f"\n[STOP: {url} has returned a 5xx {_url_5xx[url]} times. Do NOT request "
+                    "it again or rewrite the same file again. Fix the SPECIFIC error in the "
+                    "server log above, or call final_answer honestly stating what's failing.]"
+                )
         _emit({"type": "step", "text": f"HTTP {method.upper()} {url} → {status_line}"})
         _log(f"http_request {method.upper()} {url} → {result[:80]}")
         _last_obs["text"] = result
@@ -4307,14 +4382,23 @@ def run_agent_chat(cfg):
             text = (_last_obs.get("text") or "").strip()
             if text:
                 _log(f"max-steps fallback (last tool obs) → {text[:80]}")
-                # Without this, `text` (a tool's RAW return value — e.g. a bare grep_repo
-                # dump of file:line hits) becomes the entire chat reply with zero framing,
-                # reading as a bizarre non-answer. A short honest note makes clear this is
-                # a partial result from an interrupted run, not the actual answer/edit.
-                text = (
-                    "I ran out of steps before finishing this. Here's the last thing I "
-                    "found — reply to have me continue from here:\n\n" + text
-                )
+                # Summarize WHAT WAS TRIED + the current blocker, not just the last tool
+                # observation (task #79): a bare last obs ('Stopped npm run dev') reads as a
+                # non-answer and hides the loop the run got stuck in. Build a compact bullet
+                # list of the tool calls from this turn's step trace + the last result.
+                _tried = []
+                for _st in _turn_steps[-8:]:
+                    _did = str(_st.get("did") or "").strip().replace("\n", " ")
+                    _m = re.search(r"([a-z_]+\([^\n]{0,70})", _did)
+                    _label = (_m.group(1) if _m else _did)[:70].strip()
+                    if _label:
+                        _tried.append(f"  • {_label}")
+                _summary = "I ran out of steps before finishing this."
+                if _tried:
+                    _summary += " Here's what I tried:\n" + "\n".join(_tried)
+                _summary += "\n\nCurrent blocker (last result):\n" + text[:600]
+                _summary += "\n\nReply 'continue' to have me keep going from here."
+                text = _summary
             else:
                 # No usable tool output (e.g. every step's code failed to parse).
                 # Don't dead-end on a canned apology — answer from the conversation.
@@ -4425,6 +4509,10 @@ def run_agent_chat(cfg):
                     out = f"{root} is a file ({os.path.getsize(root)} bytes)."
                     _last_obs["text"] = out
                     return out
+                _rb = _read_repeat_block(root)
+                if _rb:
+                    _last_obs["text"] = _rb
+                    return _rb
                 entries = []
                 for dirpath, dirnames, filenames in os.walk(root):
                     dirnames[:] = [d for d in dirnames if d not in _RAG_SKIP_DIRS]
@@ -4467,6 +4555,10 @@ def run_agent_chat(cfg):
                     msg = "Error: file too large to read (> 5 MB)."
                     _last_obs["text"] = msg
                     return msg
+                _rb = _read_repeat_block(rp)
+                if _rb:
+                    _last_obs["text"] = _rb
+                    return _rb
                 with open(rp, "r", encoding="utf-8", errors="replace") as fh:
                     data = fh.read(max(500, min(int(max_chars or 20000), 100000)))
                 out = _ws_cap_obs(data or "(empty file)")
@@ -4800,12 +4892,26 @@ def run_agent_chat(cfg):
             try:
                 rp = _ws_write_allowed((path or "").strip())
                 import os
+                import hashlib as _hl
                 existed = os.path.exists(rp)
                 if existed and not overwrite:
                     msg = (f"Error: {path} already exists — pass overwrite=True to replace the "
                            "whole file, or use edit_lines/edit_file for a partial change.")
                     _last_obs["text"] = msg
                     return msg
+                # Oscillation guard (task #79): if the model rewrites a file to a version it
+                # ALREADY wrote this run (the NextResponse ↔ new Response flip-flop), that
+                # exact content already failed — refuse instead of looping on a non-fix.
+                _ch = _hl.sha1((content or "").encode("utf-8", "replace")).hexdigest()
+                _seen = _file_writes.setdefault(rp, set())
+                if existed and _ch in _seen:
+                    msg = (f"You already wrote this EXACT content to {os.path.basename(rp)} "
+                           "earlier this task and it did not fix the problem — writing it "
+                           "again won't help. Do NOT rewrite this file with the same content. "
+                           "Read the server error log, try a genuinely DIFFERENT fix, or call "
+                           "final_answer honestly stating what's still failing.")
+                    _last_obs["text"] = msg
+                    return msg
                 # Snapshot BEFORE overwriting so revert restores the prior version. Record as
                 # an "edit" (not "create") when the file already existed, so revert restores
                 # the backup instead of deleting a file the user may have had before.
@@ -4820,6 +4926,7 @@ def run_agent_chat(cfg):
                     ("Rewrote file — " if existed else "Added ") + f"{len(content_ls)} line(s)",
                     added=[(i + 1, t) for i, t in enumerate(content_ls)],
                 )})
+                _seen.add(_ch)  # remember this content so a later revert-to-it is caught
                 out = f"{'Overwrote' if existed else 'Created'} {rp} ({len(content)} chars)."
                 _last_obs["text"] = out
                 return out
@@ -4938,6 +5045,23 @@ def run_agent_chat(cfg):
                         _last_obs["text"] = msg
                         return msg
                     # else: destructive but non-interactive → allowed by default (unchanged)
+                # Don't spawn a DUPLICATE of a server that's already running (task #79): the
+                # model re-runs 'npm run dev' and Next/Vite then bind a SECOND port, which
+                # confused the whole debug loop (3000 500 vs 3001 refused). If the identical
+                # command+workdir is still listening, reuse it.
+                for _srv in _ws_load_servers():
+                    if _srv.get("command") == command and _srv.get("workdir") == wd:
+                        _live = _ws_listening_ports(_srv.get("pid") or 0)
+                        if _live:
+                            _urls = ", ".join(f"http://localhost:{p}" for p in _live)
+                            msg = (f"'{command}' is ALREADY running — {_urls} (pid "
+                                   f"{_srv.get('pid')}). Reusing it; do NOT start another. A "
+                                   "dev server hot-reloads code changes automatically, so just "
+                                   f"request {_urls} again. Use stop_server first only if you "
+                                   "truly need a full restart.")
+                            _emit({"type": "step", "text": f"Server already up → {_urls} (reused)"})
+                            _last_obs["text"] = msg
+                            return msg
                 _emit({"type": "step", "text": f"Running → {command[:70]}"})
                 t = max(5, min(int(timeout_seconds or 180), 600))
                 # Own process group (start_new_session) + output to a log file. This is
@@ -5275,8 +5399,38 @@ def run_agent_chat(cfg):
                 _log(f"compact system prompt unavailable ({_e}); using smolagents default")
         agent = _ToolAgent(**agent_kwargs)
         _agent_ref["a"] = agent  # let step_callback trim this agent's step memory (#63)
+        # At the step budget the run ends WITHOUT final_answer (_maxsteps_partial hit). Offer
+        # to keep going instead of dead-ending (task #80): a terminal user says Yes → extend
+        # the budget to a large ceiling and CONTINUE with the existing memory (reset=False,
+        # so the model keeps all prior observations). smolagents captures max_steps as a
+        # LOCAL at run() time, so we can't bump it mid-loop — we re-enter run() with a raised
+        # agent.max_steps instead. The real bound is the 30-min worker job cap, so 1000 just
+        # means "run to completion". 'Yes, don't ask again' is handled REPL-side: it flips a
+        # session flag so the NEXT turn arrives with alwaysExtendOnMaxStep and we auto-extend
+        # without prompting.
+        _MAXSTEP_CEILING = 1000
+        _always_extend = bool(cfg.get("alwaysExtendOnMaxStep"))
         with contextlib.redirect_stdout(sys.stderr):
             result = agent.run(task_with_hint)
+            while _maxsteps_partial.get("hit"):
+                if _always_extend:
+                    _log(f"max-steps reached → auto-extending to {_MAXSTEP_CEILING} "
+                         "(don't-ask-again session flag)")
+                    _do_extend = True
+                elif _interactive_approval and _job_id and pdf_api_base and pdf_worker_key:
+                    _do_extend = _ws_request_approval(
+                        pdf_api_base, pdf_worker_key, _job_id,
+                        f"__MAXSTEP__::Reached the step budget ({agent.max_steps}). "
+                        "Keep going?", "max-steps")
+                else:
+                    _do_extend = False  # web / no interactive channel → current wrap-up
+                if not _do_extend:
+                    break
+                _maxsteps_partial["hit"] = False
+                agent.max_steps = _MAXSTEP_CEILING
+                _emit({"type": "step", "text": "Continuing — step budget extended…"})
+                _log(f"continuing run with raised budget {agent.max_steps}")
+                result = agent.run(task_with_hint, reset=False)
         # Final formatting — NO extra summarizer model call. In multi-step mode the
         # agent's own final_answer() (or the max-steps fallback above) already holds the
         # synthesized answer; we just strip the internal hint tags we appended to tool

package/package.json

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