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

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

@@ -28,6 +28,49 @@ the project follows [semantic versioning](https://semver.org/).
 
 ---
 
+## [0.2.9] - 2026-09-27
+
+### Added
+
+- `~/.hx/AGENTS.md` holds your own instructions and is loaded into every
+  session in every project, ahead of the project's `AGENTS.md`. The first
+  session creates it empty, ready to fill in. `hx prompt` and `/prompt` now
+  name each `AGENTS.md` in force, and `/prompt` says when one has changed on
+  disk since the session started.
+
+### Fixed
+
+- An `AGENTS.md` or system-prompt override that is not valid UTF-8 is skipped
+  like an unreadable one, instead of stopping HX from starting.
+
+---
+
+## [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 +742,9 @@ 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.9...HEAD
+[0.2.9]: https://github.com/aletisunil/hx/compare/v0.2.8...v0.2.9
+[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.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: hx-cli
-Version: 0.2.7
+Version: 0.2.9
 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
 
@@ -747,6 +753,7 @@ files load here unchanged. `src/hx/tui/themes/dark.json` is the reference.
 | `~/.hx/keybindings.json` | your key overrides |
 | `~/.hx/system-prompt.md` | your system prompt, replacing the built-in one |
 | `~/.hx/system-prompt-append.md` | text appended to whichever prompt is in force |
+| `~/.hx/AGENTS.md` | your instructions, loaded into every session in every project; created empty |
 | `~/.hx/sessions/` | transcripts, spilled tool output, subagent sessions |
 | `~/.hx/sessions/<id>/trace.html` | where `/trace` writes, unless you name a path |
 | `~/.hx/skills/`, `~/.hx/agents/` | your skills and agents |
@@ -761,6 +768,12 @@ files load here unchanged. `src/hx/tui/themes/dark.json` is the reference.
 tests, conventions, what not to touch. `/init` writes a first draft. It is
 loaded once per session and frozen, so it costs one prefix, not one per turn.
 
+`~/.hx/AGENTS.md` is the same thing for you rather than the project: how you
+like commits written, tools you always want used, in every repository. It is
+loaded first and the project's `AGENTS.md` after it, so where the two disagree
+the project has the last word. The first session creates it empty, ready to
+fill in; empty, it adds nothing. `hx prompt` and `/prompt` list each one in force.
+
 ---
 
 ## Safety

{hx_cli-0.2.7 → hx_cli-0.2.9}/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
 
@@ -707,6 +713,7 @@ files load here unchanged. `src/hx/tui/themes/dark.json` is the reference.
 | `~/.hx/keybindings.json` | your key overrides |
 | `~/.hx/system-prompt.md` | your system prompt, replacing the built-in one |
 | `~/.hx/system-prompt-append.md` | text appended to whichever prompt is in force |
+| `~/.hx/AGENTS.md` | your instructions, loaded into every session in every project; created empty |
 | `~/.hx/sessions/` | transcripts, spilled tool output, subagent sessions |
 | `~/.hx/sessions/<id>/trace.html` | where `/trace` writes, unless you name a path |
 | `~/.hx/skills/`, `~/.hx/agents/` | your skills and agents |
@@ -721,6 +728,12 @@ files load here unchanged. `src/hx/tui/themes/dark.json` is the reference.
 tests, conventions, what not to touch. `/init` writes a first draft. It is
 loaded once per session and frozen, so it costs one prefix, not one per turn.
 
+`~/.hx/AGENTS.md` is the same thing for you rather than the project: how you
+like commits written, tools you always want used, in every repository. It is
+loaded first and the project's `AGENTS.md` after it, so where the two disagree
+the project has the last word. The first session creates it empty, ready to
+fill in; empty, it adds nothing. `hx prompt` and `/prompt` list each one in force.
+
 ---
 
 ## Safety

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

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

{hx_cli-0.2.7 → hx_cli-0.2.9}/src/hx/cli.py

@@ -346,7 +346,12 @@ def build_runtime(parsed: ParsedArgs, *, resume: str | None = None) -> Runtime:
     from hx.config import load_settings
     from hx.core.checkpoints import CheckpointStore
     from hx.core.compaction import Compactor
-    from hx.core.context import ContextBuilder, build_project_context, load_system_prompt
+    from hx.core.context import (
+        ContextBuilder,
+        build_project_context,
+        load_instructions,
+        load_system_prompt,
+    )
     from hx.core.events import EventBus
     from hx.core.lateinject import Injection, InjectionRegistry
     from hx.core.loop import AgentLoop
@@ -430,6 +435,7 @@ def build_runtime(parsed: ParsedArgs, *, resume: str | None = None) -> Runtime:
         settings.cwd,
         keep_recent_turns=settings.context.keep_recent_turns,
     )
+    instructions = load_instructions(settings.cwd)
 
     checkpoints = CheckpointStore(session, session_checkpoints_dir(session.meta.session_id))
     tools = build_default_registry(shell, jobs, tracker, todos, bus_holder, auth, checkpoints)
@@ -478,7 +484,8 @@ def build_runtime(parsed: ParsedArgs, *, resume: str | None = None) -> Runtime:
         settings=settings,
         model_info=model_info,
         skills_index=build_index(list(skills.values())) or None,
-        project_context=build_project_context(settings.cwd),
+        project_context=build_project_context(settings.cwd, instructions),
+        instructions=instructions,
         hooks=hooks,
     )
 
