hx-cli 0.2.14__tar.gz → 0.2.16__tar.gz

{hx_cli-0.2.14 → hx_cli-0.2.16}/CHANGELOG.md

@@ -28,6 +28,42 @@ the project follows [semantic versioning](https://semver.org/).
 
 ---
 
+## [0.2.16] - 2026-10-13
+
+### Fixed
+
+- The "Working…" status and the tool spinners now keep moving while a tool runs. They
+  used to vanish or freeze from the moment the model asked for a tool until its next reply,
+  so a long command looked like an idle session. The clock now counts the whole turn, not
+  only the time since the last model reply.
+- A tool call waiting on an approval shows `?` and does not spin, and its "Took" counts
+  only the run, not the time you spent deciding. A denied call never ran, so it shows no
+  "Took" at all.
+
+---
+
+## [0.2.15] - 2026-10-04
+
+### Changed
+
+- `/login` and `hx auth login` list the accounts as OpenAI, Claude, OpenRouter, Devin. At the
+  `hx auth login` menu, Enter still picks OpenRouter.
+
+### Fixed
+
+- `/login claude-code` behind a network whose TLS inspection signs with a certificate not
+  valid for servers ("unsupported certificate purpose") now gives Claude Code's reason and
+  the fix: have the network fixed or exempted, or set `HX_SSL_NO_VERIFY=1` meanwhile. It
+  used to give the whole sign-in URL and no fix. Turns and HX's own requests that fail the
+  same way give the same advice, not "add the CA", which is trusted already.
+- A `HX_CA_BUNDLE`, `SSL_CERT_FILE` or `REQUESTS_CA_BUNDLE` that names a file holding no
+  certificates no longer crashes HX at startup. HX says so and verifies against the system
+  trust store, and does not hand the file to Claude Code.
+- A wrapped error notice no longer shows a bright green background under every line after
+  the first.
+
+---
+
 ## [0.2.14] - 2026-10-04
 
 ### Added
@@ -879,7 +915,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.14...HEAD
+[Unreleased]: https://github.com/aletisunil/hx/compare/v0.2.16...HEAD
+[0.2.16]: https://github.com/aletisunil/hx/compare/v0.2.15...v0.2.16
+[0.2.15]: https://github.com/aletisunil/hx/compare/v0.2.14...v0.2.15
 [0.2.14]: https://github.com/aletisunil/hx/compare/v0.2.13...v0.2.14
 [0.2.13]: https://github.com/aletisunil/hx/compare/v0.2.12...v0.2.13
 [0.2.12]: https://github.com/aletisunil/hx/compare/v0.2.11...v0.2.12

{hx_cli-0.2.14 → hx_cli-0.2.16}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: hx-cli
-Version: 0.2.14
+Version: 0.2.16
 Summary: HX - an agent harness for the terminal
 Project-URL: Homepage, https://hx.sunilaleti.dev
 Project-URL: Documentation, https://hx.sunilaleti.dev
@@ -335,7 +335,13 @@ export HX_CA_BUNDLE=/path/to/corp-ca.pem   # SSL_CERT_FILE and REQUESTS_CA_BUNDL
 `HX_SSL_NO_VERIFY=1` turns verification off entirely; it prints a warning at
 startup every session, because it is not a fix. A TLS failure is reported in
 one line - `/model` and the startup notice both name the certificate problem
-rather than reporting an empty catalogue with no cause.
+rather than reporting an empty catalogue with no cause. A file that holds no
+certificates is ignored, with a startup notice that says so.
+
+"Unsupported certificate purpose" (or "unsuitable") is different: the CA is
+trusted, but the proxy signs with a certificate that is not valid for servers,
+so no CA setting fixes it. The network has to fix that certificate or exempt
+the service from inspection; until then only `HX_SSL_NO_VERIFY=1` gets through.
 
 The same settings cover the `claude-code` route, whose requests Claude Code
 makes with its own TLS stack: HX passes `HX_CA_BUNDLE` on to it as

{hx_cli-0.2.14 → hx_cli-0.2.16}/README.md

@@ -294,7 +294,13 @@ export HX_CA_BUNDLE=/path/to/corp-ca.pem   # SSL_CERT_FILE and REQUESTS_CA_BUNDL
 `HX_SSL_NO_VERIFY=1` turns verification off entirely; it prints a warning at
 startup every session, because it is not a fix. A TLS failure is reported in
 one line - `/model` and the startup notice both name the certificate problem
-rather than reporting an empty catalogue with no cause.
+rather than reporting an empty catalogue with no cause. A file that holds no
+certificates is ignored, with a startup notice that says so.
+
+"Unsupported certificate purpose" (or "unsuitable") is different: the CA is
+trusted, but the proxy signs with a certificate that is not valid for servers,
+so no CA setting fixes it. The network has to fix that certificate or exempt
+the service from inspection; until then only `HX_SSL_NO_VERIFY=1` gets through.
 
 The same settings cover the `claude-code` route, whose requests Claude Code
 makes with its own TLS stack: HX passes `HX_CA_BUNDLE` on to it as

{hx_cli-0.2.14 → hx_cli-0.2.16}/src/hx/__init__.py

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

{hx_cli-0.2.14 → hx_cli-0.2.16}/src/hx/auth/claude_code.py

@@ -290,6 +290,22 @@ def login_terminal() -> int:
 
 
 _URL = re.compile(r"https://\S+")
+_PASTE_PROMPT = re.compile(r"^.*Paste code[^>]*>\s*")
+_FAILED = re.compile(r"^Login failed:\s*", re.IGNORECASE)
+
+
+def _failure(output: list[str]) -> str | None:
+    """Why ``claude auth login`` failed: its last line of its own, ``unsupported
+    certificate purpose`` from ``Login failed: unsupported certificate purpose``.
+
+    Not the URL it printed before - the screen already showed that, and it is
+    wider than the notice - nor the paste prompt the reason is printed after.
+    """
+    for line in reversed(output):
+        line = _FAILED.sub("", _PASTE_PROMPT.sub("", line)).strip()
+        if line and not _URL.search(line):
+            return line
+    return None
 
 
 class LoginFailed(Exception):
@@ -361,8 +377,8 @@ async def login_interactive(interaction: LoginInteraction) -> LoginStatus:
     forget_status()
 
     if code != 0:
-        tail = " ".join(line.strip() for line in output[-3:] if line.strip())
-        raise LoginFailed(f"`claude auth login` failed: {tail or f'exit {code}'}")
+        reason = _failure(output) or f"exit {code}"
+        raise LoginFailed(net.with_tls_hint(f"`claude auth login` failed: {reason}"))
     current = await status_async(fresh=True)
     if current is None or not current.logged_in:
         raise LoginFailed("Claude Code still reports no login.")

{hx_cli-0.2.14 → hx_cli-0.2.16}/src/hx/cli.py

@@ -1432,8 +1432,10 @@ def _choose_provider() -> str:
     print("Sign in to:")
     for index, spec in enumerate(registry.SPECS, start=1):
         print(f"  {index}  {spec.label}")
+    # Enter still means OpenRouter, wherever it sits in the list.
+    default = str(next(i for i, s in enumerate(registry.SPECS, start=1) if s.id == OPENROUTER))
     try:
-        choice = input("Choice [1]: ").strip() or "1"
+        choice = input(f"Choice [{default}]: ").strip() or default
     except (EOFError, KeyboardInterrupt):
         print()
         return OPENROUTER

{hx_cli-0.2.14 → hx_cli-0.2.16}/src/hx/core/loop.py

@@ -75,6 +75,30 @@ class _Steered(Exception):
     """Internal: this stream was cancelled to deliver a steer, not to stop."""
 
 
+class _Stopwatch:
+    """How long one tool call has run, for its "Took".
+
+    Started once the call is cleared to run, and zero until then. The time a
+    person spent on an approval is not the tool's: a three-second command
+    answered after a minute's thought said it took a minute, and a denied one
+    that never ran said it took as long as the user took to say no.
+    """
+
+    __slots__ = ("_started",)
+
+    def __init__(self) -> None:
+        self._started: float | None = None
+
+    def start(self) -> None:
+        self._started = time.monotonic()
+
+    @property
+    def ms(self) -> float:
+        if self._started is None:
+            return 0.0
+        return (time.monotonic() - self._started) * 1000
+
+
 @dataclass(slots=True)
 class TurnResult:
     stop_reason: StopReason
@@ -712,7 +736,7 @@ class AgentLoop:
         self, call: ToolUseBlock, results: dict[str, ToolResultBlock]
     ) -> ToolResultBlock:
         """Run one call. Interrupted, it leaves its answer in ``results``."""
