hexcli 2.18.0__tar.gz → 2.20.0__tar.gz

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

@@ -4,6 +4,80 @@ 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.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)
+and two existing rules fire where they did not.
+
+> **Gate: PASS** on the pinned 24-case set: 21 cases held 5/5 in the arm;
+> `missing-file-1`, `missing-file-2` and `regression-count-1` lost one, three
+> and one runs to backend timeouts and were re-run on a fresh server at six
+> runs, 6/6 each. Own arm, seed 20260918. **Platform: 16 invalid of 245 runs
+> (6.5 %)** -- the model server's working set grew from 3 GB to 6.7 GB over
+> the hour and the machine fell to 1.2 GB free, so the ceiling comparison
+> carries the `[PLATFORM]` flag: run-level 391/502 vs 161/214, −2.6 %, Fisher p = 0.44;
+> pass^k 26 → 30 of 46 shared cases, McNemar p = 0.13; every ceiling drop
+> (`livestate-1` 1/4, `tests-claim-1` 0/2, `claims-1` 1/5) is on a case that
+> lost runs to timeouts. **The new and widened rules did not fire once in
+> the arm**, so the arm is evidence of no regression on the gated set and
+> the effect rests on the replay below. Smoke 10/10 on a fresh server.
+
+- The intent nudge counts only a mutation that landed, catches a claimed
+  fix with no change behind it, and reads "cannot be created" however the
+  sentence goes on. Three gaps, all from the owner's 2026-09-18 session.
+  The loop had been passing "a tool with a path was called" as *mutated*,
+  which an `edit_file` on a missing file satisfies, so when the turn ended
+  "A calculator app cannot be created without a matching file" right after
+  exactly that error, the create rule stayed silent -- and its wording only
+  knew "cannot be created in this environment" anyway. Later, "fix it" was
+  answered with "The file has been fixed by removing the malformed line"
+  after a `run_code` that showed the SyntaxError and no edit at all; nothing
+  looked at that. Now *mutated* means a write, edit or append that did not
+  error; the denial wording matches `cannot be (built|created|done|made)`
+  with any continuation; and a request to fix, correct, update or change
+  something (an instruction, not a question) answered with "has been fixed",
+  "was corrected", "is now updated" and no mutation gets one nudge to make
+  the change or say plainly that nothing was changed. Replayed over the 206
+  real turns and 5,389 recorded runs with the loop's own semantics: on real
+  turns the nudge fires 11 times, all genuine (two new: the refusal above
+  and the claimed fix); on recorded runs the new rule fires on seven, five
+  of them `ambiguous-2` answering "Update the file." with "Updated the file
+  as requested" and no tool call, two of them `tests-claim-1` claiming a
+  correction it never made. The question form is what keeps `memory-1`
+  ("which file did you fix?") out: its honest recall fired 14 times in the
+  first draft and zero now.
+
 ## 2.18.0 — 2026-09-18
 
 A minor release: what `write_file` writes for one shape of body changes,

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: hexcli
-Version: 2.18.0
+Version: 2.20.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.18.0 → hexcli-2.20.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.18.0"
+__version__ = "2.20.0"

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

