soothe-cli 0.7.10__tar.gz → 0.7.11__tar.gz

{soothe_cli-0.7.10 → soothe_cli-0.7.11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: soothe-cli
-Version: 0.7.10
+Version: 0.7.11
 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.7.10 → soothe_cli-0.7.11}/src/soothe_cli/runtime/state/step_router.py

@@ -174,9 +174,8 @@ class StepTaskRouter:
     ) -> None:
         """Promote a pending step card to running only when it is executing (RFC-628).
 
-        Pre-mounted future steps must stay ``pending`` until ``step.started`` even when
-        tools are stamped with their unified step id. The pre-``step.started`` race for
-        the active step is allowed only while no sibling step card is already running.
+        Future steps are not pre-mounted in the message list; only the active step
+        may transition to ``running`` before ``step.started`` when tools arrive early.
         """
         if getattr(step_w, "_status", "") != "pending":
             return

{soothe_cli-0.7.10 → soothe_cli-0.7.11}/src/soothe_cli/tui/preview_limits.py

@@ -15,7 +15,7 @@ from typing import Final
 STEP_CARD_SHOW_TOOL_ROW_DETAILS: Final[bool] = False
 
 # Latest per-tool invocation lines on step and SubAgent cards (shared activity tree).
-STEP_CARD_TOOL_ACTIVITY_PREVIEW_COUNT: Final[int] = 3
+STEP_CARD_TOOL_ACTIVITY_PREVIEW_COUNT: Final[int] = 2
 
 # Optional manual full tool-list folding threshold (not auto-collapse).
 STEP_TASK_CARD_COLLAPSE_LINE_THRESHOLD: Final[int] = 3

{soothe_cli-0.7.10 → soothe_cli-0.7.11}/src/soothe_cli/tui/textual_adapter.py

@@ -298,9 +298,6 @@ class TextualUIAdapter:
         self._execute_wave_completed: int = 0
         """Completed steps in the current execute batch."""
 
