soothe-cli 0.7.15__tar.gz → 0.7.16__tar.gz

{soothe_cli-0.7.15 → soothe_cli-0.7.16}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: soothe-cli
-Version: 0.7.15
+Version: 0.7.16
 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.15 → soothe_cli-0.7.16}/src/soothe_cli/tui/app/_execution.py

@@ -179,6 +179,7 @@ class _ExecutionMixin:
             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
 
@@ -417,12 +418,14 @@ 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))
@@ -908,6 +911,7 @@ class _ExecutionMixin:
             if self._queued_widgets:
                 widget = self._queued_widgets.popleft()
                 await widget.remove()
+                self._refresh_queued_goal_tips()
 
             await self._process_message(msg.text, msg.mode)
         except Exception:

{soothe_cli-0.7.15 → soothe_cli-0.7.16}/src/soothe_cli/tui/app/_messages_mixin.py

@@ -43,6 +43,70 @@ logger = logging.getLogger(__name__)
 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:
+            return
+        tip_index = -1
+        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(index == tip_index if tip_index >= 0 else False)
+
+    def _has_pending_chat_input(self) -> bool:
+        """Return whether chat input has draft content that should be preserved."""
+        chat_input = self._chat_input
+        return bool(
+            chat_input
+            and (
+                chat_input.value.strip()
+                or chat_input.mode != "normal"
+                or chat_input._current_suggestions
+            )
+        )
+
+    def _can_run_queued_goal_now_from_enter(self) -> bool:
+        """Return whether Enter should cancel the current goal for queued-head run."""
+        if not self._agent_running or not self._pending_messages:
+            return False
+        if self._has_pending_chat_input():
+            return False
+        queue_head = self._pending_messages[0]
+        return queue_head.mode == "normal"
+
+    def run_queued_goal_now_from_enter(self) -> bool:
+        """Cancel the running goal so queued head can start immediately.
+
+        Returns:
+            `True` when an interrupt was triggered, otherwise `False`.
+        """
+        if not self._can_run_queued_goal_now_from_enter():
+            return False
+        return self._interrupt_running_goal_preserving_queue()
+
+    def _interrupt_running_goal_preserving_queue(self) -> bool:
+        """Interrupt current agent turn while keeping queued goals intact."""
+        if not (self._agent_running and self._agent_worker):
+            return False
+        if self._daemon_session is not None:
+            self.run_worker(
+                self._interrupt_daemon_agent_turn(discard_queue=False),
+                exclusive=False,
+                group="daemon-interrupt",
+            )
+        else:
+            self.run_worker(
+                self._tear_down_interrupt_ui(),
+                exclusive=False,
+                group="interrupt-ui",
+            )
+            self._cancel_worker(self._agent_worker, discard_queue=False)
+        self._quit_pending = False
+        return True
+
     async def _load_loop_history(
         self,
         *,
@@ -322,40 +386,42 @@ class _MessagesMixin:
                 "Messages container (#messages) not found during clear; UI may be out of sync with message store"
             )
 
-    def _pop_last_queued_message(self) -> None:
-        """Remove the most recently queued message (LIFO).
-
-        If the chat input is empty the evicted text is restored there so the
-        user can edit and re-submit. Otherwise the message is discarded. The
-        toast message distinguishes between the two outcomes.
-
-        Caller must ensure `_pending_messages` is non-empty. A defensive guard
-        is included in case of async TOCTOU races.
-        """
+    def _pop_last_queued_entry(self) -> Any | None:
+        """Pop the latest queued message and paired widget, if available."""
         if not self._pending_messages:
-            return
+            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"
             )
+        return msg
+
+    def _restore_last_queued_goal_to_input(self) -> bool:
+        """Restore the latest queued goal into an empty chat input for editing."""
+        msg = self._pop_last_queued_entry()
+        if msg is None:
+            return False
 
         if not self._chat_input:
             logger.warning(
                 "Chat input unavailable during queue pop; message text cannot be restored: %s",
                 msg.text[:60],
             )
-            self.notify("Queued message discarded", timeout=2)
-            return
+            return False
 
-        if not self._chat_input.value.strip():
-            self._chat_input.value = msg.text
-            self.notify("Queued message moved to input", timeout=2)
-        else:
-            self.notify("Queued message discarded (input not empty)", timeout=3)
+        if self._has_pending_chat_input():
+            logger.warning(
+                "Queue restore requested while input has draft content; skipping restore"
+            )
+            return False
+        self._chat_input.value = msg.text
+        self.notify("Queued goal moved to input", timeout=2)
+        return True
 
     def _discard_queue(self) -> None:
         """Clear pending messages, deferred actions, and queued widgets."""
