@tiens.nguyen/gu-cli 1.0.749 → 1.0.751

package/gonext_agent_chat.py

@@ -3813,6 +3813,12 @@ def _normalize_code_tags(text: str) -> str:
          <code> tag is present, so we don't touch backticks inside a real <code> block).
       5. opened-but-never-closed (exactly one "<code>", no "</code>"): append "</code>"
          so the parser can still extract the code instead of failing the whole step.
+      6. NO DELIMITERS AT ALL, but the reply is Python that calls something — an optional
+         "Thought:" line, then e.g. `print(read_file_lines(...))`. Measured on Claude: 13
+         such replies in one turn, each thrown away as "no runnable code block" and re-asked,
+         about a quarter of the turn's steps. Wrapped only when the code (after the Thought
+         line) COMPILES and contains a call — prose does not parse as Python, so a sentence
+         is never mistaken for code.
     Idempotent — already-correct "<code>…</code>" is returned unchanged."""
     if not text:
         return text
@@ -3823,9 +3829,36 @@ def _normalize_code_tags(text: str) -> str:
         fixed = _MD_FENCE_BLOCK.sub(lambda m: f"<code>\n{m.group(1)}</code>", fixed, count=1)
     if fixed.count("<code>") == 1 and "</code>" not in fixed:
         fixed = fixed + "\n</code>"
+    if "<code>" not in fixed and "</code>" not in fixed:
+        bare = _bare_code_block(fixed)
+        if bare is not None:
+            thought, code = bare
+            fixed = (thought + "\n" if thought else "") + "<code>\n" + code + "\n</code>"
     return fixed
 
 
+def _bare_code_block(text: str):
+    """(thought, code) when `text` is Python with no delimiters — an optional leading
+    "Thought: …" line, then code that compiles and calls something. Else None."""
+    import ast
+    t = (text or "").strip()
+    if not t:
+        return None
+    thought = ""
+    lines = t.splitlines()
+    if lines and lines[0].lstrip().lower().startswith("thought:"):
+        thought, t = lines[0].strip(), "\n".join(lines[1:]).strip()
+    if not t:
+        return None
+    try:
+        tree = ast.parse(t)
+    except SyntaxError:
+        return None
+    if not any(isinstance(n, ast.Call) for n in ast.walk(tree)):
+        return None
+    return thought, t
+
+
 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
@@ -6915,6 +6948,35 @@ def _ws_distill_output(out: str, cap_head: int = 1200, cap_tail: int = 4000) ->
             + out[-cap_tail:])
 
 
+# READ CAPS SCALE WITH THE WINDOW (issue #49). A flat 3,000 chars (~750 tokens, ~60-80 lines,
+# middle cut) was right for #63's weak models with no prompt cache. Measured over 625 Claude
+# steps it cut a read in 23 of 37 turns (>=14.6% of steps), and each cut is a follow-up read:
+# d6ad7211 walked a 6,665-line file in slices for ~40 steps. With cache reads at 0.1x a bigger
+# read costs about what the extra step did, and steps are what we save. Claude Code's own Read
+# allows 25k tokens. Small or unknown windows keep 3,000 — a 16k local Ollama is unchanged.
+_OBS_CAP_FLOOR = 3000
+_OBS_CAP_READ_MAX = 24_000    # ≈ read_file_lines' own 400-line limit
+_OBS_CAP_SEARCH_MAX = 12_000  # ≈ grep_repo's 100 hits / list_dir's 300 entries
+_OBS_CAP_WINDOW_SHARE = 0.03  # one read may take ~3% of the window
+_OBS_CAPS = {"read": _OBS_CAP_FLOOR, "search": _OBS_CAP_FLOOR}
+
+
+def _obs_caps_for_window(window_tokens: int) -> dict:
+    """{read, search} character caps for a model with this context window (0 = unknown)."""
+    if not window_tokens or window_tokens <= 0:
+        return {"read": _OBS_CAP_FLOOR, "search": _OBS_CAP_FLOOR}
+    read = int(window_tokens * 4 * _OBS_CAP_WINDOW_SHARE)  # ~4 chars per token
+    read = max(_OBS_CAP_FLOOR, min(_OBS_CAP_READ_MAX, read))
+    search = max(_OBS_CAP_FLOOR, min(_OBS_CAP_SEARCH_MAX, read // 2))
+    return {"read": read, "search": search}
+
+
+def _set_obs_caps(window_tokens: int) -> dict:
+    """Set this turn's caps (the worker runs one turn per process)."""
+    _OBS_CAPS.update(_obs_caps_for_window(window_tokens))
+    return dict(_OBS_CAPS)
+
+
 def _ws_cap_obs(text: str, cap: int = 3000) -> str:
     """Cap a READ tool's observation (read_file_lines / list_dir / read_text_file /
     grep_repo) before it's returned to the CodeAgent. Every observation stays in the
@@ -8974,6 +9036,8 @@ def run_agent_chat(cfg):
     _trim_state: dict = {"next_at": _TRIM_FIRST_AT_CHARS}
     _ctx_window = _model_context_window(coding_base_url, coding_model_id, coding_api_key)
     _compact_at = _compact_threshold(_ctx_window)
+    _caps = _set_obs_caps(_ctx_window)
+    _log(f"read caps: {_caps['read']} chars per read, {_caps['search']} per search (issue #49)")
     if _ctx_window:
         # SAY WHICH SOURCE ANSWERED. A measured window and a remembered one are not the same
         # claim, and a table entry presented as fact is how a stale number survives unquestioned.
@@ -10310,7 +10374,11 @@ def run_agent_chat(cfg):
                         r"send_email)\s*\("
                     )
                     fence_is_toolcall = any(re.search(_tool_call_re, b) for b in fence_bodies)
-                    if has_code_tag or fence_is_toolcall:
+                    # Bare Python with no delimiters at all (case 6 of _normalize_code_tags) —
+                    # it used to fall through to the prose branch and cost a whole step.
+                    bare_code = (not has_code_tag and not fence_bodies
+                                 and _bare_code_block(content) is not None)
+                    if has_code_tag or fence_is_toolcall or bare_code:
                         normalized = _normalize_code_tags(content)
                         if normalized != content:
                             _log("normalized code-block tags (<code >/fence → <code>)")
@@ -10462,13 +10530,16 @@ def run_agent_chat(cfg):
         # from the prompt, not writing code. Deliberately carries NO literal delimiter (the
         # system prompt already shows the format with a worked example), so there is nothing
         # to echo. Applied only when kind=openai; Ollama keeps the stock message.
+        # STRONG MODELS (2026-09-25): the delimiters are named again. Leaving them out was a
+        # workaround for Kimi echoing them; on Claude it did the opposite — told to use "the
+        # delimiters shown in the system prompt", it replied with bare code, which failed the
+        # same way, 13 times in one turn. And "call exactly one tool" contradicted batching.
         _PARSE_ERROR_REPLACEMENT = (
             "Error: your last reply contained no runnable code block, so nothing executed "
             "and no observation was produced.\n"
-            "Reply with ONE 'Thought:' line, then the code block using the exact opening and "
-            "closing delimiters shown in the system prompt, with ONLY Python between them — "
-            "no prose inside the block, and do not repeat these instructions back to me. "
-            "Call exactly one tool, or call final_answer(...) if you are done."
+            "Reply with ONE 'Thought:' line, then your Python between <code> and </code> — "
+            "nothing else inside the block. Batch independent calls as usual, or call "
+            "final_answer(...) if you are done."
         )
 
         def _sanitize_parse_errors(self, msgs):
@@ -10771,7 +10842,8 @@ def run_agent_chat(cfg):
                 entries.sort()
                 more = " …(truncated)" if len(entries) >= 300 else ""
                 out = _ws_cap_obs(
-                    f"{len(entries)} files under {root}:\n" + "\n".join(entries) + more)
+                    f"{len(entries)} files under {root}:\n" + "\n".join(entries) + more,
+                    cap=_OBS_CAPS["search"])
                 _emit_read("Listing files", path, f"{len(entries)} file(s)")
                 _last_obs["text"] = out
                 return out
@@ -10810,7 +10882,7 @@ def run_agent_chat(cfg):
                     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)")
+                out = _ws_cap_obs(data or "(empty file)", cap=_OBS_CAPS["read"])
                 _emit_read("Reading file", path, f"{data.count(chr(10)) + 1} line(s)"
                            if data else "empty")
                 _last_obs["text"] = out
@@ -11469,7 +11541,8 @@ def run_agent_chat(cfg):
                     _last_obs["text"] = msg
                     return msg
                 more = "\n…(capped at 100 hits)" if len(hits) >= 100 else ""
-                out = _ws_cap_obs(f"Matches under {root}:\n" + "\n".join(hits) + more)
+                out = _ws_cap_obs(f"Matches under {root}:\n" + "\n".join(hits) + more,
+                                  cap=_OBS_CAPS["search"])
                 _last_obs["text"] = out
                 return out
             except Exception as e:  # noqa: BLE001
@@ -11555,7 +11628,7 @@ def run_agent_chat(cfg):
                 _emit({"type": "step",
                        "text": f"Locating symbol → {name} ({len(defs)} def, "
                                f"{len(calls)} call, {len(tests)} test)"})
-                res = _ws_cap_obs("\n".join(out))
+                res = _ws_cap_obs("\n".join(out), cap=_OBS_CAPS["search"])
                 _last_obs["text"] = res
                 return res
             except Exception as ex:  # noqa: BLE001
@@ -11594,7 +11667,8 @@ def run_agent_chat(cfg):
                     _last_obs["text"] = _rb
                     return _rb
                 body = "".join(f"{i}: {lines[i - 1]}" for i in range(s, e + 1))
-                out = _ws_cap_obs(f"{rp} (lines {s}-{e} of {len(lines)}):\n{body}")
+                out = _ws_cap_obs(f"{rp} (lines {s}-{e} of {len(lines)}):\n{body}",
+                                  cap=_OBS_CAPS["read"])
                 _search_tally_bump("read")
                 _emit_read("Reading lines", f"{path}:{s}-{e}", f"of {len(lines)} line(s)")
                 _last_obs["text"] = out

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tiens.nguyen/gu-cli",
-  "version": "1.0.749",
+  "version": "1.0.751",
   "description": "Gu CLI — the gu terminal plus the local worker that runs agent / OCR / PDF / embedding jobs on your Mac (Ollama / MLX / OpenAI-compatible).",
   "type": "module",
   "license": "MIT",
@@ -37,6 +37,8 @@
     "test:cache-e2e": "GONEXT_OLLAMA1_LIVE=1 node --test --test-timeout=1800000 tests/prefix-cache-e2e.test.mjs",
     "test:tokens": "python3 -m unittest discover tests -p \"test_cached_tokens.py\" -v && node --test tests/prefix-cache.test.mjs tests/agent-turn-shape.test.mjs",
     "test:selection": "node --test tests/selection-scrollback.test.mjs tests/selection-while-thinking.test.mjs tests/terminal-selection.test.mjs tests/terminal-copy.test.mjs tests/terminal-viewport.test.mjs tests/hover-repaint.test.mjs",
+    "test:steps": "python3 scripts/py-tap.py tests/test_read_caps.py tests/test_trim_payback.py tests/test_explore.py tests/test_and_chains.py tests/test_edit_file_primary.py tests/test_bare_code_rescue.py tests/test_batching_rule.py tests/test_no_pdf_routing.py",
+    "test:skills": "python3 scripts/py-tap.py tests/test_skills_mcp_turn.py tests/test_hooks_turn.py tests/test_mcp_client.py && node --test tests/skills.test.mjs tests/mcp-config.test.mjs tests/hooks-config.test.mjs tests/slash-menu.test.mjs tests/conversation-archive.test.mjs",
     "capture:turn": "GONEXT_OLLAMA1_LIVE=1 node scripts/capture-turn-fixture.mjs",
     "test:bearer": "node --test tests/bearer-routing.test.mjs tests/bearer-verify.test.mjs",
     "test:bearer-e2e": "bash scripts/bearer-e2e.sh"