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

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

@@ -28,6 +28,20 @@ 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
@@ -901,7 +915,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.15...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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: hx-cli
-Version: 0.2.15
+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

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

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

{hx_cli-0.2.15 → 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.15 → 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.15 → 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.15 → 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.15 → 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.

{hx_cli-0.2.15 → hx_cli-0.2.16}/src/hx/tui/views/transcript.py

@@ -138,21 +138,25 @@ class WorkingIndicator:
     def running(self) -> bool:
         return self._running
 
-    def start(self) -> None:
+    def start(self, elapsed: float = 0.0) -> None:
+        """Show the status, ``elapsed`` seconds into the turn - not zero when it
+        comes back after an approval."""
         self._running = True
-        self._elapsed = 0.0
+        self._elapsed = elapsed
         self._paint()
 
     def stop(self) -> None:
         self._running = False
         self.target.set_status("")
 
-    def tick(self, elapsed: float) -> None:
+    def tick(self, elapsed: float) -> bool:
+        """Advance the spinner. Whether anything changed."""
         if not self._running:
-            return
+            return False
         self._frame = (self._frame + 1) % len(SPINNER)
         self._elapsed = elapsed
         self._paint()
+        return True
 
     def _paint(self) -> None:
         from hx.keys import primary_key

{hx_cli-0.2.15 → hx_cli-0.2.16}/tests/e2e/terminal.py

@@ -277,7 +277,11 @@ class Terminal:
             if test(screen):
                 # Matched mid-paint is not matched: a frame is often drawn in
                 # more than one write, so look again once HX has gone quiet.
-                self.settle(quiet=0.08, timeout=2)
+                # Quiet for less than a spinner frame (80ms): while a turn runs
+                # HX repaints every frame, and a longer wait is never met - it
+                # ran out its timeout, and a tool the test meant to catch
+                # running had finished by then.
+                self.settle(quiet=0.04, timeout=2)
                 screen = read()
                 if test(screen):
                     return screen

{hx_cli-0.2.15 → hx_cli-0.2.16}/tests/e2e/test_chat.py

@@ -120,8 +120,9 @@ def test_typing_while_busy_queues_the_message(hx: HX, stub: Stub) -> None:
     term.submit("first")
     term.wait_for("Working on")
     term.submit("second")
-    term.wait_for("second")
-    term.settle()
+    # Not settle(): the working status repaints every frame while the turn runs,
+    # so HX never goes quiet and a settle only ever ran out its timeout.
+    term.wait_for(lambda screen: "second" in screen and "⧗1 queued" in screen)
     term.snapshot("second message queued while the first runs")
     assert len(stub.requests) == 1
 

{hx_cli-0.2.15 → hx_cli-0.2.16}/tests/e2e/test_tools.py

@@ -3,9 +3,12 @@
 from __future__ import annotations
 
 import json
+import re
+import time
 
 from tests.e2e.conftest import HX
 from tests.e2e.stub import Stub, ToolCall, call, calls, say
+from tests.e2e.terminal import Terminal
 
 
 def test_write_asks_and_allow_once(hx: HX, stub: Stub) -> None:
@@ -52,6 +55,35 @@ def test_deny_tells_the_model(hx: HX, stub: Stub) -> None:
     assert stub.requests[1].tool_results()[0] == "Write was not permitted: the user declined"
 
 
+def test_a_denied_command_says_nothing_about_time(hx: HX, stub: Stub) -> None:
+    """A denied call never ran, so it has no "Took": the time the user spent deciding
+    is not the command's. The allowed call beside it still reports its own run."""
+    stub.script(
+        call("Bash", "First this.", command="touch denied.txt"),
+        call("Bash", "Then this.", command="touch allowed.txt && sleep 1"),
+        say("Done."),
+    )
+    term = hx.tui()
+    term.submit("make two files")
+    term.wait_for("Permission needed")
+    time.sleep(3)  # the user thinks about it
+    term.type("n")
+    term.wait_for(lambda screen: "Permission needed" in screen and "allowed.txt" in screen)
+    time.sleep(3)
+    term.type("y")
+    term.wait_for("Done.")
+    term.settle()
+    term.snapshot("one call denied, one allowed")
+
+    assert not (hx.project / "denied.txt").exists()
+    assert (hx.project / "allowed.txt").exists()
+    scrollback = term.scrollback()
+    denied = scrollback[scrollback.index("✗ $ touch denied.txt") : scrollback.index("Then this.")]
+    assert "Took" not in denied, denied
+    took = [float(seconds) for seconds in re.findall(r"Took ([\d.]+)s", scrollback)]
+    assert len(took) == 1 and 1 <= took[0] < 2, took
+
+
 def test_always_allow_is_remembered(hx: HX, stub: Stub) -> None:
     """`a` saves a rule under ~/.hx for this project, so the next session does not ask again."""
     target = hx.project / "notes.txt"
@@ -324,3 +356,86 @@ def test_glob_on_a_bare_directory_pattern_is_a_usable_error(hx: HX, stub: Stub)
     for answer in (dot, dot_slash, absolute):
         assert "Error" not in answer and "Unacceptable" not in answer
     assert "main.py" in real
+
+
+WORKING = re.compile(r"([⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏]) Working… \((\d+)s")
+
+
+def _working(screen: str) -> tuple[str, int] | None:
+    """The spinner frame and the seconds the working status shows, if it is shown."""
+    found = WORKING.search(screen)
+    return (found[1], int(found[2])) if found else None
+
+
+def _watch_working(term: Terminal, seconds: float) -> list[tuple[str, int]]:
+    """What the working status showed, sampled for ``seconds``."""
+    seen: list[tuple[str, int]] = []
+    deadline = time.monotonic() + seconds
+    while time.monotonic() < deadline:
+        if (state := _working(term.text())) is not None:
+            seen.append(state)
+        time.sleep(0.03)
+    return seen
+
+
+def test_working_status_animates_while_tools_run(hx: HX, stub: Stub) -> None:
+    """The working status moves for the whole turn: through each tool the model runs,
+    and through the command after an approval. It counts the turn's time, not the time
+    since the last model call. While the approval is open nothing spins, and the held
+    call's "Took" is its own run, not the user's time to decide. The status goes when
+    the turn ends, and a `!` command approved afterwards does not bring it back."""
+    stub.script(
+        call("Bash", "Looking first.", command="printf 'phase%s\\n' one && sleep 3"),
+        call(
+            "Bash",
+            "Now the change.",
+            command="touch made.txt && printf 'phase%s\\n' two && sleep 3",
+        ),
+        say("All done."),
+    )
+    term = hx.tui()
+    term.submit("look, then change it")
+
+    term.wait_for("phaseone")
+    term.snapshot("a read-only command runs")
+    during_read = _watch_working(term, 1.5)
+    assert during_read, "the working status is shown while the command runs"
+    assert len({frame for frame, _ in during_read}) >= 3, "and its spinner moves"
+    assert during_read[-1][1] >= 1, "and its clock counts"
+
+    screen = term.wait_for("Permission needed")
+    assert "? $ touch made.txt" in screen, "the held call is shown waiting, not running"
+    # Nothing is animating, so HX goes quiet - a spinner would keep painting.
+    started = time.monotonic()
+    term.settle(quiet=0.5, timeout=3)
+    assert time.monotonic() - started < 1.5, "HX keeps writing while nothing moves"
+    term.snapshot("an approval holds the turn")
+    assert _working(term.text()) is None, "nothing claims to be working while it waits"
+    still = term.text()
+    time.sleep(4)  # the user thinks about it
+    assert term.text() == still
+
+    term.type("y")
+    term.wait_for("phasetwo")
+    term.snapshot("the approved command runs")
+    during_change = _watch_working(term, 1.5)
+    assert during_change, "the working status comes back once the approval is answered"
+    assert len({frame for frame, _ in during_change}) >= 3, "and its spinner moves"
+    assert during_change[0][1] >= 7, "the clock is the turn's, not reset by each model call"
+
+    term.wait_for("All done.")
+    term.settle()
+    term.snapshot("the turn is over")
+    screen = term.text()
+    assert _working(screen) is None
+    assert (hx.project / "made.txt").exists()
+    took = [float(seconds) for seconds in re.findall(r"Took ([\d.]+)s", term.scrollback())]
+    assert len(took) == 2 and all(3 <= seconds < 4 for seconds in took), took
+
+    term.submit("!touch made-by-bang.txt")
+    term.wait_for("Permission needed")
+    term.type("y")
+    term.wait_for("allowed once")
+    term.settle(quiet=0.5)
+    term.snapshot("after an approved ! command")
+    assert "Working…" not in term.text(), "a shell line is not a turn"