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

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

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

@@ -143,24 +143,9 @@ class DisplayPolicy:
         return event_type in INTERNAL_EVENT_TYPES or event_type.startswith("soothe.internal.")
 
 
-# =============================================================================
-# Factory Function
-# =============================================================================
-
-
-def create_display_policy() -> DisplayPolicy:
-    """Create the shared display policy instance (single fixed UX tier)."""
-    return DisplayPolicy()
-
-
-# =============================================================================
-# Exports
-# =============================================================================
-
 __all__ = [
     "INTERNAL_EVENT_TYPES",
     "SKIP_EVENT_TYPES",
     "DisplayPolicy",
     "VerbosityTier",
-    "create_display_policy",
 ]

{soothe_cli-0.7.7 → soothe_cli-0.7.9}/src/soothe_cli/runtime/state/stream_accumulator.py

@@ -139,6 +139,3 @@ class StreamingTextAccumulator:
     def clear(self) -> None:
         """Clear all accumulated state (call after finalizing)."""
         self.streams.clear()
-
-
-StreamAccumulator = StreamingTextAccumulator

{soothe_cli-0.7.7 → soothe_cli-0.7.9}/src/soothe_cli/tui/app/_app.py

@@ -23,7 +23,6 @@ from textual.message import Message
 
 from soothe_cli.runtime.state.session_stats import SessionStats
 from soothe_cli.tui import theme
-from soothe_cli.tui.app._commands import _CommandsMixin
 from soothe_cli.tui.app._execution import _ExecutionMixin
 from soothe_cli.tui.app._history import _HistoryMixin
 from soothe_cli.tui.app._messages_mixin import _MessagesMixin
