soothe-cli 0.5.5__tar.gz → 0.5.7__tar.gz

{soothe_cli-0.5.5 → soothe_cli-0.5.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: soothe-cli
-Version: 0.5.5
+Version: 0.5.7
 Summary: Soothe CLI client - communicates with daemon via WebSocket
 Project-URL: Homepage, https://github.com/OpenSoothe/soothe
 Project-URL: Documentation, https://soothe.readthedocs.io

{soothe_cli-0.5.5 → soothe_cli-0.5.7}/src/soothe_cli/cli/execution/headless.py

@@ -59,7 +59,7 @@ def run_headless(
             import subprocess
 
             subprocess.Popen(
-                [sys.executable, "-m", "soothe.daemon", "--detached"],
+                [sys.executable, "-m", "soothe_daemon", "--detached"],
                 stdout=subprocess.DEVNULL,
                 stderr=subprocess.DEVNULL,
             )

{soothe_cli-0.5.5 → soothe_cli-0.5.7}/src/soothe_cli/shared/core/event_processor.py

@@ -229,7 +229,7 @@ class EventProcessor:
         """Headless stdout: only RFC-614 loop-tagged finals (IG-343 / IG-345).
 
         Suppresses unphased execute-wave narration on the main graph; ``goal_completion``,
-        ``chitchat``, etc. are routed via ``assistant_output_phase`` before this path.
+        ``quiz``, etc. are routed via ``assistant_output_phase`` before this path.
 
         Subgraph streams without RFC-614 phases are skipped in ``_handle_ai_message`` before
         this runs; loop-tagged subgraph finals use ``_dispatch_loop_tagged_assistant_text``.

{soothe_cli-0.5.5 → soothe_cli-0.5.7}/src/soothe_cli/shared/core/presentation_engine.py

@@ -49,7 +49,7 @@ class PresentationEngine:
 
     @property
     def final_answer_locked(self) -> bool:
-        """True after a custom final/chitchat response was emitted for this turn."""
+        """True after a custom final or quiz-phase response was emitted for this turn."""
         return self._state.final_answer_locked
 
     def mark_final_answer_locked(self) -> None:

{soothe_cli-0.5.5 → soothe_cli-0.5.7}/src/soothe_cli/tui/app/_execution.py

@@ -46,6 +46,19 @@ InputMode = Literal["normal", "shell", "command"]
 
 logger = logging.getLogger(__name__)
 
+# Partial match for daemon pool_runner RuntimeError when an OS worker exits mid-turn.
+_DAEMON_WORKER_SUBPROCESS_LOST = "Worker subprocess exited unexpectedly during query execution"
+
+
+def _friendly_agent_execution_error(exc: BaseException) -> str:
+    """Map known daemon failures to concise TUI copy."""
+    if isinstance(exc, RuntimeError) and _DAEMON_WORKER_SUBPROCESS_LOST in str(exc):
+        return (
+            "The daemon execution worker stopped unexpectedly (for example after the pool "
+            "recycled an idle subprocess). Send your message again."
+        )
+    return str(exc)
+
 
 class _ExecutionMixin:
     """Agent execution, message routing, queue, shell commands, and daemon events."""
@@ -859,13 +872,14 @@ class _ExecutionMixin:
             )
         except Exception as e:  # Resilient tool rendering
             logger.exception("Agent execution failed")
+            display_err = _friendly_agent_execution_error(e)
             # Ensure any in-flight tool calls don't remain stuck in "Running..."
             # when streaming aborts before tool results arrive.
             if self._ui_adapter:
-                self._ui_adapter.finalize_pending_tools_with_error(f"Agent error: {e}")
-                self._ui_adapter.finalize_pending_steps_with_error(f"Agent error: {e}")
+                self._ui_adapter.finalize_pending_tools_with_error(f"Agent error: {display_err}")
+                self._ui_adapter.finalize_pending_steps_with_error(f"Agent error: {display_err}")
             try:
-                await self._mount_message(ErrorMessage(f"Agent error: {e}"))
+                await self._mount_message(ErrorMessage(f"Agent error: {display_err}"))
             except Exception:
                 logger.debug("Could not mount error message (app closing?)", exc_info=True)
         finally:

{soothe_cli-0.5.5 → soothe_cli-0.5.7}/src/soothe_cli/tui/textual_adapter/_turn.py

@@ -841,7 +841,7 @@ async def execute_task_textual(
                             # Main graph: skip standalone AssistantMessage cards for
                             # intermediate AIMessage streams (execute_wave, unphased, etc.).
                             # ``goal_completion`` is handled above. Other RFC-614 user-output
-                            # phases (chitchat, quiz, autonomous_goal) still use cards.
+                            # phases (quiz, autonomous_goal) still use cards.
                             if (
                                 is_main_agent
                                 and assistant_output_phase(message)

{soothe_cli-0.5.5 → soothe_cli-0.5.7}/src/soothe_cli/tui/widgets/loading.py

@@ -137,7 +137,8 @@ class LoadingWidget(Static):
         now = monotonic()
         if self._turn_start_mono is None:
             self._turn_start_mono = now
-        self._animation_timer = self.set_interval(0.1, self._update_animation)
+        # Reduced from 0.1s (10fps) to 0.2s (5fps) to reduce UI thread contention
+        self._animation_timer = self.set_interval(0.2, self._update_animation)
 
     def on_unmount(self) -> None:
         """Stop the animation timer when the widget leaves the DOM."""
@@ -159,13 +160,20 @@ class LoadingWidget(Static):
             self._animation_timer = None
 
     def _update_animation(self) -> None:
-        """Update spinner and elapsed time."""
+        """Update spinner and elapsed time (optimized to reduce render overhead)."""
         if self._paused:
             return
 
+        # Skip update if widget is not visible on screen
+        if not self.is_on_screen:
+            return
+
         if self._spinner_widget:
             frame = self._spinner.next_frame()
-            self._spinner_widget.update(frame)
+            # Use refresh with layout=False to avoid expensive layout recalculation
+            self._spinner_widget._content = frame
+            self._spinner_widget._render_cache = None
+            self._spinner_widget.refresh(repaint=True, layout=False)
 
         if self._hint_widget and self._turn_start_mono is not None:
             now = monotonic()

{soothe_cli-0.5.5 → soothe_cli-0.5.7}/src/soothe_cli/tui/widgets/messages.py

@@ -59,7 +59,7 @@ _STEP_TOOL_PREVIEW_ROWS = STEP_TASK_CARD_COLLAPSE_LINE_THRESHOLD
 """Collapsed step/task activity preview shows this many rows (IG-402)."""
 
 _MAX_STEP_STAT_TOOL_KINDS = 4
-"""Max distinct tool display names in the step header before ``+N more``."""
+"""Max distinct tool display names in the running-line stats suffix before ``+N more``."""
 
 _RUNNING_SPINNER_INTERVAL_SECONDS = 0.2
 """Spinner/status animation cadence for running cards."""
@@ -711,6 +711,10 @@ class AssistantMessage(Vertical):
     }
     """
 
+    # Performance optimization: batch streaming updates to reduce render frequency
+    _STREAM_FLUSH_INTERVAL: float = 0.05  # 50ms batching for streaming
+    _VISIBILITY_REFRESH_INTERVAL: float = 0.1  # 100ms throttle for visibility refresh
+
     def __init__(self, content: str = "", **kwargs: Any) -> None:
         """Initialize an assistant message.
 
@@ -726,6 +730,11 @@ class AssistantMessage(Vertical):
         self._preview_widget: Static | None = None
         self._hint_widget: Static | None = None
 
+        # Batching buffer for streaming content
+        self._pending_buffer: str = ""
+        self._flush_timer: Timer | None = None
+        self._last_visibility_refresh: float = 0.0
+
     def compose(self) -> ComposeResult:  # noqa: PLR6301  # Textual widget method convention
         """Compose markdown body, plain preview, and expand hint."""
         from textual.widgets import Markdown
@@ -851,14 +860,50 @@ class AssistantMessage(Vertical):
         else:
             _show_timestamp_toast(self)
 
+    def _should_refresh_visibility(self) -> bool:
+        """Check if visibility refresh should run (throttled)."""
+        from time import monotonic
+
+        now = monotonic()
+        if now - self._last_visibility_refresh > self._VISIBILITY_REFRESH_INTERVAL:
+            self._last_visibility_refresh = now
+            return True
+        return False
+
+    async def _flush_pending_content(self) -> None:
+        """Flush buffered content to stream (batched update)."""
+        self._flush_timer = None
+        if not self._pending_buffer:
+            return
+
+        text = self._pending_buffer
+        self._pending_buffer = ""
+
+        stream = self._ensure_stream()
+        await stream.write(text)
+
+        # Throttle visibility refresh
+        if self._should_refresh_visibility():
+            self._refresh_body_visibility()
+
     async def append_content(self, text: str) -> None:
-        """Append content to the message (for streaming)."""
+        """Append content to the message (for streaming with batching).
+
+        Uses internal buffering to batch writes and reduce render frequency.
+        """
         if not text:
             return
+
+        # Accumulate content
         self._content += text
-        stream = self._ensure_stream()
-        self._refresh_body_visibility()
-        await stream.write(text)
+        self._pending_buffer += text
+
+        # Schedule batched flush if not already scheduled
+        if self._flush_timer is None:
+            self._flush_timer = self.set_timer(
+                self._STREAM_FLUSH_INTERVAL,
+                self._flush_pending_content,
+            )
 
     async def write_initial_content(self) -> None:
         """Write initial content from constructor and finalize the stream."""
@@ -869,6 +914,15 @@ class AssistantMessage(Vertical):
 
     async def stop_stream(self) -> None:
         """Stop the streaming and apply collapsed layout when appropriate."""
+        # Cancel any pending flush timer
+        if self._flush_timer is not None:
+            self._flush_timer.stop()
+            self._flush_timer = None
+
+        # Flush any remaining buffered content
+        if self._pending_buffer:
+            await self._flush_pending_content()
+
         if self._stream is not None:
             await self._stream.stop()
             self._stream = None
@@ -878,6 +932,7 @@ class AssistantMessage(Vertical):
         """Set the full message content (stops any active stream)."""
         await self.stop_stream()
         self._content = content
+        self._pending_buffer = ""  # Clear any pending buffer
         if self._markdown:
             await self._markdown.update(content)
         self._refresh_body_visibility()
@@ -2461,8 +2516,9 @@ class _StepToolRow:
 class CognitionStepMessage(Vertical):
     """Agent-loop act step card: aggregates main-agent tool calls (IG-402).
 
-    Header shows per-tool counts; body lists one CLI-style row per call. When
-    there are more than ``_STEP_TOOL_PREVIEW_ROWS`` rows, click first folds or
+    Header is the step description only; per-tool counts appear on the running
+    status line (and match the prior header format). Body lists one CLI-style row
+    per call. When there are more than ``_STEP_TOOL_PREVIEW_ROWS`` rows, click first folds or
     unfolds the tool list; otherwise click toggles whole-card collapse. When tool
     rows, subagent notes, and execute prose together exceed that same threshold,
     the card body auto-collapses until the user expands it (a new ``set_running``
@@ -2630,7 +2686,7 @@ class CognitionStepMessage(Vertical):
         return _assemble_card_header(
             self,
             "🚀 ",
-            f"{self._description}{self._stats_title_suffix()}",
+            self._description,
         )
 
     def compose(self) -> ComposeResult:
@@ -3169,7 +3225,8 @@ class CognitionStepMessage(Vertical):
         toggle_icon = ""
         if has_collapsible:
             toggle_icon = f" {g.expand if self._card_collapsed else g.collapse}"
-        line = f"{gutter}{frame} Running...{elapsed}{toggle_icon}"
+        stats_suffix = self._stats_title_suffix()
+        line = f"{gutter}{frame} Running...{elapsed}{stats_suffix}{toggle_icon}"
         self._status_widget.update(Content.styled(line, colors.cognition))
         now = monotonic()
         if any(r.phase == "running" for r in self._rows) and (