soothe-cli 0.6.13__tar.gz → 0.6.15__tar.gz

{soothe_cli-0.6.13 → soothe_cli-0.6.15}/PKG-INFO

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

{soothe_cli-0.6.13 → soothe_cli-0.6.15}/src/soothe_cli/tui/textual_adapter.py

@@ -119,6 +119,9 @@ from soothe_cli.tui.widgets.messages import (
 
 logger = logging.getLogger(__name__)
 
+# IG-504: LLM retry event type for step card status display
+LLM_RETRY_ATTEMPT = "soothe.cognition.llm.retry.attempt"
+
 # ---------------------------------------------------------------------------
 # Adapter core
 # ---------------------------------------------------------------------------
@@ -2793,12 +2796,37 @@ async def execute_task_textual(
                                             )
                                     continue
 
+                            # IG-504: Handle LLM retry events for step card status display
+                            if event_type == LLM_RETRY_ATTEMPT:
+                                # Find the running step card for this thread and update retry status
+                                attempt = int(data.get("attempt", 0))
+                                max_attempts = int(data.get("max_attempts", 0))
+                                error_type = str(data.get("error_type", "timeout"))
+                                # Try to find a running step card via namespace or active steps
+                                widget = None
+                                if ns_key:
+                                    widget = adapter._step_by_namespace.get(ns_key)
+                                if widget is None:
+                                    # Fallback: find any running step in current step messages
+                                    for step_widget in adapter._current_step_messages.values():
+                                        if step_widget._status == "running":  # noqa: SLF001
+                                            widget = step_widget
+                                            break
+                                if widget is not None:
+                                    widget.set_retry_status(attempt, max_attempts, error_type)
+                                continue
+
                             if event_type == LOOP_REASON_EVENT_TYPE:
                                 assessment_reasoning = str(
                                     data.get("assessment_reasoning", "")
                                 ).strip()
                                 plan_reasoning = str(data.get("plan_reasoning", "")).strip()
-                                if not assessment_reasoning and not plan_reasoning:
+                                next_action = str(data.get("next_action", "")).strip()
+                                if (
+                                    not assessment_reasoning
+                                    and not plan_reasoning
+                                    and not next_action
+                                ):
                                     continue
                                 pending_text = pending_text_by_namespace.get(ns_key, "")
                                 if pending_text:
@@ -2814,7 +2842,7 @@ async def execute_task_textual(
                                 pa_raw = data.get("plan_action", "")
                                 plan_action = pa_raw if pa_raw in ("keep", "new") else ""
                                 plan_widget = CognitionReasonMessage(
-                                    next_action="",
+                                    next_action=next_action,
                                     status=str(data.get("status", "")),
                                     iteration=int(data.get("iteration", 0)),
                                     plan_action=str(plan_action),

{soothe_cli-0.6.13 → soothe_cli-0.6.15}/src/soothe_cli/tui/widgets/messages.py

@@ -1303,6 +1303,10 @@ class CognitionStepMessage(Vertical):
         self._last_tool_call_count: int = 0
         self._last_summary: str = ""
         self._input_tokens: int = 0
+        # IG-504: Retry tracking for running status display
+        self._retry_attempt: int = 0
+        self._max_retry_attempts: int = 0
+        self._retry_error_type: str | None = None
         self._output_tokens: int = 0
         self._interrupt_message: str | None = None
         self._deferred_interrupted: str | None = None
@@ -2856,14 +2860,53 @@ class CognitionStepMessage(Vertical):
         self._refresh_tools_display()
 
     def _sync_running_status_line(self) -> None:
-        """Refresh status text when tool stats change without repainting tool rows."""
+        """Refresh status text when tool stats change without repainting tool rows.
+
+        This method is called when tool calls arrive during a running step,
+        so it updates the status line immediately (without visibility check)
+        to show the tool count in real-time.
+        """
         if self._status == "running":
-            self._update_running_animation()
+            self._sync_running_status_text()
         elif self._status == "queued":
             self._refresh_queued_display()
         elif self._status == "pending":
             self._refresh_pending_display()
 
+    def _sync_running_status_text(self) -> None:
+        """Update running status line text immediately (no visibility check).
+
+        Called when tool stats change during running state to show tool count
+        in real-time, bypassing the animation visibility check that would
+        prevent updates for newly-mounted or off-screen widgets.
+        """
+        if self._status != "running" or self._status_widget is None:
+            return
+        frames = get_glyphs().spinner_frames
+        frame = frames[self._spinner_position]
+        elapsed = ""
+        if self._start_time is not None:
+            elapsed_secs = int(time() - self._start_time)
+            elapsed = f" ({format_duration(float(elapsed_secs))})"
+        try:
+            colors = theme.get_theme_colors(self)
+        except Exception:  # noqa: BLE001
+            colors = theme.DARK_COLORS
+        gutter = f"{get_glyphs().output_prefix} "
+        stats_suffix = self._stats_title_suffix()
+        token_suffix = self._token_budget_suffix()
+        # IG-504: Show retry count in running status when retries are happening
+        retry_suffix = ""
+        if self._retry_attempt > 0 and self._max_retry_attempts > 0:
+            retry_suffix = f" ({self._retry_attempt}/{self._max_retry_attempts} attempts)"
+        head = f"{gutter}{frame} Running{retry_suffix}...{elapsed}"
+        tail = f"{stats_suffix}{token_suffix}"
+        clear_widget_text_selection(self._status_widget)
+        parts: list[object] = [Content.styled(head, colors.warning)]
+        if tail:
+            parts.append(Content.styled(tail, colors.cognition))
+        self._status_widget.update(Content.assemble(*parts))
+
     def _refresh_pending_display(self) -> None:
         """Show waiting state for planned steps that are not executing yet."""
         if self._status != "pending" or self._status_widget is None:
@@ -2918,7 +2961,9 @@ class CognitionStepMessage(Vertical):
             self._status_widget.remove_class("pending")
             self._status_widget.remove_class("queued")
             self._status_widget.display = True
-        self._update_running_animation()
+        # Immediate status line update (bypasses visibility check) so tool count
+        # appears in real-time when tools arrive before the animation timer fires.
+        self._sync_running_status_text()
         self._refresh_task_activity_display()
         self._animation_timer = self.set_interval(
             _RUNNING_SPINNER_INTERVAL_SECONDS,
@@ -2930,29 +2975,38 @@ class CognitionStepMessage(Vertical):
             self._animation_timer.stop()
             self._animation_timer = None
 
+    def set_retry_status(self, attempt: int, max_attempts: int, error_type: str) -> None:
+        """IG-504: Update retry status for running animation display.
+
+        Args:
+            attempt: Current attempt number (1-indexed).
+            max_attempts: Maximum attempts allowed.
+            error_type: "timeout" or "rate_limit".
+        """
+        self._retry_attempt = attempt
+        self._max_retry_attempts = max_attempts
+        self._retry_error_type = error_type
+        # Trigger immediate refresh of running status (bypass visibility check)
+        if self._status == "running":
+            self._sync_running_status_text()
+
     def _update_running_animation(self) -> None:
+        """Animation timer callback: advance spinner and update status line.
+
+        The visibility check here is for efficiency - skipping expensive
+        re-renders when the widget is off-screen. For immediate tool-stats
+        updates (called when tool calls arrive), use `_sync_running_status_text`
+        which bypasses this check.
+        """
         if self._status != "running" or self._status_widget is None:
             return
         if not _is_widget_animation_visible(self):
             return
+        # Advance spinner position for animation effect
         frames = get_glyphs().spinner_frames
-        frame = frames[self._spinner_position]
         self._spinner_position = (self._spinner_position + 1) % len(frames)
-        elapsed = ""
-        if self._start_time is not None:
-            elapsed_secs = int(time() - self._start_time)
-            elapsed = f" ({format_duration(float(elapsed_secs))})"
-        colors = theme.get_theme_colors(self)
-        gutter = f"{get_glyphs().output_prefix} "
-        stats_suffix = self._stats_title_suffix()
-        token_suffix = self._token_budget_suffix()
-        head = f"{gutter}{frame} Running...{elapsed}"
-        tail = f"{stats_suffix}{token_suffix}"
-        clear_widget_text_selection(self._status_widget)
-        parts: list[object] = [Content.styled(head, colors.warning)]
-        if tail:
-            parts.append(Content.styled(tail, colors.cognition))
-        self._status_widget.update(Content.assemble(*parts))
+        # Update status line with current stats
+        self._sync_running_status_text()
         if self._has_active_task_branch_animation():
             self._refresh_task_activity_display()
 
@@ -3187,12 +3241,12 @@ class CognitionReasonMessage(Vertical):
         """Initialize a plan-reason card.
 
         Args:
-            next_action: Deprecated; retained for message-store replay only.
+            next_action: User-facing plan-generate line (RFC-604 / IG-329).
             status: Plan status (continue, replan, done).
             iteration: Agent-loop iteration index.
             plan_action: ``keep`` or ``new`` (execution strategy).
-            assessment_reasoning: Phase-1 status justification.
-            plan_reasoning: Phase-2 plan-strategy text.
+            assessment_reasoning: Phase-1 status justification from plan-assess.
+            plan_reasoning: Legacy phase-2 strategy text (usually empty after IG-329).
             **kwargs: Passed to ``Vertical``.
         """
         super().__init__(**kwargs)
@@ -3209,6 +3263,8 @@ class CognitionReasonMessage(Vertical):
             parts.append(self._assessment_reasoning)
         if self._plan_reasoning:
             parts.append(self._plan_reasoning)
+        elif self._next_action:
+            parts.append(self._next_action)
         if len(parts) == 2:
             first = parts[0]
             if not first.endswith((".", "!", "?")):
@@ -3217,7 +3273,7 @@ class CognitionReasonMessage(Vertical):
         elif parts:
             body = parts[0]
         else:
-            body = self._next_action or ""
+            body = ""
         if self._plan_action in ("keep", "new") and body:
             body = f"{body} · {self._plan_action}"
         return _assemble_card_header(self, "", body)