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

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

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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: soothe-cli
-Version: 1.0.4
+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

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

@@ -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."""
 
@@ -496,6 +504,13 @@ class SootheApp(
             default_visible=plan_visible,
         )
         with Container(id="bottom-app-container"):
+            # 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(

{soothe_cli-1.0.4 → 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)
@@ -1165,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:
@@ -1301,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.4 → 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():

{soothe_cli-1.0.4 → 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.4 → soothe_cli-1.0.5}/src/soothe_cli/tui/app/_startup.py

@@ -646,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

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

@@ -20,6 +20,7 @@ from soothe_cli.runtime.token_events_debug import TokenEventTrace
 from soothe_cli.tui.widgets.loading import LoadingWidget
 from soothe_cli.tui.widgets.messages import AssistantMessage, UserMessage
 from soothe_cli.tui.widgets.pinned_goal_bar import PinnedGoalBar
+from soothe_cli.tui.widgets.queued_goals_bar import QueuedGoalsBar
 
 logger = logging.getLogger(__name__)
 _monotonic = time.monotonic
@@ -520,6 +521,23 @@ class _UIMixin:
         # scroll position.
         self._sync_pinned_goal_visibility()
 
+    def action_focus_queued_goals(self) -> None:
+        """Focus the queued goals bar (Ctrl+q).
+
+        When the bar has queued goals, moves keyboard focus to it so the
+        user can navigate with arrow keys, edit with Enter, or cancel
+        with Esc. When the queue is empty, this is a no-op.
+        """
+        if self.screen.is_modal:
+            return
+        try:
+            bar = self.query_one("#queued-goals", QueuedGoalsBar)
+        except NoMatches:
+            return
+        if not bar.has_goals:
+            return
+        bar.activate()
+
     def _on_chat_scroll_y_changed(self, _old: float, _new: float) -> None:
         """React to chat scroll position changes to show/hide the pinned bar.
 

{soothe_cli-1.0.4 → soothe_cli-1.0.5}/src/soothe_cli/tui/app/app.tcss

@@ -32,6 +32,18 @@ Screen {
     display: none;
 }
 
+/* Queued goals bar — inside #bottom-app-container, above the thinking row
+   and chat input. Hidden when the queue is empty; shows all pending queued
+   goals as selectable rows. Not docked separately because Textual overlaps
+   multiple docked-to-same-edge widgets. Focus styling (background, border,
+   color, text-style) is defined in QueuedGoalsBar.DEFAULT_CSS. */
+#queued-goals {
+    height: auto;
+    max-height: 40vh;
+    width: 100%;
+    display: none;
+}
+
 /* Chat area - main scrollable messages area */
 #chat {
     height: 1fr;