@tiens.nguyen/gonext-local-worker 1.0.252 → 1.0.254

package/gonext-local-worker.mjs

@@ -1984,6 +1984,8 @@ async function runAgentChatJob(job) {
     // each python "tokens" event, persisted to the job doc (Mongo) so the REPL can show
     // it live and it survives on the completed job.
     let latestCodeTokens = 0;
+    // Task #84: peak single-request prompt-token count seen this turn (not the sum).
+    let latestMaxCodeTokens = 0;
     // Raw model-stream tokens (event.type === "stream") are Python code + `Thought:`
     // prose + <code>/<|"|> fragments. The web Thought panel renders reasoning as
     // markdown, which turns `#`-prefixed code comments into <h1> headings and
@@ -2111,16 +2113,24 @@ async function runAgentChatJob(job) {
         enqueueText(event.text);
         answerStreamed = true;
       } else if (event.type === "tokens" && Number.isFinite(event.codeInput)) {
-        // Prompt tokens sent to the agent CODE model (task #83). Persist the running
-        // total to the job doc so it's in Mongo and the REPL can render it live. Steps
-        // are seconds apart, so a fire-and-forget PATCH per event is cheap; it only
-        // touches agentCodeTokens (never resultText/jobStatus), so it can't race the
-        // chunk/completed writes.
-        if (event.codeInput > latestCodeTokens) {
-          latestCodeTokens = event.codeInput;
+        // Prompt tokens sent to the agent CODE model (tasks #83 accumulated + #84 peak).
+        // Persist both to the job doc so they're in Mongo and the REPL can render them
+        // live. Steps are seconds apart, so a fire-and-forget PATCH per event is cheap;
+        // it only touches agentCodeTokens/agentMaxCodeTokens (never resultText/jobStatus),
+        // so it can't race the chunk/completed writes.
+        const nextTotal = Math.max(latestCodeTokens, event.codeInput);
+        const nextMax = Number.isFinite(event.codeMax)
+          ? Math.max(latestMaxCodeTokens, event.codeMax)
+          : latestMaxCodeTokens;
+        if (nextTotal !== latestCodeTokens || nextMax !== latestMaxCodeTokens) {
+          latestCodeTokens = nextTotal;
+          latestMaxCodeTokens = nextMax;
           workerFetch(`/api/worker/jobs/${jobId}`, {
             method: "PATCH",
-            body: JSON.stringify({ agentCodeTokens: latestCodeTokens }),
+            body: JSON.stringify({
+              agentCodeTokens: latestCodeTokens,
+              agentMaxCodeTokens: latestMaxCodeTokens,
+            }),
           }).catch(() => {});
         }
       } else if (event.type === "final" && typeof event.text === "string") {
@@ -2174,6 +2184,7 @@ async function runAgentChatJob(job) {
         resultText: answerStreamed ? fullText : finalText || fullText,
         tokenCount: Math.max(1, Math.ceil((finalText || fullText).length / 4)),
         ...(latestCodeTokens > 0 ? { agentCodeTokens: latestCodeTokens } : {}),
+        ...(latestMaxCodeTokens > 0 ? { agentMaxCodeTokens: latestMaxCodeTokens } : {}),
         totalTimeSeconds,
       }),
     });

package/gonext-repl.mjs