-        self._successful_step_ids: set[str] = set()
-        """Step ids that finished successfully this loop (survives plan=keep replays)."""
-
         self._clarification_input_by_step: dict[str, ClarificationInputMessage] = {}
         """Active inline ``ClarificationInputMessage`` widgets keyed by step id.
 
@@ -406,7 +403,7 @@ def _stream_end_pending_error_message(
     if is_daemon_worker_thread_lost(err_msg) or is_daemon_worker_subprocess_lost(err_msg):
         return "Worker stopped during stream"
     if end_state == "idle" and any(
-        getattr(widget, "_status", "") in {"running", "queued"}
+        getattr(widget, "_status", "") == "running"
         for widget in adapter._current_step_messages.values()
     ):
         return "Stream ended before steps completed"
@@ -1448,12 +1445,16 @@ async def _ensure_goal_tree_message(
     return widget
 
 
-async def sync_pending_step_cards_from_plan(
+async def cleanup_stale_plan_step_cards(
     adapter: TextualUIAdapter,
     *,
     steps: list[dict[str, Any]],
 ) -> None:
-    """Mount step cards in ``pending`` state for planned steps not yet executing."""
+    """Drop stale pending step cards after replan; do not mount future steps.
+
+    Planned and queued steps appear only in the Ctrl+T plan quick view (goal tree).
+    Step cards mount in the message list when ``step_started`` fires.
+    """
     planned_ids = {
         str(row.get("id", "")).strip()
         for row in steps
@@ -1468,23 +1469,6 @@ async def sync_pending_step_cards_from_plan(
                 if bound is widget:
                     adapter._step_by_namespace.pop(ns, None)
 
-    for row in steps:
-        if not isinstance(row, dict):
-            continue
-        sid = str(row.get("id", "")).strip()
-        if not sid or sid in adapter._current_step_messages:
-            continue
-        if _is_successful_step_id(adapter, sid):
-            continue
-        desc = str(row.get("description", "")).strip() or "(step)"
-        step_widget = CognitionStepMessage(
-            step_id=sid,
-            description=desc,
-            id=f"step-{uuid.uuid4().hex[:8]}",
-        )
-        await adapter._mount_message(step_widget)
-        adapter._current_step_messages[sid] = step_widget
-
 
 def _step_card_lookup_keys(step_id: str) -> list[str]:
     """Return dict lookup keys for a step id (canonical and wire variants)."""
@@ -1501,17 +1485,6 @@ def _step_card_lookup_keys(step_id: str) -> list[str]:
     return keys
 
 
-def _register_successful_step_id(adapter: TextualUIAdapter, step_id: str) -> None:
-    """Remember a step that completed successfully so plan=keep does not remount it."""
-    for key in _step_card_lookup_keys(step_id):
-        adapter._successful_step_ids.add(key)
-
-
-def _is_successful_step_id(adapter: TextualUIAdapter, step_id: str) -> bool:
-    """True when this step already succeeded earlier in the current loop."""
-    return any(key in adapter._successful_step_ids for key in _step_card_lookup_keys(step_id))
-
-
 def _lookup_step_card(
     adapter: TextualUIAdapter,
     step_id: str,
@@ -2856,7 +2829,6 @@ async def execute_task_textual(
     router.reset_turn()
     adapter._execute_wave_total = 0
     adapter._execute_wave_completed = 0
-    adapter._successful_step_ids.clear()
     ui_coalesce = TurnToolUiCoalescer()
     adapter._goal_completion_mounted_this_turn = False
     adapter._goal_tree_message = None
@@ -3865,7 +3837,7 @@ async def execute_task_textual(
                                         done_steps,
                                         len(raw_steps),
                                     )
-                                    await sync_pending_step_cards_from_plan(
+                                    await cleanup_stale_plan_step_cards(
                                         adapter,
                                         steps=raw_steps,
                                     )
@@ -3883,26 +3855,13 @@ async def execute_task_textual(
                             if event_type == STRANGE_LOOP_STEP_QUEUED:
                                 step_id = str(data.get("step_id", "")).strip()
                                 description = str(data.get("description", "")).strip()
-                                if step_id:
-                                    step_widget = adapter._current_step_messages.get(step_id)
-                                    if step_widget is None:
-                                        step_widget = CognitionStepMessage(
-                                            step_id=step_id,
-                                            description=description or "(step)",
-                                            id=f"step-{uuid.uuid4().hex[:8]}",
-                                        )
-                                        await adapter._mount_message(step_widget)
-                                        adapter._current_step_messages[step_id] = step_widget
-                                    elif description:
-                                        step_widget.set_description(description)
-                                    step_widget.set_queued()
-                                    if not ns_key:
-                                        _sync_goal_tree_step_phase(
-                                            adapter,
-                                            step_id,
-                                            "queued",
-                                            description=description,
-                                        )
+                                if step_id and not ns_key:
+                                    _sync_goal_tree_step_phase(
+                                        adapter,
+                                        step_id,
+                                        "queued",
+                                        description=description,
+                                    )
                                 continue
 
                             if event_type == STRANGE_LOOP_STEP_STARTED:
@@ -4018,8 +3977,6 @@ async def execute_task_textual(
                                         pending_text_by_namespace[ns_key] = ""
                                         assistant_message_by_namespace.pop(ns_key, None)
                                     success = bool(data.get("success", True))
-                                    if success:
-                                        _register_successful_step_id(adapter, step_id)
                                     duration_ms = int(data.get("duration_ms", 0))
                                     tool_call_count = int(data.get("tool_call_count", 0))
                                     summary = str(

{soothe_cli-0.7.10 → soothe_cli-0.7.11}/src/soothe_cli/tui/widgets/messages/cognition_step.py

@@ -135,7 +135,7 @@ class CognitionStepMessage(Vertical):
         super().__init__(**kwargs)
         self._step_id = step_id
         self._description = description.strip()
-        self._status = "pending"  # pending | queued | running | success | error
+        self._status = "pending"  # pending | running | success | error
         self._spinner_position = 0
         self._start_time: float | None = None
         self._animation_timer: Timer | None = None
@@ -217,7 +217,7 @@ class CognitionStepMessage(Vertical):
             return
         self._input_tokens += input_tokens
         self._output_tokens += output_tokens
-        if self._status in ("running", "pending", "queued"):
+        if self._status in ("running", "pending"):
             self._sync_running_status_line()
 
     def _token_budget_suffix(self) -> str:
@@ -283,8 +283,6 @@ class CognitionStepMessage(Vertical):
             return
         if self._status == "running":
             self._ensure_running_ui()
-        elif self._status == "queued":
-            self._sync_step_card_surface()
         elif self._status == "pending":
             self._sync_step_card_surface()
 
@@ -466,8 +464,6 @@ class CognitionStepMessage(Vertical):
             self._sync_running_status_text(index)
         elif self._status == "pending":
             self._refresh_pending_display(index)
-        elif self._status == "queued":
-            self._refresh_queued_display(index)
 
         if STEP_CARD_SHOW_TOOL_ROW_DETAILS:
             self._refresh_tools_display()
@@ -1156,37 +1152,6 @@ class CognitionStepMessage(Vertical):
         )
         self._status_widget.display = True
 
-    def _refresh_queued_display(self, index: StepRowIndex | None = None) -> None:
-        """Show ready steps waiting for a concurrency slot (``max_parallel_steps``)."""
-        if self._status != "queued" or self._status_widget is None:
-            return
-        if index is None:
-            index = self._build_row_index()
-        try:
-            colors = theme.get_theme_colors(self)
-        except Exception:  # noqa: BLE001
-            colors = theme.DARK_COLORS
-        g = get_glyphs()
-        gutter = f"{g.output_prefix} "
-        self._status_widget.update(
-            StepCardStatusLine.footer_queued(
-                gutter=gutter,
-                circle_empty=g.circle_empty,
-                stats_suffix=stats_title_suffix(index),
-                token_suffix=self._token_budget_suffix(),
-                colors=colors,
-            )
-        )
-        self._status_widget.display = True
-
-    def set_queued(self) -> None:
-        """Mark a ready step as waiting for an execute batch slot."""
-        if self._status in ("running", "success", "error"):
-            return
-        self._status = "queued"
-        self._refresh_header_title()
-        self._sync_step_card_surface()
-
     def _maybe_start_running_timer(self) -> None:
         """Start the spinner timer when the step is running and mounted."""
         if self._status != "running":

{soothe_cli-0.7.10 → soothe_cli-0.7.11}/src/soothe_cli/tui/widgets/messages/cognition_step_activity.py

@@ -458,23 +458,6 @@ class StepCardStatusLine:
             parts.append(Content.styled(tail, theme.SECONDARY_TEXT_STYLE))
         return Content.assemble(*parts)
 
-    @staticmethod
-    def footer_queued(
-        *,
-        gutter: str,
-        circle_empty: str,
-        stats_suffix: str,
-        token_suffix: str = "",
-        colors: Any,
-    ) -> Content:
-        """Step card footer for ready steps waiting for a concurrency slot."""
-        head = f"{gutter}{circle_empty} Queued..."
-        tail = f"{stats_suffix}{token_suffix}"
-        parts: list[object] = [Content.styled(head, colors.cognition)]
-        if tail:
-            parts.append(Content.styled(tail, theme.SECONDARY_TEXT_STYLE))
-        return Content.assemble(*parts)
-
 
 # Activity tree renderer
 # ---------------------------------------------------------------------------