hexcli 2.8.1__tar.gz → 2.9.1__tar.gz

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

@@ -6,6 +6,154 @@ the Hexagon NPU, not single-run anecdotes.
 
 ## Unreleased
 
+## 2.9.1 — 2026-09-13
+
+A patch release: the input line and the status bar; nothing model-facing
+and nothing the launcher hands the server. Gate: CI green on main; smoke
+10/10 on a fresh server.
+
+- The status bar no longer flickers while a turn runs. Every spinner tick
+  (12 a second) went through the full redraw: erase the box to the end of
+  the screen, then rewrite its rows, with the cursor visible during the
+  erase, so Windows Terminal could present the blank frame in between.
+  `LiveArea.repaint` now overwrites the box in place when its row count is
+  unchanged, each row clears its own line, and `_draw` emits one write with
+  the cursor hidden throughout inside a DEC 2026 synchronized update
+  (Terminal 1.24 presents the frame atomically; a console that does not
+  know the sequence ignores it). The erase path, still used when the box
+  grows or shrinks, joins the same frame.
+- The input line previews the best slash-command match while a command
+  name is typed: `/he` shows a dim `lp` after the caret, Right arrow
+  accepts it with the trailing space a Tab completion adds, and the text
+  submitted is only ever what was typed. The preview appears for a bare
+  `/word` at the end of the line, never for arguments or paths (no
+  filesystem walk per keystroke), and not once the name is complete. Ties
+  go to the first match in `REPL_COMMANDS` order (`/c` previews `/clear`);
+  Tab still lists the rest. The preview counts toward the row's width so a
+  long name still wraps exactly; the caret arithmetic sees only the real
+  text.
+- Ctrl+Backspace deletes the word before the caret. A Windows console
+  delivers it as DEL (0x7f), which the key map bound to a one-character
+  backspace, so it ate one letter per press. Ctrl+Delete deletes the word
+  after the caret, and Ctrl+Home / Ctrl+End jump to the start or end of a
+  multi-line entry (Home / End stay on the current line), all through the
+  extended scancodes the console already sends.
+- Undo and redo on the input line: Ctrl+Z and Ctrl+Y. A run of typed
+  characters up to a space is one step, so undo removes the last word; a
+  kill, a paste, a completion or a history recall is one step each; cursor
+  moves are none. A new edit after an undo drops the redo branch. Two
+  hundred steps per entry, cleared when the line is submitted.
+- A command menu under the input while a bare `/word` is typed: the
+  matching commands in command order with their one-line descriptions
+  (parsed from the `/help` text, so the two can never disagree; custom
+  commands say so), the pick marked, eight rows with a "… n more" line
+  past that. Up and Down move the pick, Tab takes it with the argument
+  space, Enter runs it, Esc closes the menu with the line, and the dim
+  preview after the caret follows the pick. Tab on an ambiguous command
+  word therefore takes the pick now instead of stopping at the shared
+  prefix; off the menu (config keys, paths) Tab still advances as far as
+  certainty goes. The menu rows are part of the entry, so the box grows
+  into the pad the way a multi-line entry does.
+- `/clear` and `/new` on the live layout. The first fix printed the banner
+  with the box up, and text written then is conversation: anchored above
+  the box at the bottom, growing upward, so the banner appeared at the
+  bottom. Both commands now take the box down without padding, clear,
+  print, and pin the box again under what they printed. `/new` always
+  prints the banner (a new session starts the way the program does);
+  `/clear` prints it only if it was still on screen, which the live area
+  tracks: set when the banner is printed, cleared when a write scrolls the
+  window past its pad, when a growing entry scrolls it, or when the screen
+  is cleared.
+
+## 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.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: hexcli
-Version: 2.8.1
+Version: 2.9.1
 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
@@ -163,9 +163,15 @@ follows the command:
 |---|---|
 | `↑` `↓` | history. With text typed, searches by that prefix |
 | `Tab` | complete commands, config keys, and file paths |
+| `Right` | accept the dim preview of a slash command (`/he` shows `lp`) |
+| `/` | opens the command menu under the input; `Up` `Down` pick, `Tab` takes the pick, `Enter` runs it |
+| `Ctrl+Z` `Ctrl+Y` | undo, redo (a typed word is one step) |
 | `Ctrl+←` `Ctrl+→` | move by word |
 | `Home` `End` | start or end of line |
-| `Ctrl+W` `Ctrl+U` `Ctrl+K` | delete the word before, to line start, to line end |
+| `Ctrl+W` `Ctrl+Backspace` | delete the word before the caret |
+| `Ctrl+Delete` | delete the word after the caret |
+| `Ctrl+U` `Ctrl+K` | delete to line start, to line end |
+| `Ctrl+Home` `Ctrl+End` | start or end of a multi-line entry |
 | `Esc` | clear the line |
 | `Ctrl+V` | paste a block. Nothing is sent until you press Enter |
 | `Shift+Enter` | new line inside the entry |