-        started = time.monotonic()
+        clock = _Stopwatch()
 
         # PreToolUse runs before the call is announced. A hook that rewrites the
         # input must not leave the transcript showing a command that never ran,
@@ -730,7 +754,7 @@ class AgentLoop:
         )
         streamed: list[str] = []
         try:
-            return await self._run_announced(call, pre, started, streamed, results)
+            return await self._run_announced(call, pre, clock, streamed, results)
         except asyncio.CancelledError:
             if call.id in results:
                 # The tool had finished and only its hooks were cut off.
@@ -743,7 +767,7 @@ class AgentLoop:
                 ToolCallFinished(
                     tool_use_id=call.id,
                     is_error=True,
-                    duration_ms=(time.monotonic() - started) * 1000,
+                    duration_ms=clock.ms,
                     summary="interrupted",
                     interrupted=True,
                 )
@@ -754,7 +778,7 @@ class AgentLoop:
         self,
         call: ToolUseBlock,
         pre: HookOutcome,
-        started: float,
+        clock: _Stopwatch,
         streamed: list[str],
         results: dict[str, ToolResultBlock],
     ) -> ToolResultBlock:
@@ -772,7 +796,7 @@ class AgentLoop:
                 ToolCallFinished(
                     tool_use_id=call.id,
                     is_error=True,
-                    duration_ms=(time.monotonic() - started) * 1000,
+                    duration_ms=clock.ms,
                     summary="blocked by hook",
                     detail=refusal.content,
                 )
