hexcli 2.17.0__tar.gz → 2.19.0__tar.gz

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

@@ -4,6 +4,81 @@ 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.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,
+so the run that follows it changes.
+
+> **Gate: PASS** on the pinned 24-case set after rechecks. Own arm, fresh
+> server, seed 20260918, 2 invalid of 245 runs. `agentic-5` and
+> `error-recovery-3` (a counting answer and a denied search, no write in
+> either) missed once at 5 runs; `agentic-5` held 6/6, `error-recovery-3`
+> read 3/4 with two invalid runs on a server 70 minutes into its traffic and
+> 6/6 on a fresh one. Against the v2.11.1 12-run baseline: run-level
+> 402/514 vs 182/228, +1.6 %, Fisher p = 0.70; pass^k 26 → 29 of 46 shared
+> cases, McNemar p = 0.51. The unescape fired on three writes in the arm
+> (a `trap-1` poem and two `runit-1` bodies, all of which decode the same
+> under both rules), so the arm is evidence of no regression and the effect
+> rests on the fixture. Smoke 10/10 on a fresh server.
+
+- A double-escaped Python body is decoded the way that parses. The model
+  writes its line breaks as literal `\n` when it escapes a reply twice, and
+  the `\n` it means as a string escape inside the code looks exactly the
+  same: `print(\"\nWelcome\")` and the line break after it are the same two
+  characters. The 2.9.0 rule decoded all of them, so on 2026-09-18 the owner
+  got a file that read `print("` on one line and `Welcome to the Calculator
+  App!")` on the next, and the model spent the rest of the session not
+  fixing it. For a `.py` path the body is now decoded in full and parsed; if
+  that fails, every `\n` except one sitting right after an opening quote or
+  right before a closing one is decoded and the result parsed again, and
+  whichever parses is written (the full decode when neither does, as
+  before). Other file types are unchanged. Of the 511 `write_file` bodies on
+  record five are double-escaped, two have a quote-adjacent `\n`, and one of
+  those, the session above, parses only this way.
+
 ## 2.17.0 — 2026-09-18
 
 A minor release: the parser accepts a reply it used to send back for a

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

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

{hexcli-2.17.0 → hexcli-2.19.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.17.0 → hexcli-2.19.0}/hexcli/editing.py

@@ -12,6 +12,7 @@ audit (2026-07) through the merge tier (2026-09-13).
 """
 from __future__ import annotations
 
+import ast
 import difflib
 import re
 
@@ -140,6 +141,45 @@ def unescape_json(text: str) -> str:
     return _unescape_json(text)
 
 
+_QUOTE_ADJACENT_NL = re.compile(r'(["\'])\\n|\\n(["\'])')
+
+
+def unescape_body(text: str, path: str) -> str:
+    """Decode a double-escaped file body, keeping a Python source parseable.
+
+    A body the model escaped twice carries its line breaks as literal \\n --
+    and so does every \\n it meant as a string escape inside the code:
+    `print(\\"\\nWelcome\\")` and the line break after it are the same two
+    characters. Decoding all of them (the 2.9.0 rule) turns the escape into a
+    real newline inside the string literal, and the file the owner got on
+    2026-09-18 read `print("` / `Welcome to the Calculator App!")` -- a
+    SyntaxError the model then spent eleven steps not fixing.
+
+    For a .py path, decode everything and parse; if that fails, decode
+    everything EXCEPT a \\n that sits right after an opening quote or right
+    before a closing one, and parse again; keep whichever parses, and the
+    full decode when neither does (the caller's checker will say so). Other
+    file types get the full decode as before. Measured over the 511
+    write_file bodies on record: five are double-escaped, two of those have
+    a quote-adjacent \\n, and one of the two (the session above) parses only
+    this way."""
+    full = _unescape_json(text)
+    if not path.lower().endswith(".py"):
+        return full
+    try:
+        ast.parse(full)
+        return full
+    except SyntaxError:
+        pass
+    kept = _QUOTE_ADJACENT_NL.sub(lambda m: (m.group(1) or "") + "\x00" + (m.group(2) or ""), text)
+    candidate = _unescape_json(kept).replace("\x00", "\\n")
+    try:
+        ast.parse(candidate)
+        return candidate
+    except SyntaxError:
+        return full
+
+
 _DELTA_TOKEN_RE = re.compile(r"\w+|\s+|[^\w\s]")
 _ESCAPED_RE = re.compile(r'\\["nt\\]')
 _BARE_QUOTE_RE = re.compile(r'(?<!\\)"')

{hexcli-2.17.0 → hexcli-2.19.0}/hexcli/tools.py

@@ -461,7 +461,7 @@ def write_file_tool(path_text: str, content: str) -> str:
     path.parent.mkdir(parents=True, exist_ok=True)
     note = ""
     if p2.looks_double_escaped(content):
-        content = p2.unescape_json(content)
+        content = p2.unescape_body(content, str(path))
         note = ", unescaped"
     tmp = path.parent / (path.name + ".tmp")
     tmp.write_text(content, encoding="utf-8")