hx-cli 0.2.11__tar.gz → 0.2.12__tar.gz

{hx_cli-0.2.11 → hx_cli-0.2.12}/CHANGELOG.md

@@ -28,6 +28,24 @@ the project follows [semantic versioning](https://semver.org/).
 
 ---
 
+## [0.2.12] - 2026-10-01
+
+### Fixed
+
+- `/exit` and `ctrl+d` return the shell at once. They used to wait up to 10
+  seconds on a model call renaming the session; sessions are no longer renamed
+  on the way out, in the TUI or with `hx -p`.
+- A name set with `/title` is no longer replaced by a generated one, including
+  one that was still being generated when you set it.
+- The session name is generated from the opening and the latest stretch of the
+  conversation, not only its first 2000 characters.
+- A session left before its first name came back is named from your first
+  message, instead of being listed by `/resume` with no name.
+- A session left with `/resume` into another directory is renamed for what it
+  became, by the HX that starts there, in the background.
+
+---
+
 ## [0.2.11] - 2026-10-01
 
 ### Fixed
@@ -776,7 +794,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.11...HEAD
+[Unreleased]: https://github.com/aletisunil/hx/compare/v0.2.12...HEAD
+[0.2.12]: https://github.com/aletisunil/hx/compare/v0.2.11...v0.2.12
 [0.2.11]: https://github.com/aletisunil/hx/compare/v0.2.10...v0.2.11
 [0.2.10]: https://github.com/aletisunil/hx/compare/v0.2.9...v0.2.10
 [0.2.9]: https://github.com/aletisunil/hx/compare/v0.2.8...v0.2.9

{hx_cli-0.2.11 → hx_cli-0.2.12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: hx-cli
-Version: 0.2.11
+Version: 0.2.12
 Summary: HX - an agent harness for the terminal
 Project-URL: Homepage, https://hx.sunilaleti.dev
 Project-URL: Documentation, https://hx.sunilaleti.dev
@@ -709,8 +709,14 @@ After the first exchange, HX asks the model for a short name for the session and
 writes it to `~/.hx/sessions/<id>/meta.json`, so `/resume` lists work rather
 than timestamps. It is one small call — cap 32 output tokens, `models.title_model`
 if you want a cheaper model for it — and it is counted in `/cost` like any other.
-If the call fails the session is still named, from your first message. `/title
-<text>` renames it.
+If the call fails, or you leave before it is back, the session is still named,
+from your first message.
+
+The live session is never renamed while it runs, and nothing is renamed on
+`/exit`, which returns your shell at once. A session you leave with `/clear` or
+`/resume` - including a `/resume` into another directory - is renamed in the
+background for what it became. `/title <text>` renames it yourself, and a name
+you chose is never replaced.
 
 `/resume` lists every session except the one you are in: this directory's
 first, then other directories', each row naming where it lives. A session from

{hx_cli-0.2.11 → hx_cli-0.2.12}/README.md

@@ -669,8 +669,14 @@ After the first exchange, HX asks the model for a short name for the session and
 writes it to `~/.hx/sessions/<id>/meta.json`, so `/resume` lists work rather
 than timestamps. It is one small call — cap 32 output tokens, `models.title_model`
 if you want a cheaper model for it — and it is counted in `/cost` like any other.
-If the call fails the session is still named, from your first message. `/title
-<text>` renames it.
+If the call fails, or you leave before it is back, the session is still named,
+from your first message.
+
+The live session is never renamed while it runs, and nothing is renamed on
+`/exit`, which returns your shell at once. A session you leave with `/clear` or
+`/resume` - including a `/resume` into another directory - is renamed in the
+background for what it became. `/title <text>` renames it yourself, and a name
+you chose is never replaced.
 
 `/resume` lists every session except the one you are in: this directory's
 first, then other directories', each row naming where it lives. A session from

{hx_cli-0.2.11 → hx_cli-0.2.12}/src/hx/__init__.py

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

{hx_cli-0.2.11 → hx_cli-0.2.12}/src/hx/cli.py

@@ -609,6 +609,8 @@ def run_tui_command(parsed: ParsedArgs) -> int:
     from hx.auth.resolve import MissingCredential
     from hx.tui.app import run_tui
 
+    # Taken before anything starts, so no tool, MCP server or nested hx inherits it.
+    rename_left = os.environ.pop(RENAME_LEFT_ENV, None)
     try:
         resume = _resume_target(parsed)
         moved = _adopt_session_directory(parsed, resume)
@@ -648,10 +650,8 @@ def run_tui_command(parsed: ParsedArgs) -> int:
                 notices=runtime.notices,
                 checkpoints=runtime.checkpoints,
                 tracker=runtime.tracker,
+                rename_left=rename_left,
             )
-            # The TUI is down but the provider is not, which is the one moment
-            # the whole session exists and nothing is competing for the screen.
-            await _rename_closed_session(runtime.loop)
         finally:
             runtime.bus.close()
             # Everything, not only the provider: a relaunch replaces this
@@ -661,7 +661,8 @@ def run_tui_command(parsed: ParsedArgs) -> int:
 
     asyncio.run(main_async())
     if relaunch is not None:
-        _relaunch(relaunch)
+        left = runtime.loop.session
+        _relaunch(relaunch, left=left.meta.session_id if left.messages else None)
     return 0
 
 
@@ -724,9 +725,19 @@ def relaunch_argv(argv: list[str], session_id: str) -> list[str]:
     return [*kept, "resume", session_id]
 
 
-def _relaunch(session_id: str) -> None:
+RENAME_LEFT_ENV = "HX_RENAME_LEFT_SESSION"
+"""The session a relaunch left behind, handed to the HX that replaces it.
+
+``/clear`` and ``/resume`` rename the session the user leaves, in the
+background. A relaunch cannot: ``exec`` ends this process before the call is
+back. So the new process does it, as detached as it is everywhere else."""
+
+
+def _relaunch(session_id: str, *, left: str | None = None) -> None:
     """Replace this process with HX resumed on ``session_id``.
 
+    ``left`` is the session being left, for the new process to rename.
+
     ``exec`` rather than a child: the terminal, the pid and the shell's job
     control stay exactly as they were, and there is no parent left waiting.
 
@@ -738,30 +749,13 @@ def _relaunch(session_id: str) -> None:
     """
     prefix = sys.orig_argv[: len(sys.orig_argv) - len(sys.argv) + 1]
     command = [sys.executable, *prefix[1:], *relaunch_argv(sys.argv[1:], session_id)]
+    if left is not None:
+        os.environ[RENAME_LEFT_ENV] = left
     sys.stdout.flush()
     sys.stderr.flush()
     os.execv(sys.executable, command)
 
 
-RENAME_TIMEOUT_SECONDS = 10.0
-"""A session name is not worth making the user wait for. Exit wins the tie."""
-
-
-async def _rename_closed_session(loop: Any) -> None:
-    """Re-name the session now that it is over, if the work moved on.
-
-    The first name is written after one exchange and never revisited, so
-    ``/resume`` ends up listing opening questions. Bounded and swallowed: this
-    runs while the user is waiting for their shell prompt back.
-    """
-    try:
-        await asyncio.wait_for(loop.retitle_session(), timeout=RENAME_TIMEOUT_SECONDS)
-    except Exception:
-        # Including the timeout. A rename that cannot happen is not an error the
-        # user needs at the moment they are leaving; the old name still stands.
-        return
-
-
 def run_print_command(parsed: ParsedArgs) -> int:
     """Headless single-prompt run. Streams assistant text to stdout and tool
     activity to stderr, so stdout stays pipeable."""
@@ -828,7 +822,6 @@ def run_print_command(parsed: ParsedArgs) -> int:
                     print(f"[mcp] {status.name} unavailable: {status.error}", file=sys.stderr)
         try:
             result = await runtime.loop.run(parsed.prompt, images)
-            await _rename_closed_session(runtime.loop)
         finally:
             await asyncio.sleep(0.05)
             runtime.bus.close()

{hx_cli-0.2.11 → hx_cli-0.2.12}/src/hx/core/loop.py

@@ -352,7 +352,8 @@ class AgentLoop:
         moment ``run`` returns - a background task would simply be killed.
 
         Naming must never cost the user a turn, so every failure falls back to
-        the first thing they said.
+        the first thing they said - including leaving before the call is back,
+        which would otherwise list the session in ``/resume`` with no name.
         """
         if self.origin is not None or self.session.meta.title or self._cancelled:
             return
@@ -361,37 +362,50 @@ class AgentLoop:
         if messages is None:
             return
 
-        title = await self._ask_for_title(messages, self.session)
         from hx.core.title import fallback_title
 
+        try:
+            title = await self._ask_for_title(messages, self.session)
+        except asyncio.CancelledError:
+            if not self.session.meta.title:
+                self.session.set_title(fallback_title(messages))
+            raise
+        # The user may have named it with /title while the call was out; the
+        # turn is over by then, and their name stands.
+        if self.session.meta.title:
+            return
+
         self.session.set_title(title or fallback_title(messages))
 
-    async def retitle_session(self, session: Session | None = None) -> None:
-        """Rename a session for what it turned into, as it closes.
+    async def retitle_session(self, target: Session) -> None:
+        """Rename a session for what it turned into, as the user leaves it.
 
         The first name is written after one exchange, so it describes an opening
-        question. Two hours later it is the wrong label on the row the user has
-        to recognise in ``/resume``, and the list gives them no way to know that.
-
-        ``session`` names the one to rename, for the cases where it is no longer
-        the live one - ``/clear`` and ``/resume`` both leave a session behind.
-
-        Only when the transcript grew since the name was written, and never at
-        the cost of the name already there: a rename that fails leaves the old
-        title alone rather than replacing something specific with a guess.
+        question. ``/clear`` and ``/resume`` both leave a session behind, and
+        that is the moment to name it for what it became - detached, so nobody
+        waits on it. The live session is never renamed while it runs.
+
+        Only when the conversation changed since the name was written, never
+        over a name the user chose, and never at the cost of the name already
+        there: a rename that fails leaves the old title alone rather than
+        replacing something specific with a guess.
         """
         if self.origin is not None:
             return
 
-        target = session if session is not None else self.session
+        if target.meta.title_pinned:
+            return
         messages = self._nameable_messages(target)
         if messages is None:
             return
-        if len(target.messages) <= target.meta.title_message_count:
+        prompt_count = target.meta.prompt_count
+        if prompt_count == target.meta.title_prompt_count:
             return
 
-        if title := await self._ask_for_title(messages, target):
-            target.set_title(title)
+        title = await self._ask_for_title(messages, target)
+        # The user may have named it while the call was out; their name stands.
+        if title and not target.meta.title_pinned:
+            target.set_title(title, prompt_count=prompt_count)
 
     def _nameable_messages(self, session: Session) -> list[Message] | None:
         """The transcript a name is derived from, or ``None`` if there is none."""

{hx_cli-0.2.11 → hx_cli-0.2.12}/src/hx/core/session.py

@@ -39,9 +39,12 @@ class SessionMeta:
     updated_at: float
     model: str
     title: str | None = None
-    title_message_count: int = 0
-    """How long the transcript was when the title was written, so closing the
-    session can tell whether the name still describes it."""
+    title_prompt_count: int = 0
+    """How many prompts the session held when the title was written, so the
+    session can tell when the conversation has moved on from its name."""
+    title_pinned: bool = False
+    """The user named the session with ``/title``. Their name is never replaced
+    by a generated one."""
     message_count: int = 0
     """Every message record: the user's prompts, the assistant's replies, and
     the tool-result messages that ride the user role to match the provider wire
@@ -166,14 +169,24 @@ class Session:
         self._pending.append({"kind": "environment", "data": asdict(environment)})
         self.flush()
 
-    def set_title(self, title: str) -> None:
+    def set_title(
+        self, title: str, *, pinned: bool = False, prompt_count: int | None = None
+    ) -> None:
         """Name the session for ``/resume``.
 
+        ``pinned`` marks a name the user chose, which generated names never
+        replace. ``prompt_count`` is how much of the conversation the name
+        describes, when that is less than the whole of it - a name generated in
+        the background describes the transcript as it was when it was asked for.
+
         ``updated_at`` is deliberately left alone: it orders the picker and must
         keep reflecting real activity, not the moment a name was written.
         """
         self.meta.title = title.strip() or None
-        self.meta.title_message_count = len(self.messages)
+        self.meta.title_pinned = pinned and self.meta.title is not None
+        self.meta.title_prompt_count = (
+            self.meta.prompt_count if prompt_count is None else prompt_count
+        )
         self._write_meta()
 
     def record_usage(self, usage: TurnUsage) -> None:

{hx_cli-0.2.11 → hx_cli-0.2.12}/src/hx/core/title.py

@@ -27,6 +27,10 @@ TITLE_MAX_TOKENS = 32
 MAX_TITLE_CHARS = 50
 """A session row is read at a glance, in a list. Longer names stop being names."""
 TRANSCRIPT_CHARS = 2_000
+"""How much of the conversation the naming call sees."""
+OPENING_CHARS = 500
+"""Of that, how much is the opening. The rest is the latest stretch: a session
+renamed for what it turned into has to be shown what it turned into."""
 
 TITLE_PROMPT = """\
 Name this coding session so it can be recognised in a list of sessions.
@@ -49,7 +53,7 @@ def build_title_request(messages: list[Message], model: str) -> ProviderRequest:
     from hx.core.context import AssembledContext, PromptSection
     from hx.providers.base import ProviderRequest
 
-    transcript = render_transcript(messages)[:TRANSCRIPT_CHARS]
+    transcript = _excerpt(render_transcript(messages))
     context = AssembledContext(
         system=[PromptSection("system", "You name things briefly and precisely.")],
         messages=[
@@ -83,6 +87,15 @@ async def generate_title(
     return clean_title("".join(parts)) or None, usage
 
 
+def _excerpt(transcript: str) -> str:
+    """The opening and the latest stretch of a transcript too long to send whole."""
+    if len(transcript) <= TRANSCRIPT_CHARS:
+        return transcript
+    opening = transcript[:OPENING_CHARS]
+    latest = transcript[-(TRANSCRIPT_CHARS - OPENING_CHARS) :]
+    return f"{opening}\n[... earlier conversation omitted ...]\n{latest}"
+
+
 def clean_title(raw: str) -> str:
     """Strip the decoration models add to a name, and cap its length.
 

{hx_cli-0.2.11 → hx_cli-0.2.12}/src/hx/tui/app.py

@@ -31,12 +31,15 @@ async def run_tui(
     notices: list[str] | None = None,
     checkpoints: Any = None,
     tracker: Any = None,
+    rename_left: str | None = None,
 ) -> str | None:
     """Run the interactive session.
 
     The signature is the boundary ``hx.cli`` calls, and it did not change as
     the frontend underneath it was replaced. Returns the id of a session to
     relaunch into, when ``/resume`` picked one from another directory.
+    ``rename_left`` is the session such a relaunch left behind, to be renamed
+    in the background for what it became.
     """
     from hx.tui.runtime import run_session
 
@@ -54,4 +57,5 @@ async def run_tui(
         notices=notices,
         checkpoints=checkpoints,
         tracker=tracker,
+        rename_left=rename_left,
     )

{hx_cli-0.2.11 → hx_cli-0.2.12}/src/hx/tui/commands.py

@@ -504,7 +504,7 @@ async def cmd_title(ctx: CommandContext, args: str) -> None:
             "info" if current else "warning",
         )
         return
-    session.set_title(args.strip())
+    session.set_title(args.strip(), pinned=True)
     ctx.app.notice(f"Session title: {session.meta.title}", "success")
 
 

{hx_cli-0.2.11 → hx_cli-0.2.12}/src/hx/tui/runtime.py

@@ -45,7 +45,7 @@ from hx.tui.views.prompt import Prompt
 from hx.tui.views.transcript import Session
 
 if TYPE_CHECKING:
-    from collections.abc import Sequence
+    from collections.abc import Coroutine, Sequence
 
     from hx.config import Settings
     from hx.core.events import EventBus
@@ -136,7 +136,7 @@ class HXSession:
         self._queued: list[UserTurn] = []
         self._background: set[asyncio.Task[Any]] = set()
         """Detached work - session renaming - held so it is not garbage
-        collected mid-flight."""
+        collected mid-flight, and cancelled on the way out."""
         self._mouse = False
         self._clear_armed = False
         """Set by one ctrl+c on an empty, idle prompt; a second one exits."""
@@ -185,10 +185,14 @@ class HXSession:
         events = asyncio.create_task(self._consume_events())
         spinner = asyncio.create_task(self._spin())
         branch = asyncio.create_task(self._watch_branch())
+        if left := self.extra.get("rename_left"):
+            self._detach(self._rename_left_behind(left))
         try:
             await self.runner.run()
         finally:
-            for task in (events, spinner, branch, self._turn, self._side):
+            # Detached work included: renaming a session left with /clear is not
+            # worth the user waiting for their shell prompt. Its old name stands.
+            for task in (events, spinner, branch, self._turn, self._side, *self._background):
                 if task is not None and not task.done():
                     task.cancel()
                     with contextlib.suppress(asyncio.CancelledError):
@@ -489,9 +493,29 @@ class HXSession:
         """
         if not session.messages:
             return
-        task = asyncio.create_task(self.loop.retitle_session(session))
+        self._detach(self.loop.retitle_session(session))
+
+    async def _rename_left_behind(self, session_id: str) -> None:
+        """Rename the session a ``/resume`` into another directory left behind.
+
+        The process that left it was replaced before it could; see
+        :data:`hx.cli.RENAME_LEFT_ENV`. A session that cannot be read is simply
+        not renamed - its old name still stands.
+        """
+        from hx.core.session import load_session
+
+        try:
+            session = await asyncio.to_thread(load_session, session_id)
+        except Exception:
+            return
+        if session.messages:
+            await self.loop.retitle_session(session)
+
+    def _detach(self, work: Coroutine[Any, Any, None]) -> asyncio.Task[None]:
+        task = asyncio.create_task(work)
         self._background.add(task)
         task.add_done_callback(self._background.discard)
+        return task
 
     def start_new_session(self) -> None:
         """Fresh transcript, same directory. The old session stays on disk."""
@@ -1139,9 +1163,7 @@ class HXSession:
                 self._notice(f"Could not attach the image: {error}", "error")
                 self.runner.request_immediate_render()
 
-        task = asyncio.create_task(attach())
-        self._background.add(task)
-        task.add_done_callback(self._background.discard)
+        self._detach(attach())
 
     async def _attach_images(self, paths: list[Path] | None) -> None:
         """Read, normalise and attach, off the event loop.

{hx_cli-0.2.11 → hx_cli-0.2.12}/tests/e2e/stub.py

@@ -188,6 +188,9 @@ class Stub:
         self.title_requests: list[Request] = []
         self.unexpected: list[str] = []
         self.title = "E2E session"
+        self.title_hold: threading.Event | None = None
+        """When set, a naming call is answered only once this event is - a slow
+        title model, caught with the call still out."""
         self.models = list(CATALOGUE)
         self.model_fetches = 0
         self._closing = threading.Event()
@@ -237,6 +240,19 @@ class Stub:
                 self._arrived.wait(remaining)
             return list(self.requests)
 
+    def wait_for_title_requests(self, count: int, timeout: float = 15.0) -> list[Request]:
+        """Block until ``count`` session-naming requests have arrived."""
+        deadline = time.monotonic() + timeout
+        with self._arrived:
+            while len(self.title_requests) < count:
+                remaining = deadline - time.monotonic()
+                if remaining <= 0:
+                    raise AssertionError(
+                        f"expected {count} title request(s), got {len(self.title_requests)}"
+                    )
+                self._arrived.wait(remaining)
+            return list(self.title_requests)
+
     def log(self) -> list[dict[str, Any]]:
         """What the report records: each request's model, last user text and tools."""
         return [
@@ -275,9 +291,17 @@ class Stub:
                     return
                 request = Request(body=body, headers=dict(self.headers.items()))
                 if request.system == TITLE_SYSTEM:
-                    with stub._lock:
+                    with stub._arrived:
                         stub.title_requests.append(request)
-                    self._stream(Reply(text=stub.title, prompt_tokens=300, completion_tokens=5))
+                        stub._arrived.notify_all()
+                    self._stream(
+                        Reply(
+                            text=stub.title,
+                            prompt_tokens=300,
+                            completion_tokens=5,
+                            hold=stub.title_hold,
+                        )
+                    )
                     return
                 if unanswered := _unanswered_tool_calls(request.messages):
                     # Every upstream rejects a tool call left without its

{hx_cli-0.2.11 → hx_cli-0.2.12}/tests/e2e/test_commands.py

@@ -4,6 +4,7 @@ from __future__ import annotations
 
 import json
 import re
+import threading
 import time
 
 from tests.e2e.conftest import HX, SANDBOX, SANDBOX_STATUS
@@ -224,6 +225,177 @@ def test_title_command(hx: HX, stub: Stub) -> None:
     assert hx.sessions()[-1]["title"] == "Release planning"
 
 
+def test_session_is_named_once_and_exit_does_not_wait(hx: HX, stub: Stub) -> None:
+    """The session is named once, after its first exchange, and never renamed while it
+    runs. /exit returns the shell at once, even with a rename of a left session still out."""
+    parser = hx.project / "parser.py"
+    parser.write_text(
+        "".join(f"def rule_{n}(tokens):\n    return tokens[{n}:]\n\n" for n in range(80))
+    )
+    stub.title = "Parser rules overview"
+    stub.script(
+        call("Read", file_path=str(parser)),
+        say("It is a table of slicing rules."),
+        say("rule_3 drops the first three tokens."),
+        say("Yes, every rule slices."),
+        say("Added --verbose."),
+        say("Tests pass."),
+    )
+    term = hx.tui()
+    term.submit("what does parser.py do")
+    term.wait_for("It is a table of slicing rules.")
+    asked = stub.wait_for_title_requests(1)[0].last_user_text()
+    assert "what does parser.py do" in asked, "the opening is shown"
+    assert "It is a table of slicing rules." in asked, "so is how the exchange ended"
+    assert "earlier conversation omitted" in asked, "the long middle is cut, and says so"
+    assert hx.sessions()[-1]["title"] == "Parser rules overview"
+
+    stub.title = "Never asked for"
+    for prompt, reply in (
+        ("what does rule_3 do", "rule_3 drops the first three tokens."),
+        ("do they all slice", "Yes, every rule slices."),
+        ("now add a --verbose flag to the CLI", "Added --verbose."),
+        ("run the tests", "Tests pass."),
+    ):
+        term.submit(prompt)
+        term.wait_for(reply)
+    term.settle(0.5)
+    assert len(stub.title_requests) == 1, "the live session is not renamed while it runs"
+    assert hx.sessions()[-1]["title"] == "Parser rules overview"
+
+    # Leaving it with /clear renames it for what it became, in the background.
+    # A slow title model holds that call; /exit must not wait on it.
+    stub.title_hold = threading.Event()
+    term.submit("/clear")
+    term.wait_for("New session started.")
+    stub.wait_for_title_requests(2)
+    term.type("/exit")
+    started = time.monotonic()
+    term.press("enter")
+    assert term.wait_exit(timeout=5) == 0
+    took = time.monotonic() - started
+    hx.note(f"/exit with a rename in flight returned in {took:.2f}s")
+    assert took < 1.0, f"/exit took {took:.2f}s"
+    term.snapshot("shell prompt back")
+    assert "Traceback" not in term.scrollback()
+    (left,) = [meta for meta in hx.sessions() if meta["prompt_count"] == 5]
+    assert left["title"] == "Parser rules overview", "the abandoned rename wrote nothing"
+
+
+def test_exit_while_the_session_is_being_named_still_names_it(hx: HX, stub: Stub) -> None:
+    """Leaving with the naming call still out names the session from the first prompt,
+    rather than leaving /resume a row with no name at all."""
+    stub.title_hold = threading.Event()
+    stub.title = "Never arrives"
+    stub.script(say("The retry wraps the request, not the session."))
+    term = hx.tui()
+    term.submit("why does the login test flake on CI")
+    term.wait_for("The retry wraps the request, not the session.")
+    stub.wait_for_title_requests(1)
+    term.type("/exit")
+    started = time.monotonic()
+    term.press("enter")
+    assert term.wait_exit(timeout=5) == 0
+    took = time.monotonic() - started
+    hx.note(f"/exit with the first naming call in flight returned in {took:.2f}s")
+    assert took < 1.0, f"/exit took {took:.2f}s"
+    assert "Traceback" not in term.scrollback()
+    (meta,) = hx.sessions()
+    assert meta["title"] == "why does the login test flake on CI"
+    assert meta["title_pinned"] is False
+
+    # Not a name the user chose: leaving it again, having moved on, renames it.
+    stub.title_hold = None
+    stub.title = "Login test flake on CI"
+    stub.script(say("Pinned the session cookie."))
+    term = hx.tui("resume")
+    term.wait_for("The retry wraps the request, not the session.")
+    term.submit("fix it")
+    term.wait_for("Pinned the session cookie.")
+    term.submit("/clear")
+    term.wait_for("New session started.")
+    stub.wait_for_title_requests(2)
+    term.settle(0.5)
+    (meta,) = [meta for meta in hx.sessions() if meta["prompt_count"] == 2]
+    assert meta["title"] == "Login test flake on CI"
+    term.press("ctrl+d")
+    assert term.wait_exit() == 0
+
+
+def test_resume_into_another_directory_renames_the_session_left(hx: HX, stub: Stub) -> None:
+    """/resume of a session from another directory relaunches HX there. The session left
+    behind is still renamed for what it became - by the new process, in the background."""
+    elsewhere = hx.root / "elsewhere"
+    elsewhere.mkdir()
+    stub.title = "Owl facts"
+    stub.script(say("Owls are nocturnal."))
+    hx.run("-p", "tell me about owls", cwd=elsewhere, check=True)
+
+    stub.title = "Parser question"
+    stub.script(say("It parses rules."), say("Added --verbose."), say("Tests pass."))
+    term = hx.tui()
+    for prompt, reply in (
+        ("what does parser.py do", "It parses rules."),
+        ("now add a --verbose flag to the CLI", "Added --verbose."),
+        ("run the tests", "Tests pass."),
+    ):
+        term.submit(prompt)
+        term.wait_for(reply)
+    stub.wait_for_title_requests(2)
+
+    stub.title = "Verbose flag for the CLI"
+    term.submit("/resume")
+    screen = term.wait_for("Resume session")
+    assert "Owl facts" in screen
+    term.press("enter")
+    term.wait_for("Owls are nocturnal.")
+    term.snapshot("relaunched into the other directory")
+    stub.wait_for_title_requests(3)
+    term.settle(0.5)
+    (left,) = [meta for meta in hx.sessions() if meta["prompt_count"] == 3]
+    assert left["title"] == "Verbose flag for the CLI"
+    (resumed,) = [meta for meta in hx.sessions() if meta["cwd"] == str(elsewhere)]
+    assert resumed["title"] == "Owl facts", "the live session is not renamed"
+
+    # The handoff stops at HX: nothing it starts inherits it, so a nested hx
+    # cannot rename the session a second time.
+    term.submit("!echo left=${HX_RENAME_LEFT_SESSION:-none}")
+    term.wait_for("left=none")
+    term.press("ctrl+d")
+    assert term.wait_exit() == 0
+    assert "Traceback" not in term.scrollback()
+
+
+def test_a_title_the_user_chose_is_never_replaced(hx: HX, stub: Stub) -> None:
+    """/title pins the name: neither the first naming, still out when it is set, nor the
+    rename on /clear replaces it."""
+    stub.title_hold = threading.Event()
+    stub.title = "Generated name"
+    stub.script(say("Hello."), say("A."), say("B."))
+    term = hx.tui()
+    term.submit("hi")
+    term.wait_for("Hello.")
+    stub.wait_for_title_requests(1)
+    # The model is still naming the session when the user names it themselves.
+    term.submit("/title Release planning")
+    term.wait_for("✓ Session title: Release planning")
+    stub.title_hold.set()
+    stub.title_hold = None
+
+    for prompt, reply in (("a", "A."), ("b", "B.")):
+        term.submit(prompt)
+        term.wait_for(reply)
+    term.submit("/clear")
+    term.wait_for("New session started.")
+    term.settle(0.5)
+    assert len(stub.title_requests) == 1, "a pinned name is not asked for again"
+    term.press("ctrl+d")
+    assert term.wait_exit() == 0
+    (meta,) = [meta for meta in hx.sessions() if meta["prompt_count"] == 3]
+    assert meta["title"] == "Release planning"
+    assert meta["title_pinned"] is True
+
+
 def test_copy_puts_the_last_reply_on_the_clipboard(hx: HX, stub: Stub) -> None:
     """/copy copies the last answer - not the command's own echo - and says how."""
     stub.script(say("Copy me, please."))