@@ -785,12 +809,13 @@ class AgentLoop:
                 ToolCallFinished(
                     tool_use_id=call.id,
                     is_error=True,
-                    duration_ms=(time.monotonic() - started) * 1000,
+                    duration_ms=clock.ms,
                     summary="denied",
                     detail=denied.content,
                 )
             )
             return denied
+        clock.start()
 
         def progress(chunk: str) -> None:
             streamed.append(chunk)
@@ -812,12 +837,12 @@ class AgentLoop:
         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)
+            results[call.id] = self._finish(call, result, HookOutcome(), clock)
             raise
-        return self._finish(call, result, post, started)
+        return self._finish(call, result, post, clock)
 
     def _finish(
-        self, call: ToolUseBlock, result: ToolResult, post: HookOutcome, started: float
+        self, call: ToolUseBlock, result: ToolResult, post: HookOutcome, clock: _Stopwatch
     ) -> ToolResultBlock:
         """Announce a call the tool finished, and its result for the model."""
         content = result.content
@@ -830,7 +855,7 @@ class AgentLoop:
             ToolCallFinished(
                 tool_use_id=call.id,
                 is_error=result.is_error or post.blocked,
-                duration_ms=(time.monotonic() - started) * 1000,
+                duration_ms=clock.ms,
                 summary=result.summary or ("error" if result.is_error else "done"),
                 detail=content if result.is_error or post.blocked else "",
                 metadata=dict(result.metadata),
@@ -863,6 +888,7 @@ class AgentLoop:
             detail=detail,
             detail_kind=detail_kind,
             origin=self.origin,
+            tool_use_id=call.id,
         )
         allowed, reason = await self.permissions.request(
             request, on_ask=lambda: self._announce_ask(call.id, request)

{hx_cli-0.2.14 → hx_cli-0.2.16}/src/hx/net.py

@@ -41,11 +41,38 @@ _TRUTHY = frozenset({"1", "true", "yes", "on"})
 
 
 def ca_bundle() -> Path | None:
-    """The CA bundle the environment names, if it points at a real file."""
+    """The CA bundle the environment names, if it points at a file of certificates."""
+    named = _named_bundle()
+    if named is None or _load_error(named[1]) is not None:
+        return None
+    return named[1]
+
+
+def _named_bundle() -> tuple[str, Path] | None:
+    """The first of :data:`CA_BUNDLE_VARS` that names a real file, and that file."""
     for name in CA_BUNDLE_VARS:
         raw = (os.environ.get(name) or "").strip()
         if raw and Path(raw).expanduser().is_file():
-            return Path(raw).expanduser()
+            return name, Path(raw).expanduser()
+    return None
+
+
+def _load_error(path: Path) -> str | None:
+    """Why ``path`` cannot serve as a CA bundle - a DER file, a key, an empty
+    file - or ``None`` when it can. Asked again only when the file changes."""
+    try:
+        stat = path.stat()
+    except OSError as exc:
+        return exc.strerror or str(exc)
+    return _load_error_of(path, stat.st_mtime_ns, stat.st_size)
+
+
+@lru_cache(maxsize=4)
+def _load_error_of(path: Path, mtime_ns: int, size: int) -> str | None:
+    try:
+        ssl.create_default_context(cafile=str(path))
+    except (ssl.SSLError, OSError, ValueError) as exc:
+        return _flatten(getattr(exc, "reason", None) or str(exc))
     return None
 
 
@@ -80,6 +107,15 @@ def tls_notice() -> str | None:
     """One line for the startup transcript when TLS is not stock."""
     if verification_disabled():
         return f"{NO_VERIFY_VAR} is set: TLS certificates are not being verified."
+    named = _named_bundle()
+    if named is not None and (error := _load_error(named[1])) is not None:
+        # Ignored, as OpenSSL and Node ignore a CA file they cannot read: failing
+        # to start would cost every route, the ones this file is not for too.
+        name, path = named
+        return (
+            f"{name} names {path}, which holds no usable CA certificates ({error}). "
+            f"Verifying TLS against the system trust store instead."
+        )
     bundle = ca_bundle()
     return f"Verifying TLS against {bundle}." if bundle is not None else None
 
@@ -108,13 +144,29 @@ _CERT_FAILURE = re.compile(
     r"certificate verif"
     r"|self[- ]signed certificate"
     r"|unable to (?:get local issuer|verify the first) certificate"
-    r"|UNABLE_TO_VERIFY_LEAF_SIGNATURE|UNABLE_TO_GET_ISSUER_CERT|SELF_SIGNED_CERT_IN_CHAIN",
+    r"|UNABLE_TO_VERIFY_LEAF_SIGNATURE|UNABLE_TO_GET_ISSUER_CERT|SELF_SIGNED_CERT_IN_CHAIN"
+    r"|certificate purpose|INVALID_PURPOSE",
     re.IGNORECASE,
 )
 
+_WRONG_PURPOSE = re.compile(r"(?:unsupported|unsuitable) certificate purpose|INVALID_PURPOSE")
+"""A chain the client does trust, but with a certificate in it - typically the
+issuing CA of a network that intercepts TLS - that may not serve as a TLS
+server's: OpenSSL says "unsuitable", the BoringSSL in Claude Code "unsupported"."""
+
 
-def tls_hint() -> str:
-    """What to do about a certificate the client would not trust."""
+def tls_hint(reason: str = "") -> str:
+    """What to do about a certificate the client would not accept.
+
+    ``reason`` is the client's own words, when there are any: a certificate of
+    the wrong purpose is already trusted, so adding its CA again changes nothing.
+    """
+    if _WRONG_PURPOSE.search(reason):
+        return (
+            "Your network intercepts TLS with a certificate that is not valid for servers. "
+            "Ask its administrator to fix that certificate or to exclude this service from "
+            f"inspection; until then, {NO_VERIFY_VAR}=1 turns verification off."
+        )
     bundle = ca_bundle()
     if bundle is not None:
         return (
@@ -130,7 +182,7 @@ def tls_hint() -> str:
 def with_tls_hint(message: str) -> str:
     """``message``, followed by :func:`tls_hint` when it reports a certificate
     failure - in any client's words: OpenSSL's, Node's, Claude Code's."""
-    hint = tls_hint()
+    hint = tls_hint(message)
     if not _CERT_FAILURE.search(message) or hint in message:
         return message
     return f"{message.rstrip().rstrip('.')}. {hint}"
@@ -156,7 +208,8 @@ def describe(exc: BaseException) -> str:
                 or getattr(err, "reason", None)
                 or "certificate verify failed"
             )
-            return f"TLS certificate verification failed ({_flatten(reason)}). {tls_hint()}"
+            reason = _flatten(reason)
+            return f"TLS certificate verification failed ({reason}). {tls_hint(reason)}"
         if isinstance(err, ssl.SSLError):
             return f"TLS handshake failed: {_flatten(err.reason or str(err))}."
     if isinstance(exc, httpx.TimeoutException):

{hx_cli-0.2.14 → hx_cli-0.2.16}/src/hx/permissions/engine.py

@@ -78,6 +78,9 @@ class PermissionRequest:
     """
     origin: str | None = None
     """Which subagent asked, when it was not the main conversation."""
+    tool_use_id: str | None = None
+    """The call waiting on this, so the UI can show that call as waiting
+    rather than running. None for a request no tool call made - a `!` line."""
 
     def all_specifiers(self) -> tuple[str, ...]:
         """Everything a rule has to be matched against for this one call."""

{hx_cli-0.2.14 → hx_cli-0.2.16}/src/hx/providers/registry.py

@@ -145,13 +145,7 @@ def _build_claude_code(
 
 
 SPECS: tuple[ProviderSpec, ...] = (
-    ProviderSpec(
-        id=OPENROUTER,
-        label="OpenRouter API key",
-        kind=AuthKind.API_KEY,
-        namespace=None,
-        build=_build_openrouter,
-    ),
+    # In the order /login and `hx auth login` offer them.
     ProviderSpec(
         id=CODEX,
         label="OpenAI (ChatGPT Plus/Pro)",
@@ -159,13 +153,6 @@ SPECS: tuple[ProviderSpec, ...] = (
         namespace=f"{CODEX}/",
         build=_build_codex,
     ),
-    ProviderSpec(
-        id=DEVIN,
-        label="Devin (personal or Enterprise)",
-        kind=AuthKind.SUBSCRIPTION,
-        namespace=f"{DEVIN}/",
-        build=_build_devin,
-    ),
     ProviderSpec(
         id=CLAUDE_CODE,
         label="Claude (Pro/Max, via Claude Code)",
@@ -173,6 +160,20 @@ SPECS: tuple[ProviderSpec, ...] = (
         namespace=f"{CLAUDE_CODE}/",
         build=_build_claude_code,
     ),
+    ProviderSpec(
+        id=OPENROUTER,
+        label="OpenRouter API key",
+        kind=AuthKind.API_KEY,
+        namespace=None,
+        build=_build_openrouter,
+    ),
+    ProviderSpec(
+        id=DEVIN,
+        label="Devin (personal or Enterprise)",
+        kind=AuthKind.SUBSCRIPTION,
+        namespace=f"{DEVIN}/",
+        build=_build_devin,
+    ),
 )
 
 BY_ID: dict[str, ProviderSpec] = {spec.id: spec for spec in SPECS}

{hx_cli-0.2.14 → hx_cli-0.2.16}/src/hx/term/ansi.py

@@ -266,6 +266,13 @@ def active_background(text: str) -> str:
                     # Truncated. Nothing legible to re-open, and consuming the
                     # rest would be a guess at parameters that never arrived.
                     break
+            elif code == 38 and index + 1 < len(codes):
+                # A foreground's parameters are not codes: the 102 of
+                # 38;2;204;102;102 would otherwise open a bright green 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
+                index += span - 1
             index += 1
     return current
 

{hx_cli-0.2.14 → hx_cli-0.2.16}/src/hx/tui/glyphs.py

@@ -18,6 +18,10 @@ TOOL_DONE = "●"
 TOOL_FAILED = "✗"
 """A tool call failed, or a notice reports an error."""
 
+TOOL_AWAITING = "?"
+"""A tool call held at an approval. Not the spinner: nothing is running until
+the user answers, and a spinner says something is."""
+
 TODO_PENDING = "○"
 """A todo not started. Only that - a running tool uses the spinner."""
 

{hx_cli-0.2.14 → hx_cli-0.2.16}/src/hx/tui/runtime.py

@@ -122,6 +122,10 @@ class HXSession:
         )
 
         self._tools: dict[str, ToolBlock] = {}
+        self._awaiting: set[str] = set()
+        """Calls held at an approval. Kept by id rather than set on the block,
+        because the approval is asked before ``ToolCallStarted`` comes off the
+        bus and the block that will show the call does not exist yet."""
         self._pending: list[PermissionPrompt] = []
         """Approvals waiting on the user, oldest first.
 
@@ -204,10 +208,13 @@ class HXSession:
             if not self._turn_started:
                 continue
             elapsed = time.monotonic() - self._turn_started
-            self.view.dock.working.tick(elapsed)
+            # A frame only when something moved. Held at an approval nothing
+            # does, and a frame per tick then is output for its own sake.
+            moved = self.view.dock.working.tick(elapsed)
             for block in self._tools.values():
-                block.tick()
-            self.runner.request_render()
+                moved = block.tick() or moved
+            if moved:
+                self.runner.request_render()
 
     async def _watch_branch(self) -> None:
         """Keep the branch in the status bar current across external checkouts."""
@@ -876,6 +883,8 @@ class HXSession:
         )
         self.view.transcript.append(prompt)
         self._pending.append(prompt)
