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

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

@@ -28,6 +28,42 @@ 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
+
+- `esc` while a tool runs no longer breaks the session: the next question is
+  answered instead of every later turn failing. A session that was interrupted
+  or killed mid-tool before this release also carries on after `hx resume`.
+- `esc` during a `Bash` command stops the command. The next `Bash` call gets its
+  own output and exit code, not what was left of the one stopped.
+- An interrupted call keeps what it printed, on screen and for the model, and
+  reads "Interrupted after <time>" instead of looking like a failure.
+- A tool that finished keeps its result when `esc` lands while its
+  `PostToolUse` hook runs.
+- `Bash` shows a short line such as "Starting..." as soon as it is printed,
+  rather than only when more output follows.
+
+---
+
 ## [0.2.10] - 2026-09-29
 
 ### Fixed
@@ -758,7 +794,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.10...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
 [0.2.8]: https://github.com/aletisunil/hx/compare/v0.2.7...v0.2.8

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: hx-cli
-Version: 0.2.10
+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.10 → 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.10 → hx_cli-0.2.12}/src/hx/__init__.py

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

{hx_cli-0.2.10 → 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.10 → hx_cli-0.2.12}/src/hx/core/events.py

@@ -67,6 +67,9 @@ class ToolCallFinished(Event):
     metadata: dict[str, Any] = field(default_factory=dict)
     """Structured detail the renderer draws with - an edit's diff, a command's
     exit code. Presentation only: the model never sees it."""
+    interrupted: bool = False
+    """The user stopped the turn while this call ran. Whatever it streamed is
+    kept: how far a command got is what the user wants to see."""
 
 
 @dataclass(slots=True)

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

@@ -42,7 +42,9 @@ from hx.core.messages import (
     ToolResultBlock,
     ToolUseBlock,
     UserTurn,
+    answer_unanswered_calls,
     assistant_message,
+    interrupted_result,
     tool_result_message,
     user_message,
 )
@@ -50,7 +52,7 @@ from hx.core.session import Environment
 from hx.core.usage import TurnUsage, compute_cost
 from hx.hooks.spec import HookOutcome
 from hx.providers.base import ProviderError, ProviderRequest, StreamDelta, StreamEnd
-from hx.tools.base import ToolContext
+from hx.tools.base import ToolContext, ToolResult
 
 if TYPE_CHECKING:
     from collections.abc import Awaitable, Callable, Sequence
@@ -225,6 +227,27 @@ class AgentLoop:
                 self.bus.publish(TurnFinished(self._turn_index, stop_reason))
 
             calls = message.tool_uses()
+            if calls and self._cancelled:
+                # Stopped between the answer and its tools: none of them ran,
+                # and the transcript has to say so before the turn ends - as
+                # does the screen, which a resumed session draws them on too.
+                for call in calls:
+                    self.bus.publish(
+                        ToolCallStarted(
+                            tool_use_id=call.id,
+                            name=self._display_name(call.name),
+                            input=call.input,
+                        )
+                    )
+                    self.bus.publish(
+                        ToolCallFinished(
+                            tool_use_id=call.id,
+                            is_error=True,
+                            summary="interrupted",
+                            interrupted=True,
+                        )
+                    )
+                produced.append(self._answer_calls(calls, {}))
             if not calls or self._cancelled:
                 # A steer that arrived during the last stretch is the next thing
                 # the user said, so the conversation continues rather than
@@ -234,10 +257,15 @@ class AgentLoop:
                 await self._name_session()
                 return TurnResult(stop_reason, produced)
 
