soothe-cli 0.5.0__tar.gz → 0.5.1__tar.gz

{soothe_cli-0.5.0 → soothe_cli-0.5.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: soothe-cli
-Version: 0.5.0
+Version: 0.5.1
 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.0 → soothe_cli-0.5.1}/src/soothe_cli/cli/execution/daemon.py

@@ -26,7 +26,7 @@ from soothe_cli.shared.core.presentation_engine import PresentationEngine
 logger = logging.getLogger(__name__)
 
 _DAEMON_FALLBACK_EXIT_CODE = 42
-_SESSION_BOOTSTRAP_TIMEOUT_S = 5.0
+_SESSION_BOOTSTRAP_TIMEOUT_S = 30.0
 _QUERY_START_TIMEOUT_S = 20.0
 
 

{soothe_cli-0.5.0 → soothe_cli-0.5.1}/src/soothe_cli/cli/stream/display_line.py

@@ -4,7 +4,7 @@ from __future__ import annotations
 
 from dataclasses import dataclass
 
-_MS_PER_SECOND = 1000
+from soothe_cli.shared.duration_format import format_duration_ms
 
 
 @dataclass
@@ -44,10 +44,7 @@ class DisplayLine:
             parts.append(f" [{self.status}]")
 
         if self.duration_ms is not None:
-            if self.duration_ms >= _MS_PER_SECOND:
-                parts.append(f" ({self.duration_ms / _MS_PER_SECOND:.1f}s)")
-            else:
-                parts.append(f" ({self.duration_ms}ms)")
+            parts.append(f" ({format_duration_ms(self.duration_ms)})")
 
         return "".join(parts)
 

{soothe_cli-0.5.0 → soothe_cli-0.5.1}/src/soothe_cli/cli/stream/formatter.py

@@ -7,6 +7,7 @@ from soothe_cli.cli.stream.task_scope import (
     format_task_scope_prefix,
     format_task_subagent_line,
 )
+from soothe_cli.shared.duration_format import format_duration_ms
 
 # Emoji presentation for step-done success (U+2705 + VS16); distinct from ✓ tool rows.
 _STEP_DONE_OK_MARK = "\u2705\ufe0f"