@@ -365,6 +431,25 @@ class _MessagesMixin:
         self._queued_widgets.clear()
         self._deferred_actions.clear()
 
+    def _cancel_last_queued_message(self) -> bool:
+        """Cancel the most recently queued goal without restoring it to input."""
+        msg = self._pop_last_queued_entry()
+        if msg is None:
+            return False
+        self.notify(f"Cancelled queued goal: {msg.text[:60]}", timeout=2)
+        return True
+
+    def edit_queued_goal_from_up(self) -> bool:
+        """Move the latest queued goal back to input for editing."""
+        if not self._pending_messages:
+            return False
+        if self._has_pending_chat_input():
+            return False
+        queue_tail = self._pending_messages[-1]
+        if queue_tail.mode != "normal":
+            return False
+        return self._restore_last_queued_goal_to_input()
+
     def _defer_action(self, action: DeferredAction) -> None:
         """Queue a deferred action, replacing any existing action of the same kind.
 
@@ -434,7 +519,7 @@ class _MessagesMixin:
             worker.cancel()
 
     async def _interrupt_daemon_agent_turn(self, *, discard_queue: bool = True) -> None:
-        """Stop in-flight UI, send daemon ``/cancel``, then cancel the local worker.
+        """Stop in-flight UI and request daemon-side cancel.
 
         UI teardown runs first so Ctrl+C does not leave the thinking spinner or
         goal-tree running rows active while the daemon winds down (which can take
@@ -442,17 +527,24 @@ class _MessagesMixin:
 
         Args:
             discard_queue: When ``False``, preserve queued user goals so they
-                run after the cancelled turn finishes cleanup.
+                run after the cancelled turn finishes cleanup. In this mode,
+                the local worker is left running when daemon cancel succeeds.
         """
         await self._tear_down_interrupt_ui()
         session = self._daemon_session
         worker = self._agent_worker
+        cancel_sent = False
         if session is not None:
             try:
                 await session.cancel_remote_query()
+                cancel_sent = True
             except Exception:
                 logger.warning("Failed to send cancel to daemon", exc_info=True)
-        if worker is not None:
+        # For Enter-triggered queued-goal handoff (discard_queue=False), avoid
+        # force-cancelling the local worker after /cancel is accepted.
+        # Let the active stream finish naturally so queue-drain ordering stays
+        # stable and the loop subscription is not torn down mid-handoff.
+        if worker is not None and (discard_queue or not cancel_sent):
             self._cancel_worker(worker, discard_queue=discard_queue)
 
     def action_copy_selection(self) -> None:
@@ -476,11 +568,7 @@ class _MessagesMixin:
         so Ctrl+C is reserved for interrupt/quit only.
         """
         # Check if input has pending content (text, mode, or completion)
-        has_pending_input = self._chat_input and (
-            self._chat_input.value.strip()
-            or self._chat_input.mode != "normal"
-            or self._chat_input._current_suggestions
-        )
+        has_pending_input = self._has_pending_chat_input()
 
         # If shell command is running: clear input first, then kill shell
         if self._shell_running and self._shell_worker:
@@ -498,20 +586,7 @@ class _MessagesMixin:
                 self._chat_input.clear_input()
                 self._quit_pending = False
                 return
-            if self._daemon_session is not None:
-                self.run_worker(
-                    self._interrupt_daemon_agent_turn(discard_queue=False),
-                    exclusive=False,
-                    group="daemon-interrupt",
-                )
-            else:
-                self.run_worker(
-                    self._tear_down_interrupt_ui(),
-                    exclusive=False,
-                    group="interrupt-ui",
-                )
-                self._cancel_worker(self._agent_worker, discard_queue=False)
-            self._quit_pending = False
+            self._interrupt_running_goal_preserving_queue()
             return
 
         # Double Ctrl+C to quit (same detach path as Ctrl+D and /quit)
@@ -534,13 +609,14 @@ class _MessagesMixin:
         self.set_timer(quit_timeout, lambda: setattr(self, "_quit_pending", False))
 
     def action_dismiss_ui(self) -> None:
-        """Handle Escape — dismiss overlays and modals only (never cancel agent work).
+        """Handle Escape — dismiss overlays and optionally cancel queued goals.
 
         Priority order:
         1. If modal screen is active, dismiss it
         2. If plan quick-view overlay is open, collapse it
-        3. If completion popup is open, dismiss it
-        4. If input is in command/shell mode, exit to normal mode
+        3. If input is idle and queue has a normal goal, cancel queued tail
+        4. If completion popup is open, dismiss it
+        5. If input is in command/shell mode, exit to normal mode
         """
         from contextlib import suppress
 