{hexcli-2.8.1 → hexcli-2.9.1}/README.md

@@ -136,9 +136,15 @@ follows the command:
 |---|---|
 | `↑` `↓` | history. With text typed, searches by that prefix |
 | `Tab` | complete commands, config keys, and file paths |
+| `Right` | accept the dim preview of a slash command (`/he` shows `lp`) |
+| `/` | opens the command menu under the input; `Up` `Down` pick, `Tab` takes the pick, `Enter` runs it |
+| `Ctrl+Z` `Ctrl+Y` | undo, redo (a typed word is one step) |
 | `Ctrl+←` `Ctrl+→` | move by word |
 | `Home` `End` | start or end of line |
-| `Ctrl+W` `Ctrl+U` `Ctrl+K` | delete the word before, to line start, to line end |
+| `Ctrl+W` `Ctrl+Backspace` | delete the word before the caret |
+| `Ctrl+Delete` | delete the word after the caret |
+| `Ctrl+U` `Ctrl+K` | delete to line start, to line end |
+| `Ctrl+Home` `Ctrl+End` | start or end of a multi-line entry |
 | `Esc` | clear the line |
 | `Ctrl+V` | paste a block. Nothing is sent until you press Enter |
 | `Shift+Enter` | new line inside the entry |

{hexcli-2.8.1 → hexcli-2.9.1}/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.1"

{hexcli-2.8.1 → hexcli-2.9.1}/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.1}/hexcli/lineedit.py

@@ -32,7 +32,7 @@ import re
 import sys
 import time
 import unicodedata
-from collections.abc import Callable, Iterable, Sequence
+from collections.abc import Callable, Iterable, Mapping, Sequence
 from pathlib import Path
 from typing import Any
 
@@ -52,9 +52,14 @@ HOME = "<home>"
 END = "<end>"
 WORD_LEFT = "<word-left>"
 WORD_RIGHT = "<word-right>"
-KILL_WORD = "<kill-word>"    # Ctrl+W
+KILL_WORD = "<kill-word>"    # Ctrl+W, Ctrl+Backspace
+KILL_WORD_FORWARD = "<kill-word-forward>"  # Ctrl+Delete
+BUFFER_START = "<buffer-start>"  # Ctrl+Home: the first line of a multi-line entry
+BUFFER_END = "<buffer-end>"      # Ctrl+End
 KILL_LINE = "<kill-line>"    # Ctrl+K
 KILL_TO_START = "<kill-to-start>"  # Ctrl+U
+UNDO = "<undo>"              # Ctrl+Z
+REDO = "<redo>"              # Ctrl+Y
 CLEAR_SCREEN = "<clear-screen>"    # Ctrl+L
 INTERRUPT = "<interrupt>"    # Ctrl+C
 EOF_KEY = "<eof>"            # Ctrl+D on an empty buffer
@@ -73,16 +78,18 @@ _EXTENDED = {
     "H": UP, "P": DOWN, "K": LEFT, "M": RIGHT,
     "G": HOME, "O": END, "S": DELETE,
     "s": WORD_LEFT, "t": WORD_RIGHT,
+    "\x93": KILL_WORD_FORWARD, "w": BUFFER_START, "u": BUFFER_END,
 }
 _CONTROL = {
     "\r": ENTER, "\n": NEWLINE, "\t": TAB,
-    "\x08": BACKSPACE, "\x7f": BACKSPACE,
+    "\x08": BACKSPACE, "\x7f": KILL_WORD,   # 0x7f is Ctrl+Backspace on a Windows console
     "\x01": HOME, "\x05": END,
     "\x02": LEFT, "\x06": RIGHT,
     "\x0e": DOWN, "\x10": UP,
     "\x03": INTERRUPT, "\x04": EOF_KEY,
     "\x0b": KILL_LINE, "\x15": KILL_TO_START, "\x17": KILL_WORD,
     "\x0c": CLEAR_SCREEN, "\x1b": ESCAPE,
+    "\x1a": UNDO, "\x19": REDO,
 }
 
 
@@ -480,6 +487,7 @@ class LineEditor:
         *,
         history: History | None = None,
         completer: Callable[[str], list[str]] | None = None,
+        command_help: Mapping[str, str] | None = None,
         read_key: Callable[[], str] | None = None,
         write: Callable[[str], None] | None = None,
         width: int | None = None,
@@ -498,6 +506,16 @@ class LineEditor:
     ) -> None:
         self.history = history or History()
         self.completer = completer
