soothe-cli 1.0.3__tar.gz → 1.0.5__tar.gz

{soothe_cli-1.0.3 → soothe_cli-1.0.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: soothe-cli
-Version: 1.0.3
+Version: 1.0.5
 Summary: Soothe CLI client - communicates with daemon via WebSocket
 Project-URL: Homepage, https://github.com/mirasoth/soothe
 Project-URL: Documentation, https://soothe.readthedocs.io
@@ -21,7 +21,7 @@ Requires-Dist: pillow<12.0.0,>=10.0.0
 Requires-Dist: python-dotenv<2.0.0,>=1.0.0
 Requires-Dist: pyyaml<7.0.0,>=6.0.0
 Requires-Dist: rich<15.0.0,>=13.0.0
-Requires-Dist: soothe-client-python<2.0.0,>=1.0.18
+Requires-Dist: soothe-client-python<2.0.0,>=1.0.21
 Requires-Dist: soothe-sdk<2.0.0,>=1.0.12
 Requires-Dist: termaid<1.0.0,>=0.7.1
 Requires-Dist: textual<10.0.0,>=8.0.0

{soothe_cli-1.0.3 → soothe_cli-1.0.5}/pyproject.toml

@@ -23,7 +23,7 @@ classifiers = [
 ]
 dependencies = [
     "soothe-sdk>=1.0.12,<2.0.0",   # events/display/wire contracts
-    "soothe-client-python>=1.0.18,<2.0.0",  # WebSocket transport client; matched to latest release v1.0.18
+    "soothe-client-python>=1.0.21,<2.0.0",  # WebSocket transport client; matched to latest release v1.0.21
     "typer>=0.9.0,<2.0.0",          # CLI framework
     "textual>=8.0.0,<10.0.0",       # TUI framework
     "rich>=13.0.0,<15.0.0",         # Console output

{soothe_cli-1.0.3 → soothe_cli-1.0.5}/src/soothe_cli/cli/main.py

@@ -198,10 +198,10 @@ def main(
             help=(
                 "Auto-show the in-flow plan panel while a goal is executing "
                 "and hide it when the goal completes. Ctrl+t toggles "
-                "thereafter. Default: enabled."
+                "thereafter. Default: disabled (hidden)."
             ),
         ),
-    ] = True,
+    ] = False,
     show_version: Annotated[  # noqa: FBT002
         bool,
         typer.Option("--version", help="Show version and exit."),

{soothe_cli-1.0.3 → soothe_cli-1.0.5}/src/soothe_cli/commands/slash_commands.py

@@ -154,7 +154,7 @@ KEYBOARD_SHORTCUTS: dict[str, str] = {
     "Ctrl+V": "Paste image from clipboard as [image N] attachment",
     "Ctrl+T": "Toggle plan panel above thinking row",
     "Ctrl+O": "Toggle expand/collapse of the most recent skill or tool card",
-    "Shift+Tab": "Cycle composer mode (Auto → Manual → Plan → Ask)",
+    "Shift+Tab": "Cycle composer mode (Auto → Bypass → Manual → Plan → Ask)",
 }
 
 

{soothe_cli-1.0.3 → soothe_cli-1.0.5}/src/soothe_cli/config/cli_config.py

@@ -33,9 +33,9 @@ class CLIConfig:
     """Markdown appearance preset (``match-app``, ``langchain``, ``standard``, …)."""
 
     # Plan panel visibility preference
-    plan_panel_default_visible: bool = True
+    plan_panel_default_visible: bool = False
     """When True, auto-show the in-flow plan panel while a goal is executing and
-    hide it when the goal completes. Default True (Ctrl+t to close)."""
+    hide it when the goal completes. Default False (hidden; Ctrl+t to open)."""
 
     # Output streaming overrides (RFC-614)
     output_streaming_enabled: bool | None = None

{soothe_cli-1.0.3 → soothe_cli-1.0.5}/src/soothe_cli/display/tips.py

@@ -1,4 +1,4 @@
-"""Rotating session tips for the status bar below the chat input."""
+"""Rotating session tips for the thinking row shown when the loop is idle."""
 
 from __future__ import annotations
 

{soothe_cli-1.0.3 → soothe_cli-1.0.5}/src/soothe_cli/tui/app/_app.py

@@ -40,7 +40,7 @@ from soothe_cli.tui.app._types import (
 from soothe_cli.tui.app._ui import _UIMixin
 from soothe_cli.tui.composer_mode import normalize_composer_mode
 from soothe_cli.tui.widgets.chat_input import ChatInput
-from soothe_cli.tui.widgets.loading import LoadingWidget
+from soothe_cli.tui.widgets.loading import LoadingWidget, TipRow
 from soothe_cli.tui.widgets.message_store import MessageStore
 from soothe_cli.tui.widgets.messages import (
     AssistantMessage,
@@ -48,6 +48,7 @@ from soothe_cli.tui.widgets.messages import (
 )
 from soothe_cli.tui.widgets.pinned_goal_bar import PinnedGoalBar
 from soothe_cli.tui.widgets.plan_quick_view_overlay import PlanQuickViewOverlay
+from soothe_cli.tui.widgets.queued_goals_bar import QueuedGoalsBar
 from soothe_cli.tui.widgets.status import StatusBar
 from soothe_cli.tui.widgets.welcome import WelcomeBanner
 
@@ -133,6 +134,13 @@ class SootheApp(
             show=False,
             priority=True,
         ),
+        Binding(
+            "ctrl+q",
+            "focus_queued_goals",
+            "Focus Queued Goals",
+            show=False,
+            priority=True,
+        ),
     ]
     """App-level keybindings for dismiss, quit, and navigation."""
 
@@ -226,10 +234,11 @@ class SootheApp(
         self._mcp_tool_count = sum(len(s.tools) for s in (mcp_server_info or []))
 
         self._status_bar: StatusBar | None = None
+        self._tip_row: TipRow | None = None
         self._default_session_tip: str = ""
         self._status_notification_timer: Timer | None = None
         self._status_notification_active = False
-        # Rotating tip source + interval timer for the status footer.
+        # Rotating tip source + interval timer for the thinking row.
         self._tip_rotator: TipRotator = TipRotator()
         self._tip_rotation_timer: Timer | None = None
 
@@ -381,11 +390,11 @@ class SootheApp(
         """Persist and render the fallback tip shown when no notification is active."""
         cleaned = (tip or "").strip()
         self._default_session_tip = cleaned
-        if self._status_bar is not None and not self._status_notification_active:
-            self._status_bar.set_session_tip(cleaned)
+        if self._tip_row is not None and not self._status_notification_active:
+            self._tip_row.set_tip(cleaned)
 
     def start_tip_rotation(self, interval: float = 12.0) -> None:
-        """Cycle through rotating tips in the status footer at a fixed interval.
+        """Cycle through rotating tips in the thinking row at a fixed interval.
 
         Args:
         interval: Seconds between tip rotations.
@@ -401,7 +410,7 @@ class SootheApp(
             self._tip_rotation_timer = None
 
     def _rotate_session_tip(self) -> None:
-        """Advance to the next tip and push it to the status footer.
+        """Advance to the next tip and push it to the thinking row.
 
         Transient notifications take precedence: rotation is skipped while a
         notification is active so it can run its timeout uninterrupted.
@@ -411,7 +420,7 @@ class SootheApp(
         self.set_default_session_tip(self._tip_rotator.next_tip())
 
     def _set_status_notification(self, message: str, *, timeout: float | None = None) -> None:
-        """Render a transient notification in the status-tip area."""
+        """Render a transient notification in the thinking-row tip area."""
         text = (message or "").strip()
         if not text:
             return
@@ -420,8 +429,8 @@ class SootheApp(
                 self._status_notification_timer.stop()
             self._status_notification_timer = None
         self._status_notification_active = True
-        if self._status_bar is not None:
-            self._status_bar.set_notification_message(text)
+        if self._tip_row is not None:
+            self._tip_row.set_notification(text)
 
         duration = timeout if timeout and timeout > 0 else 3.0
         self._status_notification_timer = self.set_timer(duration, self._clear_status_notification)
@@ -430,8 +439,8 @@ class SootheApp(
         """Restore the default tip after transient notification timeout."""
         self._status_notification_timer = None
         self._status_notification_active = False
-        if self._status_bar is not None:
-            self._status_bar.set_session_tip(self._default_session_tip)
+        if self._tip_row is not None:
+            self._tip_row.set_tip(self._default_session_tip)
 
     def notify(  # type: ignore[override]
         self,
@@ -442,7 +451,7 @@ class SootheApp(
         timeout: float | None = None,
         markup: bool = True,  # noqa: ARG002
     ) -> None:
-        """Display notifications in the status-tip area instead of toast bubbles."""
+        """Display notifications in the thinking-row tip area instead of toast bubbles."""
         text = str(message or "").strip()
         if not text:
             return
@@ -488,14 +497,22 @@ class SootheApp(
         # In-flow plan panel: sits above the sticky bottom chrome so Ctrl+t
         # never covers the thinking row or chat input. Auto-shows while a goal
         # is executing when CLIConfig.plan_panel_default_visible is True
-        # (default); --no-plan-panel disables it.
-        plan_visible = getattr(self._daemon_config, "plan_panel_default_visible", True)
+        # (--plan-panel); default is False (hidden, Ctrl+t to open).
+        plan_visible = getattr(self._daemon_config, "plan_panel_default_visible", False)
         yield PlanQuickViewOverlay(
             id="plan-quick-view-overlay",
             default_visible=plan_visible,
         )
         with Container(id="bottom-app-container"):
-            yield Container(id="thinking-status")
+            # Queued goals bar — inside the docked bottom container, above
+            # the thinking row and chat input. Hidden when the queue is
+            # empty; shows all pending queued goals as selectable rows.
+            # Placed inside #bottom-app-container (rather than as a separate
+            # docked sibling) because Textual does not stack multiple
+            # docked-to-same-edge widgets — they overlap instead.
+            yield QueuedGoalsBar(id="queued-goals")
+            with Container(id="thinking-status"):
+                yield TipRow(id="tip-row")
             yield ChatInput(
                 cwd=self._cwd,
                 image_tracker=self._image_tracker,

{soothe_cli-1.0.3 → soothe_cli-1.0.5}/src/soothe_cli/tui/app/_execution.py

@@ -189,10 +189,7 @@ class _ExecutionMixin:
                 await self._process_message(value, mode)
                 return
             self._pending_messages.append(QueuedMessage(text=value, mode=mode))
-            queued_widget = QueuedUserMessage(value)
-            self._queued_widgets.append(queued_widget)
             self._refresh_queued_goal_tips()
-            await self._mount_message(queued_widget)
             return
 
         await self._process_message(value, mode)
@@ -576,14 +573,12 @@ class _ExecutionMixin:
         if self._agent_running or self._shell_running:
             queued_widget = QueuedUserMessage(command)
             self._queued_widgets.append(queued_widget)
-            self._refresh_queued_goal_tips()
             await self._mount_message(queued_widget)
 
             async def _mount_output() -> None:
                 # Remove the ephemeral queued widget, then mount real output.
                 if queued_widget in self._queued_widgets:
                     self._queued_widgets.remove(queued_widget)
-                    self._refresh_queued_goal_tips()
                 with suppress(Exception):
                     await queued_widget.remove()
                 await self._mount_message(UserMessage(command))
@@ -677,6 +672,7 @@ class _ExecutionMixin:
         elif cmd == "/clear":
             self._pending_messages.clear()
             self._queued_widgets.clear()
+            self._refresh_queued_goal_tips()
             await self._clear_messages()
             self._reset_loop_token_usage(None)
             # Clear status message (e.g., "Interrupted" from previous session)
@@ -941,6 +937,10 @@ class _ExecutionMixin:
                         )
                     )
                     return
+                except Exception as exc:
+                    logger.warning("Unexpected error connecting to daemon", exc_info=True)
+                    await self._mount_message(ErrorMessage(f"Unexpected connection error. {exc}"))
+                    return
             self._agent_running = True
 
             # Stop passive reads so active turn streaming has sole websocket access.
@@ -1093,6 +1093,11 @@ class _ExecutionMixin:
                             continue
                         except (ConnectionError, OSError, TimeoutError):
                             pass
+                        except Exception:
+                            logger.debug(
+                                "Unexpected error during daemon reconnect retry",
+                                exc_info=True,
+                            )
                     raise
         except Exception as e:  # Resilient tool rendering
             # Attach-only idle timeout is benign: the prior turn had already
@@ -1156,12 +1161,7 @@ class _ExecutionMixin:
         self._processing_pending = True
         try:
             msg = self._pending_messages.popleft()
-
-            # Remove the ephemeral queued-message widget
-            if self._queued_widgets:
-                widget = self._queued_widgets.popleft()
-                await widget.remove()
-                self._refresh_queued_goal_tips()
+            self._refresh_queued_goal_tips()
 
             await self._process_message(msg.text, msg.mode)
         except Exception:
@@ -1292,11 +1292,7 @@ class _ExecutionMixin:
         if self._pending_messages:
             msg = self._pending_messages.popleft()
             prompt = msg.text
-            if self._queued_widgets:
-                widget = self._queued_widgets.popleft()
-                with suppress(Exception):
-                    await widget.remove()
-                self._refresh_queued_goal_tips()
+            self._refresh_queued_goal_tips()
             if msg.mode != "normal":
                 # Shell/command still need their normal handlers.
                 await self._process_message(msg.text, msg.mode)

{soothe_cli-1.0.3 → soothe_cli-1.0.5}/src/soothe_cli/tui/app/_messages_mixin.py

@@ -38,6 +38,7 @@ from soothe_cli.tui.widgets.messages import (
     SkillMessage,
     SummarizationMessage,
 )
+from soothe_cli.tui.widgets.queued_goals_bar import QueuedGoalsBar
 
 logger = logging.getLogger(__name__)
 
@@ -66,17 +67,40 @@ class _MessagesMixin:
     """Message widget lifecycle, store management, queue, interrupt/quit, toggles, editor, and events."""
 
     def _refresh_queued_goal_tips(self) -> None:
-        """Show queue interaction tips on the most recently queued goal only."""
-        if not self._queued_widgets:
+        """Sync the queued goals bar with the current queue state.
+
+        Feeds the current ``_pending_messages`` snapshot to the
+        ``QueuedGoalsBar`` so it re-renders all rows.  Shows queue
+        interaction tips on the bar when the tail goal is a normal-mode
+        goal and the agent is running.
+        """
+        self._sync_queued_goals_bar()
+        if not self._pending_messages:
             return
-        tip_index: int | None = None
+        show_tips = False
         if self._pending_messages and self._pending_messages[-1].mode == "normal":
-            pending_tail_index = len(self._pending_messages) - 1
-            if pending_tail_index < len(self._queued_widgets):
-                tip_index = pending_tail_index
-        for index, widget in enumerate(self._queued_widgets):
-            with suppress(Exception):
-                widget.set_show_queue_tips(tip_index is not None and index == tip_index)
+            show_tips = True
+        try:
+            bar = self.query_one("#queued-goals", QueuedGoalsBar)
+        except Exception:
+            # NoMatches, ScreenStackError, or no app/screen in test stubs.
+            return
+        with suppress(Exception):
+            bar.set_show_tips(show_tips)
+
+    def _sync_queued_goals_bar(self) -> None:
+        """Push the current ``_pending_messages`` snapshot to the bar widget.
+
+        Safe to call when the bar is not yet mounted (e.g. during startup
+        or in unit tests using stubs) — the call is silently skipped.
+        """
+        try:
+            bar = self.query_one("#queued-goals", QueuedGoalsBar)
+        except Exception:
+            # NoMatches, ScreenStackError, or no app/screen in test stubs.
+            return
+        goals = list(self._pending_messages)
+        bar.set_goals(goals)
 
     def _has_pending_chat_input(self) -> bool:
         """Return whether chat input has draft content that should be preserved."""
@@ -369,7 +393,11 @@ class _MessagesMixin:
         return False
 
     def _assistant_card_already_visible(self, card: Any) -> bool:
-        """True when stream already mounted this assistant body (avoid double report)."""
+        """True when the stream already mounted this assistant body.
+
+        Also suppresses the raw plan ASSISTANT card when a plan-review
+        `StructuredAskUserWidget` with overlapping body is mounted.
+        """
         from soothe_sdk.display.transcript_types import MessageType
 
         adapter = getattr(self, "_ui_adapter", None)
@@ -388,6 +416,54 @@ class _MessagesMixin:
                 return True
             # Only inspect the latest assistant card.
             break
+        # Plan-mode: suppress ASSISTANT card when a plan-review widget already
+        # shows the same plan body.
+        if self._plan_review_widget_shows_text(text):
+            return True
+        return False
+
+    @staticmethod
+    def _text_overlaps_plan_body(text: str, body: str) -> bool:
+        """True when `text` and `body` overlap (exact, prefix, substring, or 200-char prefix).
+
+        Substring checks require the shorter string to be at least 50 chars
+        to avoid false positives.
+        """
+        if not text or not body:
+            return False
+        if text == body or text.startswith(body) or body.startswith(text):
+            return True
+        # Substring containment: handles preface trimming (e.g. "Here is the
+        # plan.\n\n## Plan:..." card vs "## Plan:..." widget body). Require the
+        # shorter string to be at least 50 chars to avoid false positives.
+        shorter = body if len(body) <= len(text) else text
+        longer = text if shorter is body else body
+        if len(shorter) >= 50 and shorter in longer:
+            return True
+        # Handle truncation: compare a significant prefix of the shorter text.
+        prefix_len = min(200, len(text), len(body))
+        if prefix_len >= 50 and text[:prefix_len] == body[:prefix_len]:
+            return True
+        return False
+
+    def _plan_review_widget_shows_text(self, text: str) -> bool:
+        """True when a mounted plan-review widget's body overlaps `text`.
+
+        Only plan-review widgets (`_is_plan_review`) are considered, so
+        non-plan ASSISTANT cards are never suppressed.
+        """
+        adapter = getattr(self, "_ui_adapter", None)
+        if adapter is None:
+            return False
+        by_step = getattr(adapter, "_clarification_input_by_step", None) or {}
+        for widget in by_step.values():
+            if not getattr(widget, "_is_plan_review", False):
+                continue
+            body = str(getattr(widget, "_body_markdown", "") or "").strip()
+            if not body:
+                continue
+            if self._text_overlaps_plan_body(text, body):
+                return True
         return False
 
     def _cognition_reason_already_visible(self, card: Any) -> bool:
@@ -624,18 +700,15 @@ class _MessagesMixin:
         await self._set_spinner(None)
 
     def _pop_last_queued_entry(self) -> Any | None:
-        """Pop the latest queued message and paired widget, if available."""
+        """Pop the latest queued message, if available.
+
+        Removes the tail entry from ``_pending_messages`` and refreshes
+        the ``QueuedGoalsBar`` so the row disappears.
+        """
         if not self._pending_messages:
             return None
         msg = self._pending_messages.pop()
-        if self._queued_widgets:
-            widget = self._queued_widgets.pop()
-            widget.remove()
-            self._refresh_queued_goal_tips()
-        else:
-            logger.warning(
-                "Queued-widget deque empty while pending-messages was not; widget/message tracking may be out of sync"
-            )
+        self._refresh_queued_goal_tips()
         return msg
 
     def _restore_last_queued_goal_to_input(self) -> bool:
@@ -661,11 +734,10 @@ class _MessagesMixin:
         return True
 
     def _discard_queue(self) -> None:
-        """Clear pending messages, deferred actions, and queued widgets."""
+        """Clear pending messages, deferred actions, and queued goals bar."""
         self._pending_messages.clear()
-        for w in self._queued_widgets:
-            w.remove()
         self._queued_widgets.clear()
+        self._refresh_queued_goal_tips()
         self._deferred_actions.clear()
 
     def _cancel_last_queued_message(self) -> bool:
@@ -687,6 +759,86 @@ class _MessagesMixin:
             return False
         return self._restore_last_queued_goal_to_input()
 
+    def cancel_queued_goal_at_index(self, index: int) -> bool:
+        """Cancel the queued goal at ``index`` without restoring it to input.
+
+        Args:
+            index: Zero-based index into ``_pending_messages`` (0 = head/oldest).
+
+        Returns:
+            ``True`` when a goal was cancelled, ``False`` when the index is
+            out of range.
+        """
+        if index < 0 or index >= len(self._pending_messages):
+            return False
+        # deque doesn't support del[] — convert to list, remove, rebuild.
+        items = list(self._pending_messages)
+        msg = items.pop(index)
+        self._pending_messages.clear()
+        self._pending_messages.extend(items)
+        self._refresh_queued_goal_tips()
+        self.notify(f"Cancelled queued goal: {msg.text[:60]}", timeout=2)
+        return True
+
+    def edit_queued_goal_at_index(self, index: int) -> bool:
+        """Move the queued goal at ``index`` into the chat input for editing.
+
+        Only normal-mode goals can be edited; shell/command goals are skipped
+        to avoid clobbering the input with a mode prefix.
+
+        Args:
+            index: Zero-based index into ``_pending_messages`` (0 = head/oldest).
+
+        Returns:
+            ``True`` when the goal was moved to input, ``False`` otherwise.
+        """
+        if index < 0 or index >= len(self._pending_messages):
+            return False
+        if self._has_pending_chat_input():
+            return False
+        items = list(self._pending_messages)
+        msg = items[index]
+        if msg.mode != "normal":
+            return False
+        items.pop(index)
+        self._pending_messages.clear()
+        self._pending_messages.extend(items)
+        if self._chat_input:
+            self._chat_input.value = msg.text
+        self._refresh_queued_goal_tips()
+        self.notify("Queued goal moved to input", timeout=2)
+        return True
+
+    def submit_queued_goal_at_index(self, index: int) -> bool:
+        """Submit the queued goal at ``index`` for immediate execution.
+
+        Pops the goal from the queue and processes it right away, bypassing
+        the normal FIFO order.  Only valid when no agent/worker is already
+        running, since submitting while busy would just re-queue the goal.
+
+        Args:
+            index: Zero-based index into ``_pending_messages`` (0 = head/oldest).
+
+        Returns:
+            ``True`` when the goal was submitted, ``False`` when the index is
+            out of range or an agent is already running.
+        """
+        if index < 0 or index >= len(self._pending_messages):
+            return False
+        if self._agent_running or self._shell_running or self._processing_pending:
+            self.notify("Agent is busy — goal stays queued", timeout=2)
+            return False
+        items = list(self._pending_messages)
+        msg = items.pop(index)
+        self._pending_messages.clear()
+        self._pending_messages.extend(items)
+        self._refresh_queued_goal_tips()
+        import asyncio
+
+        asyncio.ensure_future(self._process_message(msg.text, msg.mode))
+        self.notify(f"Submitting: {msg.text[:60]}", timeout=2)
+        return True
+
     def _defer_action(self, action: DeferredAction) -> None:
         """Queue a deferred action, replacing any existing action of the same kind.
 
@@ -891,13 +1043,25 @@ class _MessagesMixin:
 
         # Close completion popup or exit slash/shell command mode
         if self._chat_input:
-            # When queue has pending goals and input is idle, Esc cancels the
-            # latest queued normal goal (without interrupting current work).
+            # When queue has pending goals and input is idle, Esc cancels a
+            # queued normal goal (without interrupting current work). If the
+            # QueuedGoalsBar is focused, cancel the selected goal; otherwise
+            # cancel the latest (tail) goal.
             if not self._has_pending_chat_input():
-                queue_tail = self._pending_messages[-1] if self._pending_messages else None
-                if queue_tail is not None and queue_tail.mode == "normal":
-                    if self._cancel_last_queued_message():
-                        return
+                cancelled = False
+                try:
+                    bar = self.query_one("#queued-goals", QueuedGoalsBar)
+                except Exception:
+                    # NoMatches, ScreenStackError, or no app/screen in test stubs.
+                    bar = None
+                if bar is not None and self.focused is bar:
+                    cancelled = bar.cancel_selected()
+                if not cancelled:
+                    queue_tail = self._pending_messages[-1] if self._pending_messages else None
+                    if queue_tail is not None and queue_tail.mode == "normal":
+                        cancelled = self._cancel_last_queued_message()
+                if cancelled:
+                    return
             if self._chat_input.dismiss_completion():
                 return
             if self._chat_input.exit_mode():
@@ -983,7 +1147,7 @@ class _MessagesMixin:
         """Shift+Tab: navigate loop selector when active, otherwise cycle mode.
 
         - In the LoopSelectorScreen, defer to its filter navigation.
-        - On the main screen, cycle composer mode Auto → Manual → Plan → Ask.
+        - On the main screen, cycle composer mode Auto → Bypass → Manual → Plan → Ask.
         """
         from soothe_cli.tui.widgets.loop_selector import LoopSelectorScreen
 
@@ -995,15 +1159,9 @@ class _MessagesMixin:
     def cycle_composer_mode(self) -> None:
         """Advance composer mode and refresh the status-bar badge.
 
-        The mode is held on the app (`self._composer_mode`). Auto/Manual map
-        to the `clarification_mode` wire field; Plan sets
-        `interaction_mode=plan` on subsequent turns. The badge updates
-        immediately; no toast is emitted because the badge is the feedback.
-
-        When a goal is running and the new mode is Auto or Manual, the mode is
-        also hot-swapped on the daemon's live `LoopRuntimeContext` via the
-        `loop_set_clarification_mode` RPC so the next clarification uses the
-        new policy without waiting for the next turn.
+        Cycle: Auto → Bypass → Manual → Plan → Ask → Auto. When a goal is
+        running and the new mode is Auto or Manual, hot-swaps the daemon's
+        live clarification policy via `loop_set_clarification_mode`.
         """
         from soothe_cli.tui.composer_mode import next_composer_mode
 

{soothe_cli-1.0.3 → soothe_cli-1.0.5}/src/soothe_cli/tui/app/_model.py

@@ -486,6 +486,7 @@ class _ModelMixin:
             # Clear conversation (similar to /clear, without creating a new loop)
             self._pending_messages.clear()
             self._queued_widgets.clear()
+            self._refresh_queued_goal_tips()
             await self._clear_messages()
             self._reset_loop_token_usage(None)
             self._update_status("")

{soothe_cli-1.0.3 → soothe_cli-1.0.5}/src/soothe_cli/tui/app/_startup.py

@@ -24,6 +24,7 @@ from soothe_cli.tui.app._types import (
     TextualSessionState,
 )
 from soothe_cli.tui.widgets.chat_input import ChatInput
+from soothe_cli.tui.widgets.loading import TipRow
 from soothe_cli.tui.widgets.messages import (
     AppMessage,
     ErrorMessage,
@@ -129,6 +130,7 @@ class _StartupMixin:
         self.watch(chat, "scroll_y", self._on_chat_scroll_y_changed)
 
         self._status_bar = self.query_one("#status-bar", StatusBar)
+        self._tip_row = self.query_one("#tip-row", TipRow)
         self._chat_input = self.query_one("#input-area", ChatInput)
         with suppress(NoMatches):
             from soothe_cli.tui.widgets.plan_quick_view_overlay import PlanQuickViewOverlay
@@ -142,8 +144,11 @@ class _StartupMixin:
         # hard-coded "auto" fallback before the daemon-default seed runs).
         self._status_bar.set_clarification_mode(self._composer_mode)
 
-        # Seed the status footer with the first rotating tip and start rotation.
+        # Seed the thinking-row tip with the first rotating tip and start rotation.
+        # The tip row is visible while the loop is idle; `_set_spinner` hides it
+        # when the agent starts working and restores it when the loop goes idle.
         self.set_default_session_tip(self._tip_rotator.next_tip())
+        self._show_tip_row()
         self.start_tip_rotation()
 
         # Focus the input immediately so the cursor is visible on first paint
@@ -641,9 +646,8 @@ class _StartupMixin:
         # Discard any messages queued while connecting
         if self._pending_messages:
             self._pending_messages.clear()
-            for w in self._queued_widgets:
-                w.remove()
             self._queued_widgets.clear()
+            self._refresh_queued_goal_tips()
         self._deferred_actions.clear()
 
     @staticmethod