hexcli 2.9.1__tar.gz → 2.10.0__tar.gz

{hexcli-2.9.1 → hexcli-2.10.0}/.gitignore

@@ -56,3 +56,7 @@ tools/backend_bench/.battery_probe.ps1
 
 # python -m build output
 dist/
+
+# Local-only notes: research surveys and working documents that are not user-facing.
+# Only the paper (docs/paper) and user-facing docs are committed (owner rule, 2026-09-14).
+docs/local/

{hexcli-2.9.1 → hexcli-2.10.0}/CHANGELOG.md

@@ -6,6 +6,42 @@ the Hexagon NPU, not single-run anecdotes.
 
 ## Unreleased
 
+## 2.10.0 — 2026-09-14
+
+A minor release: the retry feedback the model reads changed. Gate: extended
+suite at 5 runs, seed 20260914, 32/44 pass^5 (the 2.7.x baseline is 32/44), run-level
+159/205 vs 165/208 (p=0.72); one gate case missed once and passed its 6-run
+recheck; CI green on main and the tag.
+
+- A reply whose first JSON object does not decode is never "finished" by a
+  later object in the same reply. The owner's 2026-09-13 session: asked for
+  a calculator page, the model answered with a `write_file` holding 1.6K of
+  HTML and, behind it, a `finish` saying the file was created. Fifteen
+  attribute quotes (`onclick=\"input('7')">`) were unescaped, the string
+  closed early, the object failed to decode, the parser moved on to the
+  next complete object, accepted the finish, and the turn claimed a file it
+  never wrote; the next turn found nothing to open. `parse_json_object` now
+  decodes the first object from the first brace with `raw_decode` (batched
+  actions still take the first and let the loop drive the rest), repairs a
+  stray quote inside a string value up to sixty-four times by escaping the
+  last unescaped quote before the decoder's error (a truncated string is
+  left alone), accepts raw control characters inside strings, and returns
+  nothing when the first object still fails, so the loop's existing retry
+  fires. That retry now tells the model the decoder's complaint, the
+  character offset, the text around it and the quoting rule instead of
+  "not valid JSON". The session's reply, verbatim, is a fixture: it decodes
+  to the write with all 1,466 characters of HTML.
+- The `/` command menu sits above the input row, between the top rule and
+  the prompt. The box is pinned to the window's last rows, so the rows
+  2.9.1 added below the input pushed the input row and the caret up
+  whenever the menu appeared or changed height; rows above the input grow
+  the box upward and the caret stays where it is.
+- `run_arm.cmd` stops when the suite exits non-zero. An aborted suite (six
+  consecutive backend timeouts on a starved machine, 2026-09-13) left the
+  previous arm's results file in place, and the script copied it as the
+  candidate and gated it, which read as a RECHECK verdict against stale
+  data. It now logs the abort and writes no candidate.
+
 ## 2.9.1 — 2026-09-13
 
 A patch release: the input line and the status bar; nothing model-facing