@@ -122,6 +122,7 @@ const SPINNERS = [
 // green, cyan, blue, indigo, pink, amber).
 const WAIT_COLORS_256 = [120, 87, 111, 147, 218, 221];
 const color256 = (n, s) => `\x1b[38;5;${n}m${s}\x1b[0m`;
+const orange = (s) => color256(208, s); // peak-token label (task #84)
 // Compact token count: 950 → "950", 12300 → "12.3k", 1500000 → "1.5M" (task #83).
 const fmtTokens = (n) => {
   if (n < 1000) return String(n);
@@ -564,6 +565,16 @@ async function loadSessionServer(cwd) {
   }
 }
 
+// Peak single-request agent-code-model token count remembered per folder (task #84).
+async function loadSessionMaxCodeTokens(cwd) {
+  try {
+    const raw = JSON.parse(await readFile(sessionFilePath(cwd), "utf8"));
+    return Number.isFinite(raw?.maxCodeTokens) ? raw.maxCodeTokens : 0;
+  } catch {
+    return 0;
+  }
+}
+
 async function saveSession(cwd, history) {
   try {
     await mkdir(SESSIONS_DIR, { recursive: true });
@@ -576,6 +587,7 @@ async function saveSession(cwd, history) {
           updatedAt: new Date().toISOString(),
           testAuto: sessionTestAuto,
           deployServer: selectedServer, // remember the /server pick per folder (task #69)
+          maxCodeTokens: sessionMaxCodeTokens, // peak per-request tokens (task #84)
           history: trimmed,
         },
         null,
@@ -919,6 +931,10 @@ 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;
+// Task #84: peak single-request agent-code-model token count for THIS workspace, kept
+// as a max across turns and persisted per folder in the session file. Shown in orange
+// next to the live token count.
+let sessionMaxCodeTokens = 0;
 
 // While a turn runs, mute readline's own echo/redraws so keystrokes can't corrupt the
 // live status display and there's no way to type a new question — only Ctrl+C works.
@@ -1148,10 +1164,12 @@ async function runAgentTurn(history) {
     // Line 2 (indented): the SPINNER + the playful word together, both in the cycling
     // color — the spinner belongs with the word (dot on the label line, spinner leading
     // the flavor line).
-    // Task #83: after the playful word, ALWAYS show the running agent-code-model token
-    // count (dim), e.g. "  ⠙ Caffeinating… · 12.3k tok" — starts at "· 0 tok" and climbs
-    // as steps send more, so it's visible from the first thinking frame.
-    const tokLabel = dim(` · ${fmtTokens(latestCodeTokens)} tok`);
+    // Task #83/#84: after the playful word, show the running agent-code-model token
+    // count (dim) plus the per-workspace PEAK single-request count (orange), e.g.
+    // "  ⠙ Caffeinating… · 12.3k tok · 8.1k max". Both start at 0 and climb.
+    const tokLabel =
+      dim(` · ${fmtTokens(latestCodeTokens)} tok`) +
+      orange(` · ${fmtTokens(sessionMaxCodeTokens)} max`);
     process.stdout.write(
       `${green(BULLET)} ${green(`${fit(primary)}… (${secs}s)`)}` +
         "\n" + `  ${color256(wc, `${glyph} ${thinkWord}…`)}${tokLabel}`
@@ -1424,6 +1442,10 @@ async function runAgentTurn(history) {
       if (Number.isFinite(job.agentCodeTokens) && job.agentCodeTokens > latestCodeTokens) {
         latestCodeTokens = job.agentCodeTokens;
       }
+      // Peak single-request tokens (task #84): keep the per-workspace max across turns.
+      if (Number.isFinite(job.agentMaxCodeTokens) && job.agentMaxCodeTokens > sessionMaxCodeTokens) {
+        sessionMaxCodeTokens = job.agentMaxCodeTokens;
+      }
       const text = typeof job.resultText === "string" ? job.resultText : "";
       if (job.jobStatus === "completed") {
         // The job can flip to "completed" between polls with authoritative resultText that
@@ -1541,6 +1563,7 @@ async function main() {
   // reflect them (both survive a fresh terminal in the same project).
   sessionTestAuto = await loadSessionTestAuto(resolve(process.cwd()));
   selectedServer = await loadSessionServer(resolve(process.cwd()));
+  sessionMaxCodeTokens = await loadSessionMaxCodeTokens(resolve(process.cwd()));
   // Show which models will answer, straight from user settings (also validates auth).
   try {
     const probe = await fetchAgentPayload([{ role: "user", content: "ping" }]);

package/gonext_agent_chat.py

@@ -3117,11 +3117,17 @@ def run_agent_chat(cfg):
         [_active_ws] if _active_ws else _WS_ROOTS
     ) if _WS_AVAILABLE else []
     _ws_overview = _workspace_overview(_overview_roots) if _overview_roots else ""
-    _ws_tool_block = (
+    # VARIABLE workspace context (task #86): the active-folder line, workspace list and
+    # 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.
+    _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"
         + "\n".join(f"    {line}" for line in _ws_overview.splitlines()) + "\n"
+    ) if _WS_AVAILABLE else ""
+    _ws_tool_block = (
         "    - 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"
@@ -3225,19 +3231,18 @@ def run_agent_chat(cfg):
             f"(Permission denied publickey,password), STOP and tell the user to run "
             f"'ssh-copy-id {_du}@{_dh}' once, then retry. ***\n"
         )
+    # STATIC ONLY (task #86): everything in tool_hint must be byte-identical between
+    # turns so the model server's prefix KV-cache covers it (see task_with_hint below).
+    # Variable text — the deploy target and the current date/time — lives in the
+    # variable tail next to the task instead.
     tool_hint = (
-        # Deploy target FIRST (when a server is picked) — a small model buries context deep
-        # in a 20k-char hint, so the chosen server must lead, not trail (task #69 retest fix).
-        _deploy_block
-        + f"Solve the TASK step by step (up to {max_steps} steps). At EACH step write a "
+        f"Solve the TASK step by step (up to {max_steps} steps). At EACH step write a "
         "brief Thought, then ONE code block that calls a SINGLE tool. You will SEE that "
         "tool's result (Observation) before the next step — use it to decide what to do "
         "next (e.g. web_search to find a URL, THEN fetch_url to read it). When you have "
         "enough to answer, call final_answer(<your answer>) in a code block. Prefer "
         "FEWER steps, and never repeat a tool call that already succeeded.\n\n"
         "{{TOOL_LIST}}\n"  # filled in below, once from the REAL registered tool objects
-        f"(Current date/time: {now_str} — pass a timezone to get_current_datetime() only "
-        "if the task needs a DIFFERENT one.)\n"
         + _rag_tool_block + _ws_tool_block + _auto_test_block +
         "\n"
         "http_request RETURN FORMAT: 'HTTP 200\\n{body}' — first line is 'HTTP <code>', body follows.\n"
@@ -3322,14 +3327,30 @@ def run_agent_chat(cfg):
                 f"Previous task: {_ck.get('task', '')}\n" + "\n".join(_kept)
             )
 
-    # Lead with the TASK so the weak model anchors on what's actually being asked —
-    # not on the tool reference below. (Previously the hint led with the date, and the
-    # 3B model treated every message as a date question.)
+    # ORDER (task #86 — prefix-cache fix): STATIC first, VARIABLE last.
+    # The ~16k-char tool reference is byte-identical between turns; leading with it
+    # (right after the equally static system prompt) lets the model server's prefix
+    # KV-cache cover ~7k tokens across turns. Previously the variable task text came
+    # FIRST, so every new turn forced a cold re-eval of the whole reference (~2 min to
+    # first token on step 1 of each turn; steps 2+ were 10-30s because within a turn
+    # the prompt only grows at the end).
+    # The TASK now comes LAST, under a loud header: recency is the position a model
+    # attends to most, so anchoring is preserved (the historical "hint led with the
+    # date → 3B model answered everything as a date question" regression was about a
+    # misleading LEAD, not about where the task sits). The two VARIABLE blocks — the
+    # current date/time and the deploy target — live here in the tail, next to the
+    # task: the deploy target must stay near the task, not buried mid-hint (#69), and
+    # the timestamp changes every minute, which would bust the cache mid-reference.
     task_with_hint = (
-        "TASK (answer THIS, choose the tool that fits it):\n"
-        f"{task_text}\n\n"
-        "----- TOOL REFERENCE -----\n"
-        + tool_hint
+        "----- TOOL REFERENCE (how to work — your actual TASK follows below) -----\n"
+        + tool_hint +
+        "\n----- YOUR TASK -----\n"
+        f"(Current date/time: {now_str} — pass a timezone to get_current_datetime() only "
+        "if the task needs a DIFFERENT one.)\n"
+        + _deploy_block
+        + _ws_context_block +
+        "\nTASK (answer THIS, choose the tool that fits it):\n"
+        f"{task_text}\n"
     )
 
     # Track URLs that have already failed so we don't retry dead endpoints across steps.
@@ -3940,6 +3961,9 @@ def run_agent_chat(cfg):
             # turn (task #83). Only this wrapper counts — the chat/brain helper calls
             # (_chat_completion) don't route through here, so this is "code model only".
             self._code_tokens_total = 0
+            # 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
             # 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
@@ -4182,6 +4206,19 @@ def run_agent_chat(cfg):
             # _mark_first), read by the heartbeat below to switch its wording.
             self._first_token_seen = False
 
+            # Task #83: emit the PROMPT-token estimate NOW, at request time — so the
+            # code-model token count climbs the instant a step is SENT, not only after a
+            # slow step returns usage (a cold gemma4 can wait minutes for the first token,
+            # during which the count would otherwise sit at 0). We reconcile to the exact
+            # server-reported prompt_tokens after the call when it's higher.
+            _step_est = self._estimate_prompt_tokens(args, kwargs)
+            if _step_est > 0:
+                self._code_tokens_total += _step_est
+                if _step_est > self._code_tokens_max:
+                    self._code_tokens_max = _step_est
+                _emit({"type": "tokens", "codeInput": self._code_tokens_total,
+                       "codeMax": self._code_tokens_max, "stepInput": _step_est})
+
             def _heartbeat():
                 waited = 0
                 while not hb_stop.wait(45):
@@ -4226,20 +4263,21 @@ def run_agent_chat(cfg):
                     raise last_err
             finally:
                 hb_stop.set()
-            # Task #83: tally PROMPT tokens sent to the code model this step, then emit
-            # the running total so the worker can persist it (Mongo) and the REPL can
-            # show it live. Best-effort — never let accounting break the run.
+            # Task #83: reconcile the pre-call estimate with the server's EXACT
+            # prompt_tokens when it's higher — keeps the running total monotonic (the
+            # estimate already showed the count climbing at request time). Best-effort.
             try:
                 tu = getattr(msg, "token_usage", None)
-                step_in = int(getattr(tu, "input_tokens", 0) or 0) if tu else 0
-                if step_in <= 0:
-                    step_in = self._estimate_prompt_tokens(args, kwargs)
-                if step_in > 0:
-                    self._code_tokens_total += step_in
+                exact = int(getattr(tu, "input_tokens", 0) or 0) if tu else 0
+                if exact > _step_est:
+                    self._code_tokens_total += (exact - _step_est)
+                    if exact > self._code_tokens_max:
+                        self._code_tokens_max = exact
                     _emit({
                         "type": "tokens",
                         "codeInput": self._code_tokens_total,
-                        "stepInput": step_in,
+                        "codeMax": self._code_tokens_max,
+                        "stepInput": exact,
                     })
             except Exception:  # noqa: BLE001
                 pass

package/package.json

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