@@ -55,7 +54,6 @@ class SootheApp(
     App,
     _StartupMixin,
     _HistoryMixin,
-    _CommandsMixin,
     _ModelMixin,
     _ExecutionMixin,
     _UIMixin,

{soothe_cli-0.7.7 → soothe_cli-0.7.9}/src/soothe_cli/tui/app/_execution.py

@@ -450,6 +450,37 @@ class _ExecutionMixin:
         """
         return f"{prefix}: {loop_id}"
 
+    async def _get_conversation_token_count(self) -> int | None:
+        """Return the approximate conversation-only token count.
+
+        Returns:
+            Token count as an integer, or `None` if state is unavailable.
+        """
+        if not self._lc_loop_id:
+            return None
+        try:
+            from langchain_core.messages import messages_from_dict
+            from langchain_core.messages.utils import count_tokens_approximately
+
+            if self._daemon_session is None:
+                return None
+            snap = await self._daemon_session.aget_loop_state(self._lc_loop_id)
+            vals = getattr(snap, "values", None)
+            if not isinstance(vals, dict):
+                return None
+            raw = vals.get("messages")
+            if not isinstance(raw, list) or not raw:
+                return None
+            if isinstance(raw[0], dict):
+                messages = messages_from_dict(raw)
+            else:
+                messages = raw
+
+            return count_tokens_approximately(messages)
+        except Exception:  # best-effort for /tokens display
+            logger.debug("Failed to retrieve conversation token count", exc_info=True)
+            return None
+
     async def _handle_command(self, command: str) -> None:
         """Handle a slash command.
 

{soothe_cli-0.7.7 → soothe_cli-0.7.9}/src/soothe_cli/tui/config.py

@@ -1242,51 +1242,6 @@ class Settings:
             return None
         return self.project_root / ".agents" / "skills"
 
-    @staticmethod
-    def get_user_claude_skills_dir() -> Path:
-        """Get user-level `~/.claude/skills/` directory (experimental).
-
-        Convenience bridge for cross-tool skill sharing with Claude Code.
-        This is experimental and may be removed.
-
-        Returns:
-            Path to `~/.claude/skills/`
-        """
-        return Path.home() / ".claude" / "skills"
-
-    def get_project_claude_skills_dir(self) -> Path | None:
-        """Get project-level `.claude/skills/` directory (experimental).
-
-        Convenience bridge for cross-tool skill sharing with Claude Code.
-        This is experimental and may be removed.
-
-        Returns:
-            Path to `{project_root}/.claude/skills/`, or `None` if not in a project.
-        """
-        if not self.project_root:
-            return None
-        return self.project_root / ".claude" / "skills"
-
-    @staticmethod
-    def get_built_in_skills_dir() -> Path:
-        """Get the directory containing built-in skills that ship with the CLI.
-
-        Returns:
-            Path to the `built_in_skills/` directory within the package.
-        """
-        return Path(__file__).parent / "built_in_skills"
-
-    def get_extra_skills_dirs(self) -> list[Path]:
-        """Get user-configured extra skill directories.
-
-        Set via `SOOTHE_EXTRA_SKILLS_DIRS` (colon-separated paths) or
-        `[skills].extra_allowed_dirs` in `SOOTHE_HOME/config/config.yml`.
-
-        Returns:
-            List of extra skill directory paths, or empty list if not configured.
-        """
-        return self.extra_skills_dirs or []
-
 
 class SessionState:
     """Mutable session state shared across the app, adapter, and agent."""

{soothe_cli-0.7.7 → soothe_cli-0.7.9}/src/soothe_cli/tui/preview_limits.py

@@ -48,8 +48,5 @@ APPROVAL_WARNING_TEXT_TRUNCATE_CHARS: Final[int] = 220
 # --- Unified diff snippets in chat (`file_ops`, DiffMessage) ---
 APPROVAL_DIFF_MAX_LINES: Final[int] = 15
 
-# --- Autopilot dashboard (`autopilot_dashboard`) ---
-AUTOPILOT_GOAL_DESCRIPTION_PREVIEW_CHARS: Final[int] = 50
-AUTOPILOT_FINDING_LINE_PREVIEW_CHARS: Final[int] = 80
-AUTOPILOT_FINDINGS_VISIBLE_COUNT: Final[int] = 20
-AUTOPILOT_GRAPH_EDGE_PREVIEW_COUNT: Final[int] = 3
+# --- Plan quick-view overlay (Ctrl+T goal tree step rows) ---
+PLAN_QUICK_VIEW_STEP_LINE_MAX_CHARS: Final[int] = 76

{soothe_cli-0.7.7 → soothe_cli-0.7.9}/src/soothe_cli/tui/textual_adapter.py

@@ -148,6 +148,7 @@ from soothe_cli.tui.widgets.messages import (
     flush_deferred_tools_refreshes,
     reset_turn_tool_refresh_state,
 )
+from soothe_cli.tui.widgets.messages.cognition_goal_tree import _normalize_step_dependencies
 
 logger = logging.getLogger(__name__)
 
@@ -1522,8 +1523,9 @@ def _record_plan_step_dag(adapter: TextualUIAdapter, raw_steps: list[Any]) -> No
         order.append(sid)
         in_plan.add(sid)
         raw_deps = raw.get("dependencies")
-        if isinstance(raw_deps, list):
-            dep_map[sid] = tuple(str(dep).strip() for dep in raw_deps if str(dep).strip())
+        deps = _normalize_step_dependencies(raw_deps)
+        if deps:
+            dep_map[sid] = deps
     adapter._plan_step_order = order
     adapter._plan_step_ids = in_plan
     adapter._plan_step_dependencies = dep_map
@@ -1743,7 +1745,7 @@ def _tui_effective_ai_blocks(
     """Build content blocks for TUI streaming (text + tool calls).
 
     Tool kwargs are merged in
-    :func:`soothe_cli.shared.tool_call_resolution.materialize_ai_blocks_with_resolved_tools`.
+    :func:`soothe_cli.runtime.parse.tool_call_resolution.materialize_ai_blocks_with_resolved_tools`.
     """
     from langchain_core.messages import AIMessageChunk
 
@@ -2256,6 +2258,7 @@ async def _try_mount_instant_loop_assistant_phase(
             await current_msg.append_content(text)
             if adapter._sync_message_content and current_msg.id:
                 adapter._sync_message_content(current_msg.id, current_msg._content)
+        await current_msg.stop_stream()
         if adapter._set_active_message:
             adapter._set_active_message(None)
         await _maybe_set_thinking_spinner(adapter, clarification_pending=clarification_pending)
@@ -2270,6 +2273,7 @@ async def _try_mount_instant_loop_assistant_phase(
     assistant_message_by_namespace[ns_key] = output_widget
     if repaired:
         await output_widget.append_content(repaired)
+    await output_widget.stop_stream()
     if adapter._sync_message_content and output_widget.id:
         adapter._sync_message_content(output_widget.id, output_widget._content)
     if adapter._set_active_message:

{soothe_cli-0.7.7 → soothe_cli-0.7.9}/src/soothe_cli/tui/widgets/context_viewer.py

@@ -28,7 +28,7 @@ from soothe_cli.tui.config import get_glyphs, is_ascii_mode
 logger = logging.getLogger(__name__)
 _REFRESH_INTERVAL_S = 1.0
 
-# Status color mapping (mirrors autopilot_dashboard.py conventions)
+# Status color mapping for goal/context display
 STATUS_COLORS: dict[str, str] = {
     "pending": "dim",
     "active": "yellow",

{soothe_cli-0.7.7 → soothe_cli-0.7.9}/src/soothe_cli/tui/widgets/messages/cognition_goal_tree.py

@@ -3,6 +3,8 @@
 from __future__ import annotations
 
 import logging
+import re
+from time import time
 from typing import TYPE_CHECKING, Any
 
 from textual.containers import Vertical
@@ -12,6 +14,7 @@ from textual.widgets import Static
 from soothe_cli.runtime.presentation.duration_format import format_duration
 from soothe_cli.tui import theme
 from soothe_cli.tui.config import get_glyphs
+from soothe_cli.tui.preview_limits import PLAN_QUICK_VIEW_STEP_LINE_MAX_CHARS
 from soothe_cli.tui.widgets.messages._helpers import _assemble_card_header
 
 if TYPE_CHECKING:
@@ -20,14 +23,36 @@ if TYPE_CHECKING:
 logger = logging.getLogger(__name__)
 
 _MAX_GOAL_HEADER = 100
-_MAX_GOAL_STEP_DESC = 200
+_MAX_GOAL_STEP_DESC = 80
+_MAX_STEP_SUMMARY_TAIL = 80
+_MAX_DEPENDENCY_IDS = 3
 
+_DONE_WITH_TOOLS_RE = re.compile(r"^Done(?:\s*\[\d+\s+tools?\])?$", re.IGNORECASE)
 
-def _plan_quick_view_step_summary(success: bool, summary: str) -> str:
+
+def _dependency_suffix(deps: tuple[str, ...]) -> str:
+    """Return a compact dependency hint for plan quick-view rows."""
+    if not deps:
+        return ""
+    shown = deps[:_MAX_DEPENDENCY_IDS]
+    text = ", ".join(shown)
+    if len(deps) > _MAX_DEPENDENCY_IDS:
+        text += ", …"
+    return f" (→ {text})"
+
+
+def _plan_quick_view_step_summary(
+    success: bool,
+    summary: str,
+    *,
+    tool_call_count: int = 0,
+) -> str:
     """Return a Ctrl+T-safe step summary tail (hide recoverable tool errors)."""
     tail = (summary or "").strip()
     if not tail or tail in ("Done", "Failed"):
         return ""
+    if success and tool_call_count > 0 and _DONE_WITH_TOOLS_RE.match(tail):
+        return ""
     if success:
         try:
             from soothe.foundation.sloop.engine.act_wave_finalize import is_error_tool_result_text
@@ -39,6 +64,12 @@ def _plan_quick_view_step_summary(success: bool, summary: str) -> str:
     return tail
 
 
+def _normalize_step_dependencies(raw_deps: Any) -> tuple[str, ...]:
+    if not isinstance(raw_deps, list):
+        return ()
+    return tuple(str(dep).strip() for dep in raw_deps if str(dep).strip())
+
+
 class _StepLineState:
     """Mutable row state for the goal → steps aggregate."""
 
@@ -50,6 +81,8 @@ class _StepLineState:
         "duration_ms",
         "tool_call_count",
         "summary",
+        "dependencies",
+        "started_at",
     )
 
     def __init__(
@@ -62,6 +95,8 @@ class _StepLineState:
         duration_ms: int = 0,
         tool_call_count: int = 0,
         summary: str = "",
+        dependencies: tuple[str, ...] = (),
+        started_at: float | None = None,
     ) -> None:
         self.step_id = step_id
         self.description = description
@@ -70,6 +105,8 @@ class _StepLineState:
         self.duration_ms = duration_ms
         self.tool_call_count = tool_call_count
         self.summary = summary
+        self.dependencies = dependencies
+        self.started_at = started_at
 
 
 class CognitionGoalTreeMessage(Vertical):
@@ -138,8 +175,12 @@ class CognitionGoalTreeMessage(Vertical):
     @staticmethod
     def _clip(text: str, max_len: int) -> str:
         t = (text or "").strip().replace("\n", " ")
+        if max_len <= 0:
+            return "…"
         if len(t) <= max_len:
             return t
+        if max_len == 1:
+            return "…"
         return t[: max_len - 1].rstrip() + "…"
 
     def _goal_tree_status(self) -> str:
@@ -198,45 +239,111 @@ class CognitionGoalTreeMessage(Vertical):
         g = get_glyphs()
         return f"{g.output_prefix} "
 
-    def _goal_tree_step_line_content(self, st: _StepLineState) -> Content:
-        """One goal→step row: dim tree gutter, foreground body (parity with ``CognitionStepMessage`` tool rows)."""
+    def _step_icon(self, st: _StepLineState) -> str:
         g = get_glyphs()
+        if st.phase == "pending" or st.phase == "queued":
+            return g.circle_empty
+        if st.phase == "running":
+            frames = g.spinner_frames
+            return frames[self._spinner_position % len(frames)]
+        return g.checkmark if st.success else g.error
+
+    def _step_stats_suffix(self, st: _StepLineState) -> str:
+        """Duration and tool-count suffix for running or completed rows."""
+        if st.phase == "running":
+            parts: list[str] = []
+            if st.started_at is not None:
+                elapsed_s = max(0.001, time() - st.started_at)
+                parts.append(format_duration(elapsed_s))
+            if st.tool_call_count > 0:
+                parts.append(f"{st.tool_call_count} tools")
+            if not parts:
+                return ""
+            return " · " + " · ".join(parts)
+        if st.phase not in ("done", "error"):
+            return ""
+        dur_s = max(0.001, st.duration_ms / 1000.0)
+        parts = [format_duration(dur_s)]
+        if st.tool_call_count > 0:
+            parts.append(f"{st.tool_call_count} tools")
+        return " · " + " · ".join(parts)
+
+    def _step_summary_suffix(self, st: _StepLineState) -> str:
+        if st.phase not in ("done", "error"):
+            return ""
+        tail = _plan_quick_view_step_summary(
+            st.success,
+            st.summary,
+            tool_call_count=st.tool_call_count,
+        )
+        if not tail:
+            return ""
+        return f" — {self._clip(tail, _MAX_STEP_SUMMARY_TAIL)}"
+
+    def _fit_step_line(
+        self,
+        st: _StepLineState,
+        *,
+        icon: str,
+        max_line_width: int | None,
+    ) -> str:
+        """Build a single-line step row, clipping description to fit ``max_line_width``."""
+        step_prefix = f"{st.step_id}: " if st.step_id else ""
+        dep_suffix = _dependency_suffix(st.dependencies)
+        queued_suffix = " · queued" if st.phase == "queued" else ""
+        stats_suffix = self._step_stats_suffix(st)
+        summary_suffix = self._step_summary_suffix(st)
+        lead = f"{icon} {step_prefix}"
+
+        def assemble(desc: str, *, include_summary: bool) -> str:
+            summary = summary_suffix if include_summary else ""
+            return f"{lead}{desc}{dep_suffix}{queued_suffix}{stats_suffix}{summary}"
+
+        width = max_line_width or PLAN_QUICK_VIEW_STEP_LINE_MAX_CHARS
+        desc = self._clip(st.description, _MAX_GOAL_STEP_DESC)
+        line = assemble(desc, include_summary=True)
+        if len(line) <= width:
+            return line
+
+        line = assemble(desc, include_summary=False)
+        if len(line) <= width:
+            return line
+
+        fixed_len = len(f"{lead}{dep_suffix}{queued_suffix}{stats_suffix}")
+        budget = width - fixed_len
+        clipped_desc = self._clip(st.description, budget)
+        return f"{lead}{clipped_desc}{dep_suffix}{queued_suffix}{stats_suffix}"
+
+    def _goal_tree_step_line_content(
+        self,
+        st: _StepLineState,
+        *,
+        max_line_width: int | None = None,
+    ) -> Content:
+        """One goal→step row: dim tree gutter, foreground body (parity with ``CognitionStepMessage`` tool rows)."""
         try:
             colors = theme.get_theme_colors(self)
         except Exception:  # noqa: BLE001
             colors = theme.DARK_COLORS
         gutter = self._indent_prefix()
-        body = self._clip(st.description, _MAX_GOAL_STEP_DESC)
-        label = f"{st.step_id}: {body}" if st.step_id else body
+        icon = self._step_icon(st)
+        rest = self._fit_step_line(st, icon=icon, max_line_width=max_line_width)
+
         if st.phase == "pending":
-            rest = f"{g.circle_empty} {label}"
             return Content.assemble(
                 Content.styled(gutter, "dim"),
                 Content.styled(rest, "dim"),
             )
         if st.phase == "queued":
-            rest = f"{g.circle_empty} {label} · queued"
             return Content.assemble(
                 Content.styled(gutter, "dim"),
                 Content.styled(rest, colors.cognition),
             )
         if st.phase == "running":
-            frames = g.spinner_frames
-            frame = frames[self._spinner_position % len(frames)]
-            rest = f"{frame} {label}"
             return Content.assemble(
                 Content.styled(gutter, "dim"),
                 Content.styled(rest, colors.foreground),
             )
-        icon = g.checkmark if st.success else g.error
-        dur_s = max(0.001, st.duration_ms / 1000.0)
-        dur = format_duration(dur_s)
-        rest = f"{icon} {label} · {dur}"
-        if st.tool_call_count > 0:
-            rest += f" · {st.tool_call_count} tools"
-        tail = _plan_quick_view_step_summary(st.success, st.summary)
-        if tail:
-            rest += f" — {self._clip(tail, 80)}"
         if st.phase == "error" or (st.phase == "done" and not st.success):
             return Content.assemble(
                 Content.styled(gutter, "dim"),
@@ -247,13 +354,15 @@ class CognitionGoalTreeMessage(Vertical):
             Content.styled(rest, colors.foreground),
         )
 
-    def _assemble_steps_content(self) -> Content:
+    def _assemble_steps_content(self, *, max_line_width: int | None = None) -> Content:
         line_contents: list[Content] = []
         for sid in self._step_order:
             st = self._steps.get(sid)
             if st is None:
                 continue
-            line_contents.append(self._goal_tree_step_line_content(st))
+            line_contents.append(
+                self._goal_tree_step_line_content(st, max_line_width=max_line_width)
+            )
         if not line_contents:
             return Content("")
         parts: list[object] = []
@@ -273,16 +382,29 @@ class CognitionGoalTreeMessage(Vertical):
         except Exception:
             pass
 
-    def plan_quick_view_content(self) -> Content:
+    def plan_quick_view_content(self, *, max_line_width: int | None = None) -> Content:
         """Full goal tree snapshot for the sticky plan quick-view overlay."""
         parts: list[object] = [self._goal_header_content()]
-        steps = self._assemble_steps_content()
+        steps = self._assemble_steps_content(max_line_width=max_line_width)
         if steps.plain.strip():
             parts.extend([Content("\n"), steps])
         if self._footer_visible and self._footer_plain:
             parts.extend([Content("\n"), self._goal_footer_styled_content()])
         return Content.assemble(*parts)
 
+    def sync_running_live_stats(
+        self,
+        stats: dict[str, tuple[int, float | None]],
+    ) -> None:
+        """Update in-flight tool counts and started_at from step cards."""
+        for sid, (tool_count, started_at) in stats.items():
+            st = self._steps.get(sid)
+            if st is None or st.phase != "running":
+                continue
+            st.tool_call_count = max(0, int(tool_count))
+            if started_at is not None:
+                st.started_at = started_at
+
     def tick_running_spinner(self) -> None:
         """Advance the running-row spinner when any step is in flight."""
         if not any(st.phase == "running" for st in self._steps.values()):
@@ -339,6 +461,8 @@ class CognitionGoalTreeMessage(Vertical):
                     "duration_ms": st.duration_ms,
                     "tool_call_count": st.tool_call_count,
                     "summary": st.summary,
+                    "dependencies": list(st.dependencies),
+                    "started_at": st.started_at,
                 }
             )
         return {
@@ -366,6 +490,8 @@ class CognitionGoalTreeMessage(Vertical):
             sid = str(row.get("id", "")).strip()
             if not sid:
                 continue
+            started_raw = row.get("started_at")
+            started_at = float(started_raw) if started_raw is not None else None
             st = _StepLineState(
                 sid,
                 str(row.get("description", "")),
@@ -374,6 +500,8 @@ class CognitionGoalTreeMessage(Vertical):
                 duration_ms=int(row.get("duration_ms", 0)),
                 tool_call_count=int(row.get("tool_call_count", 0)),
                 summary=str(row.get("summary", "")),
+                dependencies=_normalize_step_dependencies(row.get("dependencies")),
+                started_at=started_at,
             )
             self._step_order.append(sid)
             self._steps[sid] = st
@@ -398,14 +526,23 @@ class CognitionGoalTreeMessage(Vertical):
                 continue
             planned_ids.add(sid)
             desc = str(row.get("description", "")).strip() or "(step)"
+            deps = _normalize_step_dependencies(row.get("dependencies"))
             existing = self._steps.get(sid)
             if existing is None:
                 self._step_order.append(sid)
-                self._steps[sid] = _StepLineState(sid, desc, phase="pending")
+                self._steps[sid] = _StepLineState(
+                    sid,
+                    desc,
+                    phase="pending",
+                    dependencies=deps,
+                )
             elif existing.phase in ("pending", "queued"):
                 existing.description = desc
+                existing.dependencies = deps
             elif existing.phase == "running" and desc:
                 existing.description = desc
+                if deps:
+                    existing.dependencies = deps
         for sid in list(self._step_order):
             st = self._steps.get(sid)
             if st is not None and st.phase == "pending" and sid not in planned_ids:
@@ -440,12 +577,10 @@ class CognitionGoalTreeMessage(Vertical):
             st.phase = phase
             if desc:
                 st.description = desc
+        if phase == "running" and st.started_at is None:
+            st.started_at = time()
         self._refresh_steps_display()
 
-    def add_step_running(self, step_id: str, description: str) -> None:
-        """Register a step in running state and refresh the aggregate."""
-        self.set_step_phase(step_id, "running", description=description)
-
     def complete_step(
         self,
         step_id: str,
@@ -468,6 +603,7 @@ class CognitionGoalTreeMessage(Vertical):
         st.duration_ms = duration_ms
         st.tool_call_count = tool_call_count
         st.summary = summary or ""
+        st.started_at = None
         self._refresh_steps_display()
 
     def set_loop_finished(
@@ -523,6 +659,7 @@ class CognitionGoalTreeMessage(Vertical):
                 st.success = False
                 st.duration_ms = 0
                 st.summary = msg
+                st.started_at = None
         self._refresh_steps_display()
         self._footer_plain = self._clip(msg, 120)
         self._footer_visible = True

{soothe_cli-0.7.7 → soothe_cli-0.7.9}/src/soothe_cli/tui/widgets/plan_quick_view_overlay.py

@@ -9,6 +9,8 @@ from textual.containers import Vertical, VerticalScroll
 from textual.content import Content
 from textual.widgets import Static
 
+from soothe_cli.tui.config import get_glyphs
+from soothe_cli.tui.preview_limits import PLAN_QUICK_VIEW_STEP_LINE_MAX_CHARS
 from soothe_cli.tui.widgets.messages._helpers import _RUNNING_SPINNER_INTERVAL_SECONDS
 
 if TYPE_CHECKING:
@@ -29,6 +31,17 @@ def get_live_goal_tree(app: Any) -> CognitionGoalTreeMessage | None:
     return tree
 
 
+def _goal_tree_running_live_stats(adapter: Any) -> dict[str, tuple[int, float | None]]:
+    """Collect live tool counts and start times from running step cards."""
+    stats: dict[str, tuple[int, float | None]] = {}
+    for sid, card in getattr(adapter, "_current_step_messages", {}).items():
+        if card._status != "running":
+            continue
+        idx = card._build_row_index()
+        stats[sid] = (idx.main_tool_count, card._start_time)
+    return stats
+
+
 class PlanQuickViewOverlay(Vertical):
     """Floating quick-view panel of the full plan above the chat prompt.
 
@@ -143,8 +156,21 @@ class PlanQuickViewOverlay(Vertical):
             self._content.update(Content.styled("No active plan.", "dim"))
             return
         try:
+            adapter = getattr(self.app, "_ui_adapter", None)
+            if adapter is not None:
+                tree.sync_running_live_stats(_goal_tree_running_live_stats(adapter))
             tree.tick_running_spinner()
-            self._content.update(tree.plan_quick_view_content())
+            max_line_width = self._plan_quick_view_line_width()
+            self._content.update(tree.plan_quick_view_content(max_line_width=max_line_width))
         except Exception:  # noqa: BLE001
             logger.debug("Failed to render plan quick view", exc_info=True)
             self._content.update(Content.styled("(plan view unavailable)", "dim"))
+
+    def _plan_quick_view_line_width(self) -> int:
+        """Available columns for one plan step row inside the overlay."""
+        overlay_padding = 4
+        gutter_len = len(get_glyphs().output_prefix) + 1
+        width = self.size.width if self.size.width else 0
+        if width > overlay_padding + gutter_len:
+            return max(PLAN_QUICK_VIEW_STEP_LINE_MAX_CHARS, width - overlay_padding - gutter_len)
+        return PLAN_QUICK_VIEW_STEP_LINE_MAX_CHARS

soothe_cli-0.7.7/src/soothe_cli/runtime/wire/display_text.py

@@ -1,15 +0,0 @@
-"""Re-export shim for ``soothe_sdk.display.text_extract`` (RFC-413)."""
-
-from __future__ import annotations
-
-from soothe_sdk.display.text_extract import (
-    extract_ai_text_for_display,
-    extract_user_text_for_display,
-    normalize_stream_message,
-)
-
-__all__ = [
-    "extract_ai_text_for_display",
-    "extract_user_text_for_display",
-    "normalize_stream_message",
-]