@@ -842,15 +849,17 @@ def run_print_command(parsed: ParsedArgs) -> int:
 def run_prompt_command(parsed: ParsedArgs) -> int:
     """``hx prompt`` - print the system prompt this directory resolves to.
 
-    The prompt goes to stdout so it can be piped or diffed; where it came from
-    goes to stderr so it never contaminates that output.
+    The prompt goes to stdout so it can be piped or diffed; where it came from,
+    and which AGENTS.md files ride alongside it, goes to stderr so it never
+    contaminates that output.
     """
     from hx.config import load_settings
-    from hx.core.context import resolve_system_prompt
+    from hx.core.context import load_instructions, resolve_system_prompt
 
     try:
         settings = load_settings(parsed.cwd, parsed.overrides)
         resolved = resolve_system_prompt(settings.cwd, settings.prompt)
+        instructions = load_instructions(settings.cwd)
     except Exception as exc:
         return _report(exc)
 
@@ -858,6 +867,8 @@ def run_prompt_command(parsed: ParsedArgs) -> int:
     print(f"[source] {resolved.source}", file=sys.stderr)
     for append in resolved.appends:
         print(f"[append] {append}", file=sys.stderr)
+    for loaded in instructions:
+        print(f"[instructions] {loaded.path}", file=sys.stderr)
     return 0
 
 

{hx_cli-0.2.7 → hx_cli-0.2.9}/src/hx/core/context.py

@@ -10,7 +10,7 @@ Layout, in order::
     [1] system prompt          static for the session
     [2] tool schemas           deterministic sort: builtins, then mcp__* alphabetical
     [3] skills index           name + description only (progressive disclosure)
-    [4] project context        AGENTS.md, cwd, git branch, top-level listing
+    [4] project context        cwd, git branch, top-level listing, ~/.hx/AGENTS.md, AGENTS.md
     --- breakpoint A (static) ---
     [5] conversation history
     --- breakpoint B (rolling, before the last few turns) ---
@@ -238,11 +238,46 @@ def _message_text(message: Message) -> str:
     return "\n".join(parts)
 
 
-def build_project_context(cwd: Path) -> str:
-    """Static per-session project preamble: AGENTS.md contents, cwd, git branch, listing.
+@dataclass(slots=True)
+class Instructions:
+    """One AGENTS.md in force: what it is, where it lives, what it says."""
+
+    heading: str
+    path: Path
+    text: str
+
+
+def load_instructions(cwd: Path) -> list[Instructions]:
+    """Every AGENTS.md in force, least specific first.
+
+    ``~/.hx/AGENTS.md`` follows the user into every project; the project's own
+    ``AGENTS.md`` comes after it, so where the two disagree the more specific
+    one has the last word. A blank or unreadable file is skipped, and running
+    from inside ``$HX_HOME`` - where both paths name the same file - loads it once.
+    """
+    from hx.paths import project_instructions_file, tilde, user_instructions_file
+
+    user = user_instructions_file()
+    found: list[Instructions] = []
+    seen: set[Path] = set()
+    for heading, path in (
+        (f"User instructions ({tilde(user)})", user),
+        ("Project instructions (AGENTS.md)", project_instructions_file(cwd)),
+    ):
+        body = _read_prompt_file(path)
+        if not body or path.resolve() in seen:
+            continue
+        seen.add(path.resolve())
+        found.append(Instructions(heading, path, body))
+    return found
+
+
+def build_project_context(cwd: Path, instructions: list[Instructions] | None = None) -> str:
+    """Static per-session project preamble: cwd, git branch, listing, AGENTS.md contents.
 
     Computed once at startup and then frozen - refreshing it mid-session would