+        call_id = getattr(request, "tool_use_id", None)
+        self._hold_call(call_id, held=True)
         self._keyboard_owner()
         # The turn is blocked on a person, so the indicator must stop claiming
         # the tool is running.
@@ -892,15 +901,28 @@ class HXSession:
         finally:
             if prompt in self._pending:
                 self._pending.remove(prompt)
+            self._hold_call(call_id, held=False)
             # Hands the keyboard to whoever is next, so the block below stops
             # saying it is waiting the moment this one is answered.
             self._keyboard_owner()
             # Only the last one out hands the indicator back: with another
-            # approval still open the turn is still blocked on a person.
-            if not self._pending:
-                self.view.dock.working.start()
+            # approval still open the turn is still blocked on a person. And
+            # only to a turn: a `!` line asks here too, with nothing running.
+            if not self._pending and self._turn_started:
+                self.view.dock.working.start(time.monotonic() - self._turn_started)
             self.runner.request_immediate_render()
 
+    def _hold_call(self, tool_use_id: str | None, *, held: bool) -> None:
+        """Show a call as waiting on its approval, or as running again."""
+        if tool_use_id is None:
+            return
+        if held:
+            self._awaiting.add(tool_use_id)
+        else:
+            self._awaiting.discard(tool_use_id)
+        if (block := self._tools.get(tool_use_id)) is not None:
+            block.set_awaiting(held)
+
     def _keyboard_owner(self) -> PermissionPrompt | None:
         """The oldest approval still waiting on an answer.
 
@@ -1243,6 +1265,15 @@ class HXSession:
         self.runner.request_immediate_render()
 
     async def _run_turn(self, text: str, images: Sequence[ImageBlock] = ()) -> None:
+        # Working from here to the end of the task, not from TurnStarted to
+        # TurnFinished: the loop publishes that pair around each model call, and
+        # the tools between two calls are the turn too. Driven by the events,
+        # the status went the moment the model asked for a tool, every spinner
+        # froze while the tool ran, and the clock restarted at the next call.
+        self._turn_started = time.monotonic()
+        self.view.dock.working.start()
+        self.prompt.set_running(True, enter_steers=self._enter_steers)
+        self.runner.request_immediate_render()
         try:
             await self.loop.run(text, images)
         except asyncio.CancelledError:
@@ -1262,6 +1293,7 @@ class HXSession:
         finally:
             self._turn_started = 0.0
             self.view.dock.working.stop()
+            self.prompt.set_running(False)
             self.runner.request_immediate_render()
 
         # Only on a turn that ended on its own: an interrupt re-raises above
@@ -1277,16 +1309,14 @@ class HXSession:
     async def _consume_events(self) -> None:
         transcript = self.view.transcript
         status = self.view.dock.status
-        working = self.view.dock.working
 
         async for event in self.bus.subscribe():
             match event:
                 case ev.TurnStarted():
+                    # One model call, not the user's turn: the working status
+                    # belongs to ``_run_turn``. A new call starts new blocks.
                     self._assistant = None
                     self._thinking = None
-                    self._turn_started = time.monotonic()
-                    working.start()
-                    self.prompt.set_running(True, enter_steers=self._enter_steers)
                 case ev.TextDelta():
                     if self._assistant is None:
                         self._assistant = AssistantMessage()
@@ -1306,6 +1336,7 @@ class HXSession:
                         )
                     )
                     self._tools[event.tool_use_id] = started
+                    started.set_awaiting(event.tool_use_id in self._awaiting)
                     # A silent tool is held back rather than dropped: it is
                     # silent because something else draws its result, and if it
                     # fails there is no result and nothing else to draw. The
@@ -1368,10 +1399,6 @@ class HXSession:
                     )
                 case ev.ErrorRaised():
                     self._notice(event.message, "error")
-                case ev.TurnFinished():
-                    self._turn_started = 0.0
-                    working.stop()
-                    self.prompt.set_running(False)
 
             self.runner.request_render()
 

{hx_cli-0.2.14 → hx_cli-0.2.16}/src/hx/tui/views/blocks.py

@@ -20,7 +20,7 @@ from hx.term.component import Widget
 from hx.term.markdown import render_markdown
 from hx.term.primitives import Box, HangingText, Lines
 from hx.term.sanitize import plain_text
-from hx.tui.glyphs import IMAGE, NOTICE, SPINNER, TOOL_DONE, TOOL_FAILED
+from hx.tui.glyphs import IMAGE, NOTICE, SPINNER, TOOL_AWAITING, TOOL_DONE, TOOL_FAILED
 from hx.tui.limits import PREVIEW_LINES, STREAM_TAIL
 from hx.tui.paint import ThemePainter, fg, tint
 from hx.tui.renderers import (
@@ -163,7 +163,7 @@ class ToolBlock(Widget):
     for the red one without reading any of it.
     """
 