+        self.command_help: Mapping[str, str] = dict(command_help or {})
+        # Undo/redo over the entry: (buffer, pos) snapshots. Typing a word
+        # is one step (a run of non-space characters, then the space), a
+        # kill or a paste is one step; a cursor move is none.
+        self._undo: list[tuple[str, int]] = []
+        self._redo: list[tuple[str, int]] = []
+        self._undo_kind = ""
+        # The / menu: which of the matching commands is selected.
+        self._menu_index = 0
+        self._menu_key: str | None = None
         self._read_key = read_key or windows_key_reader()
         self._write = write or (lambda s: (sys.stdout.write(s), sys.stdout.flush()) and None)
         self._forced_width = width
@@ -621,6 +639,16 @@ class LineEditor:
             hint = self.placeholder[: max(0, self.usable - visible_len(last_prompt) - 1)]
             styled = f"\033[2m{hint}\033[0m" if self.styled else hint
             logical[-1] = (last_prompt + styled, visible_len(last_prompt) + len(hint))
+        ghost = self._ghost() if chrome else ""
+        if ghost:
+            # The rest of the best slash-command match, dim, after the
+            # cursor. It counts toward the row's width so wrapping stays
+            # exact; the cursor arithmetic below only sees the real text.
+            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)))
 
@@ -825,6 +853,84 @@ class LineEditor:
 
     # -- completion ---------------------------------------------------------
 
+    def _ghost(self) -> str:
+        """The rest of the best slash-command match while a command name is
+        being typed at the end of the line: "/he" previews "lp". Empty when
+        the name is complete, ambiguous beyond a shared prefix is fine (the
+        first match in command order wins, Tab still lists them), and empty
+        for anything that is not a bare command word, so paths and
+        arguments never trigger a filesystem walk on every keystroke."""
+        buf = self.buffer
+        if (self.completer is None or self.pos != len(buf) or not buf.startswith("/")
+                or any(ch.isspace() for ch in buf)):
+            return ""
+        try:
+            candidates = self.completer(buf)
+        except Exception:  # noqa: BLE001 — a preview must never break typing
+            return ""
+        word = buf.lower()
+        if any(c.lower() == word for c in candidates):
+            return ""
+        items = self._menu_items()
+        if items:
+            cand = items[self._menu_index]
+            return cand[len(buf):] if cand.lower().startswith(word) and len(cand) > len(buf) else ""
+        for cand in candidates:
+            if cand.lower().startswith(word) and len(cand) > len(buf):
+                return cand[len(buf):]
+        return ""
+
+    MENU_ROWS = 8
+
+    def _menu_items(self) -> list[str]:
+        """The slash commands matching a bare /word at the end of the line,
+        in command order; the menu the editor draws under the input row.
+        The selection index survives while the list is the same and resets
+        when typing changes it."""
+        buf = self.buffer
+        if (self.completer is None or self.pos != len(buf) or not buf.startswith("/")
+                or any(ch.isspace() for ch in buf)):
+            self._menu_key = None
+            return []
+        try:
+            items = [c for c in self.completer(buf) if c.startswith("/")]
+        except Exception:  # noqa: BLE001
+            items = []
+        key = "\0".join(items)
+        if key != self._menu_key:
+            self._menu_key = key
+            self._menu_index = 0
+        if self._menu_index >= len(items):
+            self._menu_index = 0
+        return items
+
+    def _menu_rows(self) -> list[tuple[str, int]]:
+        """(rendered row, visible width) per menu line, clipped to the width."""
+        items = self._menu_items()
+        if not items:
+            return []
+        first = max(0, min(self._menu_index - self.MENU_ROWS + 1, len(items) - self.MENU_ROWS))
+        first = max(0, min(first, self._menu_index))
+        shown = items[first:first + self.MENU_ROWS]
+        name_w = max(len(c) for c in shown)
+        rows: list[tuple[str, int]] = []
+        for n, cand in enumerate(shown, first):
+            desc = self.command_help.get(cand, "custom command" if cand not in self.command_help and cand in items else "")
+            avail = max(0, self.usable - 4 - name_w - 2)
+            desc = desc[:avail]
+            plain = f"  {'▸' if n == self._menu_index else ' '} {cand.ljust(name_w)}  {desc}".rstrip()
+            if self.styled and n == self._menu_index:
+                text = f"\033[1m{plain}\033[0m"
+            elif self.styled:
+                text = f"\033[2m{plain}\033[0m"
+            else:
+                text = plain
+            rows.append((text, visible_len(plain)))
+        if len(items) > len(shown):
+            more = f"    … {len(items) - len(shown)} more"
+            rows.append((f"\033[2m{more}\033[0m" if self.styled else more, len(more)))
+        return rows
+
     def _complete(self, prompt: str) -> None:
         if self.completer is None:
             return