-    invalidate the prefix.
+    invalidate the prefix. Pass ``instructions`` to fold in the AGENTS.md files
+    already loaded, so the caller can remember exactly which ones are in force.
     """
     lines = [f"Working directory: {cwd}"]
 
@@ -256,9 +291,8 @@ def build_project_context(cwd: Path) -> str:
     if entries:
         lines.append("Top level: " + ", ".join(entries[:60]))
 
-    agents_md = cwd / "AGENTS.md"
-    if agents_md.is_file():
-        lines.append(f"\n# Project instructions (AGENTS.md)\n\n{agents_md.read_text()}")
+    for loaded in load_instructions(cwd) if instructions is None else instructions:
+        lines.append(f"\n# {loaded.heading}\n\n{loaded.text}")
 
     return "\n".join(lines)
 
@@ -367,12 +401,12 @@ def resolve_system_prompt(cwd: Path, prompt: PromptSettings | None = None) -> Re
 def _read_prompt_file(path: Path) -> str:
     """Contents of a prompt override file, or ``""`` when it is absent or empty.
 
-    An unreadable file is treated as absent: a permissions problem on an
-    optional override must not stop the session from starting.
+    An unreadable file - no permission, or not UTF-8 - is treated as absent: a
+    problem with an optional override must not stop the session from starting.
     """
     try:
-        return path.read_text().strip() if path.is_file() else ""
-    except OSError:
+        return path.read_text(encoding="utf-8").strip() if path.is_file() else ""
+    except (OSError, UnicodeDecodeError):
         return ""
 
 

{hx_cli-0.2.7 → hx_cli-0.2.9}/src/hx/core/loop.py

@@ -18,7 +18,7 @@ import time
 from dataclasses import dataclass, replace
 from typing import TYPE_CHECKING, Any, ClassVar
 
-from hx.core.context import AssembledContext
+from hx.core.context import AssembledContext, Instructions
 from hx.core.events import (
     CompactionFinished,
     CompactionStarted,
@@ -103,6 +103,7 @@ class AgentLoop:
         active_skills: ActiveSkills | None = None,
         skills_index: str | None = None,
         project_context: str | None = None,
+        instructions: list[Instructions] | None = None,
         hooks: HookEngine | None = None,
     ) -> None:
         self.provider = provider
@@ -118,6 +119,8 @@ class AgentLoop:
         self.active_skills = active_skills
         self.skills_index = skills_index
         self.project_context = project_context
+        self.instructions = instructions or []
+        """The AGENTS.md files folded into ``project_context``, least specific first."""
         self.hooks = hooks
         self._cancelled = False
         self._turn_index = 0

{hx_cli-0.2.7 → hx_cli-0.2.9}/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.9}/src/hx/paths.py

@@ -30,6 +30,20 @@ def user_home() -> Path:
     return Path(override).expanduser() if override else Path.home() / ".hx"
 
 
+def tilde(path: str | Path) -> str:
+    """``path`` with the home directory written as ``~``.
+
+    Compared as text, not resolved: a session records the path it resolved
+    when it was made, and the directory may be gone by the time it is drawn.
+    """
+    text, home = str(path), str(Path.home())
+    if text == home:
+        return "~"
+    if text.startswith(home.rstrip("/") + "/"):
+        return "~" + text[len(home.rstrip("/")) :]
+    return text
+
+
 def user_settings_file() -> Path:
     return user_home() / "settings.json"
 
@@ -198,7 +212,28 @@ def project_system_prompt_append_file(cwd: Path | None = None) -> Path:
     return project_dir(cwd) / "system-prompt-append.md"
 
 
+def user_instructions_file() -> Path:
+    """Your ``AGENTS.md``: instructions that follow you into every project."""
+    return user_home() / "AGENTS.md"
+
+
+def project_instructions_file(cwd: Path | None = None) -> Path:
+    """The project's ``AGENTS.md``, at the root of the working directory."""
+    return (cwd or Path.cwd()) / "AGENTS.md"
+
+
 def ensure_user_dirs() -> None:
-    """Create the user-level directory skeleton if it does not exist."""
+    """Create the user-level skeleton if it does not exist.
+
+    That includes an empty ``AGENTS.md``, so there is a file to find and fill
+    in; empty, it adds nothing to the prompt. An existing one - including a
+    symlink, dangling or not - is never touched, and failing to create it never
+    stops a session: the file is optional.
+    """
     for path in (user_home(), sessions_dir(), user_skills_dir(), user_agents_dir(), logs_dir()):
         path.mkdir(parents=True, exist_ok=True)
+    try:
+        with user_instructions_file().open("x"):
+            pass
+    except OSError:
+        pass

{hx_cli-0.2.7 → hx_cli-0.2.9}/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))