-    __slots__ = ("_call", "_frame", "_stream", "_stream_dirty", "_streamed")
+    __slots__ = ("_awaiting", "_call", "_frame", "_stream", "_stream_dirty", "_streamed")
 
     def __init__(self, call: ToolCall) -> None:
         super().__init__()
@@ -173,6 +173,8 @@ class ToolBlock(Widget):
         """What the tool has streamed, raw; the output is its sanitized form."""
         self._streamed = 0
         self._stream_dirty = False
+        self._awaiting = False
+        """Held at an approval: not running yet, so it does not spin."""
 
     @property
     def call(self) -> ToolCall:
@@ -230,10 +232,18 @@ class ToolBlock(Widget):
         self._stream, self._streamed, self._stream_dirty = [raw], len(raw), False
         self._call = replace(self._call, output=plain_text(raw))
 
-    def tick(self) -> None:
-        """Advance the spinner. Only meaningful while the call is running."""
-        if not self._call.finished:
-            self._frame = (self._frame + 1) % len(SPINNER)
+    def tick(self) -> bool:
+        """Advance the spinner while the call runs. Whether anything changed."""
+        if self._call.finished or self._awaiting:
+            return False
+        self._frame = (self._frame + 1) % len(SPINNER)
+        self.invalidate()
+        return True
+
+    def set_awaiting(self, awaiting: bool) -> None:
+        """Whether the call is held at an approval rather than running."""
+        if awaiting != self._awaiting:
+            self._awaiting = awaiting
             self.invalidate()
 
     def toggle(self) -> None:
@@ -242,7 +252,7 @@ class ToolBlock(Widget):
     @property
     def _state(self) -> str:
         if not self._call.finished:
-            return "running"
+            return "awaiting" if self._awaiting else "running"
         if self._call.interrupted:
             return "interrupted"
         return "error" if self._call.is_error else "done"
@@ -252,6 +262,7 @@ class ToolBlock(Widget):
         state = self._state
         marker, marker_role, background = {
             "running": (SPINNER[self._frame], "accent", "tool_pending_bg"),
+            "awaiting": (TOOL_AWAITING, "warning", "tool_pending_bg"),
             "done": (TOOL_DONE, "success", "tool_success_bg"),
             "error": (TOOL_FAILED, "error", "tool_error_bg"),
             # Stopped, not failed: the warning the "Interrupted" line is drawn in.