hx-cli 0.2.7__tar.gz → 0.2.8__tar.gz

{hx_cli-0.2.7 → hx_cli-0.2.8}/CHANGELOG.md

@@ -28,6 +28,32 @@ the project follows [semantic versioning](https://semver.org/).
 
 ---
 
+## [0.2.8] - 2026-09-27
+
+### Changed
+
+- `ctrl+z` undoes in the prompt and `ctrl+shift+z` redoes; `cmd+z` and
+  `cmd+shift+z` do the same in terminals that pass cmd through (kitty,
+  WezTerm). Apple's Terminal sends `ctrl+shift+z` as `ctrl+z`, so there it
+  undoes. Suspend no longer has a default key: bind `app.suspend` in
+  `keybindings.json`, which now also accepts `cmd+` and `option+`.
+
+### Fixed
+
+- A markdown table wider than the terminal - pasted into the prompt or in a
+  reply - wraps its cells inside their columns instead of cutting them off,
+  so every word shows; in a terminal too narrow for its columns it is drawn as
+  `header: value` records. A bold phrase or link that wraps keeps its style
+  on the next line.
+- A long draft in the prompt wraps between words instead of splitting them
+  across rows; only a word longer than the row still breaks inside it. The
+  cursor after the last character of a full row no longer hides that
+  character.
+- The welcome lines wrap on a narrow terminal instead of being cut off
+  mid-word.
+
+---
+
 ## [0.2.7] - 2026-09-27
 
 ### Added
@@ -699,7 +725,8 @@ First release, published to PyPI as [`hx-cli`](https://pypi.org/project/hx-cli/)
 - `/configure` and `hx auth` for the OpenRouter key, `hx upgrade` for
   self-update, and `install.sh` bootstrapping uv with a pinned Python.
 
-[Unreleased]: https://github.com/aletisunil/hx/compare/v0.2.7...HEAD
+[Unreleased]: https://github.com/aletisunil/hx/compare/v0.2.8...HEAD
+[0.2.8]: https://github.com/aletisunil/hx/compare/v0.2.7...v0.2.8
 [0.2.7]: https://github.com/aletisunil/hx/compare/v0.2.6...v0.2.7
 [0.2.6]: https://github.com/aletisunil/hx/compare/v0.2.5...v0.2.6
 [0.2.5]: https://github.com/aletisunil/hx/compare/v0.2.4...v0.2.5

{hx_cli-0.2.7 → hx_cli-0.2.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: hx-cli
-Version: 0.2.7
+Version: 0.2.8
 Summary: HX - an agent harness for the terminal
 Project-URL: Homepage, https://hx.sunilaleti.dev
 Project-URL: Documentation, https://hx.sunilaleti.dev
@@ -366,7 +366,6 @@ be rebound (see [Keybindings](#keybindings)).
 | `esc` | interrupt the current turn |
 | `ctrl+c` | copy the selected text; with nothing selected, clear the prompt (twice on an empty prompt exits) |
 | `ctrl+d` | exit, when the prompt is empty |
-| `ctrl+z` | suspend to the background |
 | `shift+tab` | cycle permission mode |
 | `ctrl+p` | command palette |
 | `ctrl+l` | model picker |
@@ -390,8 +389,13 @@ The prompt is a readline-style editor: `ctrl+a`/`ctrl+e` for line start and end,
 `ctrl+b`/`ctrl+f` by character, `alt+b`/`alt+f` by word, `ctrl+w` and `alt+d` to
 kill a word, `ctrl+u` and `ctrl+k` to kill to the start or end of a line, then
 `ctrl+y` to yank it back and `alt+y` to walk further down the kill ring.
-`ctrl+_` undoes, `ctrl+shift+z` redoes - `ctrl+z` belongs to the shell, and
-suspends HX.
+`ctrl+z` undoes and `ctrl+shift+z` redoes (`ctrl+_` undoes too). `cmd+z` and
+`cmd+shift+z` work in a terminal that passes cmd through to the program, such
+as kitty or WezTerm; Apple's Terminal, iTerm2 and Ghostty keep cmd+z for their
+own Edit menu. A terminal without the kitty protocol or modifyOtherKeys sends
+`ctrl+shift+z` as `ctrl+z`, so there it undoes. Suspending to the background
+has no key by default - bind `app.suspend` in `keybindings.json` (for example
+to `"ctrl+g"`) to get it back.
 
 Typing `/` or `@` opens a completion list above the prompt; `tab` cycles it,
 `enter` accepts, `esc` dismisses.
@@ -461,8 +465,10 @@ Any key can be rebound in `~/.hx/keybindings.json`, keyed by the action ids in
 }
 ```
 
-Conflicts and unknown action names are reported as a notice at startup rather
-than being silently resolved.
+Modifiers are `ctrl`, `alt` (or `option`), `shift` and `cmd` (or `super`);
+a `cmd` key only arrives from a terminal that passes cmd through. Conflicts and
+unknown action names are reported as a notice at startup rather than being
+silently resolved.
 
 ### Commands
 

{hx_cli-0.2.7 → hx_cli-0.2.8}/README.md

@@ -326,7 +326,6 @@ be rebound (see [Keybindings](#keybindings)).
 | `esc` | interrupt the current turn |
 | `ctrl+c` | copy the selected text; with nothing selected, clear the prompt (twice on an empty prompt exits) |
 | `ctrl+d` | exit, when the prompt is empty |
-| `ctrl+z` | suspend to the background |
 | `shift+tab` | cycle permission mode |
 | `ctrl+p` | command palette |
 | `ctrl+l` | model picker |
@@ -350,8 +349,13 @@ The prompt is a readline-style editor: `ctrl+a`/`ctrl+e` for line start and end,
 `ctrl+b`/`ctrl+f` by character, `alt+b`/`alt+f` by word, `ctrl+w` and `alt+d` to
 kill a word, `ctrl+u` and `ctrl+k` to kill to the start or end of a line, then
 `ctrl+y` to yank it back and `alt+y` to walk further down the kill ring.
-`ctrl+_` undoes, `ctrl+shift+z` redoes - `ctrl+z` belongs to the shell, and
-suspends HX.
+`ctrl+z` undoes and `ctrl+shift+z` redoes (`ctrl+_` undoes too). `cmd+z` and
+`cmd+shift+z` work in a terminal that passes cmd through to the program, such
+as kitty or WezTerm; Apple's Terminal, iTerm2 and Ghostty keep cmd+z for their
+own Edit menu. A terminal without the kitty protocol or modifyOtherKeys sends
+`ctrl+shift+z` as `ctrl+z`, so there it undoes. Suspending to the background
+has no key by default - bind `app.suspend` in `keybindings.json` (for example
+to `"ctrl+g"`) to get it back.
 
 Typing `/` or `@` opens a completion list above the prompt; `tab` cycles it,
 `enter` accepts, `esc` dismisses.
@@ -421,8 +425,10 @@ Any key can be rebound in `~/.hx/keybindings.json`, keyed by the action ids in
 }
 ```
 
-Conflicts and unknown action names are reported as a notice at startup rather
-than being silently resolved.
+Modifiers are `ctrl`, `alt` (or `option`), `shift` and `cmd` (or `super`);
+a `cmd` key only arrives from a terminal that passes cmd through. Conflicts and
+unknown action names are reported as a notice at startup rather than being
+silently resolved.
 
 ### Commands
 

{hx_cli-0.2.7 → hx_cli-0.2.8}/src/hx/__init__.py

@@ -1,5 +1,5 @@
 """HX - an agent harness for the terminal."""
 
-__version__ = "0.2.7"
+__version__ = "0.2.8"
 
 __all__ = ["__version__"]

{hx_cli-0.2.7 → hx_cli-0.2.8}/src/hx/keys.py

@@ -71,7 +71,10 @@ def _defaults() -> dict[str, KeyBinding]:
         ),
         KeyBinding("app.clear", ("ctrl+c",), "Clear the prompt (twice to exit)"),
         KeyBinding("app.exit", ("ctrl+d",), "Exit when the prompt is empty"),
-        KeyBinding("app.suspend", ("ctrl+z",), "Suspend to the background"),
+        # Unbound: ctrl+z is undo, as in every windowed editor. Raw mode means
+        # the terminal will not suspend for us, so a user who wants job
+        # control back binds this in keybindings.json.
+        KeyBinding("app.suspend", (), "Suspend to the background"),
         # Session and mode.
         KeyBinding("app.mode.cycle", ("shift+tab",), "Cycle permission mode"),
         KeyBinding("app.commands", ("ctrl+p",), "Open the command palette"),
@@ -102,21 +105,31 @@ def _defaults() -> dict[str, KeyBinding]:
         KeyBinding("tui.editor.deleteWordForward", ("alt+d",), "Delete the word ahead"),
         KeyBinding("tui.editor.yank", ("ctrl+y",), "Yank the last kill"),
         KeyBinding("tui.editor.yankPop", ("alt+y",), "Cycle back through kills"),
-        # ctrl+z is the app's suspend, as it is in every other terminal
-        # program, so undo takes readline's own key rather than the one a
-        # windowed editor would use. The editor had the operation and no
-        # binding at all, which made ctrl+z-undoes a documented fiction.
-        KeyBinding("tui.editor.undo", ("ctrl+underscore",), "Undo"),
-        KeyBinding("tui.editor.redo", ("ctrl+shift+z",), "Redo"),
+        # The windowed editor's keys, plus readline's own undo. cmd reaches
+        # HX as super, and only from a terminal that passes it through rather
+        # than keeping it for its own Edit menu - kitty and WezTerm do. A
+        # legacy terminal sends ctrl+shift+z as ctrl+z, so there it undoes.
+        KeyBinding("tui.editor.undo", ("ctrl+z", "super+z", "ctrl+underscore"), "Undo"),
+        KeyBinding("tui.editor.redo", ("ctrl+shift+z", "super+shift+z"), "Redo"),
     ]
     return {binding.id: binding for binding in bindings}
 
 
+_ALIASES = {"cmd": "super", "command": "super", "option": "alt"}
+"""Modifiers as a Mac user writes them - and as ``/help`` shows them there -
+spelled the way the decoder names them."""
+
+
+def _canonical(key: str) -> str:
+    """``cmd+z`` -> ``super+z``, so a keybindings file can say what it means."""
+    return "+".join(_ALIASES.get(part, part) for part in key.split("+"))
+
+
 def _normalize(value: object) -> tuple[str, ...] | None:
     if isinstance(value, str):
-        return (value,)
+        return (_canonical(value),)
     if isinstance(value, list) and all(isinstance(item, str) for item in value):
-        return tuple(value)
+        return tuple(_canonical(item) for item in value)
     return None
 
 
@@ -173,6 +186,8 @@ def display_key(key: str) -> str:
         part = _DISPLAY.get(part, part)
         if part == "alt" and sys.platform == "darwin":
             part = "option"
+        elif part == "super" and sys.platform == "darwin":
+            part = "cmd"
         parts.append(part)
     return "+".join(parts)
 

{hx_cli-0.2.7 → hx_cli-0.2.8}/src/hx/term/ansi.py

@@ -270,6 +270,71 @@ def active_background(text: str) -> str:
     return current
 
 
+def open_styles(text: str) -> tuple[str, str]:
+    """``(reopen, close)`` for the styling still in force at the end of ``text``.
+
+    Foreground, bold, italic, underline and a hyperlink - everything but the
+    background, which :func:`active_background` carries. A table cell wrapped
+    onto a second line needs both halves: ``close`` at its column edge, or a
+    link or a bold word runs on into the next cell, and ``reopen`` at the start
+    of the next line, or the rest of it arrives unstyled. Each half only
+    touches what is actually open, so a caller's own colour around the cell
+    survives.
+    """
+    foreground = link = ""
+    bold = italic = underline = False
+    for match in _ANY_ESCAPE.finditer(text):
+        escape = match.group()
+        if escape.startswith("\x1b]8;"):
+            link = escape if escape.split(";", 2)[2].rstrip("\x07\x1b\\") else ""
+            continue
+        sgr = _SGR_PATTERN.fullmatch(escape)
+        if not sgr:
+            continue
+        codes = [int(code or 0) for code in (sgr.group(1) or "0").split(";")]
+        index = 0
+        while index < len(codes):
+            code = codes[index]
+            if code == 0:
+                foreground, bold, italic, underline = "", False, False, False
+            elif code == 1:
+                bold = True
+            elif code == 22:
+                bold = False
+            elif code == 3:
+                italic = True
+            elif code == 23:
+                italic = False
+            elif code == 4:
+                underline = True
+            elif code == 24:
+                underline = False
+            elif 30 <= code <= 37 or 90 <= code <= 97:
+                foreground = f"\x1b[{code}m"
+            elif code == 39:
+                foreground = ""
+            elif code in (38, 48) and index + 1 < len(codes):
+                # Skip a colour's parameters so they are not read as codes;
+                # a truncated one ends the escape, as in active_background.
+                span = 3 if codes[index + 1] == 5 else 5 if codes[index + 1] == 2 else 0
+                if not span or index + span > len(codes):
+                    break
+                if code == 38:
+                    foreground = "\x1b[" + ";".join(map(str, codes[index : index + span])) + "m"
+                index += span - 1
+            index += 1
+
+    reopen = close = ""
+    if foreground:
+        reopen, close = reopen + foreground, close + FG_RESET
+    for on, start, end in ((bold, "1", "22"), (italic, "3", "23"), (underline, "4", "24")):
+        if on:
+            reopen, close = reopen + f"\x1b[{start}m", close + f"\x1b[{end}m"
+    if link:
+        reopen, close = reopen + link, close + "\x1b]8;;\x07"
+    return reopen, close
+
+
 def fill_line(text: str, width: int, background: str = "") -> str:
     """One rendered line: padded to ``width``, tinted, and terminated.
 
@@ -360,7 +425,7 @@ def _wrap_one(text: str, width: int) -> list[str]:
             emitted = "".join(line[:upto])
             rest = line[upto + 1 :]  # drop the space itself
         lines.append(carry + emitted)
-        carry = active_background(carry + emitted)
+        carry = active_background(carry + emitted) + open_styles(carry + emitted)[0]
         line = rest
         used = sum(
             0 if is_escape else cell_width(chunk) for is_escape, chunk in _tokenize("".join(rest))

{hx_cli-0.2.7 → hx_cli-0.2.8}/src/hx/term/editor.py

@@ -54,11 +54,12 @@ class LayoutLine:
 
 
 def layout(text: str, width: int, cursor: int) -> list[LayoutLine]:
-    """Map the buffer onto visual rows, wrapping to ``width``.
+    """Map the buffer onto visual rows, wrapping to ``width`` between words.
 
-    Wrapping happens at the width, not at a word boundary: a prompt is being
-    typed into, and a line that reflows under the cursor as a word grows is
-    disorienting in a way it is not in rendered prose.
+    The rows of a line are exactly its text, cut up: nothing is added or
+    dropped at a break, so a buffer offset maps onto a row and a column by
+    counting alone. That is why the space a line breaks on stays at the end
+    of its row - see :func:`_wrap_words` - rather than being swallowed.
     """
     if width < 1:
         width = 1
@@ -66,42 +67,66 @@ def layout(text: str, width: int, cursor: int) -> list[LayoutLine]:
     rows: list[LayoutLine] = []
     offset = 0
     for logical in text.split("\n"):
-        chunks = _wrap_hard(logical, width)
-        for chunk in chunks:
+        chunks = _wrap_words(logical, width)
+        for index, chunk in enumerate(chunks):
             length = len(chunk)
             column: int | None = None
-            if offset <= cursor <= offset + length:
-                # A cursor exactly at a wrap point belongs to the row it
-                # continues onto, not the one it just left - except at the very
-                # end of the buffer, where there is no next row.
-                at_wrap = cursor == offset + length and length == _visible_len(chunk, width)
-                if not (at_wrap and chunk is not chunks[-1]):
-                    column = cell_width(chunk[: cursor - offset])
+            # A cursor at a break belongs to the row it continues onto: what
+            # is typed there lands at the start of that row, so the cursor is
+            # drawn there too. Past the last row there is nothing to continue.
+            last = index == len(chunks) - 1
+            if offset <= cursor < offset + length or (cursor == offset + length and last):
+                column = cell_width(chunk[: cursor - offset])
             rows.append(LayoutLine(chunk, column))
             offset += length
         offset += 1  # the newline itself
     return rows
 
 
-def _visible_len(chunk: str, width: int) -> int:
-    return len(chunk) if cell_width(chunk) >= width else -1
+def _wrap_words(line: str, width: int) -> list[str]:
+    """Break a logical line into rows of at most ``width`` cells, between words.
 
-
-def _wrap_hard(line: str, width: int) -> list[str]:
-    """Break a logical line into rows of at most ``width`` cells."""
+    A row ends after the last space that fits. The space the break falls on
+    may hang one cell past ``width`` - a word that exactly fills a row keeps
+    its space rather than pushing it to the front of the next one - which is
+    what the editor's right-hand padding is for. A word too long for any row
+    breaks where it hits the edge, as does a run that is nothing but spaces.
+    """
     if not line:
         return [""]
+    clusters = list(grapheme_clusters(line))
     rows: list[str] = []
-    current = ""
+    start = 0
     used = 0
-    for cluster in grapheme_clusters(line):
+    # Where the row may end: just past a space with a word before it.
+    fold: int | None = None
+    worded = False
+    index = 0
+    while index < len(clusters):
+        cluster = clusters[index]
         step = cell_width(cluster)
-        if used + step > width and current:
-            rows.append(current)
-            current, used = "", 0
-        current += cluster
+        if used + step > width and index > start:
+            if cluster == " " and worded and used == width:
+                end = index + 1  # hang it
+            elif fold is not None:
+                end = fold
+            else:
+                end = index
+            rows.append("".join(clusters[start:end]))
+            start, fold, worded = end, None, False
+            used = sum(cell_width(c) for c in clusters[start:index])
+            worded = any(c != " " for c in clusters[start:index])
+            if end > index:
+                index = end
+            continue
+        if cluster == " ":
+            if worded:
+                fold = index + 1
+        else:
+            worded = True
         used += step
-    rows.append(current)
+        index += 1
+    rows.append("".join(clusters[start:]))
     return rows
 
 
@@ -224,6 +249,10 @@ class Editor(Widget):
         placeholder = not self.buffer.text and self.placeholder
         if row.cursor_column is None:
             return truncate_to_width(row.text, inner)
+        # The cursor may sit one cell past the text column - on a space hanging
+        # off a full row, or after the last character of one - and it is drawn
+        # there, in the right-hand padding, rather than over the text.
+        room = inner + min(1, self._padding_x)
 
         clusters = list(grapheme_clusters(row.text))
         consumed = 0
@@ -247,12 +276,12 @@ class Editor(Widget):
 
         if under:
             painted = head + CURSOR_MARKER + inverse(under) + "".join(after)
-            return truncate_to_width(painted, inner)
+            return truncate_to_width(painted, room)
 
         # At end of line the cursor is an appended cell, which costs a column
         # the text did not need. Without trimming for it the line comes out one
         # cell too wide and the renderer refuses to draw the frame.
-        head = truncate_to_width(head, max(0, inner - 1))
+        head = truncate_to_width(head, max(0, room - 1))
         return head + CURSOR_MARKER + inverse(" ")
 
     # -- editing helpers ---------------------------------------------------

{hx_cli-0.2.7 → hx_cli-0.2.8}/src/hx/term/keydecode.py

@@ -417,8 +417,13 @@ def _unicode_key(code: int, shifted: int | None, base: int | None, mods: list[st
             return Key(_with_modifiers(_CTRL_PUNCTUATION[char], rest))
         return Key(_with_modifiers("space" if char == " " else char.lower(), mods))
 
-    # alt without ctrl. The legacy encoding sends ESC then the shifted
-    # character, so alt+shift+b has always been alt+B.
+    # super, hyper and meta have no legacy encoding to agree with, so shift is
+    # named like ctrl's: cmd+shift+z is super+shift+z, as a user writes it.
+    if set(chording) - {"alt"}:
+        return Key(_with_modifiers("space" if char == " " else char.lower(), mods))
+
+    # alt alone. The legacy encoding sends ESC then the shifted character, so
+    # alt+shift+b has always been alt+B.
     if "shift" in mods:
         char = chr(shifted) if shifted else char.upper()
         mods = [mod for mod in mods if mod != "shift"]

{hx_cli-0.2.7 → hx_cli-0.2.8}/src/hx/term/markdown.py

@@ -24,7 +24,7 @@ Two conventions worth naming, both taken from pi:
 
 from __future__ import annotations
 
-from hx.term.ansi import fill_line, hyperlink, wrap
+from hx.term.ansi import fill_line, hyperlink, open_styles, wrap
 from hx.term.component import Widget
 from hx.term.width import cell_width, truncate_to_width
 
@@ -38,6 +38,10 @@ HR_MAX = 80
 """A rule spanning a very wide terminal reads as a divider in a book, not a
 paragraph break. Capping it keeps it proportionate to the text."""
 
+MIN_COLUMN = 3
+"""The narrowest a table column is squeezed to. Below this a table is drawn as
+records instead - see :meth:`_Renderer._stacked_table`."""
+
 
 class Painter:
     """How each markdown element is coloured.
@@ -294,30 +298,61 @@ class _Renderer:
             return
 
         count = max(len(row) for row in rows)
-        widths = [
-            max((cell_width(row[i]) for row in rows if i < len(row)), default=0)
-            for i in range(count)
-        ]
-        # Shrink to fit rather than overflowing the terminal.
+        rows = [row + [""] * (count - len(row)) for row in rows]
+        widths = [max(cell_width(row[i]) for row in rows) for i in range(count)]
+        # Narrowed to fit, widest column first, and the cells wrapped inside
+        # it. Truncating instead dropped the end of every long cell without a
+        # mark, so a pasted table echoed back missing text the model was sent.
         budget = self.width - indent - (3 * count + 1)
-        while sum(widths) > budget and max(widths) > 3:
+        if budget < MIN_COLUMN * count:
+            self._stacked_table(rows, header, indent)
+            return
+        while sum(widths) > budget:
             widths[widths.index(max(widths))] -= 1
 
-        def line(row: list[str]) -> str:
-            cells = []
-            for i in range(count):
-                cell = row[i] if i < len(row) else ""
-                cell = truncate_to_width(cell, widths[i])
-                cells.append(cell + " " * (widths[i] - cell_width(cell)))
-            return "│ " + " │ ".join(cells) + " │"
+        body = [
+            [_cell_lines(cell, width) for cell, width in zip(row, widths, strict=True)]
+            for row in rows
+        ]
+        # Once a row takes more than one line, only a rule says where the next
+        # one starts.
+        ruled = any(max(map(len, row)) > 1 for row in body[header:])
+
+        def divider() -> str:
+            line = "├─" + "─┼─".join("─" * w for w in widths) + "─┤"
+            return self.painter.paint("md_code_block_border", line)
+
+        self.blank()
+        for index, row in enumerate(body):
+            if index and (index == header or (index > header and ruled)):
+                self.emit(divider(), indent)
+            for depth in range(max(map(len, row))):
+                cells = []
+                for lines, width in zip(row, widths, strict=True):
+                    piece = lines[depth] if depth < len(lines) else ""
+                    cells.append(piece + " " * (width - cell_width(piece)))
+                self.emit("│ " + " │ ".join(cells) + " │", indent)
+        self.blank()
 
-        divider = "├─" + "─┼─".join("─" * w for w in widths) + "─┤"
+    def _stacked_table(self, rows: list[list[str]], header: int, indent: int) -> None:
+        """A table too wide for the terminal, one record at a time.
 
+        Every column at its narrowest would still overflow, and a grid of
+        three-cell slivers is not readable. Each row becomes ``header: value``
+        lines instead, the records a rule apart.
+        """
+        names = rows[header - 1] if header else [""] * len(rows[0])
         self.blank()
-        for index, row in enumerate(rows):
-            if index == header and header:
-                self.emit(self.painter.paint("md_code_block_border", divider), indent)
-            self.emit(line(row), indent)
+        for index, row in enumerate(rows[header:]):
+            if index:
+                span = min(self.width - indent, HR_MAX)
+                self.emit(self.painter.paint("md_code_block_border", "─" * span), indent)
+            for name, cell in zip(names, row, strict=True):
+                label = self.painter.paint("md_heading", name + ":", bold=True) if name else ""
+                lines = self.wrapped(f"{label} {cell}" if label else cell, indent, 2)
+                for position, line in enumerate(lines):
+                    # Continuation hangs under the value, clear of the name.
+                    self.emit(line, indent + (2 if position else 0))
         self.blank()
 
     # -- inline ------------------------------------------------------------
@@ -359,6 +394,18 @@ class _Renderer:
         return str(getattr(node, "content", "") or "") or self.inline(node)
 
 
+def _cell_lines(text: str, width: int) -> list[str]:
+    """One table cell wrapped to its column.
+
+    Wrapping reopens on each line whatever styling was open at the break; each
+    line here also closes it, so a link or a bold phrase broken across lines
+    stays inside its own cell instead of running on into the next.
+    """
+    # Truncated because wrap only overflows for a glyph wider than the column.
+    lines = [truncate_to_width(piece, width) for piece in wrap(text, width)]
+    return [line + open_styles(line)[1] for line in lines]
+
+
 class Markdown(Widget):
     """A block of markdown as a component."""
 

{hx_cli-0.2.7 → hx_cli-0.2.8}/src/hx/term/terminal.py

@@ -87,7 +87,7 @@ it to an application that asks - which is how shift+enter survives tmux."""
 
 _RESIZE_SIGNALS = (signal.SIGWINCH, signal.SIGCONT)
 """SIGWINCH is not delivered while the process is stopped, so a resize during
-``ctrl+z`` is only discoverable on the way back - which is what SIGCONT is
+a suspend is only discoverable on the way back - which is what SIGCONT is
 doing in a list of resize signals."""
 
 

{hx_cli-0.2.7 → hx_cli-0.2.8}/src/hx/tui/runtime.py

@@ -758,7 +758,7 @@ class HXSession:
         self.runner.request_immediate_render()
 
     def _suspend(self) -> None:
-        """``ctrl+z``. Raw mode means the terminal will not do this for us."""
+        """``app.suspend``. Raw mode means the terminal will not do this for us."""
         self.runner.suspend()
 
     def _terminal_rows(self) -> int:

{hx_cli-0.2.7 → hx_cli-0.2.8}/src/hx/tui/views/status.py

@@ -310,12 +310,24 @@ class Header(Widget):
         lines = [title]
 
         if not self._expanded:
-            lines.append(fg("muted", "An agent harness. Ask a question, or start with /help."))
-            lines.append(fg("dim", f"{KEYMAP.primary('app.tools.expand')} shows every key."))
+            from hx.term.ansi import wrap
+
+            # Prose, so wrapped between words on a narrow terminal rather than
+            # cut off mid-word the way the key table's columns are.
+            inner = max(1, width - 2)
+            lines += wrap(
+                fg("muted", "An agent harness. Ask a question, or start with /help."), inner
+            )
+            lines += wrap(
+                fg("dim", f"{KEYMAP.primary('app.tools.expand')} shows every key."), inner
+            )
         else:
             rows = [
                 (fg("dim", KEYMAP.text(binding.id)), fg("muted", binding.description))
                 for binding in KEYMAP.bindings.values()
+                # An action with no key, like suspend by default, has nothing
+                # to show here but a blank where its key would be.
+                if KEYMAP.keys_for(binding.id)
             ]
             from hx.tui.format import columns
 

{hx_cli-0.2.7 → hx_cli-0.2.8}/tests/e2e/terminal.py

@@ -69,6 +69,10 @@ _KITTY: dict[str, str] = {
     # character (flag 4, alternate keys), and ctrl+shift.
     "ctrl+_": "\x1b[45:95;6u",
     "ctrl+shift+z": "\x1b[122:90;6u",
+    # cmd is the protocol's super. Only a terminal that leaves cmd to the
+    # program sends these (kitty, WezTerm); the rest keep it for their menus.
+    "cmd+shift+z": "\x1b[122:90;10u",
+    **{f"cmd+{c}": f"\x1b[{ord(c)};9u" for c in "abcdefghijklmnopqrstuvwxyz"},
     **{f"alt+{c}": f"\x1b[{ord(c)};3u" for c in "bfdy"},
     **{f"ctrl+{c}": f"\x1b[{ord(c)};5u" for c in "abcdefghijklnopqrstuvwxyz"},
 }