@@ -1165,6 +1165,7 @@ def _run_autopilot_turn(
     # must observe something (run/read/check) before its answer is accepted.
     # One nudge per turn — it guides, never traps.
     _unverified_mutation = False
+    _mutated_ok = False            # a write/edit/append that did not error, this turn
     _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.
@@ -1343,8 +1344,8 @@ def _run_autopilot_turn(
             # claimed to have checked with no tool call at all.
             if not _intent_nudge_used and config.get("require_verification", True):
                 _intent_text = _intent_nudge(
-                    query, msg, mutated=bool(touched_paths), ran=_ran_anything,
-                    tools_used=tools_used)
+                    query, msg, mutated=_mutated_ok, ran=_ran_anything,
+                    tools_used=tools_used, touched=bool(touched_paths))
                 if _intent_text:
                     _intent_nudge_used = True
                     messages.append({"role": "assistant", "content": strip_thinking(raw)})
@@ -1476,6 +1477,7 @@ def _run_autopilot_turn(
         _is_error = tool_output.lstrip().startswith("Error:")
         if tool_name in {"edit_file", "write_file", "append_file"} and not _is_error:
             _unverified_mutation = True
+            _mutated_ok = True
         elif tool_name in {"read_file", "run_code", "verify_syntax", "lint_code",
                            "run_command"} and not _is_error:
             _unverified_mutation = False
@@ -1790,9 +1792,22 @@ _WANTS_FIND_RE = re.compile(
 # means, which for a file-writing agent is false.
 _DENIES_MEANS_RE = re.compile(
     r"\b(no tools? (are )?available|not feasible|unable to (build|create|make|generate)"
-    r"|cannot be (built|created|done) (in|within) this environment"
+    r"|cannot be (built|created|done|made)\b"
     r"|outside the (scope|capabilities)|no (tool|way|mechanism) (to|for)\b)", re.IGNORECASE)
 
+# "fix it" answered with "has been fixed" and no file changed. 2026-09-18
+# 07:03: "The file has been fixed by removing the malformed line" after a
+# run_code that showed the SyntaxError and no edit at all. The request has
+# to be an instruction, not a question: memory-1 asks "which file did you
+# fix?" and the honest recall "the syntax error was fixed in buggy_calc.py"
+# must not fire (it did, in the first draft, 14 runs of a 12/12 case).
+_WANTS_FIX_RE = re.compile(
+    r"\b(fix|correct|repair|patch|update|change|modify|edit)\b", re.IGNORECASE)
+_CLAIMS_FIXED_RE = re.compile(
+    r"\b(has been|have been|was|were|is now|are now|successfully)\s+"
+    r"(fixed|corrected|updated|modified|changed|repaired|resolved|patched)\b"
+    r"|\b(fixed|corrected|updated|modified|repaired|patched) (the|it|this)\b", re.IGNORECASE)
+
 _CLAIMS_NEGATIVE_RE = re.compile(
     r"\b(no|none|not|nothing|couldn't|could not|unable to)\b[^.]{0,40}"
     r"\b(found|find|locate|exists?|present)\b", re.IGNORECASE)
@@ -1926,10 +1941,22 @@ def _contradicted_not_found(msg: str, outputs: list[str]) -> str:
 
 
 def _intent_nudge(query: str, msg: str, *, mutated: bool, ran: bool,
-                  tools_used: list[str]) -> str:
+                  tools_used: list[str], touched: bool | None = None) -> str:
     """One nudge when the turn did none of the work the request implies.
-    Empty string when there is nothing to say."""
-    if (_WANTS_RUN_RE.search(query) and mutated and not ran
+    Empty string when there is nothing to say.
+
+    `mutated` is a write/edit/append that SUCCEEDED this turn. Until
+    2026-09-18 the loop passed "any tool with a path was called", which is
+    true after a read_file or after an edit_file that errored, so the
+    create rule below was silenced by the very failure it exists for: the
+    owner's "please create a working calculator app" turn ended "A
+    calculator app cannot be created without a matching file" right after
+    an edit_file on a file that did not exist. `touched` keeps the run
+    rule's older, wider sense (a file was at least read) for callers that
+    have it."""
+    if touched is None:
+        touched = mutated
+    if (_WANTS_RUN_RE.search(query) and touched and not ran
             and not _asks_to_run_tests(query)):
         return ("You were asked to run it and nothing was run this turn. Run it now "
                 "with run_code (or run_command) and report the output you actually "
@@ -1949,6 +1976,11 @@ def _intent_nudge(query: str, msg: str, *, mutated: bool, ran: bool,
         return ("You said you checked, but this turn made no tool call at all. "
                 "Check it with a tool and report what the tool returned, or say "
                 "plainly that you did not check. Respond with JSON only.")
+    if (_WANTS_FIX_RE.search(query) and "?" not in query and not mutated
+            and _CLAIMS_FIXED_RE.search(msg)):
+        return ("You said it was fixed, but no file was changed this turn. Make "
+                "the change with edit_file (or write_file) and then verify it, or "
+                "say plainly that nothing was changed. Respond with JSON only.")
     return ""
 
 

{hexcli-2.18.0 → hexcli-2.20.0}/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}"
     )