@@ -871,6 +977,8 @@ class LineEditor:
         ``input()`` does, so callers keep their existing handlers."""
         self.buffer, self.pos = "", 0
         self._hist_index, self._hist_prefix, self._saved_draft = None, "", ""
+        self._undo, self._redo, self._undo_kind = [], [], ""
+        self._menu_index, self._menu_key = 0, None
         self._rendered_rows, self._cursor_row = 0, 0
         self._last_text = None
         self._last_size = (self.usable, self.height)
@@ -951,9 +1059,56 @@ class LineEditor:
         self.render(prompt)
 
     def _handle(self, key: str, prompt: str) -> str | None:
-        """Apply one key. Returns the finished line, or None to keep editing."""
+        """Apply one key. Returns the finished line, or None to keep editing.
+        Every change to the text lands on the undo stack; a run of typed
+        characters up to a space is one step."""
+        if key == UNDO:
+            if self._undo:
+                self._redo.append((self.buffer, self.pos))
+                self.buffer, self.pos = self._undo.pop()
+            self._undo_kind = ""
+            return None
+        if key == REDO:
+            if self._redo:
+                self._undo.append((self.buffer, self.pos))
+                self.buffer, self.pos = self._redo.pop()
+            self._undo_kind = ""
+            return None
+        before = (self.buffer, self.pos)
+        result = self._handle_key(key, prompt)
+        if self.buffer != before[0]:
+            if key == BACKSPACE:
+                kind = "backspace"
+            elif len(key) == 1 and key.isprintable() and not key.isspace():
+                kind = "type"
+            else:
+                kind = ""
+            if not (kind and kind == self._undo_kind):
+                self._undo.append(before)
+                del self._undo[:-200]
+            self._undo_kind = kind
+            self._redo.clear()
+        elif key not in (LEFT, RIGHT, HOME, END, WORD_LEFT, WORD_RIGHT, BUFFER_START, BUFFER_END, IDLE):
+            self._undo_kind = ""
+        return result
+
+    def _handle_key(self, key: str, prompt: str) -> str | None:
         buf = self.buffer
 
+        # The / menu: Up/Down pick, Tab takes the pick, Enter runs it.
+        menu = self._menu_items() if key in (UP, DOWN, TAB, ENTER) else []
+        if menu and key in (UP, DOWN) and len(menu) > 1:
+            self._menu_index = (self._menu_index + (-1 if key == UP else 1)) % len(menu)
+            return None
+        if menu and key == TAB:
+            self.buffer = menu[self._menu_index] + " "
+            self.pos = len(self.buffer)
+            return None
+        if menu and key == ENTER and buf.lower() != menu[self._menu_index].lower():
+            self.buffer = menu[self._menu_index]
+            self.pos = len(self.buffer)
+            buf = self.buffer
+
         if key == ENTER:
             # A trailing backslash is an explicit "keep going" — the one way to
             # get a multi-line entry without pasting. It must be preceded by
@@ -989,6 +1144,14 @@ class LineEditor:
             self.pos = max(0, self.pos - 1)
             return None
         if key == RIGHT:
+            if self.pos == len(buf):
+                ghost = self._ghost()
+                if ghost:
+                    # Accept the preview; the space means "now the argument",
+                    # as a Tab completion does.
+                    self.buffer = buf + ghost + " "
+                    self.pos = len(self.buffer)
+                    return None
             self.pos = min(len(buf), self.pos + 1)
             return None
         if key == WORD_LEFT:
@@ -1008,6 +1171,15 @@ class LineEditor:
             self.buffer = buf[:start] + buf[self.pos:]
             self.pos = start
             return None
+        if key == KILL_WORD_FORWARD:
+            self.buffer = buf[:self.pos] + buf[self._word_end():]
+            return None
+        if key == BUFFER_START:
+            self.pos = 0
+            return None
+        if key == BUFFER_END:
+            self.pos = len(buf)
+            return None
         if key == KILL_TO_START:
             start = self._line_start()
             self.buffer = buf[:start] + buf[self.pos:]
@@ -1061,6 +1233,7 @@ def make_reader(
     config: dict[str, Any],
     commands: Sequence[str],
     config_keys: Callable[[], Iterable[str]] | None = None,
+    command_help: Mapping[str, str] | None = None,
     on_zoom: Callable[[int], Any] | None = None,
     on_resize: Callable[[], Any] | None = None,
     chrome: Callable[[int], tuple[list[str], list[str]]] | None = None,
@@ -1095,6 +1268,7 @@ def make_reader(
     editor = LineEditor(
         history=History(path, int(config.get("input_history_limit", 500))),
         completer=default_completer(commands, config_keys),
+        command_help=command_help,
         margin=int(config.get("side_padding", 0) or 0),
         on_zoom=on_zoom,
         on_resize=on_resize,

{hexcli-2.8.1 → hexcli-2.9.1}/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."