-            results = await self._execute_tools(calls)
-            result_message = tool_result_message(results)
-            self.session.append(result_message)
-            produced.append(result_message)
+            results: dict[str, ToolResultBlock] = {}
+            try:
+                await self._execute_tools(calls, results)
+            finally:
+                # Also on interrupt. The calls are already in the transcript,
+                # and a call left without a result is rejected by every route on
+                # the next request - so every later turn in the session would
+                # fail the same way. What finished keeps its real result.
+                produced.append(self._answer_calls(calls, results))
 
         self.bus.publish(
             ErrorRaised(message=f"Stopped after {self.MAX_TURNS} turns", recoverable=True)
@@ -324,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
@@ -333,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."""
@@ -459,7 +501,9 @@ class AgentLoop:
         )
 
     async def _build_request(self) -> ProviderRequest:
-        messages = await self.injections.apply(self.session.active_messages())
+        messages = answer_unanswered_calls(
+            await self.injections.apply(self.session.active_messages())
+        )
         if self.model_info is None or not self.model_info.supports_images:
             from hx.core.images import without_images
 
@@ -570,31 +614,48 @@ class AgentLoop:
             )
         )
 
-    async def _execute_tools(self, calls: list[ToolUseBlock]) -> list[ToolResultBlock]:
+    async def _execute_tools(
+        self, calls: list[ToolUseBlock], results: dict[str, ToolResultBlock]
+    ) -> None:
         """Permission-check, then run. Read-only calls are gathered concurrently;
         mutating calls run in emission order.
 
+        Each result lands in ``results`` the moment its call finishes, so an
+        interrupt keeps what had already run.
+
         A denied call becomes an ``is_error`` result rather than an exception, so
         the model can react instead of the turn dying.
         """
-        results: dict[str, ToolResultBlock] = {}
         concurrent: list[ToolUseBlock] = []
 
+        async def run(call: ToolUseBlock) -> None:
+            results[call.id] = await self._run_one(call, results)
+
         for call in calls:
             if self._runs_serially(call):
                 for pending in concurrent:
-                    results[pending.id] = await self._run_one(pending)
+                    await run(pending)
                 concurrent.clear()
-                results[call.id] = await self._run_one(call)
+                await run(call)
             else:
                 concurrent.append(call)
 
         if concurrent:
-            gathered = await asyncio.gather(*(self._run_one(c) for c in concurrent))
-            for call, result in zip(concurrent, gathered, strict=True):
-                results[call.id] = result
+            await asyncio.gather(*(run(c) for c in concurrent))
 
-        return [results[c.id] for c in calls]
+    def _answer_calls(
+        self, calls: list[ToolUseBlock], results: dict[str, ToolResultBlock]
+    ) -> Message:
+        """Append the results for ``calls``, in the order the model asked for them.
+
+        A call with no result was cut off by the user, before it started or
+        while it ran, and is answered as exactly that.
+        """
+        message = tool_result_message(
+            [results.get(call.id) or interrupted_result(call.id) for call in calls]
+        )
+        self.session.append(message)
+        return message
 
     def _runs_serially(self, call: ToolUseBlock) -> bool:
         try:
@@ -609,7 +670,10 @@ class AgentLoop:
         """Attribute a subagent's tool calls so they do not read as the parent's."""
         return name if self.origin is None else f"{self.origin} > {name}"
 
-    async def _run_one(self, call: ToolUseBlock) -> ToolResultBlock:
+    async def _run_one(
+        self, call: ToolUseBlock, results: dict[str, ToolResultBlock]
+    ) -> ToolResultBlock:
+        """Run one call. Interrupted, it leaves its answer in ``results``."""
         started = time.monotonic()
 
         # PreToolUse runs before the call is announced. A hook that rewrites the
@@ -626,7 +690,40 @@ class AgentLoop:
                 tool_use_id=call.id, name=self._display_name(call.name), input=call.input
             )
         )
+        streamed: list[str] = []
+        try:
+            return await self._run_announced(call, pre, started, streamed, results)
+        except asyncio.CancelledError:
+            if call.id in results:
+                # The tool had finished and only its hooks were cut off.
+                raise
+            cap = self.settings.context.tool_output_char_cap
+            results[call.id] = interrupted_result(call.id, "".join(streamed)[-cap:])
+            # The call is on screen as running; left alone it would spin on
+            # under the "Interrupted" notice for the rest of the session.
+            self.bus.publish(
+                ToolCallFinished(
+                    tool_use_id=call.id,
+                    is_error=True,
+                    duration_ms=(time.monotonic() - started) * 1000,
+                    summary="interrupted",
+                    interrupted=True,
+                )
+            )
+            raise
 
+    async def _run_announced(
+        self,
+        call: ToolUseBlock,
+        pre: HookOutcome,
+        started: float,
+        streamed: list[str],
+        results: dict[str, ToolResultBlock],
+    ) -> ToolResultBlock:
+        """The part of :meth:`_run_one` after the call is on screen.
+
+        What the tool prints is kept in ``streamed`` for an interrupt to report.
+        """
         if pre.blocked:
             refusal = ToolResultBlock(
                 tool_use_id=call.id,
@@ -657,18 +754,34 @@ class AgentLoop:
             )
             return denied
 
+        def progress(chunk: str) -> None:
+            streamed.append(chunk)
+            self._emit_progress(call.id, chunk)
+
         ctx = ToolContext(
             cwd=self.settings.cwd,
             session_id=self.session.meta.session_id,
             tool_use_id=call.id,
             settings=self.settings,
-            emit_progress=lambda chunk: self._emit_progress(call.id, chunk),
+            emit_progress=progress,
         )
         result = await self.tools.call(call.name, call.input, ctx)
 
-        post = await self._fire_hooks(
-            lambda h: h.post_tool_use(call.name, call.input, result.content, result.is_error)
-        )
+        try:
+            post = await self._fire_hooks(
+                lambda h: h.post_tool_use(call.name, call.input, result.content, result.is_error)
+            )
+        except asyncio.CancelledError:
+            # The tool finished and its effects are real: its own result stands,
+            # rather than telling the model a write that happened never did.
+            results[call.id] = self._finish(call, result, HookOutcome(), started)
+            raise
+        return self._finish(call, result, post, started)
+
+    def _finish(
+        self, call: ToolUseBlock, result: ToolResult, post: HookOutcome, started: float
+    ) -> ToolResultBlock:
+        """Announce a call the tool finished, and its result for the model."""
         content = result.content
         if post.blocked:
             content = f"{content}\n\nA hook rejected this result: {post.reason}"

{hx_cli-0.2.10 → hx_cli-0.2.12}/src/hx/core/messages.py

@@ -9,7 +9,7 @@ from __future__ import annotations
 
 import time
 from collections.abc import Sequence
-from dataclasses import dataclass, field
+from dataclasses import dataclass, field, replace
 from enum import StrEnum
 from typing import Any, Literal
 
@@ -238,3 +238,60 @@ def assistant_message(blocks: list[ContentBlock], model: str | None = None) -> M
 def tool_result_message(results: list[ToolResultBlock]) -> Message:
     """Tool results are carried on a ``user``-role message, matching the provider wire format."""
     return Message(role="user", content=list(results))
+
+
+INTERRUPTED = "Interrupted by the user before this call finished."
+_OUTPUT_SO_FAR = "\n\nOutput before the interrupt:\n"
+
+
+def interrupted_result(tool_use_id: str, output: str = "") -> ToolResultBlock:
+    """The answer for a call the user cut off, before it started or while it ran.
+
+    What it printed before then goes with it: how far a command got is what
+    the model needs to decide whether to run it again.
+    """
+    content = f"{INTERRUPTED}{_OUTPUT_SO_FAR}{output}" if output.strip() else INTERRUPTED
+    return ToolResultBlock(tool_use_id=tool_use_id, content=content, is_error=True)
+
+
+def interrupted_output(result: ToolResultBlock) -> str | None:
+    """What an interrupted call printed, or ``None`` when ``result`` is not one."""
+    if not (result.is_error and result.content.startswith(INTERRUPTED)):
+        return None
+    return result.content.removeprefix(INTERRUPTED).removeprefix(_OUTPUT_SO_FAR)
+
+
+def answer_unanswered_calls(messages: Sequence[Message]) -> list[Message]:
+    """``messages`` with every tool call answered by the message after it.
+
+    The loop answers every call it starts, interrupted or not, so a request is
+    never built while a call waits. A transcript can still hold a call with no
+    result: written before the loop did that, or by a process killed mid-tool.
+    Every route rejects such a call - on every request after it, since it never
+    leaves the history - so the missing results are filled in as interrupted.
+    Only the request is repaired; the transcript on disk keeps what happened.
+    """
+    repaired: list[Message] = []
+    waiting: list[ToolUseBlock] = []
+    for message in [*messages, None]:
+        if waiting:
+            results = {r.tool_use_id: r for r in message.tool_results()} if message else {}
+            if any(call.id not in results for call in waiting):
+                answers = [results.get(c.id) or interrupted_result(c.id) for c in waiting]
+                ids = {call.id for call in waiting}
+                if message is not None and results:
+                    # Into the results already there: the calls stay answered
+                    # by one message, in the order they were made.
+                    rest = [
+                        b
+                        for b in message.content
+                        if not (isinstance(b, ToolResultBlock) and b.tool_use_id in ids)
+                    ]
+                    message = replace(message, content=[*answers, *rest])
+                else:
+                    repaired.append(tool_result_message(answers))
+        if message is None:
+            break
+        repaired.append(message)
+        waiting = message.tool_uses() if message.role == "assistant" else []
+    return repaired

{hx_cli-0.2.10 → 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.10 → 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.