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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: soothe-cli
-Version: 0.7.9
+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.9 → soothe_cli-0.7.11}/src/soothe_cli/runtime/policy/display_policy.py

@@ -134,9 +134,9 @@ class DisplayPolicy:
         """Check if this is a plan-related event."""
         return event_type.startswith("soothe.cognition.plan.")
 
-    def is_deep_research_event(self, event_type: str) -> bool:
-        """Check if this is a Deep Research subagent event."""
-        return event_type.startswith("soothe.subagent.deep_research.")
+    def is_subagent_wire_event(self, event_type: str) -> bool:
+        """Check if this is a curated subagent wire event."""
+        return event_type.startswith("soothe.subagent.")
 
     def is_internal_event(self, event_type: str) -> bool:
         """Check if this is an internal (never-shown) event."""

{soothe_cli-0.7.9 → 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.9 → 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.9 → soothe_cli-0.7.11}/src/soothe_cli/tui/textual_adapter.py

@@ -52,6 +52,11 @@ from soothe_sdk.ux.loop_stream import (
     is_stream_terminal,
 )
 from soothe_sdk.ux.stream_tool_wire import STREAM_TOOL_CALL_UPDATE, TOOL_CALL_UPDATES_BATCH
+from soothe_sdk.ux.subagent_wire_display import (
+    SubagentWireRenderKind,
+    classify_subagent_wire_render,
+    subagent_wire_row_params,
+)
 from soothe_sdk.ux.task_namespace import (
     TaskScope,
     is_inner_subgraph_task_tool_id,
@@ -293,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.
 
@@ -401,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"
@@ -951,34 +953,6 @@ def _ingest_wire_step_on_subagent_card(
         subagent_card.set_tool_success(row_id, "", duration_ms=duration_ms)
 
 
-def _subagent_wire_step_params(
-    event_type: str,
-    data: dict[str, Any],
-) -> tuple[str, dict[str, Any], str, int] | None:
-    """Map curated subagent wire events to SubAgent card row fields."""
-    et = str(event_type or "").strip()
-    if et.endswith(".gather.summary"):
-        query = str(data.get("query_preview", "") or "").strip()
-        rc = int(data.get("result_count", 0) or 0)
-        st = int(data.get("sources_touched", 0) or 0)
-        preview = query
-        if rc or st:
-            tail = f"{rc} hits, {st} sources"
-            preview = f"{query} → {tail}" if query else tail
-        return "WebSearch", {"query": preview or query}, "success", 0
-    if et.endswith(".step.completed"):
-        tool_name = str(data.get("tool_name", "") or "").strip() or "Step"
-        args_preview = str(data.get("args_preview", "") or "").strip()
-        status = str(data.get("status", "done") or "done").strip().lower()
-        phase = "success" if status in ("done", "success", "complete") else "running"
-        if status in ("error", "failed"):
-            phase = "error"
-        duration_ms = int(data.get("duration_ms", 0) or 0)
-        args = {"preview": args_preview} if args_preview else {}
-        return tool_name, args, phase, duration_ms
-    return None
-
-
 def _apply_subagent_wire_step_event(
     adapter: TextualUIAdapter,
     *,
@@ -986,8 +960,8 @@ def _apply_subagent_wire_step_event(
     data: dict[str, Any],
     task_scope: TaskScope,
 ) -> bool:
-    """Render ``*.step.completed`` / ``*.gather.summary`` on the SubAgent (TASK) card."""
-    params = _subagent_wire_step_params(event_type, data)
+    """Render row-style subagent wire events on the SubAgent (TASK) card."""
+    params = subagent_wire_row_params(event_type, data)
     if params is None:
         return False
     tool_name, args, phase, duration_ms = params
@@ -1011,6 +985,29 @@ def _apply_subagent_wire_step_event(
     return True
 
 
+def _apply_subagent_wire_activity_event(
+    adapter: TextualUIAdapter,
+    *,
+    event_type: str,
+    data: dict[str, Any],
+    task_scope: TaskScope,
+) -> bool:
+    """Render note-style subagent wire events on the SubAgent card."""
+    from soothe_sdk.ux.subagent_progress import summarize_subagent_wire_activity
+
+    line = summarize_subagent_wire_activity(str(event_type or "").strip(), data).strip()
+    if not line:
+        return False
+    step_id = task_scope_step_id(task_scope)
+    if not step_id:
+        return True
+    subagent_card = _ensure_subagent_card_for_task_scope(adapter, task_scope)
+    if subagent_card is None:
+        return True
+    subagent_card.append_subagent_activity(line)
+    return True
+
+
 def _apply_subagent_wire_lifecycle_event(
     adapter: TextualUIAdapter,
     *,
@@ -1021,7 +1018,7 @@ def _apply_subagent_wire_lifecycle_event(
     """Handle subagent ``*.completed`` / ``*.failed`` wire events (RFC-628, IG-513)."""
     et = str(event_type or "").strip()
     if not (et.endswith(".completed") or et.endswith(".failed")):
-        return True
+        return False
     step_id = task_scope_step_id(task_scope)
     task_idx = task_scope_task_idx(task_scope, step_id)
     card = adapter._subagent_cards_by_key.get(_subagent_registry_key(step_id, task_idx))
@@ -1048,6 +1045,39 @@ def _apply_subagent_wire_lifecycle_event(
     return True
 
 
+def _route_subagent_wire_event(
+    adapter: TextualUIAdapter,
+    *,
+    event_type: str,
+    data: dict[str, Any],
+    task_scope: TaskScope,
+) -> bool:
+    """Route a curated subagent wire event to the unified display protocol handlers."""
+    kind = classify_subagent_wire_render(event_type)
+    if kind is SubagentWireRenderKind.ACTIVITY_ROW:
+        return _apply_subagent_wire_step_event(
+            adapter,
+            event_type=event_type,
+            data=data,
+            task_scope=task_scope,
+        )
+    if kind is SubagentWireRenderKind.ACTIVITY_NOTE:
+        return _apply_subagent_wire_activity_event(
+            adapter,
+            event_type=event_type,
+            data=data,
+            task_scope=task_scope,
+        )
+    if kind is SubagentWireRenderKind.LIFECYCLE_END:
+        return _apply_subagent_wire_lifecycle_event(
+            adapter,
+            event_type=event_type,
+            data=data,
+            task_scope=task_scope,
+        )
+    return False
+
+
 def _route_subgraph_tool_call(
     adapter: TextualUIAdapter,
     router: StepTaskRouter,
@@ -1415,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
@@ -1435,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)."""
@@ -1468,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,
@@ -2823,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
@@ -3832,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,
                                     )
@@ -3850,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:
@@ -3985,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(
@@ -4172,20 +4162,13 @@ async def execute_task_textual(
                                 and event_type.startswith("soothe.subagent.")
                                 and is_allowlisted_subagent_event_type(event_type)
                             ):
-                                if _apply_subagent_wire_step_event(
+                                if _route_subagent_wire_event(
                                     adapter,
                                     event_type=event_type,
                                     data=data,
                                     task_scope=task_scope,
                                 ):
                                     continue
-                                _apply_subagent_wire_lifecycle_event(
-                                    adapter,
-                                    event_type=event_type,
-                                    data=data,
-                                    task_scope=task_scope,
-                                )
-                                continue
                 finally:
                     await ui_coalesce.after_chunk()
 

{soothe_cli-0.7.9 → 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.9 → 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
 # ---------------------------------------------------------------------------