hexcli 2.19.0__tar.gz → 2.20.1__tar.gz

{hexcli-2.19.0 → hexcli-2.20.1}/CHANGELOG.md

@@ -4,6 +4,55 @@ 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.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
+program that waits for the keyboard).
+
+> **Gate: PASS** on the pinned 24-case set: 21 cases held 5/5 in the arm;
+> `casual-4`, `factual-4` and `memory-1` lost four, two and four runs to
+> backend timeouts and were re-run on a fresh server at six runs, 6/6 each.
+> Own arm, seed 20260918. **Platform: 13 invalid of 245 runs (5.3 %)**, the
+> server's working set again above 6 GB with 1.6 GB free, so the ceiling
+> comparison carries the `[PLATFORM]` flag: run-level 402/514 vs 166/217,
+> −1.7 %, Fisher p = 0.63; pass^k 26 → 30 of 46 shared cases, McNemar
+> p = 0.13. The change did what it is for: `run_code` timed out 0 times in
+> the arm against 10 in the 2.12.0 arm (all of them `make-py-1`'s
+> calculator waiting on `input()`), the note fired twice, and `make-py-1`
+> stayed 5/5. Smoke 10/10 on a fresh server.
+
+- `run_code` gives the program no keyboard, and says so when the program
+  asked for one. The child inherited the terminal's standard input, so a
+  program that calls `input()` sat waiting on the owner's console until the
+  tool's timeout: on 2026-09-18 "create a python cli hilo guessing game and
+  run it" wrote a working game and then waited the full ten seconds, twice,
+  to report "TIMEOUT". Standard input is now closed for the child, so
+  `input()` raises `EOFError` at once, and when it does the result adds one
+  line: the program reads from the keyboard, `run_code` has none to give
+  it, and it has to be started in a terminal, with the command. On record:
+  12 `run_code` timeouts whose output ends in a prompt (ten of them the
+  `make-py-1` calculator) and 19 runs that already hit `EOFError` under the
+  eval runner, which has no terminal; 0.6 % of recorded runs, all of them
+  this shape.
+
 ## 2.19.0 — 2026-09-18
 
 A minor release: nudge text the model reads is new (the claimed-fix rule)

{hexcli-2.19.0 → hexcli-2.20.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: hexcli
-Version: 2.19.0
+Version: 2.20.1
 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.19.0 → hexcli-2.20.1}/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.19.0"
+__version__ = "2.20.1"

{hexcli-2.19.0 → hexcli-2.20.1}/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.19.0 → hexcli-2.20.1}/hexcli/tools.py

@@ -918,8 +918,13 @@ def run_code_tool(
             )
     cmd = [*cmd_prefix, str(path), *[str(a) for a in run_args]]
     try:
+        # No keyboard. With the parent's stdin inherited, a program that
+        # calls input() sat on the owner's terminal until the timeout (10 s,
+        # twice, 2026-09-18: "create a python cli hilo guessing game and run
+        # it"); with stdin closed it raises EOFError at once, and the note
+        # below tells the model what that means.
         proc = subprocess.Popen(
-            cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE,
+            cmd, stdin=subprocess.DEVNULL, stdout=subprocess.PIPE, stderr=subprocess.PIPE,
             text=True, encoding="utf-8", errors="replace",
         )
     except (PermissionError, FileNotFoundError, OSError) as exc:
@@ -940,10 +945,16 @@ def run_code_tool(
     out = trim_text(stdout, output_limit)
     err = trim_text(stderr, output_limit)
     ui.tool_event("run", f"{path}  (exit {proc.returncode})")
+    note = ""
+    if "EOFError" in stderr:
+        note = (f"\n\nThe program stopped where it reads from the keyboard (input()). "
+                f"run_code has no keyboard to give it, so it cannot be played or driven "
+                f"here; it has to be started in a terminal: python {path.name}. The code "
+                f"up to that point ran.")
     return (
         f"Exit code: {proc.returncode}\n\n"
         f"[stdout]\n{out or '(empty)'}\n\n"
-        f"[stderr]\n{err or '(empty)'}"
+        f"[stderr]\n{err or '(empty)'}{note}"
     )