hexcli 2.20.0__tar.gz → 2.21.0__tar.gz

{hexcli-2.20.0 → hexcli-2.21.0}/CHANGELOG.md

@@ -4,6 +4,53 @@ Full evidence for every claim below — including the experiments that failed
 lives in `docs/V2_PLAN.md` §14. Numbers are pass^k over repeated live runs on
 the Hexagon NPU, not single-run anecdotes.
 
+## 2.21.0 — 2026-10-10
+
+A minor release: a tool result the model reads changes (`edit_file` when
+`old_string` is not in the file).
+
+> **Gate: PASS** on the pinned 24-case set after one recheck:
+> `error-recovery-3` missed one of five runs, and that run never called
+> `edit_file` (it reported a "permission error" after `find_files`); re-run on
+> a fresh server it was 6/6. Own arm, seed 20261010, against 2.20.0's arm:
+> run-level 189/237 vs 192/245, +1.4 %, Fisher p = 0.74; pass^k 32 → 34 of
+> 49, McNemar p = 0.73; 8 invalid runs of 245 (backend timeouts, 2.2 GB
+> free). `claims-2`, one of the three cases behind most of the recorded
+> misses, went 2/5 → 5/5. `self-correct-1` lost one run to the known
+> double-escaped `new_string` (a literal `\n` landed on the first edit,
+> before any miss), and `regression-anchor-1` lost one to the same defect
+> with no miss at all. Smoke 9/9 valid on a fresh server.
+
+- A missed `edit_file` on a file of up to 1,500 characters returns the
+  file's whole current text instead of the closest region. Of 1,279 recorded
+  `edit_file` calls, 786 were made without reading the file that turn and
+  failed 45 % of the time against 9 % after a read, and 115 of the 291
+  misses came straight after another miss on the same file: the retry was
+  rebuilt from memory again. Every fixture behind those misses is under 200
+  characters. In the arm the message fired 16 times, in `tests-claim-1`,
+  `self-correct-1`, `claims-2` and `agentic-3`, and the next edit landed
+  after 7 of them (44 %), against 14 of 39 (36 %) in the three arms before
+  it; at that count the recovery rate is not yet a measured effect. A larger
+  file keeps the closest-region report.
+
+## 2.20.1 — 2026-10-10
+
+A patch release: nothing the model reads changes. The turn's return value
+and the history entry for a stopped turn are byte-identical to 2.20.0.
+
+- A turn the loop stops now says which tool failed, on which file, and
+  whether any file changed: "Stopped after edit_file failed three times on
+  calculator.py; no file was changed." instead of "Stopped: edit_file failed
+  three times in a row." 33 recorded turns ended on a loop or step-limit stop
+  with only the raw `old_string was not found` error behind them, and none of
+  them said whether the file had been touched. The file clause comes from the
+  writes that landed this turn, not from the attempts, so a turn that wrote
+  `notes.txt` and then got stuck on `calculator.py` names `notes.txt`; a turn
+  that never tried to change a file gets no clause.
+- Off a terminal (`hex "..." | clip`, scripts) a stopped turn printed
+  nothing at all. It prints the stop sentence. The raw tool output still goes
+  to the session history, where the next turn reads it.
+
 ## 2.20.0 — 2026-09-18
 
 A minor release: a tool result the model reads changes (`run_code` on a

{hexcli-2.20.0 → hexcli-2.21.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: hexcli
-Version: 2.20.0
+Version: 2.21.0
 Summary: Local Hexagon NPU terminal agent for Snapdragon X Elite Windows ARM64
 Project-URL: Homepage, https://github.com/NathanL15/Hex-CLI
 Project-URL: Repository, https://github.com/NathanL15/Hex-CLI

{hexcli-2.20.0 → hexcli-2.21.0}/hexcli/__init__.py

@@ -3,4 +3,4 @@
 # The one place the version is written. pyproject.toml reads it (hatch
 # dynamic version), agent.VERSION re-exports it, and CI refuses a release
 # tag that does not match it.
-__version__ = "2.20.0"
+__version__ = "2.21.0"

{hexcli-2.20.0 → hexcli-2.21.0}/hexcli/agent.py

@@ -65,17 +65,48 @@ last_streamed_matches = llm.last_streamed_matches
 _LAST_TURN_STOP: str | None = None
 
 
-def _mark_turn_stopped(how: str) -> None:
-    global _LAST_TURN_STOP
+# The one sentence the user gets for a stopped turn. The turn's return value
+# stays the raw tool output because the history keeps it for the next turn;
+# this is what the console notice and a pipe show instead.
+_LAST_STOP_NOTICE: str = ""
+
+
+def _mark_turn_stopped(how: str, notice: str = "") -> None:
+    global _LAST_TURN_STOP, _LAST_STOP_NOTICE
     _LAST_TURN_STOP = how
+    _LAST_STOP_NOTICE = notice
+
+
+def last_stop_notice() -> str:
+    return _LAST_STOP_NOTICE
+
+
+def _stop_notice(how: str, tool: str = "", path: str = "", *,
+                 identical: bool = False, changed: list[str] | None = None,
+                 tried_to_change: bool = False) -> str:
+    """Say why a turn stopped and whether any file changed, in one sentence."""
+    if how == "loop":
+        what = "returned the same result" if identical else "failed"
+        where = f" on {Path(path).name}" if path else ""
+        head = f"Stopped after {tool} {what} three times{where}"
+    else:
+        head = "Stopped at the step limit"
+    names = list(dict.fromkeys(Path(p).name for p in (changed or [])))
+    if names:
+        verb = "was" if len(names) == 1 else "were"
+        return f"{head}; {', '.join(names)} {verb} changed."
+    if tried_to_change:
+        return f"{head}; no file was changed."
+    return f"{head}."
 
 
 def clear_turn_stop() -> None:
     """Called by the REPL before each turn. Also forgets what the previous
     turn streamed: a turn that never calls the model (help, small talk)
     must not match the box-skip against stale text."""
-    global _LAST_TURN_STOP
+    global _LAST_TURN_STOP, _LAST_STOP_NOTICE
     _LAST_TURN_STOP = None
+    _LAST_STOP_NOTICE = ""
     llm._LAST_STREAMED_TEXT = ""
 
 
@@ -1166,6 +1197,7 @@ def _run_autopilot_turn(
     # One nudge per turn — it guides, never traps.
     _unverified_mutation = False
     _mutated_ok = False            # a write/edit/append that did not error, this turn
+    _changed_paths: list[str] = []  # the paths those landed on, for a stop notice
     _verify_nudge_used = False
     # The user asked for the tests to be run: what the run tools executed
     # this turn, so a finish without a test run can be sent back once.
@@ -1478,6 +1510,8 @@ def _run_autopilot_turn(
         if tool_name in {"edit_file", "write_file", "append_file"} and not _is_error:
             _unverified_mutation = True
             _mutated_ok = True
+            if tool_path:
+                _changed_paths.append(str(tool_path))
         elif tool_name in {"read_file", "run_code", "verify_syntax", "lint_code",
                            "run_command"} and not _is_error:
             _unverified_mutation = False
@@ -1497,10 +1531,14 @@ def _run_autopilot_turn(
                          and all(err for _t, _tgt, err, _out in _loop_tracker)
                          and len({(t, tgt) for t, tgt, _e, _out in _loop_tracker}) == 1)
         if _identical_trip or _failure_trip:
-            what = f"{tool_name} returned the same result" if _identical_trip else f"{tool_name} failed"
             if not _in_delegate:   # a sub-agent's stop is its own result, not the turn's
-                cprint(f"\n  ⚠ Stopped: {what} three times in a row.", C.BYELLOW)
-                _mark_turn_stopped("loop")
+                notice = _stop_notice(
+                    "loop", tool_name, str(tool_path or ""),
+                    identical=_identical_trip and not _failure_trip,
+                    changed=_changed_paths,
+                    tried_to_change=any(t in _MUTATING_TOOLS for t in tools_used))
+                cprint(f"\n  ⚠ {notice}", C.BYELLOW)
+                _mark_turn_stopped("loop", notice)
             memory.maybe_index_turn(config, query, tools_used, touched_paths, outcome="error_loop")
             if session:
                 _record_undo_snapshots(session, _turn_snapshots)
@@ -1511,8 +1549,11 @@ def _run_autopilot_turn(
 
     memory.maybe_index_turn(config, query, tools_used, touched_paths, outcome="step_limit")
     if not _in_delegate:   # a sub-agent's cap is routine; its text comes back as a tool result
-        cprint("\n  ⚠ Stopped at the step limit.", C.BYELLOW)
-        _mark_turn_stopped("step_limit")
+        notice = _stop_notice(
+            "step_limit", changed=_changed_paths,
+            tried_to_change=any(t in _MUTATING_TOOLS for t in tools_used))
+        cprint(f"\n  ⚠ {notice}", C.BYELLOW)
+        _mark_turn_stopped("step_limit", notice)
     if session:
         _record_undo_snapshots(session, _turn_snapshots)
     _probe(probe, "on_end", "step_limit", last_tool_output or "Done.")
@@ -2057,7 +2098,14 @@ def one_shot_autopilot(config: dict[str, Any], query: str, shell_exe: str) -> in
     tel.record_turn(turn)
     append_session_message(session, "assistant", message)
     sync_session_store(sessions, session)
-    if last_streamed_matches(message) or last_turn_stopped():
+    if last_turn_stopped():
+        if sys.stdout.isatty():
+            print()
+        else:
+            # A pipe used to get nothing for a stopped turn. It gets the stop
+            # sentence; the raw tool output stays in the history only.
+            print(last_stop_notice())
+    elif last_streamed_matches(message):
         if sys.stdout.isatty():
             print()
     elif not sys.stdout.isatty():

{hexcli-2.20.0 → hexcli-2.21.0}/hexcli/tools.py

@@ -441,6 +441,8 @@ def edit_file_tool(path_text: str, old_string: str, new_string: str) -> str:
     else:
         new_content, err = apply_search_replace(content, [(old_string, new_string)])
         if err:
+            if err.startswith("SEARCH block 1 was not found") and len(content) <= _WHOLE_FILE_ON_MISS:
+                raise RuntimeError(_not_found_with_content(path, content))
             raise RuntimeError(err.replace("SEARCH block 1", "old_string"))
         tier = p2.LAST_APPLY_TIER
     tmp = path.parent / (path.name + ".tmp")
@@ -453,6 +455,26 @@ def edit_file_tool(path_text: str, old_string: str, new_string: str) -> str:
     return f"Edited {path}"
 
 
+# A missed edit_file on a small file gets the file's whole text back instead of
+# the closest region. Of 1,279 recorded edit_file calls (2026-09-18), 786 were
+# made without reading or writing the file that turn and failed 45 % of the
+# time against 9 % after a read, and 115 of the 291 misses came straight after
+# another miss on the same file: the retry was rebuilt from memory again. With
+# the text in the error the retry can be copied from the file, at no extra
+# step. Every fixture behind those misses is under 200 characters; a file
+# above the cap keeps the closest-region report.
+_WHOLE_FILE_ON_MISS = 1500
+
+
+def _not_found_with_content(path: Path, content: str) -> str:
+    body = content if content.strip() else "(the file is empty)"
+    return (
+        f"old_string was not found in {path}. This is the file's whole current "
+        "content; copy the lines to change from it exactly into old_string:\n"
+        f"---\n{body.rstrip(chr(10))}\n---"
+    )
+
+
 def write_file_tool(path_text: str, content: str) -> str:
     from . import editing as p2