hexcli 2.8.1__tar.gz → 2.9.0__tar.gz

{hexcli-2.8.1 → hexcli-2.9.0}/CHANGELOG.md

@@ -6,6 +6,95 @@ the Hexagon NPU, not single-run anecdotes.
 
 ## Unreleased
 
+## 2.9.0 — 2026-09-13
+
+A minor release: `edit_file` and `write_file` behave differently for the
+model, and the launcher hands the agent its package path. Gate: extended
+suite at 5 runs PASS after recheck, uc1 at 6 runs, smoke 10/10, CI green.
+
+- `edit_file` merges the model's change into the file instead of pasting
+  its memory of the file. Multi-turn traces (uc1-t3/t4, 2026-09-13) show
+  the 4B rebuilding lines from the traceback in its history rather than
+  copying them: `for item in data` where the file says `items`, `"average":
+  average` where it says `avg`, a dropped trailing comment. Its
+  `old_string` then sits at 40–95 % similarity while the change it wants is
+  small and clear (`appned` → `append`; add a key to a dict). The old
+  fallback pasted `new_string` over the closest region when similarity was
+  ≥ 95 %, which installed the misremembered names: five of six live uc1-t4
+  runs ended in `NameError: name 'average' is not defined`, put there by the
+  harness, and the model then retried the same line four times. The paste
+  is gone. `protocol_v2._apply_one` now runs a token-level three-way merge
+  between the file's closest region, `old_string` and `new_string`: hunks
+  the model changed are applied where the file agrees with what the model
+  saw, tokens the model misremembered keep the file's text, and a hunk that
+  touches a misremembered token refuses (unless the "change" merely restates
+  what the file already says, which is skipped). Inserted lines are
+  re-indented by the delta between the model's line and the file's; a
+  whitespace run holding a newline never matches one that does not; a
+  replacement that would restate the tokens beside its anchor, grow into a
+  side the model did not see correctly, or carry JSON escapes into a file
+  that has no backslashes, refuses. Every refusal still reports the closest
+  region as before. Replaying the saved traces against the fixtures: of 20
+  distinct failed uc1-t3 edits 5 now apply correctly, 15 still error, 0
+  apply wrongly; of 23 non-exact uc1-t4 attempts 8 apply, 12 refuse, 0
+  produce a harmful file (the first draft produced two syntax errors, from
+  un-shifted indentation and literal `\"` sequences, both now refused or
+  fixed).
+- `edit_file` decodes a double-escaped `old_string`. 58 of 667 saved
+  edit_file calls (38 of them errors) carried `\"` or literal `\n` because
+  the model escaped its JSON arguments twice (agentic-3: `\"name\":
+  \"demo\"` for a file holding `"name": "demo"`). When the raw string is
+  absent from the file and the decoded one is present, both strings are
+  decoded once and the tiers run again. `write_file` does the same for a
+  body that is one line of literal `\n` sequences with no real line break
+  (1 of 389 saved calls), and leaves any body with a real newline alone.
+- Audit of the same bug classes elsewhere: protocol v2's `edit` action
+  shares the applier and gains all of the above; the JSON action parser
+  only tracks escapes to find brace boundaries and never re-escapes; tier 3
+  (indent shift) replaces whole lines and has no trailing-segment case;
+  `run_command` carried one escaped argument in 303 calls and it was a
+  legitimate regex.
+- The edit and write event lines name what landed a non-exact edit
+  (`, transfer match`, `, unescaped match`, `, indent match`; `, unescaped`
+  on a write) so an arm log shows which calls the fallbacks rescued; the
+  model still reads `Edited <path>` / `Wrote <path>`.
+- A checkout's launcher runs the checkout's code. `python -m hexcli.agent`
+  resolves the package from the working directory, then site-packages; the
+  Terminal profile starts in the home directory, so since the 2.8.0
+  packaging the launcher started from `Hex CLI.cmd` was silently running
+  the pip-installed copy (2.7.1 on the owner's machine on 2026-09-13,
+  found when a new input-line feature did not appear) while the checkout
+  sat unused. The launcher now prepends its own package's parent to the
+  child's `PYTHONPATH` (`_agent_env`), a no-op for an installed copy.
+- `run_recheck.cmd` documents that the case list must be quoted: cmd splits
+  an unquoted comma list into arguments, so the first 2026-09-13 recheck ran
+  one case and handed the second case's name to the gate as a baseline path.
+- Live numbers (fresh server per arm, 2026-09-13, a day with under 1 GB
+  free on the 16 GB machine). Smoke 10/10. uc1 at 6 runs: t1 6/6, t2 6/6,
+  t3 5/6 (3/3 on 09-12, 15/24 pooled over earlier arms; the miss called no
+  tool), t4 1/6 (0/3 in every baseline: the first pass ever, on a merged
+  insertion beside the file's own `avg`), t5 0/6, t6 0/6 as before; the
+  merge landed 13 edits across uc1/uc2 that would have errored. uc2 at 3
+  runs: t2 2/3 (the model edited on an explain-only turn; both stray edits
+  refused), the rest 3/3. uc3 at 3 runs, twice: every run invalid on both
+  attempts, the client's 300 s timeout expiring while the server answered
+  429 busy at ~3,200 tokens of context (the 09-12 baseline lost one of
+  three the same way; no HTP hang in the server log), so uc3 has no valid
+  measurement today. Extended suite at 5 runs, seed 20260913: 31/44 pass^5
+  (32/44 on the 2.7.x baseline, 31/41 on 09-05), run-level 162/205 vs
+  165/208, Fisher p=1.0; not one fallback tier fired in those 220 runs (the
+  event-line markers show none), so the suite is a regression check only.
+  Gate RECHECK on agentic-3 (4/5) and self-correct-1 (4/5); recheck at 6
+  runs: self-correct-1 5/6, agentic-3 4/6 (two double-escaped runs, one
+  rescued by the decode, one landing the model's own comma-less JSON, and
+  one old_string hallucinated three times) → gate FAIL; a second agentic-3
+  recheck on a fresh server 6/6 → gate PASS. Ceiling panel: +lint-1
+  3/5→5/5, +trap-4 0/5→1/5, −regression-anchor-1 5/5→4/5 (the model wrote
+  invalid JSON through an exact-match edit). Results:
+  `merge_transfer_r5.json`, `multiturn_uc{1,2,3}_merge_*_20260913.json`,
+  log `merge_transfer.log`; the earlier anchor-only tier's arm is
+  `delta_transfer_r5.json` (gate PASS after recheck, 27/44, superseded).
+
 ## 2.8.1 — 2026-09-12
 
 A patch release: nothing model-facing and nothing the launcher hands the

{hexcli-2.8.1 → hexcli-2.9.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: hexcli
-Version: 2.8.1
+Version: 2.9.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.8.1 → hexcli-2.9.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.8.1"
+__version__ = "2.9.0"

{hexcli-2.8.1 → hexcli-2.9.0}/hexcli/launcher.py

@@ -446,10 +446,26 @@ def run_npurun_path() -> int:
     # up the same SDK and Rewind settings, not whatever the shell had.
     return subprocess.run(
         [sys.executable, "-m", "hexcli.agent", "--config", str(NPURUN_CONFIG), *sys.argv[1:]],
-        env=_npurun_env(),
+        env=_agent_env(),
     ).returncode
 
 
+def _agent_env() -> dict[str, str]:
+    """The server environment plus the path of THIS package, so the child
+    runs the same code as the launcher. `python -m hexcli.agent` resolves
+    the package from the working directory first and site-packages next;
+    the Terminal profile starts in the home directory, so a checkout's
+    launcher was starting the pip-installed copy (2.7.1 on the owner's
+    machine on 2026-09-13, with none of the 2.8.x or later changes) while
+    the checkout sat unused. Prepending the package's parent to PYTHONPATH
+    is a no-op for an installed copy and the fix for a checkout."""
+    env = dict(_npurun_env())
+    here = str(Path(__file__).resolve().parent.parent)
+    prior = env.get("PYTHONPATH", "")
+    env["PYTHONPATH"] = here if not prior else f"{here}{os.pathsep}{prior}"
+    return env
+
+
 # Flags the REPL answers on its own; no server needed, so `hex --version`
 # must not start one (or write the runtime config) first.
 _NO_SERVER_FLAGS = frozenset({"-h", "--help", "--version", "--doctor", "--update",

{hexcli-2.8.1 → hexcli-2.9.0}/hexcli/loop_v2.py

@@ -157,7 +157,10 @@ def _tool_edit(agent: Any, args: dict[str, Any], payload: list[tuple[str, str]]
     tmp = path.parent / (path.name + ".tmp")
     tmp.write_text(new_content, encoding="utf-8")
     tmp.replace(path)
-    ui.tool_event("edit", f"{path} ({len(payload)} block(s))")
+    from . import protocol_v2 as p2
+    tier = p2.LAST_APPLY_TIER
+    suffix = "" if tier == "exact" else f", {tier} match"
+    ui.tool_event("edit", f"{path} ({len(payload)} block(s){suffix})")
     return f"Edited {path}: {len(payload)} block(s) applied."
 
 

{hexcli-2.8.1 → hexcli-2.9.0}/hexcli/protocol_v2.py

@@ -312,6 +312,12 @@ def _parse_fence(rest: str) -> tuple[str | None, str]:
 # SEARCH/REPLACE application (fuzzy, precise errors)
 # ---------------------------------------------------------------------------
 
+# Tier that landed the most recent successful block: "exact", "whitespace",
+# "indent", "transfer" or "closest". Read by tools.edit_file_tool for its
+# event line so arm logs show which edits the fuzzy tiers rescued.
+LAST_APPLY_TIER = "exact"
+
+
 def apply_search_replace(content: str, blocks: list[tuple[str, str]]) -> tuple[str | None, str]:
     """Apply blocks in order. Returns (new_content, "") or (None, error).
 
@@ -332,9 +338,22 @@ def apply_search_replace(content: str, blocks: list[tuple[str, str]]) -> tuple[s
 
 def _apply_one(content: str, search: str, replace: str, block_no: int) -> tuple[str, str]:
     # Tier 1 — exact.
+    global LAST_APPLY_TIER
     count = content.count(search)
     if count == 1:
+        LAST_APPLY_TIER = "exact"
         return content.replace(search, replace, 1), ""
+    if count == 0 and _ESCAPED_RE.search(search):
+        # The model escaped its JSON arguments twice (agentic-3, 2026-09-13:
+        # old_string '\"name\": \"demo\"' for a file holding "name": "demo").
+        # Decode the JSON escapes once, in both strings, and retry from the top
+        # when that form actually exists in the file.
+        decoded = _unescape_json(search)
+        if decoded != search and decoded in content:
+            out, err = _apply_one(content, decoded, _unescape_json(replace), block_no)
+            if not err and LAST_APPLY_TIER == "exact":
+                LAST_APPLY_TIER = "unescaped"
+            return out, err
     if count > 1:
         return "", (f"SEARCH block {block_no} matches {count} locations in the file — "
                     "add surrounding lines to make it unique.")
@@ -356,6 +375,7 @@ def _apply_one(content: str, search: str, replace: str, block_no: int) -> tuple[
     if len(hits) == 1:
         i = hits[0]
         new_lines = c_lines[:i] + replace.split("\n") + c_lines[i + win:]
+        LAST_APPLY_TIER = "whitespace"
         return "\n".join(new_lines), ""
     if len(hits) > 1:
         return "", (f"SEARCH block {block_no} matches {len(hits)} locations "
@@ -386,35 +406,329 @@ def _apply_one(content: str, search: str, replace: str, block_no: int) -> tuple[
             else:
                 adjusted.append(ln[len(delta):] if ln.startswith(delta) else ln)
         new_lines = c_lines[:i] + adjusted + c_lines[i + win:]
+        LAST_APPLY_TIER = "indent"
         return "\n".join(new_lines), ""
     if len(hits) > 1:
         return "", (f"SEARCH block {block_no} matches {len(hits)} locations "
                     "(ignoring indentation) — add more context lines.")
 
-    # Tier 4 — high-confidence closest match. Live traces (uc1-t4, 2026-07-30)
-    # show the 4B model reconstructing lines from memory instead of copying
-    # them: its old_string lands ~97% similar to exactly one region, and it
-    # repeats the SAME wrong string on every retry even when the error shows
-    # the correct text. When the best window is ≥95% similar AND the runner-up
-    # is clearly worse (<90%), applying to the best window is what the model
-    # meant; the mandatory verify step catches any residual mismatch. Ties and
-    # weaker matches still error with the closest-region report.
-    ratios: list[tuple[float, int]] = []
-    search_text = "\n".join(s_lines)
-    for i in range(max(1, len(c_lines) - win + 1)):
-        cand = "\n".join(c_lines[i:i + win])
-        r = difflib.SequenceMatcher(None, search_text, cand, autojunk=False).ratio()
-        ratios.append((r, i))
-    ratios.sort(reverse=True)
-    if ratios and ratios[0][0] >= 0.95 and (len(ratios) == 1 or ratios[1][0] < 0.90):
-        i = ratios[0][1]
-        new_lines = c_lines[:i] + replace.split("\n") + c_lines[i + win:]
-        return "\n".join(new_lines), ""
+    # Tier 4 — three-way merge against the closest region. Multi-turn traces
+    # (uc1-t3/t4, 2026-09-13) show the 4B rebuilding the lines from memory
+    # instead of copying them: "for item in data" where the file says "items",
+    # "average" where the file says "avg", a dropped trailing comment. Its
+    # old_string then lands at 40-95% similarity while the CHANGE it wants
+    # (old_string -> new_string) is small and clear. Pasting new_string over
+    # the region installs the misremembered names (five of six uc1-t4 runs
+    # ended in NameError: 'average' that way), so the change is merged
+    # instead: token hunks the model changed are applied where the file
+    # agrees with what the model saw, tokens the model misremembered keep the
+    # file's text, and a hunk that touches a misremembered token refuses.
+    merged = _delta_transfer(content, search, replace)
+    if merged is not None:
+        LAST_APPLY_TIER = "transfer"
+        return merged, ""
 
     # No match at any tier — report the closest region.
     return "", _no_match_error(c_lines, s_lines, block_no)
 
 
+def unescape_json(text: str) -> str:
+    """Decode one level of JSON escapes (\\" \\n \\t \\\\)."""
+    return _unescape_json(text)
+
+
+_DELTA_TOKEN_RE = re.compile(r"\w+|\s+|[^\w\s]")
+_ESCAPED_RE = re.compile(r'\\["nt\\]')
+_DELTA_MAX_HUNKS = 4
+_DELTA_MAX_REPLACED_CHARS = 40
+_DELTA_MAX_INSERTED_CHARS = 400
+_DELTA_MIN_MATCHED = 0.6   # fraction of old_string's tokens found in the window
+
+
+def looks_double_escaped(text: str) -> bool:
+    """A file body with two or more literal backslash-n sequences and not a
+    single real line break is JSON escaped a second time (write_file,
+    persona_guard 2026-09-12: 'import re\\n\\n\\n# Regex …' written as one
+    line). A real one-line file that spells "\\n" on purpose is rarer than the
+    model's habit; anything with a genuine newline is left alone."""
+    return "\n" not in text and text.count("\\n") >= 2
+
+
+def _unescape_json(text: str) -> str:
+    return _ESCAPED_RE.sub(lambda m: {'"': '"', "n": "\n", "t": "\t", "\\": "\\"}[m.group(0)[1]], text)
+
+
+def _keys(toks: list[str]) -> list[str]:
+    """Token keys for matching: whitespace runs compare equal to each other,
+    but a run holding a newline never equals one that does not (a line break
+    the model wrote must not be absorbed by the file's indentation)."""
+    return [("\n" if "\n" in t else " ") if t.isspace() else t for t in toks]
+
+
+def _delta_transfer(content: str, search: str, replace: str) -> str | None:
+    """Merge the search->replace change into content's closest region, or None.
+
+    Three sequences: old (what the model believes the region says), new (what
+    it wants), window (what the file says). Hunks of old->new are applied to
+    the window where the hunk's tokens are equal between old and window; the
+    rest of the window is kept verbatim, so nothing the model misremembered
+    reaches the file. Refusals, each a documented failure shape: more than
+    four hunks; a replaced fragment over 40 chars or an insertion over 400;
+    no window at 60% token similarity or a tie between windows; a replaced
+    token the file does not have at that spot (unless the "change" merely
+    restates the file, which is skipped); a hunk with no stable neighbour on
+    either side; a hunk that grows on a side the model did not see correctly;
+    an insertion whose anchor sits next to tokens the model never saw; a
+    replacement that restates the tokens already beside it.
+    """
+    while search.endswith("\n") and replace.endswith("\n"):
+        search, replace = search[:-1], replace[:-1]
+    s_tok = _DELTA_TOKEN_RE.findall(search)
+    r_tok = _DELTA_TOKEN_RE.findall(replace)
+    if not s_tok or "".join(s_tok) != search or "".join(r_tok) != replace:
+        return None
+    s_keys = _keys(s_tok)
+    b_ops = [op for op in difflib.SequenceMatcher(None, s_keys, _keys(r_tok), autojunk=False).get_opcodes()
+             if op[0] != "equal"]
+    if not b_ops or len(b_ops) > _DELTA_MAX_HUNKS:
+        return None
+    for _, i1, i2, j1, j2 in b_ops:
+        if (len("".join(s_tok[i1:i2])) > _DELTA_MAX_REPLACED_CHARS
+                or len("".join(r_tok[j1:j2])) > _DELTA_MAX_INSERTED_CHARS):
+            return None
+
+    window = _delta_window(content, s_keys, search.count("\n") + 1)
+    if window is None:
+        return None
+    start, end, w_tok = window
+    eq: dict[int, int] = {}
+    for tag, i1, i2, j1, j2 in difflib.SequenceMatcher(None, s_keys, _keys(w_tok), autojunk=False).get_opcodes():
+        if tag == "equal":
+            for k in range(i2 - i1):
+                eq[i1 + k] = j1 + k
+
+    edits: list[tuple[int, int, str]] = []
+    for tag, i1, i2, j1, j2 in b_ops:
+        after = "".join(r_tok[j1:j2])
+        if tag == "insert":
+            span = _delta_insert_span(s_tok, w_tok, eq, i1)
+        else:
+            i1, i2, after = _delta_trim(s_tok, i1, i2, after)
+            if i1 >= i2:
+                return None
+            span = _delta_replace_span(s_tok, w_tok, eq, i1, i2, after)
+        if span is None:
+            return None
+        if span == ():
+            continue  # the "change" restates the file; nothing to do
+        ws, we = span
+        if _delta_duplicates_neighbour(w_tok, ws, we, after):
+            return None
+        if _ESCAPED_RE.search(after) and "\\" not in "".join(w_tok):
+            # The model escaped part of its arguments a second time; the file
+            # holds no backslashes, so those would land literally (a uc1-t4
+            # attempt wrote '\\"median\\": median' into Python).
+            return None
+        if "\n" in after:
+            after = _delta_reindent(after, s_tok, i1, w_tok, ws)
+            if ws == we and ws > 0 and "\n" in w_tok[ws - 1]:
+                lead = _DELTA_TOKEN_RE.match(after)
+                if lead and lead.group(0).isspace() and "\n" in lead.group(0) and not after.endswith(("\n", w_tok[ws - 1])):
+                    # Inserted before a line-leading anchor with the file's
+                    # own line break already in place: the insert's leading
+                    # break belongs after its text, not before it.
+                    after = after[lead.end():] + w_tok[ws - 1]
+        edits.append((ws, we, after))
+    if not edits:
+        return None
+    edits.sort()
+    for (_, a_end, _), (b_start, _, _) in zip(edits, edits[1:]):
+        if a_end > b_start:
+            return None
+    out = list(w_tok)
+    for ws, we, after in reversed(edits):
+        out[ws:we] = [after]
+    return content[:start] + "".join(out) + content[end:]
+
+
+def _delta_window(content: str, s_keys: list[str], height: int) -> tuple[int, int, list[str]] | None:
+    """The unique best line window (height-1..height+1) by token similarity.
+
+    Ranked by the symmetric ratio (so the tightest window wins over a taller
+    one holding the same matches); a tie on that ratio refuses. The floor is
+    the fraction of old_string's own tokens found in the window, so a short
+    fragment ("    appned(item)") against a long line still qualifies while
+    unrelated text does not.
+    """
+    c_lines = content.split("\n")
+    offsets = [0]
+    for ln in c_lines:
+        offsets.append(offsets[-1] + len(ln) + 1)
+    best: tuple[float, float, int, int, list[str]] | None = None
+    tie = False
+    for h in sorted({max(1, height - 1), height, height + 1}):
+        for i in range(0, max(1, len(c_lines) - h + 1)):
+            w_tok = _DELTA_TOKEN_RE.findall("\n".join(c_lines[i:i + h]))
+            if not w_tok:
+                continue
+            sm = difflib.SequenceMatcher(None, s_keys, _keys(w_tok), autojunk=False)
+            r = sm.ratio()
+            if best is None or r > best[0] + 1e-9:
+                matched = sum(b.size for b in sm.get_matching_blocks()) / len(s_keys)
+                best, tie = (r, matched, i, h, w_tok), False
+            elif abs(r - best[0]) <= 1e-9:
+                tie = True
+    if best is None or tie or best[1] < _DELTA_MIN_MATCHED:
+        return None
+    r, matched, i, h, w_tok = best
+    return offsets[i], offsets[i + h] - 1, w_tok
+
+
+def _line_indent_at(toks: list[str], i: int) -> str:
+    """Leading whitespace of the line holding token i."""
+    for k in range(min(i, len(toks) - 1), -1, -1):
+        t = toks[k]
+        if "\n" in t:
+            return t[t.rfind("\n") + 1:]
+    return toks[0] if toks and toks[0].isspace() and "\n" not in toks[0] else ""
+
+
+def _delta_reindent(after: str, s_tok: list[str], i1: int, w_tok: list[str], ws: int) -> str:
+    """Shift the lines after the first newline of `after` by the indent delta
+    between the model's line and the file's line (the model wrote the whole
+    function four spaces deeper in one uc1-t4 attempt; its inserted lines
+    must follow the file, not its memory)."""
+    old_ind = _line_indent_at(s_tok, i1)
+    win_ind = _line_indent_at(w_tok, ws)
+    if old_ind == win_ind:
+        return after
+    first, rest = after.split("\n", 1)
+    lines = rest.split("\n")
+    out = []
+    for n, ln in enumerate(lines):
+        last = n == len(lines) - 1
+        if ln.startswith(old_ind) and (ln.strip() or last):
+            # A blank middle line stays blank; the trailing segment is the
+            # indent of the line that follows and shifts like the others.
+            out.append(win_ind + ln[len(old_ind):])
+        else:
+            out.append(ln)
+    return first + "\n" + "\n".join(out)
+
+
+def _delta_trim(s_tok: list[str], i1: int, i2: int, after: str) -> tuple[int, int, str]:
+    """Drop whitespace tokens from the edges of a hunk; a space is no anchor."""
+    while i1 < i2 and s_tok[i1].isspace():
+        i1 += 1
+        after = after.lstrip() if after[:1].isspace() else after
+    while i2 > i1 and s_tok[i2 - 1].isspace():
+        i2 -= 1
+        after = after.rstrip() if after[-1:].isspace() else after
+    return i1, i2, after
+
+
+def _nonws_left(toks: list[str], i: int) -> int | None:
+    for k in range(i - 1, -1, -1):
+        if not toks[k].isspace():
+            return k
+    return None
+
+
+def _nonws_right(toks: list[str], i: int) -> int | None:
+    for k in range(i, len(toks)):
+        if not toks[k].isspace():
+            return k
+    return None
+
+
+def _gap_is_ws(w_tok: list[str], a: int, b: int) -> bool:
+    """True when only whitespace sits strictly between window indices a and b."""
+    return all(w_tok[k].isspace() for k in range(a + 1, b))
+
+
+def _delta_replace_span(s_tok: list[str], w_tok: list[str], eq: dict[int, int],
+                        i1: int, i2: int, after: str) -> tuple[int, int] | tuple[()] | None:
+    idx = [k for k in range(i1, i2) if not s_tok[k].isspace()]
+    if not idx:
+        return None
+    lft = _nonws_left(s_tok, i1)
+    rgt = _nonws_right(s_tok, i2)
+    after_n = sum(1 for t in _DELTA_TOKEN_RE.findall(after) if not t.isspace())
+    if any(k not in eq for k in idx):
+        # The model is changing a token the file does not have there. Allowed
+        # only when its "change" reproduces what the file already says
+        # (uc1-t4 fixture: old "cnt", new "count", file "count") — then the
+        # hunk is a no-op. Anything else is a conflict.
+        if lft is None or rgt is None or lft not in eq or rgt not in eq:
+            return None
+        if any(not s_tok[k].isspace() for k in range(lft + 1, i1)) or \
+                any(not s_tok[k].isspace() for k in range(i2, rgt)):
+            return None
+        between = [t for t in w_tok[eq[lft] + 1:eq[rgt]] if not t.isspace()]
+        wanted = [t for t in _DELTA_TOKEN_RE.findall(after) if not t.isspace()]
+        return () if between == wanted else None
+    pos = [eq[k] for k in idx]
+    for a, b in zip(pos, pos[1:]):
+        if b <= a or not _gap_is_ws(w_tok, a, b):
+            return None
+    left_stable = lft is not None and lft in eq and _gap_is_ws(w_tok, eq[lft], pos[0])
+    right_stable = rgt is not None and rgt in eq and _gap_is_ws(w_tok, pos[-1], eq[rgt])
+    if not (left_stable or right_stable):
+        return None
+    if not (left_stable and right_stable) and after_n > len(idx):
+        # One side is text the model did not see correctly: a token swap is
+        # safe, growing into that side is not ("appned(" -> "result.append("
+        # beside a "result." the file already has).
+        return None
+    return pos[0], pos[-1] + 1
+
+
+def _delta_insert_span(s_tok: list[str], w_tok: list[str], eq: dict[int, int], b: int) -> tuple[int, int] | None:
+    lft = _nonws_left(s_tok, b)
+    rgt = _nonws_right(s_tok, b)
+    left_ok = lft is not None and lft in eq
+    right_ok = rgt is not None and rgt in eq
+    if left_ok and right_ok:
+        if not _gap_is_ws(w_tok, eq[lft], eq[rgt]):
+            return None  # the file has tokens between them the model never saw
+        return eq[rgt], eq[rgt]
+    if right_ok:
+        w = eq[rgt]
+        if lft is None and not all(t.isspace() for t in w_tok[:w]):
+            return None  # the region starts with tokens the model never saw
+        return w, w
+    if left_ok:
+        w = eq[lft] + 1
+        if rgt is None and not all(t.isspace() for t in w_tok[w:]):
+            return None
+        return w, w
+    return None
+
+
+def _delta_duplicates_neighbour(w_tok: list[str], ws: int, we: int, after: str) -> bool:
+    """True when `after` restates what already sits beside the span on its line."""
+    a_tok = [t for t in _DELTA_TOKEN_RE.findall(after) if not t.isspace()]
+    if len(a_tok) < 2:
+        return False
+    pre: list[str] = []
+    for k in range(ws - 1, -1, -1):
+        if "\n" in w_tok[k]:
+            break
+        if not w_tok[k].isspace():
+            pre.append(w_tok[k])
+    pre.reverse()
+    post: list[str] = []
+    for k in range(we, len(w_tok)):
+        if "\n" in w_tok[k]:
+            break
+        if not w_tok[k].isspace():
+            post.append(w_tok[k])
+    for n in range(1, len(a_tok)):
+        if (pre and pre[-n:] == a_tok[:n]) or (post and post[:n] == a_tok[-n:]):
+            return True
+    return False
+
+
 def _no_match_error(c_lines: list[str], s_lines: list[str], block_no: int) -> str:
     win = len(s_lines)
     best_ratio, best_i = 0.0, 0

{hexcli-2.8.1 → hexcli-2.9.0}/hexcli/tools.py

@@ -350,6 +350,7 @@ def edit_file_tool(path_text: str, old_string: str, new_string: str) -> str:
     is still an error, never a guess, and a genuine no-match now reports the
     closest region with line numbers so the retry has something to work with.
     """
+    from . import protocol_v2 as p2
     from .protocol_v2 import apply_search_replace
 
     path = resolve_path(path_text)
@@ -359,28 +360,38 @@ def edit_file_tool(path_text: str, old_string: str, new_string: str) -> str:
     if not path.exists():
         raise RuntimeError(f"File not found: {path}")
     content = path.read_text(encoding="utf-8")
+    tier = "exact"
     if content.count(old_string) == 1:
         new_content = content.replace(old_string, new_string, 1)
     else:
         new_content, err = apply_search_replace(content, [(old_string, new_string)])
         if err:
             raise RuntimeError(err.replace("SEARCH block 1", "old_string"))
+        tier = p2.LAST_APPLY_TIER
     tmp = path.parent / (path.name + ".tmp")
     tmp.write_text(new_content, encoding="utf-8")
     tmp.replace(path)
     delta = new_string.count("\n") - old_string.count("\n")
-    ui.tool_event("edit", f"{path}  ({delta:+d} lines)")
+    # The tier is UI-only (arm logs read it); the model sees "Edited <path>".
+    suffix = "" if tier == "exact" else f", {tier} match"
+    ui.tool_event("edit", f"{path}  ({delta:+d} lines{suffix})")
     return f"Edited {path}"
 
 
 def write_file_tool(path_text: str, content: str) -> str:
+    from . import protocol_v2 as p2
+
     path = resolve_path(path_text)
     guard_mutation(path, "write_file", _active_config())
     path.parent.mkdir(parents=True, exist_ok=True)
+    note = ""
+    if p2.looks_double_escaped(content):
+        content = p2.unescape_json(content)
+        note = ", unescaped"
     tmp = path.parent / (path.name + ".tmp")
     tmp.write_text(content, encoding="utf-8")
     tmp.replace(path)
-    ui.tool_event("write", f"{path}  ({len(content)} chars)")
+    ui.tool_event("write", f"{path}  ({len(content)} chars{note})")
     return f"Wrote {path}"