@@ -101,7 +102,7 @@ def format_subagent_done(
 ) -> DisplayLine:
     """Format a subagent completion line with metrics.
 
-    With Task scope: ``⚙ Task(type, \"…\") -> ✓ Completed (Nms)`` using wire task description
+    With Task scope: ``⚙ Task(type, \"…\") -> ✓ Completed (human duration)`` using wire task description
     when provided; falls back to summary text inside quotes.
     Without scope: legacy ``✓ …`` row with triple markers.
 
@@ -123,7 +124,7 @@ def format_subagent_done(
         ms = max(0, int(duration_s * 1000))
         outcome = "✓ Completed" if task_done_success else "✗ Failed"
         tail = (answer_summary or "").strip()
-        base = f"{quoted} -> {outcome} ({ms}ms)"
+        base = f"{quoted} -> {outcome} ({format_duration_ms(ms)})"
         content = f"{base}: {tail}" if tail else base
         return DisplayLine(
             level=2,

{soothe_cli-0.5.0 → soothe_cli-0.5.1}/src/soothe_cli/cli/stream/pipeline.py

@@ -159,7 +159,7 @@ class StreamDisplayPipeline:
     def _task_scope_from_event(self, event: dict[str, Any]) -> tuple[str, str] | None:
         """Extract IG-334 ``(task_tool_call_id, subagent_type)`` when attached by the renderer."""
         ts = event.get("task_scope")
-        if isinstance(ts, tuple) and len(ts) == 2:
+        if isinstance(ts, (list, tuple)) and len(ts) == 2:
             a, b = ts
             if isinstance(a, str) and isinstance(b, str):
                 return (a, b)

{soothe_cli-0.5.0 → soothe_cli-0.5.1}/src/soothe_cli/shared/core/presentation_engine.py

@@ -13,6 +13,8 @@ from dataclasses import dataclass
 from soothe_sdk.core.verbosity import VerbosityTier, should_show
 from soothe_sdk.utils import log_preview
 
+from soothe_cli.shared.duration_format import format_duration_ms
+
 
 @dataclass
 class PresentationState:
@@ -152,7 +154,7 @@ class PresentationEngine:
             icon = "✗" if is_error else "✓"
             result_line = f"{icon} {summarized}"
         if duration_ms > 0:
-            result_line += f" ({duration_ms}ms)"
+            result_line += f" ({format_duration_ms(duration_ms)})"
         return result_line
 
     @staticmethod

soothe_cli-0.5.1/src/soothe_cli/shared/duration_format.py

@@ -0,0 +1,42 @@
+"""Human-readable duration strings for CLI and TUI (no Textual imports)."""
+
+from __future__ import annotations
+
+
+def format_duration(seconds: float) -> str:
+    """Format a duration in seconds into a human-readable string.
+
+    Args:
+        seconds: Duration in seconds.
+
+    Returns:
+        Formatted string like `"5s"`, `"2.3s"`, `"5m 12s"`, or `"1h 23m 4s"`.
+    """
+    rounded = round(seconds, 1)
+    if rounded < 60:  # noqa: PLR2004
+        if rounded % 1 == 0:
+            return f"{int(rounded)}s"
+        return f"{rounded:.1f}s"
+    minutes, secs = divmod(int(rounded), 60)
+    if minutes < 60:  # noqa: PLR2004
+        return f"{minutes}m {secs}s"
+    hours, minutes = divmod(minutes, 60)
+    return f"{hours}h {minutes}m {secs}s"
+
+
+def format_duration_ms(milliseconds: int) -> str:
+    """Format a wall-clock duration in milliseconds for status lines and cards.
+
+    Values under one second stay in milliseconds for precision; longer durations
+    reuse :func:`format_duration` (seconds, minutes, hours).
+
+    Args:
+        milliseconds: Elapsed time in milliseconds (negative values are treated as 0).
+
+    Returns:
+        Strings such as ``\"0ms\"``, ``\"240ms\"``, ``\"1.5s\"``, or ``\"2m 15s\"``.
+    """
+    ms = max(0, int(milliseconds))
+    if ms < 1000:  # noqa: PLR2004
+        return f"{ms}ms"
+    return format_duration(ms / 1000.0)

{soothe_cli-0.5.0 → soothe_cli-0.5.1}/src/soothe_cli/shared/tools/tool_formatters/web.py

@@ -42,9 +42,13 @@ class WebFormatter(BaseFormatter):
         # Route to specific formatter (handle both legacy and wizsearch naming)
         if normalized in ("search_web", "wizsearch_search"):
             return self._format_search_web(result)
-        if normalized in ("crawl_web", "wizsearch_crawl"):
+        if normalized in ("crawl_web", "wizsearch_crawl", "fetch_url"):
             return self._format_crawl_web(result)
 
+        # Handle HTTP request tools (IG-339)
+        if normalized.startswith("requests_"):
+            return self._format_http_request(normalized, result)
+
         msg = f"Unknown web tool: {tool_name}"
         raise ValueError(msg)
 
@@ -142,3 +146,48 @@ class WebFormatter(BaseFormatter):
             detail=detail,
             metrics={"size_bytes": size_bytes, "words": words, "lines": lines},
         )
+
+    def _format_http_request(self, tool_name: str, result: Any) -> ToolBrief:  # noqa: ANN401
+        r"""Format HTTP request tool result (requests_get, requests_post, etc.).
+
+        Shows HTTP method and response status/size.
+
+        Args:
+            tool_name: Name of the HTTP tool (requests_get, requests_post, etc.).
+            result: Tool result (string with response content or error).
+
+        Returns:
+            ToolBrief with HTTP request summary.
+
+        Example:
+            >>> brief = formatter._format_http_request("requests_get", '{"data": 123}')
+            >>> brief.summary
+            'GET 12 B'
+        """
+        # Extract method from tool name
+        method = tool_name.replace("requests_", "").upper()
+
+        # Check for error
+        if text_looks_like_error(result):
+            return ToolBrief(
+                icon="✗",
+                summary=f"{method} failed",
+                detail=self._truncate_text(result, 80),
+                metrics={"error": True},
+            )
+
+        # Calculate size
+        if isinstance(result, str):
+            size_bytes = len(result.encode("utf-8"))
+        else:
+            size_bytes = len(str(result).encode("utf-8"))
+
+        size_str = self._format_size(size_bytes)
+        summary = f"{method} {size_str}"
+
+        return ToolBrief(
+            icon="✓",
+            summary=summary,
+            detail=None,
+            metrics={"method": method, "size_bytes": size_bytes},
+        )

{soothe_cli-0.5.0 → soothe_cli-0.5.1}/src/soothe_cli/tui/app/_history.py

@@ -165,8 +165,7 @@ class _HistoryMixin:
             State values keyed by channel name, or empty when none are available.
         """
         if self._daemon_session is not None:
-            config: RunnableConfig = {"configurable": {"thread_id": loop_id}}
-            snapshot = await self._daemon_session.aget_state(config)
+            snapshot = await self._daemon_session.aget_loop_state(loop_id)
             values = dict(snapshot.values)
             recovered = await self._recover_missing_checkpoint_messages(
                 loop_id=loop_id,
@@ -239,9 +238,8 @@ class _HistoryMixin:
         try:
             from langchain_core.messages.base import messages_to_dict
 
-            config: RunnableConfig = {"configurable": {"thread_id": loop_id}}
-            await self._daemon_session.aupdate_state(
-                config,
+            await self._daemon_session.aupdate_loop_state(
+                loop_id,
                 {"messages": messages_to_dict(recovered_messages)},
                 timeout=10.0,
             )
@@ -746,8 +744,8 @@ class _HistoryMixin:
             # Use iter_turn_chunks to read events (same as active turn execution)
             chunk_source = self._daemon_session.iter_turn_chunks()
             async for chunk in chunk_source:
-                if not isinstance(chunk, tuple) or len(chunk) != 3:
-                    logger.debug("Skipping non-3-tuple chunk: %s", type(chunk).__name__)
+                if not isinstance(chunk, (list, tuple)) or len(chunk) != 3:
+                    logger.debug("Skipping invalid stream chunk: %s", type(chunk).__name__)
                     continue
 
                 namespace, mode, data = chunk
@@ -762,7 +760,7 @@ class _HistoryMixin:
                     continue
 
                 if mode == "messages":
-                    if not isinstance(data, tuple) or len(data) != 2:
+                    if not isinstance(data, (list, tuple)) or len(data) != 2:
                         continue
                     message, _metadata = data
                     message = normalize_stream_message(message)

{soothe_cli-0.5.0 → soothe_cli-0.5.1}/src/soothe_cli/tui/app/_module_init.py

@@ -17,7 +17,7 @@ from soothe_cli.tui._session_stats import (
     SessionStats,
 )
 
-# Only is_ascii_mode is needed before first paint (on_mount scrollbar config).
+# Keep module-level imports minimal before first paint.
 # All other config imports — settings, create_model, detect_provider, etc. — are
 # deferred to local imports at their call sites since they are only accessed
 # after user interaction begins.

{soothe_cli-0.5.0 → soothe_cli-0.5.1}/src/soothe_cli/tui/app/_startup.py

@@ -18,7 +18,6 @@ from soothe_cli.tui._version import CHANGELOG_URL
 from soothe_cli.tui.app._module_init import (
     TextualSessionState,
 )
-from soothe_cli.tui.config import is_ascii_mode
 from soothe_cli.tui.widgets.chat_input import ChatInput
 from soothe_cli.tui.widgets.messages import (
     AppMessage,
@@ -50,8 +49,6 @@ class _StartupMixin:
 
         chat = self.query_one("#chat", VerticalScroll)
         chat.anchor()
-        if is_ascii_mode():
-            chat.styles.scrollbar_size_vertical = 0
 
         self._status_bar = self.query_one("#status-bar", StatusBar)
         self._chat_input = self.query_one("#input-area", ChatInput)

{soothe_cli-0.5.0 → soothe_cli-0.5.1}/src/soothe_cli/tui/app/app.tcss

@@ -6,9 +6,18 @@ Screen {
     layers: base autocomplete;
 }
 
-/* Thin scrollbars app-wide */
+/* Scrollable regions keep wheel / key scrolling; scrollbar chrome is hidden. */
 * {
+    scrollbar-visibility: hidden;
     scrollbar-size-vertical: 1;
+    scrollbar-size-horizontal: 1;
+    scrollbar-background: $background;
+    scrollbar-background-hover: $background;
+    scrollbar-background-active: $background;
+    scrollbar-color: $foreground-muted;
+    scrollbar-color-hover: $text-muted;
+    scrollbar-color-active: $primary-muted;
+    scrollbar-corner-color: $background;
 }
 
 /* Main content goes on base layer by default */

{soothe_cli-0.5.0 → soothe_cli-0.5.1}/src/soothe_cli/tui/daemon_session.py

@@ -4,6 +4,7 @@ from __future__ import annotations
 
 import asyncio
 import logging
+from types import SimpleNamespace
 from typing import TYPE_CHECKING, Any
 
 from soothe_sdk.client import (
@@ -12,12 +13,17 @@ from soothe_sdk.client import (
     connect_websocket_with_retries,
     websocket_url_from_config,
 )
+from soothe_sdk.client.protocol import _serialize_for_json
 
 if TYPE_CHECKING:
     pass
 
 logger = logging.getLogger(__name__)
 
+# Match headless daemon client: brief read window after ``idle`` so stream events
+# that arrive slightly after status are not dropped (``cli/execution/daemon.py``).
+_POST_IDLE_DRAIN_DEADLINE_S = 2.5
+
 
 class TuiDaemonSession:
     """Own the daemon websocket session used by the TUI."""
@@ -113,6 +119,51 @@ class TuiDaemonSession:
             raise RuntimeError("No active loop for interrupt resume")
         await self._client.send_resume_interrupts(self._loop_id, resume_payload)
 
+    async def _drain_stream_events_after_idle(
+        self,
+        *,
+        expected_loop_id: str | None,
+    ) -> Any:
+        """Yield stream chunks that arrive just after ``idle`` (headless client parity)."""
+        loop = asyncio.get_running_loop()
+        deadline = loop.time() + _POST_IDLE_DRAIN_DEADLINE_S
+        exp = expected_loop_id
+        while loop.time() < deadline:
+            try:
+                event = await asyncio.wait_for(self._client.read_event(), timeout=0.25)
+            except TimeoutError:
+                break
+            if not event:
+                break
+            event_type = event.get("type", "")
+            event_loop_id = event.get("loop_id")
+            if exp and isinstance(event_loop_id, str) and event_loop_id and event_loop_id != exp:
+                logger.debug(
+                    "Skipping daemon event for non-active loop %s (active=%s, type=%s)",
+                    event_loop_id,
+                    exp,
+                    event_type,
+                )
+                continue
+            if event_type == "error":
+                raise RuntimeError(str(event.get("message", "daemon error")))
+            if event_type == "status":
+                loop_ev = event.get("loop_id")
+                if isinstance(loop_ev, str) and loop_ev:
+                    self._loop_id = loop_ev
+                    exp = loop_ev
+                continue
+            if event_type != "event":
+                continue
+            data = event.get("data")
+            if isinstance(data, dict) and data.get("type") == "soothe.system.daemon.heartbeat":
+                continue
+            namespace = tuple(event.get("namespace", []) or [])
+            mode = str(event.get("mode", ""))
+            yield (namespace, mode, data)
+            if mode == "updates" and isinstance(data, dict) and "__interrupt__" in data:
+                return
+
     async def iter_turn_chunks(self) -> Any:
         """Yield `(namespace, mode, data)` chunks for the active daemon turn."""
         query_started = False
@@ -149,12 +200,17 @@ class TuiDaemonSession:
                         loop_ev = event.get("loop_id")
                         if isinstance(loop_ev, str) and loop_ev:
                             self._loop_id = loop_ev
-                            if expected_loop_id is None:
-                                expected_loop_id = loop_ev
+                            # Keep filter aligned with daemon-canonical loop_id whenever
+                            # status carries it (avoids dropping subsequent events).
+                            expected_loop_id = loop_ev
                         state = event.get("state", "")
                         if state == "running":
                             query_started = True
                         elif query_started and state in {"idle", "stopped"}:
+                            async for chunk in self._drain_stream_events_after_idle(
+                                expected_loop_id=expected_loop_id,
+                            ):
+                                yield chunk
                             break
                         continue
 
@@ -204,3 +260,106 @@ class TuiDaemonSession:
             return
         await connect_websocket_with_retries(self._rpc_client)
         self._rpc_connected = True
+
+    async def aget_loop_state(self, loop_id: str) -> Any:
+        """Load agent-loop state channels from the daemon (``loop_state_get`` RPC).
+
+        Returns a namespace with a ``values`` mapping so history code can share the
+        same consumption pattern as the in-process agent snapshot, without passing
+        graph config objects over the wire.
+
+        Args:
+            loop_id: AgentLoop id.
+
+        Returns:
+            ``types.SimpleNamespace`` with ``values: dict[str, Any]``.
+        """
+        lid = str(loop_id or "").strip()
+        if not lid:
+            return SimpleNamespace(values={})
+
+        async with self._rpc_lock:
+            await self._ensure_rpc_connected()
+            try:
+                resp = await self._rpc_client.request_response(
+                    {"type": "loop_state_get", "loop_id": lid},
+                    response_type="loop_state_get_response",
+                    timeout=30.0,
+                )
+            except Exception:
+                logger.warning(
+                    "loop_state_get failed for loop %s",
+                    lid[:16],
+                    exc_info=True,
+                )
+                return SimpleNamespace(values={})
+
+        raw = resp.get("values")
+        values: dict[str, Any] = dict(raw) if isinstance(raw, dict) else {}
+        return SimpleNamespace(values=values)
+
+    async def aupdate_loop_state(
+        self,
+        loop_id: str,
+        values: dict[str, Any],
+        *,
+        timeout: float = 10.0,
+    ) -> None:
+        """Merge partial state into the loop on the daemon host (``loop_state_update`` RPC).
+
+        Args:
+            loop_id: AgentLoop id.
+            values: Channel updates (e.g. ``messages``) in JSON-serializable form.
+            timeout: RPC wait budget in seconds.
+        """
+        lid = str(loop_id or "").strip()
+        if not lid:
+            return
+
+        payload_values = _serialize_for_json(values)
+        if not isinstance(payload_values, dict):
+            return
+
+        async with self._rpc_lock:
+            await self._ensure_rpc_connected()
+            await self._rpc_client.request_response(
+                {
+                    "type": "loop_state_update",
+                    "loop_id": lid,
+                    "values": payload_values,
+                },
+                response_type="loop_state_update_response",
+                timeout=timeout,
+            )
+
+    async def fetch_conversation_log(
+        self,
+        loop_id: str,
+        *,
+        limit: int = 100,
+        offset: int = 0,
+        include_events: bool = False,
+    ) -> list[dict[str, Any]]:
+        """Load persisted rows for a loop from the daemon (conversation + optional events)."""
+        lid = str(loop_id or "").strip()
+        if not lid:
+            return []
+
+        async with self._rpc_lock:
+            await self._ensure_rpc_connected()
+            resp = await self._rpc_client.request_response(
+                {
+                    "type": "loop_messages",
+                    "loop_id": lid,
+                    "limit": limit,
+                    "offset": offset,
+                    "include_events": include_events,
+                },
+                response_type="loop_messages_response",
+                timeout=10.0,
+            )
+
+        raw = resp.get("messages")
+        if not isinstance(raw, list):
+            return []
+        return [m for m in raw if isinstance(m, dict)]

soothe_cli-0.5.1/src/soothe_cli/tui/formatting.py

@@ -0,0 +1,14 @@
+"""Lightweight text-formatting helpers.
+
+Keep this module free of heavy dependencies so it can be imported anywhere
+in the CLI without pulling in large frameworks.
+
+Implementation lives in :mod:`soothe_cli.shared.duration_format` so shared code
+does not need to import the ``soothe_cli.tui`` package (avoids import cycles).
+"""
+
+from __future__ import annotations
+
+from soothe_cli.shared.duration_format import format_duration, format_duration_ms
+
+__all__ = ["format_duration", "format_duration_ms"]

{soothe_cli-0.5.0 → soothe_cli-0.5.1}/src/soothe_cli/tui/preview_limits.py

@@ -12,6 +12,11 @@ from typing import Final
 ASSISTANT_MESSAGE_PREVIEW_LINES: Final[int] = 10
 ASSISTANT_MESSAGE_PREVIEW_CHARS: Final[int] = 800
 
+# --- Step / Task cognition cards (`CognitionStepMessage`, task `ToolCallMessage`) ---
+# When estimated body lines exceed this count, the card auto-collapses (strict `>`).
+# Matches the step/task activity preview row cap (`_STEP_TOOL_PREVIEW_ROWS`).
+STEP_TASK_CARD_COLLAPSE_LINE_THRESHOLD: Final[int] = 3
+
 # --- Tool call cards (`ToolCallMessage` collapsed output) ---
 TOOL_CARD_PREVIEW_LINES: Final[int] = 1
 TOOL_CARD_PREVIEW_CHARS: Final[int] = 120

{soothe_cli-0.5.0 → soothe_cli-0.5.1}/src/soothe_cli/tui/textual_adapter/_adapter.py

@@ -47,7 +47,6 @@ from soothe_cli.tui._session_stats import (
     format_token_count as format_token_count,
 )
 from soothe_cli.tui.widgets.messages import (
-    CognitionGoalTreeMessage,
     CognitionStepMessage,
     ToolCallMessage,
 )
@@ -171,9 +170,6 @@ class TextualUIAdapter:
         self._current_step_messages: dict[str, CognitionStepMessage] = {}
         """Map of agent-loop act step IDs to step card widgets."""
 
-        self._goal_tree_by_namespace: dict[tuple[Any, ...], CognitionGoalTreeMessage] = {}
-        """Live Goal→steps tree card per stream namespace (agentic Layer 2)."""
-
         self._step_by_namespace: dict[tuple[Any, ...], CognitionStepMessage] = {}
         """Active step card per stream namespace (main-agent tool aggregation, IG-402)."""
 
@@ -254,9 +250,6 @@ class TextualUIAdapter:
         for step_msg in list(self._current_step_messages.values()):
             step_msg.set_interrupted(message)
         self._current_step_messages.clear()
-        for tree in list(self._goal_tree_by_namespace.values()):
-            tree.set_interrupted(message)
-        self._goal_tree_by_namespace.clear()
         self._tool_to_step.clear()
         self._step_by_namespace.clear()
         self._task_inner_tool_pending_lines.clear()

{soothe_cli-0.5.0 → soothe_cli-0.5.1}/src/soothe_cli/tui/textual_adapter/_turn.py

@@ -91,7 +91,6 @@ from soothe_cli.tui.textual_adapter._turn_helpers import (
 from soothe_cli.tui.widgets.messages import (
     AppMessage,
     AssistantMessage,
-    CognitionGoalTreeMessage,
     CognitionPlanReasonMessage,
     CognitionStepMessage,
     DiffMessage,
@@ -340,8 +339,8 @@ async def execute_task_textual(
                     chunk_source = daemon_session.iter_turn_chunks()
 
             async for chunk in chunk_source:
-                if not isinstance(chunk, tuple) or len(chunk) != 3:  # noqa: PLR2004  # stream chunk is a 3-tuple (namespace, mode, data)
-                    logger.debug("Skipping non-3-tuple chunk: %s", type(chunk).__name__)
+                if not isinstance(chunk, (list, tuple)) or len(chunk) != 3:  # noqa: PLR2004
+                    logger.debug("Skipping invalid stream chunk: %s", type(chunk).__name__)
                     continue
 
                 namespace, current_stream_mode, data = chunk
@@ -399,9 +398,9 @@ async def execute_task_textual(
                             ns_key,
                         )
 
-                    if not isinstance(data, tuple) or len(data) != 2:  # noqa: PLR2004  # message stream data is a 2-tuple (message, metadata)
+                    if not isinstance(data, (list, tuple)) or len(data) != 2:  # noqa: PLR2004
                         logger.debug(
-                            "Skipping non-2-tuple message data: type=%s",
+                            "Skipping non-pair message data: type=%s",
                             type(data).__name__,
                         )
                         continue
@@ -1272,8 +1271,6 @@ async def execute_task_textual(
                             continue
 
                         if event_type == AGENT_LOOP_GOAL_STARTED:
-                            goal = str(data.get("goal", "")).strip()
-                            max_it = int(data.get("max_iterations", 0))
                             if not ns_key:
                                 adapter._last_completed_main_step_execute_prose = ""
                                 adapter._last_main_flushed_assistant_prose = ""
@@ -1288,27 +1285,10 @@ async def execute_task_textual(
                                 )
                                 pending_text_by_namespace[ns_key] = ""
                                 assistant_message_by_namespace.pop(ns_key, None)
-                            tree = CognitionGoalTreeMessage(
-                                goal=goal or "(goal)",
-                                max_iterations=max_it,
-                                id=f"goaltree-{uuid.uuid4().hex[:8]}",
-                            )
-                            adapter._goal_tree_by_namespace[ns_key] = tree
-                            await adapter._mount_message(tree)
                             continue
 
                         if event_type == AGENT_LOOP_GOAL_COMPLETED:
-                            tr = adapter._goal_tree_by_namespace.get(ns_key)
-                            if tr is not None:
-                                tr.set_loop_finished(
-                                    status=str(data.get("status", "")),
-                                    goal_progress=str(
-                                        data.get("goal_progress", "none")
-                                    ),  # IG-399: descriptive level
-                                    completion_summary=str(data.get("completion_summary", "")),
-                                    total_steps=int(data.get("total_steps", 0)),
-                                )
-                                adapter._goal_tree_by_namespace.pop(ns_key, None)
+                            continue
 
                         if event_type == AGENT_LOOP_STEP_STARTED:
                             step_id = str(data.get("step_id", "")).strip()
@@ -1325,9 +1305,6 @@ async def execute_task_textual(
                                     )
                                     pending_text_by_namespace[ns_key] = ""
                                     assistant_message_by_namespace.pop(ns_key, None)
-                                goal_tree = adapter._goal_tree_by_namespace.get(ns_key)
-                                if goal_tree is not None:
-                                    goal_tree.add_step_running(step_id, description or "(step)")
                                 step_widget = CognitionStepMessage(
                                     step_id=step_id,
                                     description=description or "(step)",
@@ -1386,15 +1363,6 @@ async def execute_task_textual(
                                 )
                                 if not summary.strip():
                                     summary = "Failed" if not success else "Done"
-                                goal_tree = adapter._goal_tree_by_namespace.get(ns_key)
-                                if goal_tree is not None:
-                                    goal_tree.complete_step(
-                                        step_id,
-                                        success,
-                                        duration_ms,
-                                        tool_call_count,
-                                        summary,
-                                    )
                                 widget = adapter._current_step_messages.pop(step_id, None)
                                 if widget is not None:
                                     if adapter._step_by_namespace.get(ns_key) is widget:
@@ -1417,7 +1385,7 @@ async def execute_task_textual(
                                         adapter._last_completed_main_step_execute_prose = (
                                             widget.last_completed_execute_prose
                                         )
-                                elif goal_tree is None:
+                                else:
                                     ev = dict(data)
                                     ev["namespace"] = list(ns_key)
                                     for line in progress_pipeline.process(ev):

{soothe_cli-0.5.0 → soothe_cli-0.5.1}/src/soothe_cli/tui/textual_adapter/_turn_helpers.py

@@ -211,9 +211,6 @@ async def _handle_interrupt_cleanup(
     adapter._step_by_namespace.clear()
     adapter._pending_main_tools.clear()
 
-    for gt in list(adapter._goal_tree_by_namespace.values()):
-        gt.set_interrupted("Interrupted by user")
-    adapter._goal_tree_by_namespace.clear()
     adapter._last_completed_main_step_execute_prose = ""
     adapter._last_main_flushed_assistant_prose = ""