hexcli 2.9.0__tar.gz → 2.10.0__tar.gz

{hexcli-2.9.0 → 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.0 → hexcli-2.10.0}/CHANGELOG.md

@@ -6,6 +6,101 @@ 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
+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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: hexcli
-Version: 2.9.0
+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
@@ -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.9.0 → hexcli-2.10.0}/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.9.0 → 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.0"
+__version__ = "2.10.0"

{hexcli-2.9.0 → 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.0 → hexcli-2.10.0}/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
@@ -611,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]
@@ -621,6 +645,14 @@ 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))
         for line in below:
             logical.append((line, visible_len(line)))
 
@@ -628,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] = []
@@ -825,6 +857,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 +981,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 +1063,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 +1148,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 +1175,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 +1237,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 +1272,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.9.0 → 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
 
 

{hexcli-2.9.0 → hexcli-2.10.0}/hexcli/repl.py

@@ -384,6 +384,23 @@ def run_repl(config: dict[str, Any]) -> int:
         ui.print_banner(npu_model or str(config.get("model", "?")),
                         str(config.get("backend", "ollama")),
                         engine="Hexagon NPU" if npu_model else None)
+        if live is not None:
+            live.banner_printed()
+
+    def _fresh_screen(with_banner: bool) -> None:
+        """Clear the screen for /clear and /new. The box comes down without
+        padding first: text written while it is up is conversation and is
+        anchored above the box at the bottom, which is where the banner
+        landed on the first attempt (2026-09-13). With the box down the
+        banner keeps the top, and resume() pins the box under it again."""
+        if live is not None:
+            live.suspend()
+        os.system("cls" if os.name == "nt" else "clear")
+        if live is not None:
+            live.screen_cleared()   # the box and its pad rows are gone with the screen
+        sys.stdout.write("\r")      # the clear skipped the margin's fill for this row
+        if with_banner:
+            _banner()
 
     _banner()
     if live is not None:
@@ -455,6 +472,7 @@ def run_repl(config: dict[str, Any]) -> int:
 
     read_line = lineedit.make_reader(
         config, tuple(REPL_COMMANDS) + custom_names, lambda: sorted(sa._CONFIG_SETTABLE),
+        command_help={**ui.COMMAND_HELP, **{c: "custom command" for c in custom_names}},
         on_zoom=_zoom, on_resize=_resize,
         chrome=live.chrome if live is not None else None,
         placeholder="ask, or / for commands" if live is not None else "",
@@ -591,22 +609,26 @@ def run_repl(config: dict[str, Any]) -> int:
         # away. /clear is now the one reset command; /new remains an alias
         # that keeps the scrollback.
         if norm == "/clear":
-            os.system("cls" if os.name == "nt" else "clear")
-            if live is not None:
-                live.screen_cleared()   # the box and its pad rows are gone with the screen
+            # The banner comes back only if it was still on screen: a
+            # cleared long conversation stays clear.
+            _fresh_screen(with_banner=live is None or live.banner_visible)
             sa.sync_session_store(sessions, current_session)
             _close_session_resources(current_session)
             current_session = sa.create_session()
-            sys.stdout.write("\r")   # the clear skipped the margin's fill for this row
             sa.cprint("  Chat history cleared.", sa.C.DIM)
+            if live is not None:
+                live.resume()
             continue
 
         # ── new session ───────────────────────────────────────────────────
         if norm == "/new":
+            _fresh_screen(with_banner=True)   # a new session starts the way the program does
             sa.sync_session_store(sessions, current_session)
             _close_session_resources(current_session)
             current_session = sa.create_session()
             sa.cprint("  New session started.", sa.C.DIM)
+            if live is not None:
+                live.resume()
             continue
 
         # ── resume ────────────────────────────────────────────────────────

{hexcli-2.9.0 → hexcli-2.10.0}/hexcli/statusbar.py

@@ -408,6 +408,10 @@ class LiveArea:
         self.prompt = prompt
         self._geometry = geometry or console_geometry
         self.editor_rows = 4       # rule, input row, rule, status: what the editor draws
+        # Whether the banner printed at the top of the window is still on it:
+        # true after banner_printed(), false once anything scrolls the window
+        # or clears the screen. /clear reprints the banner only when this holds.
+        self.banner_visible = False
         self._pad_top: int | None = None   # first row of the blank pad above the conversation
         self._pad_above = 0                # how many pad rows there are
         self._last_shape: tuple[Any, int] | None = None   # (window height, usable width) at the last draw
@@ -489,13 +493,21 @@ class LiveArea:
         with self.lock:
             self._drawn = 0
             self._signature = None
+            self.banner_visible = False
             self.reset_pad()
 
+    def banner_printed(self) -> None:
+        """The banner was just written at the top of a fresh screen."""
+        with self.lock:
+            self.banner_visible = True
+
     def note_scroll(self, rows: int) -> None:
         """The window scrolled up by `rows` (the editor grew past the bottom
         with a multi-line entry): the pad moved up with it, and any part of
         it that left the window is gone."""
         with self.lock:
+            if rows > 0:
+                self.banner_visible = False
             if rows <= 0 or self._pad_top is None:
                 return
             self._pad_top -= rows
@@ -611,10 +623,17 @@ class LiveArea:
             elif below < len(rows):
                 self._delete_pad_rows(inner, len(rows) - below)   # the rest scrolls
         saved = (m.col, m.word, m.word_vis)
-        out = ["\033[?25l", "\n", "\n".join(rows), "\r", f"\033[{len(rows)}A"]
+        # One write, cursor hidden throughout, inside a synchronized update
+        # (DEC 2026: Windows Terminal presents the whole frame at once; a
+        # console that does not know the sequence ignores it). Each row
+        # clears its own line, so a repaint never needs the erase-to-end
+        # that blanked the box between frames. That erase, 12 times a
+        # second on every spinner tick, was the flicker while the model
+        # was thinking (2026-09-13).
+        out = ["\033[?2026h\033[?25l", "\n", "\n".join(f"\033[2K{r}" for r in rows), "\r", f"\033[{len(rows)}A"]
         if saved[0]:
             out.append(f"\033[{saved[0]}C")
-        out.append("\033[?25h")
+        out.append("\033[?25h\033[?2026l")
         inner.write("".join(out))
         m.col, m.word, m.word_vis = saved
         self._drawn = len(rows)
@@ -670,14 +689,16 @@ class LiveArea:
             newlines = rendered.count("\n")
             if newlines and self._pad_above and self._geometry_changed():
                 self.reset_pad()
-            if newlines and self._pad_above:
+            if newlines and (self._pad_above or self.banner_visible):
                 geo = self._geo()
                 if geo is not None:
                     row, height = geo
                     need = newlines + (self._drawn_rows_needed() if self.enabled else 0)
                     deficit = need - (height - 1 - row)
                     if deficit > 0:
-                        self._delete_pad_rows(inner, deficit, col=col_before)
+                        freed = self._delete_pad_rows(inner, deficit, col=col_before) if self._pad_above else 0
+                        if freed < deficit:
+                            self.banner_visible = False   # the window scrolls: the top row is gone
             inner._base.write(rendered)
             if self.enabled:
                 self._draw(inner)
@@ -743,6 +764,12 @@ class LiveArea:
                 rows = self._compose()
             elif self._drawn and (tuple(rows), self.margin.col) == self._signature:
                 return
+            if self._drawn == len(rows):
+                # Same rows, same place: overwrite in place. No erase, no
+                # blank frame between the old box and the new one.
+                self._draw(self._inner, rows)
+                return
+            self._inner._base.write("\033[?2026h")   # the erase joins the frame
             self._erase(self._inner)
             self._draw(self._inner, rows)
 

{hexcli-2.9.0 → hexcli-2.10.0}/hexcli/ui.py

@@ -685,7 +685,7 @@ HELP_TEXT = textwrap.dedent("""
     Hex CLI, a local agent on the Hexagon NPU
 
     Session
-      /new                    start a new session, keep the screen
+      /new                    start a new session on a fresh screen, banner and all
       /clear                  clear the screen and start a new session
       /history                list saved sessions
       /resume <n>             reopen session n
@@ -712,11 +712,14 @@ HELP_TEXT = textwrap.dedent("""
     replaced with what follows the command. Built-in names win.
 
     Keys
-      Up / Down                 history, filtered by what is typed
+      Up / Down                 history, filtered by what is typed; in the / menu, pick
       Tab                       complete commands, config keys and paths
+      Right                     accept the dim preview of a slash command
       Shift+Enter               new line; \\ then Enter also works
       Ctrl+Left / Ctrl+Right    move by word
-      Ctrl+W / Ctrl+U / Ctrl+K  delete the word, to line start, to line end
+      Ctrl+W / Ctrl+Backspace   delete the word before; Ctrl+Delete the word after
+      Ctrl+U / Ctrl+K           delete to line start, to line end
+      Ctrl+Z / Ctrl+Y           undo, redo
       Esc                       clear the line, or cancel a running turn
       Ctrl+L                    clear the screen
       Ctrl+Plus / Ctrl+Minus    text size in the classic console
@@ -724,6 +727,22 @@ HELP_TEXT = textwrap.dedent("""
     The agent runs qwen3-4b-instruct-2507 on the Hexagon NPU through npurun.
 """).strip()
 
+
+def _command_help(text: str) -> dict[str, str]:
+    """One line per slash command, parsed from HELP_TEXT so the / menu and
+    /help can never disagree: the command word, then its description."""
+    out: dict[str, str] = {}
+    for line in text.splitlines():
+        m = re.match(r"\s+(/[a-z]+)\b[^ ]*.*?\s{2,}(\S.*)$", line)
+        if m and m.group(1) not in out:
+            out[m.group(1)] = m.group(2).strip()
+    out.setdefault("/help", "this list of commands and keys")
+    out.setdefault("/quit", out.get("/exit", "quit"))
+    return out
+
+
+COMMAND_HELP = _command_help(HELP_TEXT)
+
 TOOLS_HELP = textwrap.dedent("""
     Tools available to the agent:
       run_command(command)                      run PowerShell; risky ones ask first