@tiens.nguyen/gonext-local-worker 1.0.255 → 1.0.257

package/gonext-repl.mjs

@@ -803,7 +803,22 @@ function onApprovalKey(key) {
 // again this session" choice (the caller then stops sending the prompt).
 const MAXSTEP_PREFIX = "__MAXSTEP__::";
 const TIMEOUT_PREFIX = "__TIMEOUT__::";
+const COMPACT_PREFIX = "__COMPACT__::";
 async function approvalPrompt(command) {
+  // 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).
+  if (command.startsWith(COMPACT_PREFIX)) {
+    const label = command.slice(COMPACT_PREFIX.length);
+    if (!process.stdin.isTTY) return { allow: false, dontAsk: false };
+    process.stdout.write("\n" + yellow("🗜 " + label) + dim("  (no answer in 30s = keep full)") + "\n");
+    const idx = await pickFromList(
+      ["Yes, compact older steps", "No, keep full detail"],
+      0,
+      { timeoutMs: 30000, timeoutIndex: 1 }
+    );
+    return { allow: idx === 0, dontAsk: false };
+  }
   // Time-budget prompt (task #81): the agent hit its wall-clock budget. Ask whether to
   // keep waiting; auto-answer No after 60s of no input so the run can't hang forever.
   if (command.startsWith(TIMEOUT_PREFIX)) {

package/gonext_agent_chat.py

@@ -2342,6 +2342,8 @@ def _ws_request_approval(api_base, worker_key, job_id, command, reason):
         return False
     if command.startswith("__MAXSTEP__::"):
         _emit({"type": "step", "text": "Awaiting your choice: continue past the step budget?"})
+    elif command.startswith("__COMPACT__::"):
+        _emit({"type": "step", "text": "Awaiting your choice: compact the context?"})
     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)
@@ -2485,6 +2487,32 @@ def _ws_save_servers(servers: list) -> None:
         _log(f"servers.json write failed: {e}")
 
 
+def _ws_cap_servers(max_live: int = 3) -> list:
+    """Server lifecycle (task #90 Phase 2): prune dead registry entries and STOP the
+    oldest background servers beyond max_live, so dev servers leaked from earlier
+    turns can't accumulate and squat every default port (the root cause of the
+    'port 3000/3001/3005 busy' punt seen live). Only ever touches processes in OUR
+    registry (started by run_command — never arbitrary user processes). Persists the
+    pruned registry and returns the live list, oldest first."""
+    import os
+    import signal
+    servers = _ws_load_servers()  # prune=True drops already-dead entries
+    if len(servers) > max_live:
+        for s in servers[:-max_live]:  # registry is append-ordered → oldest first
+            try:
+                pgid = int(s.get("pgid", 0))
+                if pgid <= 0:
+                    continue
+                os.killpg(pgid, signal.SIGTERM)
+                _log(f"server lifecycle: stopped old background server pid={s.get('pid')} "
+                     f"ports={s.get('ports')} ('{str(s.get('command'))[:40]}')")
+            except (OSError, ValueError) as e:  # already gone / no permission
+                _log(f"server lifecycle: stop skipped pid={s.get('pid')}: {e}")
+        servers = servers[-max_live:]
+    _ws_save_servers(servers)
+    return servers
+
+
 def _ws_scrubbed_env() -> dict:
     """Minimal child env for run_command. The worker process env holds secrets
     (GONEXT_WORKER_KEY etc. via worker.env) — a repo's test script must NEVER see
@@ -3121,13 +3149,53 @@ def run_agent_chat(cfg):
     # the on-disk folder overview change between turns (the agent creates/edits files),
     # so they must NOT sit inside the static tool_hint — they'd bust the prefix cache
     # mid-reference every turn. They join the variable tail of task_with_hint instead.
+    # Task #90 Phase 2 — environment visibility: prune/cap the background-server
+    # registry once per turn (stops the oldest beyond 3 — kills the leak class), then
+    # SHOW the survivors to the model so a 'port busy' is instantly explicable and
+    # reuse/stop_server is actionable. Variable (server state changes) → tail.
+    _ws_servers_line = ""
+    if _WS_AVAILABLE:
+        try:
+            import os as _os_srv
+            _live_srv = _ws_cap_servers()
+            if _live_srv:
+                _descs = ", ".join(
+                    ":" + ",".join(str(p) for p in (s.get("ports") or ["?"]))
+                    + f" ('{str(s.get('command'))[:30]}' in "
+                    + f"{_os_srv.path.basename(str(s.get('workdir') or '')) or '?'})"
+                    for s in _live_srv)
+                _ws_servers_line = (
+                    f"  Background servers YOU already started (still running): {_descs}. "
+                    "REUSE one if it fits the task, or stop_server(<port>) — their ports "
+                    "are TAKEN, so never start a duplicate on one of them.\n")
+        except Exception as _e:  # noqa: BLE001
+            _log(f"server context skip: {_e}")
     _ws_context_block = (
         _ws_current_line
         + f"  Other registered workspaces (use only if the user names them): {_ws_names}\n"
-        f"  Current folder contents:\n"
+        + _ws_servers_line
+        + f"  Current folder contents:\n"
         + "\n".join(f"    {line}" for line in _ws_overview.splitlines()) + "\n"
     ) if _WS_AVAILABLE else ""
     _ws_tool_block = (
+        # Task #90 (root-cause rev): senior-dev autonomy as GENERAL principles — outcome
+        # over exit code, own the environment, evidence before finishing, switch approach.
+        # Static (cached, per #86); deliberately not tied to any specific failure case.
+        "WORK LIKE A SENIOR DEVELOPER — you OWN the task until it DEMONSTRABLY works:\n"
+        "    * OUTCOME over exit code: a command exiting 0 is NOT the goal. After any "
+        "state-changing step (start/build/install/edit), VERIFY the intended EFFECT "
+        "(server responds, artifact exists, test green, file contains the change) before "
+        "moving on or finishing.\n"
+        "    * On failure: read the error, fix the ROOT CAUSE (edit the code/config, "
+        "install the missing dependency, adjust the environment), re-run to confirm. If "
+        "the SAME fix fails twice, SWITCH APPROACH — never repeat it, never just give up.\n"
+        "    * The environment is YOURS to manage: a busy port, missing package, or stale "
+        "process you started earlier is yours to RESOLVE with the tools (e.g. start on a "
+        "free port via 'env VAR=value cmd', stop_server your own old server) — not to "
+        "report back as the user's problem.\n"
+        "    * final_answer needs EVIDENCE: say what you verified and how. If a thing "
+        "truly cannot be done with these tools, state plainly WHAT failed and WHY — but "
+        "NEVER end with 'you can do it yourself' when a tool could have done it.\n"
         "    - list_dir(path) / read_text_file(path) — browse and read files.\n"
         "    - grep_repo(pattern, path='', glob='') — search code, returns file:line hits. "
         "Use this to find the EXACT lines to change.\n"
@@ -3349,7 +3417,13 @@ def run_agent_chat(cfg):
         "if the task needs a DIFFERENT one.)\n"
         + _deploy_block
         + _ws_context_block +
-        "\nTASK (answer THIS, choose the tool that fits it):\n"
+        # Task #90: ~25-token echo of the autonomy contract at the highest-attention spot
+        # (recency — right next to the task), reinforcing the full directive that lives in
+        # the cached reference above. Workspace/coding mode only.
+        + ("Remember: FINISH it yourself — fix blockers, VERIFY the outcome, then "
+           "final_answer with evidence; never hand the task back.\n"
+           if _WS_AVAILABLE else "")
+        + "\nTASK (answer THIS, choose the tool that fits it):\n"
         f"{task_text}\n"
     )
 
@@ -3873,6 +3947,81 @@ def run_agent_chat(cfg):
     # agent's memory to trim old observations (task #63, keeps the prompt from growing
     # O(n²) as big file reads pile up in the step trace).
     _agent_ref: dict = {"a": None}
+    # Task #87 rec#3: when the context grows large in an INTERACTIVE terminal turn, ask
+    # the user Yes/No before aggressively compacting it (rather than deciding silently).
+    # decision: None = not yet asked this turn; "always" = user said yes, keep compacting
+    # each step without re-asking; "never" = user said no, don't ask again this turn (the
+    # normal auto-trim above still runs). Threshold in prompt tokens for the last request.
+    _compact_state: dict = {"decision": None}
+    _COMPACT_ASK_TOKENS = 14000
+
+    # Task #90 Phase 3 — completion gate (code-enforced, complements the prompt). Fires at
+    # most ONCE per turn: refuse the first final_answer that either hands the task back to
+    # the user, or lands right after a state-changing command that was never verified — with
+    # a verify-or-explain nudge fed back to the model (smolagents final_answer_checks: a
+    # raised message becomes the check-failure the model sees and retries on). After one
+    # nudge it ACCEPTS unconditionally — no loop; an honest "here's what failed" is valid.
+    _completion_gate: dict = {"nudged": False}
+    # Punt phrases: handing the CORE task back ("…start it yourself", "you'll need to run").
+    # Deliberately narrow so a helpful tip ("you can also run npm test") does NOT trigger it.
+    _PUNT_RE = re.compile(
+        r"\b(?:do|run|start|complete|finish|build) it yourself\b"
+        r"|\byou can navigate to\b"
+        r"|\bstart (?:it|the (?:app|server|project|dev server)) yourself\b"
+        r"|\byou'?ll (?:have to|need to) (?:run|start|do|build)\b",
+        re.I)
+
+    def _final_answer_gate(final_answer, memory, agent=None):
+        """smolagents final_answer_check. True = accept; raising = reject with the message
+        the model then sees. Only nudges when there's real evidence of an unfinished job."""
+        if _completion_gate["nudged"]:
+            return True  # already nudged once this turn — accept, never loop
+        ans = str(final_answer if final_answer is not None else "")
+        punt = bool(_PUNT_RE.search(ans))
+        # The most-recent tool result: a command that finished but whose EFFECT was never
+        # verified (Phase-1 'EXITED 0 (…VERIFY…)' marker), with no server/HTTP confirmation.
+        last_unverified = False
+        try:
+            for _st in reversed(getattr(memory, "steps", []) or []):
+                _obs = getattr(_st, "observations", None)
+                if isinstance(_obs, str) and _obs.strip():
+                    last_unverified = ("EXITED 0 (" in _obs) and not any(
+                        k in _obs for k in
+                        ("RUNNING:", "listening", "HTTP 2", "http://localhost"))
+                    break
+        except Exception:  # noqa: BLE001
+            pass
+        if punt or last_unverified:
+            _completion_gate["nudged"] = True
+            raise ValueError(
+                "NOT DONE YET — you ran commands or changed files but have NOT shown the "
+                "goal actually works. Do ONE of these, then call final_answer:\n"
+                "  1) VERIFY it — curl/open the server, run the test, or re-read the file to "
+                "confirm the change took — and answer WITH that evidence; OR\n"
+                "  2) if it genuinely cannot be done with these tools, state plainly WHAT "
+                "failed and WHY.\n"
+                "Do NOT hand an unfinished task back to the user.")
+        return True
+
+    def _aggressive_compact(steps):
+        """User-approved deep compaction: keep only the LAST step in full; for every
+        older step shrink the observation to a stub and the model_output to just its
+        Thought head. More aggressive than the always-on auto-trim (keep-last-2). Returns
+        chars saved. Idempotent — already-short fields fall under the caps and are skipped."""
+        saved = 0
+        for _st in steps[:-1]:
+            _obs = getattr(_st, "observations", None)
+            if isinstance(_obs, str) and len(_obs) > 200:
+                _b = len(_obs)
+                _st.observations = _obs[:150].rstrip() + "\n…[compacted — re-read if needed]"
+                saved += _b - len(_st.observations)
+            _mo = getattr(_st, "model_output", None)
+            if isinstance(_mo, str) and len(_mo) > 220:
+                _b = len(_mo)
+                _head = re.split(r"<code[\s>]|```", _mo, maxsplit=1)[0].rstrip()
+                _st.model_output = (_head[:200].rstrip() or _mo[:150].rstrip()) + "\n…[compacted]"
+                saved += _b - len(_st.model_output)
+        return saved
 
     def step_callback(step_log):
         step_num = getattr(step_log, "step_number", "?")
@@ -3890,22 +4039,82 @@ def run_agent_chat(cfg):
         except Exception:  # noqa: BLE001
             pass
 
-        # (B) Trim OLD, LARGE tool observations out of the CodeAgent's step memory so
-        # they aren't re-sent to the model on every subsequent step (the #63 O(n²) token
-        # blow-up: an uncapped read_file_lines dump cost ~5-6k tokens PER remaining step).
-        # Keep the last 2 steps' observations intact (the model just acted on them);
-        # replace older long ones with a short placeholder — the model can re-read.
+        # (B) Trim OLD, LARGE step content out of the CodeAgent's step memory so it isn't
+        # re-sent to the model on every subsequent step (the #63 O(n²) token blow-up: an
+        # uncapped dump cost ~5-6k tokens PER remaining step). Keep the last 2 steps intact
+        # (the model just acted on them); shrink older long content. write_memory_to_messages
+        # rebuilds the prompt from memory.steps on EVERY request (no cache), so mutating the
+        # step objects here takes effect on the next request; old steps are only rendered
+        # into history, never re-parsed for execution, so trimming them is safe.
+        #   - observations = the tool's OUTPUT (a file/dir dump). Trimmed since #63.
+        #   - model_output = the model's own Thought + <code> block (task #87). For an OLD
+        #     step the code ALREADY ran and its result is in the observation, so re-sending
+        #     the code verbatim every step is pure waste — keep the Thought, drop the code.
+        # Both trims are IDEMPOTENT (a re-trimmed field falls under the size threshold, so a
+        # later step_callback skips it — the counter below only logs NEW trims).
         try:
             _mem = getattr(_agent_ref.get("a"), "memory", None)
             _steps = getattr(_mem, "steps", None)
             if _steps and len(_steps) > 2:
+                _trim_n, _trim_saved = 0, 0
                 for _st in _steps[:-2]:
                     _obs = getattr(_st, "observations", None)
                     if isinstance(_obs, str) and len(_obs) > 900:
+                        _before = len(_obs)
                         _st.observations = (
                             _obs[:400].rstrip()
                             + "\n…[earlier observation trimmed to save context — "
                             "re-read the file/dir with a small range if you still need it]")
+                        _trim_n += 1
+                        _trim_saved += _before - len(_st.observations)
+                    _mo = getattr(_st, "model_output", None)
+                    if isinstance(_mo, str) and len(_mo) > 700:
+                        _before = len(_mo)
+                        # Keep the Thought (everything before the code block); the code is
+                        # redundant with the observation that already came back.
+                        _head = re.split(r"<code[\s>]|```", _mo, maxsplit=1)[0].rstrip()
+                        _kept = (_head[:500].rstrip() if _head else _mo[:300].rstrip())
+                        _new = _kept + "\n…[code trimmed to save context — its result is in the Observation]"
+                        if len(_new) < _before:
+                            _st.model_output = _new
+                            _trim_n += 1
+                            _trim_saved += _before - len(_new)
+                if _trim_n:
+                    _log(f"context trim: shrank {_trim_n} old step field(s), "
+                         f"saved ~{_trim_saved} chars (#63/#87)")
+
+                # (C) Task #87 rec#3 — INTERACTIVE compaction consent. When the context is
+                # genuinely large and we're in a terminal that can prompt, ask the user
+                # Yes/No before deep-compacting (the auto-trim above is always-on; THIS is
+                # the extra, opt-in aggressive pass). Only in the terminal (interactive) —
+                # web has no picker, so it just keeps the auto-trim.
+                if (_interactive_approval and _job_id and pdf_api_base and pdf_worker_key
+                        and _compact_state["decision"] != "never"):
+                    # Size of the last request in prompt tokens (exact if the server
+                    # reported it, else ~chars/4 of the current step memory).
+                    _tu = getattr(step_log, "token_usage", None)
+                    _in_tok = int(getattr(_tu, "input_tokens", 0) or 0) if _tu else 0
+                    if _in_tok <= 0:
+                        _chars = sum(len(getattr(_s, "model_output", "") or "")
+                                     + len(getattr(_s, "observations", "") or "")
+                                     for _s in _steps)
+                        _in_tok = _chars // 4 + 7000  # + fixed system/reference baseline
+                    if _in_tok >= _COMPACT_ASK_TOKENS and len(_steps) > 2:
+                        if _compact_state["decision"] != "always":
+                            _kt = _in_tok // 1000
+                            _allow = _ws_request_approval(
+                                pdf_api_base, pdf_worker_key, _job_id,
+                                f"__COMPACT__::The context is getting large (~{_kt}k tokens "
+                                "per request). Compact older steps to keep it fast?",
+                                "compact-context")
+                            _compact_state["decision"] = "always" if _allow else "never"
+                            _emit({"type": "step", "text": (
+                                "Compacting context…" if _allow
+                                else "Keeping full context (won't ask again this turn).")})
+                        if _compact_state["decision"] == "always":
+                            _cs = _aggressive_compact(_steps)
+                            if _cs:
+                                _log(f"context compact (user-approved): saved ~{_cs} chars")
         except Exception as _e:  # noqa: BLE001
             _log(f"memory-trim skip: {_e}")
 
@@ -5177,8 +5386,23 @@ def run_agent_chat(cfg):
                     rc = proc.poll()
                     if rc is not None:
                         out = _ws_distill_output(_read_log())
-                        status = "PASSED (exit 0)" if rc == 0 else f"FAILED (exit {rc})"
-                        _emit({"type": "step", "text": f"Command {status.split()[0].lower()} → {command[:50]}"})
+                        # Task #90 Phase 1 — truthful perception: never claim success the
+                        # tool didn't observe. exit 0 is a FACT about the process, not
+                        # proof of the GOAL (e.g. `npm start` exits 0 when its port is
+                        # busy and the server never started — the old "PASSED (exit 0)"
+                        # label told the model it succeeded, 3× in one live run). The
+                        # RUNNING/LAUNCHED paths below stay — those ARE observed outcomes.
+                        # General (no command-name or error-string matching): the label
+                        # states the fact and hands verification to the model, which the
+                        # senior-dev directive tells it to do.
+                        status = (
+                            "EXITED 0 (the command finished — exit code alone does NOT "
+                            "prove the intended effect happened; check the output below "
+                            "and VERIFY before relying on it)"
+                            if rc == 0 else f"FAILED (exit {rc})"
+                        )
+                        _emit({"type": "step", "text":
+                               f"Command {'finished' if rc == 0 else 'failed'} → {command[:50]}"})
                         result = f"{status}\n{out}" if out.strip() else status
                         _last_obs["text"] = result
                         return result
@@ -5450,6 +5674,11 @@ def run_agent_chat(cfg):
             max_steps=max_steps,
             step_callbacks=[step_callback],
         )
+        # Task #90 Phase 3: the completion gate only makes sense in coding/workspace mode
+        # (state-changing commands + file edits); retrieval turns never trip it anyway, but
+        # gating keeps plain-chat/research answers untouched.
+        if _WS_AVAILABLE:
+            agent_kwargs["final_answer_checks"] = [_final_answer_gate]
         if _AgentBase is CodeAgent:
             # Only the CodeAgent runs a Python executor; ToolCallingAgent takes neither.
             # 660s, NOT 60 (task #74): the wall clock must exceed the LARGEST tool-internal

package/package.json

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