soothe-cli 1.0.1__tar.gz → 1.0.4__tar.gz

{soothe_cli-1.0.1 → soothe_cli-1.0.4}/.gitignore

@@ -235,3 +235,4 @@ __MACOSX
 
 # Accidental MemU test persist_dir artifacts
 packages/soothe/MagicMock/
+uv.lock

{soothe_cli-1.0.1 → soothe_cli-1.0.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: soothe-cli
-Version: 1.0.1
+Version: 1.0.4
 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.1 → soothe_cli-1.0.4}/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.1 → soothe_cli-1.0.4}/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.1 → soothe_cli-1.0.4}/src/soothe_cli/commands/binding.py

@@ -155,14 +155,14 @@ def message_to_widget(data: MessageData) -> Widget:
             is_tool_approval = origin == "tool_approval"
             refine_label = "Edit" if is_tool_approval else "Refine"
             question_spec = {
-                "question": "Action for this plan: Approve, Refine, or Reject?"
+                "question": "Action for this plan: Approve, Reject, or Refine?"
                 if not is_tool_approval
                 else "Approve this tool call?",
                 "header": "Plan review" if not is_tool_approval else "Tool approval",
                 "options": [
                     {"label": "Approve", "description": "Accept and proceed."},
-                    {"label": refine_label, "description": "Request changes."},
                     {"label": "Reject", "description": "Reject."},
+                    {"label": refine_label, "description": "Request changes."},
                 ],
             }
             w = StructuredAskUserWidget(
@@ -261,7 +261,7 @@ def message_from_widget(widget: Widget) -> MessageData:
         # Awaiting state for HITL origins.
         if is_hitl and not widget._submitted:  # noqa: SLF001
             if is_plan_review:
-                content = "Plan review: awaiting Approve / Refine / Reject"
+                content = "Plan review: awaiting Approve / Reject / Refine"
             else:
                 content = "Tool approval: awaiting Approve / Edit / Reject"
             return MessageData(type=MessageType.APP, content=content, id=widget_id)

{soothe_cli-1.0.1 → soothe_cli-1.0.4}/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.1 → soothe_cli-1.0.4}/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.1 → soothe_cli-1.0.4}/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.1 → soothe_cli-1.0.4}/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,
@@ -226,10 +226,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 +382,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 +402,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 +412,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 +421,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 +431,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 +443,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 +489,15 @@ 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")
+            with Container(id="thinking-status"):
+                yield TipRow(id="tip-row")
             yield ChatInput(
                 cwd=self._cwd,
                 image_tracker=self._image_tracker,

{soothe_cli-1.0.1 → soothe_cli-1.0.4}/src/soothe_cli/tui/app/_execution.py

@@ -341,6 +341,10 @@ class _ExecutionMixin:
         # next pauses, which freezes scrolling and chat-input focus.
         await self._send_to_agent(payload_text)
 
+        # Return focus to the chat input so the user can type immediately.
+        with suppress(Exception):
+            self.focus_primary_input()
+
     async def _resolve_default_clarification_mode(self) -> str:
         """Fetch the daemon's default clarification mode for plan approval.
 
@@ -937,6 +941,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.
@@ -1089,6 +1097,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

{soothe_cli-1.0.1 → soothe_cli-1.0.4}/src/soothe_cli/tui/app/_messages_mixin.py

@@ -793,20 +793,22 @@ class _MessagesMixin:
     def action_quit_or_interrupt(self) -> None:
         """Handle Ctrl+C — clear input, interrupt work, or exit on double-press.
 
-        Priority order when a task is running (agent/shell):
-        1. If input has pending text, clear it (first Ctrl+C).
-        2. If input is empty, interrupt the running task.
-        Interrupting a task resets the idle double-press exit state.
-
-        When idle, Ctrl+C arms a double-press exit:
-        1. First press clears any pending draft and shows a hint.
-        2. Second press within the timeout window exits the TUI.
-
-        Note: Copying selected text is bound to Ctrl+Y (`action_copy_selection`)
-        so Ctrl+C is reserved for interrupt/exit behavior.
+        Priority order: HITL review card (abandon + focus chat) → running
+        task (clear input, then interrupt) → idle double-press exit.
+        Ctrl+Y copies selection, so Ctrl+C stays reserved for this path.
         """
         current_time = time.monotonic()
 
+        # HITL review card (plan/tool): abandon and return focus to chat.
+        if self._has_active_qa_widget():
+            widget = self._active_plan_review_widget()
+            if widget is not None and not getattr(widget, "_submitted", False):
+                widget._abandon()
+                self._ctrl_c_pressed_time = None
+                if self._chat_input:
+                    self._chat_input.focus_input()
+                return
+
         # Check if input has pending content (text, mode, or completion).
         has_pending_input = self._has_pending_chat_input()
 
@@ -981,7 +983,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
 
@@ -993,15 +995,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
 
@@ -1072,25 +1068,21 @@ class _MessagesMixin:
                 inputs.append(inp)
         return inputs
 
-    def _active_plan_review_action_focus(self) -> Widget | None:
-        """Prefer the Approve button when a plan-review or tool-approval card is active."""
+    def _active_plan_review_widget(self) -> Widget | None:
+        """Return the active unsubmitted HITL review card, if any."""
         adapter = getattr(self, "_ui_adapter", None)
         if adapter is None:
             return None
         by_step = getattr(adapter, "_clarification_input_by_step", None) or {}
-        # Both option-selector origins render Approve / Refine(Edit) / Reject buttons.
         for message in by_step.values():
             if getattr(message, "_submitted", False):
                 continue
             # String compare — avoid MagicMock truthiness on property access in tests.
-            if getattr(message, "_origin_node", None) not in ("plan_mode_review", "tool_approval"):
-                continue
-            buttons = getattr(message, "_action_buttons", None) or {}
-            if not isinstance(buttons, dict):
-                continue
-            approve = buttons.get("approve")
-            if approve is not None and not getattr(approve, "disabled", False):
-                return approve
+            if getattr(message, "_origin_node", None) in (
+                "plan_mode_review",
+                "tool_approval",
+            ):
+                return message
         return None
 
     def _non_chat_focusable_inputs(self) -> list[Input]:
@@ -1107,18 +1099,13 @@ class _MessagesMixin:
         """Return the single input that should receive typing focus, if unambiguous.
 
         When an inline clarification card is active, its answer field takes
-        precedence over the bottom chat prompt. Planner-subagent review
-        focuses the Approve action. On modal screens, a lone
+        precedence over the bottom chat prompt. On modal screens, a lone
         filter box is focused automatically.
         """
         clar_inputs = self._active_clarification_inputs()
         if clar_inputs:
             return clar_inputs[0]
 
-        plan_action = self._active_plan_review_action_focus()
-        if plan_action is not None:
-            return plan_action
-
         non_chat = self._non_chat_focusable_inputs()
         if len(non_chat) == 1:
             return non_chat[0]

{soothe_cli-1.0.1 → soothe_cli-1.0.4}/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

{soothe_cli-1.0.1 → soothe_cli-1.0.4}/src/soothe_cli/tui/app/_ui.py

@@ -421,8 +421,10 @@ class _UIMixin:
                 await self._loading_widget.remove()
                 self._loading_widget = None
             self._connect_spinner_start_mono = None
+            self._show_tip_row()
             return
 
+        self._hide_tip_row()
         thinking_status = self.query_one("#thinking-status", Container)
 
         connect_start_mono: float | None = None
@@ -481,6 +483,16 @@ class _UIMixin:
         if self._loading_widget is not None:
             self._loading_widget.resume()
 
+    def _show_tip_row(self) -> None:
+        """Show the rotating tip in the thinking row when the loop is idle."""
+        if self._tip_row is not None:
+            self._tip_row.display = True
+
+    def _hide_tip_row(self) -> None:
+        """Hide the tip row so the thinking spinner gets the full row."""
+        if self._tip_row is not None:
+            self._tip_row.display = False
+
     def action_toggle_plan_quick_view(self) -> None:
         """Expand or collapse the in-flow plan panel above the thinking row."""
         if self.screen.is_modal:

{soothe_cli-1.0.1 → soothe_cli-1.0.4}/src/soothe_cli/tui/composer_mode.py

@@ -1,4 +1,8 @@
-"""Sticky TUI composer modes: Auto / Manual / Plan / Ask."""
+"""TUI composer modes — working-mode hierarchy.
+
+Agent sub-modes (auto, bypass, manual) grouped first, then plan and ask.
+Shift+Tab cycle: Auto → Bypass → Manual → Plan → Ask → Auto.
+"""
 
 from __future__ import annotations
 
@@ -8,15 +12,25 @@ COMPOSER_MODE_AUTO = "auto"
 COMPOSER_MODE_MANUAL = "manual"
 COMPOSER_MODE_PLAN = "plan"
 COMPOSER_MODE_ASK = "ask"
+COMPOSER_MODE_BYPASS = "bypass"
 
+# Agent sub-modes grouped first, then standalone working modes.
 COMPOSER_MODE_ORDER: tuple[str, ...] = (
     COMPOSER_MODE_AUTO,
+    COMPOSER_MODE_BYPASS,
     COMPOSER_MODE_MANUAL,
     COMPOSER_MODE_PLAN,
     COMPOSER_MODE_ASK,
 )
 VALID_COMPOSER_MODES: frozenset[str] = frozenset(COMPOSER_MODE_ORDER)
 
+# Agent working mode sub-modes (full mutating tool surface).
+AGENT_SUB_MODES: frozenset[str] = frozenset(
+    {COMPOSER_MODE_AUTO, COMPOSER_MODE_MANUAL, COMPOSER_MODE_BYPASS}
+)
+# Standalone working modes (not agent sub-modes).
+STANDALONE_WORKING_MODES: frozenset[str] = frozenset({COMPOSER_MODE_PLAN, COMPOSER_MODE_ASK})
+
 
 @dataclass(frozen=True)
 class ComposerWireFields:
@@ -35,11 +49,7 @@ def normalize_composer_mode(mode: str | None) -> str:
 
 
 def next_composer_mode(current: str) -> str:
-    """Advance Auto → Manual → Plan → Ask → Auto.
-
-    Unknown values normalize to `auto` (the default, same as a first
-    Shift+Tab from a garbage seed), without advancing past Auto in that step.
-    """
+    """Advance to the next mode in the cycle. Unknown values reset to `auto`."""
     if current not in VALID_COMPOSER_MODES:
         return COMPOSER_MODE_AUTO
     idx = COMPOSER_MODE_ORDER.index(current)
@@ -47,23 +57,19 @@ def next_composer_mode(current: str) -> str:
 
 
 def resolve_composer_wire_fields(mode: str) -> ComposerWireFields:
-    """Map composer mode to wire `clarification_mode`, sticky subagent, and
-    `interaction_mode`.
-
-    Args:
-    mode: Composer mode (`auto`, `manual`, `plan`, or `ask`).
+    """Map composer mode to wire fields.
 
-    Returns:
-    A :class:`ComposerWireFields`. Plan mode sends `clarification_mode=auto`
-    plus `interaction_mode=plan` (read-only plan graph); ask mode sends
-    `clarification_mode=auto` plus `interaction_mode=ask`. Slash routing
-    in the message still wins over the sticky hint at send time.
+    auto → clarification=auto, interaction=None; manual → clarification=manual;
+    bypass → clarification=auto, interaction=bypass; plan → interaction=plan;
+    ask → interaction=ask. Slash routing in the message wins over the sticky hint.
     """
     normalized = normalize_composer_mode(mode)
     if normalized == COMPOSER_MODE_PLAN:
         return ComposerWireFields(COMPOSER_MODE_AUTO, None, "plan")
     if normalized == COMPOSER_MODE_ASK:
         return ComposerWireFields(COMPOSER_MODE_AUTO, None, COMPOSER_MODE_ASK)
+    if normalized == COMPOSER_MODE_BYPASS:
+        return ComposerWireFields(COMPOSER_MODE_AUTO, None, COMPOSER_MODE_BYPASS)
     if normalized == COMPOSER_MODE_MANUAL:
         return ComposerWireFields(COMPOSER_MODE_MANUAL, None, None)
     return ComposerWireFields(COMPOSER_MODE_AUTO, None, None)

{soothe_cli-1.0.1 → soothe_cli-1.0.4}/src/soothe_cli/tui/textual_adapter.py

@@ -4121,7 +4121,15 @@ async def execute_task_textual(
                                         goal_loop_start_monotonic=goal_loop_start_monotonic,
                                         turn_start_monotonic=start_time,
                                     )
-                                    if adapter._goal_tree_message is not None:
+                                    follow_on = (
+                                        data.get("follow_on_exec")
+                                        if isinstance(data, dict)
+                                        else None
+                                    )
+                                    # Skip the terminal footer when a follow-on exec
+                                    # goal is pending: the daemon immediately enqueues
+                                    # it, so showing "Done" here is misleading.
+                                    if adapter._goal_tree_message is not None and not follow_on:
                                         goal_elapsed_start = _goal_loop_elapsed_start(
                                             goal_loop_start_monotonic=goal_loop_start_monotonic,
                                             turn_start_monotonic=start_time,
@@ -4164,11 +4172,6 @@ async def execute_task_textual(
                                     # row stays active through the plan→exec transition;
                                     # the exec goal's ``STRANGE_LOOP_STARTED`` will
                                     # re-anchor and replace it.
-                                    follow_on = (
-                                        data.get("follow_on_exec")
-                                        if isinstance(data, dict)
-                                        else None
-                                    )
                                     if adapter._set_spinner and not clarification_pending:
                                         if follow_on:
                                             adapter._plan_approve_follow_on_pending = True

{soothe_cli-1.0.1 → soothe_cli-1.0.4}/src/soothe_cli/tui/widgets/help_screen.py

@@ -69,7 +69,7 @@ def build_keyboard_shortcut_rows() -> list[tuple[str, str]]:
             "Toggle plan panel (shown by default; --no-plan-panel disables auto-show)",
         ),
         ("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)"),
         ("@filename", "Autocomplete files and inject content"),
         ("/command", "Slash commands (e.g. /help, /clear, /quit)"),
         ("!command", "Run shell commands directly"),

{soothe_cli-1.0.1 → soothe_cli-1.0.4}/src/soothe_cli/tui/widgets/loading.py

@@ -4,7 +4,7 @@ from __future__ import annotations
 
 from collections.abc import Callable
 from time import monotonic
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Any
 
 from textual.content import Content
 from textual.widgets import Static
@@ -305,3 +305,73 @@ class LoadingWidget(Static):
     def stop(self) -> None:
         """Stop the animation (widget will be removed by caller)."""
         self._stop_timer()
+
+
+class TipRow(Static):
+    """Rotating tip / transient notice shown in the thinking row when idle.
+
+    Sits in the same ``#thinking-status`` container as :class:`LoadingWidget`.
+    When the loop is inactive (no spinner) the tip is visible; when the loop
+    is active the spinner replaces it and this row is hidden by the caller.
+    """
+
+    DEFAULT_CSS = """
+    TipRow {
+        height: 1;
+        padding: 0 1;
+        margin-top: 1;
+    }
+
+    TipRow.notification {
+        color: $warning;
+        text-style: bold;
+    }
+    """
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        """Initialize the tip row with no content."""
+        super().__init__(*args, **kwargs)
+        self._is_notification = False
+        self._tip_text: str = ""
+
+    def _render_tip(self, text: str) -> Content:
+        colors = theme.get_theme_colors(self)
+        prefix = Content.styled("💡 ", colors.muted)
+        body = Content.styled(text, colors.muted)
+        return Content.assemble(prefix, body)
+
+    def _render_notice(self, text: str) -> Content:
+        colors = theme.get_theme_colors(self)
+        prefix = Content.styled("⚠ ", colors.warning)
+        body = Content.styled(text, colors.warning)
+        return Content.assemble(prefix, body)
+
+    def _refresh_content(self) -> None:
+        """Re-render the stored tip/notice text, styled only when mounted."""
+        if not self.is_mounted:
+            return
+        text = self._tip_text
+        if not text:
+            self.update("")
+        elif self._is_notification:
+            self.update(self._render_notice(text))
+        else:
+            self.update(self._render_tip(text))
+
+    def on_mount(self) -> None:
+        """Render the initial tip content once the widget is in the DOM."""
+        self._refresh_content()
+
+    def set_tip(self, text: str) -> None:
+        """Show a default rotating tip (muted, non-bold)."""
+        self._is_notification = False
+        self.remove_class("notification")
+        self._tip_text = (text or "").strip()
+        self._refresh_content()
+
+    def set_notification(self, text: str) -> None:
+        """Show a transient notice (warning-colored, bold)."""
+        self._is_notification = True
+        self.add_class("notification")
+        self._tip_text = (text or "").strip()
+        self._refresh_content()

{soothe_cli-1.0.1 → soothe_cli-1.0.4}/src/soothe_cli/tui/widgets/messages/cognition_goal_tree.py

@@ -343,9 +343,20 @@ class CognitionGoalTreeMessage(Vertical):
         return f"↑{format_token_count(total_in)} ↓{format_token_count(total_out)}"
 
     def mark_loop_started(self, started_at: float | None = None) -> None:
-        """Anchor plan-level elapsed time (matches thinking-row turn start)."""
-        if self._loop_started_at is None:
+        """Anchor plan-level elapsed time (matches thinking-row turn start).
+
+        On reuse after a terminal footer (plan-approve → exec follow-on),
+        clear the stale footer + step rows so the panel returns to live state.
+        """
+        if self._loop_started_at is None or self._footer_visible:
             self._loop_started_at = started_at if started_at is not None else time()
+            if self._footer_visible:
+                self._footer_visible = False
+                self._footer_plain = ""
+                self._footer_tone = "muted"
+                self._step_order.clear()
+                self._steps.clear()
+                self._sync_goal_tree_widgets()
 
     def _indent_prefix(self) -> str:
         """Body gutter aligned to the right of the goal header prefix dot.