{hexcli-2.9.1 → hexcli-2.10.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: hexcli
-Version: 2.9.1
+Version: 2.10.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.9.1 → hexcli-2.10.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.9.1"
+__version__ = "2.10.0"

{hexcli-2.9.1 → hexcli-2.10.0}/hexcli/agent.py

@@ -1289,9 +1289,12 @@ def _run_autopilot_turn(
                         "one JSON object. No prose."
                     )
                 else:
+                    detail = parsing.describe_json_error(raw)
                     feedback = (
-                        "Your response was not valid JSON. "
-                        "Respond with exactly one JSON object as specified. No prose."
+                        "Your response was not valid JSON"
+                        + (f": {detail}. Inside a string value every double quote must be "
+                           "written as \\\". " if detail else ". ")
+                        + "Respond with exactly one JSON object as specified. No prose."
                     )
                 messages.append({"role": "assistant", "content": strip_thinking(raw)})
                 messages.append({"role": "user", "content": feedback})

{hexcli-2.9.1 → hexcli-2.10.0}/hexcli/lineedit.py

@@ -629,6 +629,12 @@ class LineEditor:
         logical: list[tuple[str, int]] = []   # (rendered text, visible width)
         for line in above:
             logical.append((line, visible_len(line)))
+        # The / menu sits between the top rule and the input row. The box is
+        # pinned to the window's last rows, so rows added BELOW the input
+        # pushed the input row and the caret up when the menu appeared; rows
+        # above it grow the box upward and the caret stays put.
+        menu = self._menu_rows() if chrome else []
+        logical.extend(menu)
         for line in prompt_lines[:-1]:
             logical.append((line, visible_len(line)))
         last_prompt = prompt_lines[-1]
@@ -647,8 +653,6 @@ class LineEditor:
             text, vis = logical[-1]
             styled = f"\033[2m{ghost}\033[0m" if self.styled else ghost
             logical[-1] = (text + styled, vis + len(ghost))
-        if chrome:
-            logical.extend(self._menu_rows())
         for line in below:
             logical.append((line, visible_len(line)))
 
@@ -656,7 +660,7 @@ class LineEditor:
         before = self.buffer[:self.pos]
         cur_line = before.count("\n")
         col_in_line = len(before) - (before.rfind("\n") + 1)
-        cursor_logical = len(above) + len(prompt_lines) - 1 + cur_line
+        cursor_logical = len(above) + len(menu) + len(prompt_lines) - 1 + cur_line
         cursor_vis = visible_len(prefixes[cur_line]) + col_in_line
 
         pieces: list[str] = []

{hexcli-2.9.1 → hexcli-2.10.0}/hexcli/parsing.py

@@ -93,43 +93,92 @@ def strip_thinking(text: str) -> str:
 # Parsing
 # ---------------------------------------------------------------------------
 
+_STRAY_QUOTE_MSGS = ("Expecting ',' delimiter", "Expecting ':' delimiter",
+                     "Expecting property name")
+_MAX_QUOTE_REPAIRS = 64
+_DECODER = json.JSONDecoder(strict=False)   # raw newlines inside a written file are fine
+
+
+def _escaped_at(text: str, i: int) -> bool:
+    """Is the character at i preceded by an odd run of backslashes?"""
+    n = 0
+    while i - 1 - n >= 0 and text[i - 1 - n] == "\\":
+        n += 1
+    return n % 2 == 1
+
+
+def _repair_stray_quote(text: str, err: json.JSONDecodeError) -> str | None:
+    """Escape the quote that ended a string early. A 4B writing 1.6K of HTML
+    inside a JSON string forgets the backslash on a closing attribute quote
+    (`onclick=\\"input('7')">`, sixteen times in one reply, 2026-09-13): the
+    string closes there and the decoder trips on the next token. The last
+    unescaped quote before the error is that closer; escape it and let the
+    caller decode again. A truncated string (\"Unterminated string\") is not
+    repairable and is left alone."""
+    if not any(err.msg.startswith(m) for m in _STRAY_QUOTE_MSGS):
+        return None
+    q = text.rfind('"', 0, err.pos)
+    while q > 0 and _escaped_at(text, q):
+        q = text.rfind('"', 0, q)
+    if q <= 0:
+        return None
+    return text[:q] + "\\" + text[q:]
+
+
+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
+    quotes inside string values are repaired a bounded number of times."""
+    start = text.find("{")
+    if start < 0:
+        return None
+    for _ 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)
+            if fixed is None:
+                return None
+            text = fixed
+    return None
+
+
+def describe_json_error(raw_text: str) -> str:
+    """What is wrong with the first JSON object in a reply, for the retry
+    feedback: the decoder's message, the character offset and the text
+    around it. Empty when the object decodes."""
+    text = strip_thinking(raw_text).strip()
+    start = max(0, text.find("{"))
+    try:
+        _DECODER.raw_decode(text, start)
+        return ""
+    except json.JSONDecodeError as err:
+        lo, hi = max(0, err.pos - 40), min(len(text), err.pos + 20)
+        return f"{err.msg} at character {err.pos - start}, near: {text[lo:hi]!r}"
+
+
 def parse_json_object(raw_text: str) -> dict[str, Any] | None:
     text = strip_thinking(raw_text).strip()
     if not text:
         return None
     # Direct parse
-    try:
-        parsed = json.loads(text)
-        if isinstance(parsed, dict):
-            return parsed
-    except json.JSONDecodeError:
-        pass
+    parsed = _loads_object(text)
+    if parsed is not None:
+        return parsed
     # Strip markdown fences
     stripped = re.sub(r"^```[a-zA-Z]*\s*|```\s*$", "", text, flags=re.MULTILINE).strip()
-    try:
-        parsed = json.loads(stripped)
-        if isinstance(parsed, dict):
-            return parsed
-    except json.JSONDecodeError:
-        pass
-    # Extract the FIRST complete {...} object by brace balancing.
-    #
-    # This used to be a greedy re.search(r"\{.*\}"), which spans from the first
-    # brace to the LAST one. When the model emits several actions in a row —
-    # {"action":"edit_file",…},{"action":"verify_syntax",…},{"action":"run_code",…}
-    # — that match is not valid JSON, so the whole response was discarded, the
-    # identical retry was issued up to 3×, and the turn ended with no tool call
-    # at all. Measured 2026-07-30: this is what actually killed uc1-t4/t5/t6
-    # (0/3 each), NOT a context-length cliff. Batching is a natural response to
-    # rules that prescribe an edit→verify→run sequence, so take the first
-    # action and let the loop drive the rest.
-    for candidate in _iter_json_objects(text):
-        try:
-            parsed = json.loads(candidate)
-            if isinstance(parsed, dict):
-                return parsed
-        except json.JSONDecodeError:
-            continue
+    parsed = _loads_object(stripped)
+    if parsed is not None:
+        return parsed
+    # Nothing decodable from the first brace. Batched actions ({edit}{verify}
+    # {run}) are handled above: raw_decode takes the FIRST object and ignores
+    # the rest, and the loop drives the next step (measured 2026-07-30: the
+    # old greedy match discarded such replies and killed uc1-t4/t5/t6). A
+    # broken first object is a malformed reply, never skipped for a later
+    # one: on 2026-09-13 the finish behind an unparseable write_file was
+    # accepted and the turn claimed a file it had not written. The loop
+    # retries with the decoder's complaint (describe_json_error).
     return None