hexcli 2.15.0__tar.gz → 2.17.0__tar.gz

{hexcli-2.15.0 → hexcli-2.17.0}/CHANGELOG.md

@@ -4,6 +4,68 @@ 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.17.0 — 2026-09-18
+
+A minor release: the parser accepts a reply it used to send back for a
+retry, so what the model sees after such a reply changes.
+
+> **Gate: PASS** on the pinned 24-case set, all 24 held at 5 runs with no
+> recheck. Own arm, fresh server, seed 20260918, 6 invalid of 245 runs.
+> Against the v2.11.1 12-run baseline: run-level 402/514 vs 174/224, −0.5 %,
+> Fisher p = 0.92; pass^k 26 → 31 of 46 shared cases, McNemar p = 0.13. The
+> close fired on five replies in the arm (`claims-1`, `claims-2`, two in
+> `tests-claim-1`, one in `trap-3`); `claims-1` 3/5 against 3/11, `trap-3`
+> 0/5 as before. Smoke 9/10 on a fresh server; the miss was `factual-1`,
+> re-measured 7/10 against its recorded 79 % (p = 0.67).
+
+- A reply that stops before its last closing brace is closed and decoded.
+  In the owner's 2026-09-18 session two `write_file` replies, 2,239 and 782
+  characters, ended at `"}` with the outer object never closed. The parser's
+  stray-quote repair took the decoder's "Expecting ',' delimiter" at the end
+  of the text as a quote that had ended a string early, escaped the
+  content's own closing quote, and the decoder then reported an unterminated
+  string; the retry feedback told the model to fix its quoting, the model
+  escaped everything twice, and the file it wrote had `\n` and `\"` in it as
+  text. Every step after that in the session was the model failing to repair
+  that file. When the decoder's error sits at the very end of the reply,
+  every string is closed and the brace depth is still positive, the missing
+  braces are appended and the object decodes. Measured over the 10,772
+  replies on record: 185 fail to decode, and 27 of them now decode (all one
+  brace short; 23 in `claims-1`, `claims-2` and `tests-claim-1`, four in the
+  owner's sessions). The close is only tried on the reply as sent: three
+  more replies are a brace short *after* a stray quote, and a reply whose
+  content string was cut off and then followed by a second object would
+  otherwise be glued into one, so those stay retries. A reply cut off inside
+  a string is still reported as cut off, and a stray quote in the middle is
+  still repaired as before; the other 158 undecodable replies are unchanged.
+
+## 2.16.0 — 2026-09-18
+
+A minor release: a tool result the model reads changes (`find_files` returns
+a listing where it returned an argument error).
+
+> **Gate: PASS** on the pinned 24-case set after one recheck (`agentic-4`
+> and `agentic-5`, neither of which calls `find_files`, missed once at 5
+> runs and then held at 6). Own arm, fresh server, seed 20260918, 8 invalid
+> of 245 runs. Against the v2.11.1 12-run baseline: run-level 402/514 vs
+> 174/222, +0.2 %, Fisher p = 1.00; pass^k 26 → 30 of 46 shared cases,
+> McNemar p = 0.29. **The alias did not fire in this arm**: all ten
+> `find_files` calls carried `glob` (two also sent `pattern`, and `glob`
+> won as designed), so the arm is evidence of no regression, and the case
+> for the change rests on the 21 of 170 recorded calls that would have
+> hit it. `findfile-1` 2/5, all three misses the decoy answer, which is
+> the separate finding still open. Smoke 10/10 on a fresh server.
+
+- `find_files` takes `pattern` as its glob when no `glob` is sent. The
+  model names the file under the key `search_files` uses in 21 of the 170
+  `find_files` calls on record, across eight cases and one of the owner's
+  sessions, and each one came back "find_files requires 'glob'". In the
+  2.12.0 arm three of `findfile-1`'s twelve runs spent two to three steps
+  on it and one reached the step limit that way. The value is what the
+  model meant to look for either way, and a bare name is a valid glob for
+  that exact name; `glob` still wins when both are sent, and a call with
+  neither is still an error.
+
 ## 2.15.0 — 2026-09-18
 
 A minor release: one tool error the model reads is new (`edit_file` on

{hexcli-2.15.0 → hexcli-2.17.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: hexcli
-Version: 2.15.0
+Version: 2.17.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.15.0 → hexcli-2.17.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.15.0"
+__version__ = "2.17.0"

{hexcli-2.15.0 → hexcli-2.17.0}/hexcli/agent.py

@@ -826,7 +826,12 @@ def execute_tool_call(config: dict[str, Any], action: dict[str, Any], shell_exe:
             raise RuntimeError("search_files requires 'pattern'.")
         return search_files_tool(pattern, path, glob_pat, limit)
     if tool == "find_files":
-        glob_pat = str(args.get("glob") or "").strip()
+        # 21 of the 170 find_files calls on record (2026-09-17) sent the
+        # name under "pattern", the key search_files uses, and got "requires
+        # 'glob'" -- three of findfile-1's twelve runs burned steps on it,
+        # one to the step limit. The value is what the model meant to look
+        # for either way; a bare name is a valid glob for that exact name.
+        glob_pat = str(args.get("glob") or args.get("pattern") or "").strip()
         path = str(args.get("path") or ".").strip() or "."
         if not glob_pat:
             raise RuntimeError("find_files requires 'glob'.")

{hexcli-2.15.0 → hexcli-2.17.0}/hexcli/parsing.py

@@ -126,6 +126,49 @@ def _repair_stray_quote(text: str, err: json.JSONDecodeError) -> str | None:
     return text[:q] + "\\" + text[q:]
 
 
+def _close_unfinished_object(text: str, start: int, err: json.JSONDecodeError) -> str | None:
+    """The reply ended before its last closing brace(s): `{"action":"write_file",
+    "args":{...,"content":"..."}` and then nothing. The decoder reports
+    "Expecting ',' delimiter" AT THE END of the text; every string is closed
+    and the brace depth is still positive. Appending the missing braces is
+    the whole repair. 30 of the 185 undecodable replies on record are this
+    shape, all one brace short, four of them in the owner's sessions
+    (2026-09-13 and 2026-09-18), and the stray-quote repair below used to
+    make them worse: it escaped the content's own closing quote, the decoder
+    then said "Unterminated string", and the retry feedback told the model
+    to fix its quoting -- which it did by escaping everything twice, and the
+    file it then wrote had backslashes in it. None when the error is not at
+    the end, a string is still open, or the braces already balance."""
+    if err.pos < len(text.rstrip()):
+        return None
+    depth, in_string, escaped = 0, False, False
+    for ch in text[start:]:
+        if in_string:
+            if escaped:
+                escaped = False
+            elif ch == "\\":
+                escaped = True
+            elif ch == '"':
+                in_string = False
+        elif ch == '"':
+            in_string = True
+        elif ch == "{":
+            depth += 1
+        elif ch == "}":
+            depth -= 1
+    if in_string or depth <= 0:
+        return None
+    return text.rstrip() + "}" * depth
+
+
+# Only the reply AS SENT is closed this way. Once a stray-quote repair has
+# changed the text, a positive depth at the end can be the repair's own
+# doing (a write whose content string was cut off, followed by a second
+# object: the repairs walk the quotes back until the text "balances" and
+# the close would then glue the two objects into one), and that reply must
+# stay a retry -- evals/test_backports.py pins it.
+
+
 def _loads_object(text: str) -> dict[str, Any] | None:
     """The first JSON object in `text`, decoded from its first brace and
     ignoring whatever follows it (a second batched action, prose). Stray
@@ -133,12 +176,13 @@ def _loads_object(text: str) -> dict[str, Any] | None:
     start = text.find("{")
     if start < 0:
         return None
-    for _ in range(_MAX_QUOTE_REPAIRS + 1):
+    for attempt in range(_MAX_QUOTE_REPAIRS + 1):
         try:
             parsed, _end = _DECODER.raw_decode(text, start)
             return parsed if isinstance(parsed, dict) else None
         except json.JSONDecodeError as err:
-            fixed = _repair_stray_quote(text, err)
+            fixed = (_close_unfinished_object(text, start, err) if attempt == 0 else None) \
+                or _repair_stray_quote(text, err)
             if fixed is None:
                 return None
             text = fixed
@@ -155,13 +199,14 @@ def _decode_failure(text: str) -> tuple[json.JSONDecodeError | None, str]:
     if start < 0:
         return None, text
     last: json.JSONDecodeError | None = None
-    for _ in range(_MAX_QUOTE_REPAIRS + 1):
+    for attempt in range(_MAX_QUOTE_REPAIRS + 1):
         try:
             _DECODER.raw_decode(text, start)
             return None, text
         except json.JSONDecodeError as err:
             last = err
-            fixed = _repair_stray_quote(text, err)
+            fixed = (_close_unfinished_object(text, start, err) if attempt == 0 else None) \
+                or _repair_stray_quote(text, err)
             if fixed is None:
                 return err, text
             text = fixed