@@ -568,6 +644,13 @@ 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).
+            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
             if self._chat_input.dismiss_completion():
                 return
             if self._chat_input.exit_mode():

{soothe_cli-0.7.15 → soothe_cli-0.7.16}/src/soothe_cli/tui/config.py

@@ -221,10 +221,10 @@ class CharsetMode(StrEnum):
     """Character set mode for TUI display."""
 
     UNICODE = "unicode"
-    """Always use Unicode glyphs (e.g. `⏺`, `✓`, `…`)."""
+    """Always use Unicode glyphs (e.g. `●`, `✓`, `…`)."""
 
     ASCII = "ascii"
-    """Always use ASCII-safe fallbacks (e.g. `(*)`, `[OK]`, `...`)."""
+    """Always use ASCII-safe fallbacks (e.g. `[*]`, `[OK]`, `...`)."""
 
     AUTO = "auto"
     """Detect charset support at runtime and pick Unicode or ASCII."""
@@ -234,7 +234,9 @@ class CharsetMode(StrEnum):
 class Glyphs:
     """Character glyphs for TUI display."""
 
-    tool_prefix: str  # ⏺ vs (*)
+    tool_prefix: str  # ● vs [*]
+    file_edit_prefix: str  # ■ vs [#]
+    subagent_prefix: str  # ◆ vs [S]
     ellipsis: str  # … vs ...
     checkmark: str  # ✓ vs [OK]
     error: str  # ✗ vs [X]
@@ -270,7 +272,9 @@ class Glyphs:
 
 
 UNICODE_GLYPHS = Glyphs(
-    tool_prefix="⏺",
+    tool_prefix="●",
+    file_edit_prefix="■",
+    subagent_prefix="◆",
     ellipsis="…",
     checkmark="✓",
     error="✗",
@@ -301,7 +305,9 @@ UNICODE_GLYPHS = Glyphs(
 """Glyph set for terminals with full Unicode support."""
 
 ASCII_GLYPHS = Glyphs(
-    tool_prefix="(*)",
+    tool_prefix="[*]",
+    file_edit_prefix="[#]",
+    subagent_prefix="[S]",
     ellipsis="...",
     checkmark="[OK]",
     error="[X]",

{soothe_cli-0.7.15 → soothe_cli-0.7.16}/src/soothe_cli/tui/theme.py

@@ -99,7 +99,7 @@ LC_TOOL = LC_AMBER
 # Design principles:
 # - Consistent visual style across all four card types
 # - Restrained grayscale for secondary activity text
-# - Stateful ``⏺`` dot prefixes for card headers; ``⎿`` gutter for body lines
+# - Stateful card-prefix glyphs for card headers; ``⎿`` gutter for body lines
 # ---------------------------------------------------------------------------
 
 # Grayscale base colors (neutral, non-distracting)

{soothe_cli-0.7.15 → soothe_cli-0.7.16}/src/soothe_cli/tui/widgets/chat_input.py

@@ -669,10 +669,33 @@ class ChatTextArea(TextArea):
             event.prevent_default()
             event.stop()
             value = self.text.strip()
+            if not value:
+                trigger = getattr(self.app, "run_queued_goal_now_from_enter", None)
+                if callable(trigger):
+                    try:
+                        if bool(trigger()):
+                            return
+                    except Exception:  # noqa: BLE001
+                        logger.debug(
+                            "Queued-goal Enter shortcut failed; keeping empty-enter noop",
+                            exc_info=True,
+                        )
             if value:
                 self.post_message(self.Submitted(value))
             return
 
+        # Up on empty input can pull the latest queued goal back for editing.
+        if event.key == "up" and not self.text:
+            trigger_edit = getattr(self.app, "edit_queued_goal_from_up", None)
+            if callable(trigger_edit):
+                try:
+                    if bool(trigger_edit()):
+                        event.prevent_default()
+                        event.stop()
+                        return
+                except Exception:  # noqa: BLE001
+                    logger.debug("Queued-goal edit shortcut failed", exc_info=True)
+
         # Up/Down arrow: only navigate history at input boundaries.
         # Up requires cursor at position (0, 0); Down requires cursor at
         # the very end.  When already browsing history, either boundary