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

{soothe_cli-1.0.4 → soothe_cli-1.0.6}/.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.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: soothe-cli
-Version: 1.0.4
+Version: 1.0.6
 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.6/src/soothe_cli/display/card.py

@@ -0,0 +1,158 @@
+"""Card prefix glyph, header assembly, and body gutter alignment shared by TUI card widgets.
+
+These helpers encode card *appearance* (prefix tone, glyph prefix, gutter
+alignment, header assembly). They are intentionally free of Textual widget
+lifecycle concerns; refresh throttling and animation visibility stay in the
+TUI layer (``tui/widgets/messages/_helpers.py``).
+"""
+
+from __future__ import annotations
+
+from textual.content import Content
+
+from soothe_cli.display import theme
+from soothe_cli.display.preview_limits import STEP_TASK_CARD_COLLAPSE_LINE_THRESHOLD
+from soothe_cli.display.tool_display import display_width
+from soothe_cli.settings import get_glyphs
+
+# Preview limits imported from preview_limits module
+_STEP_TOOL_PREVIEW_ROWS = STEP_TASK_CARD_COLLAPSE_LINE_THRESHOLD
+"""Collapsed step/task activity preview shows this many rows."""
+
+
+def _card_dot_tone(
+    status: str,
+    colors: theme.ThemeColors,
+    *,
+    accent: str | None = None,
+    spinner_position: int = 0,
+    animate_running: bool = False,
+) -> str:
+    """Return a Textual style string for a card prefix dot from lifecycle status."""
+    phase = (status or "pending").strip().lower()
+    if phase in ("success", "done", "completed"):
+        return colors.card_success
+    if phase in ("error", "failed", "interrupted"):
+        return colors.card_error
+    if phase == "running":
+        # Yellow flash on every other spinner tick; dim amber in between.
+        if animate_running and spinner_position % 2:
+            return colors.card_running_muted
+        return colors.card_running
+    if phase in ("queued", "pending", "continue", "replan"):
+        return colors.muted
+    if accent:
+        return accent
+    return colors.muted
+
+
+def _card_dot_prefix_content(
+    widget: object,
+    status: str,
+    *,
+    accent: str | None = None,
+    glyph_override: str | None = None,
+    spinner_position: int = 0,
+    animate_running: bool = False,
+) -> Content:
+    """Build a stateful colored card-prefix glyph."""
+    try:
+        colors = theme.get_theme_colors(widget)
+    except Exception:  # noqa: BLE001
+        colors = theme.DARK_COLORS
+    glyph = glyph_override or get_glyphs().tool_prefix
+    tone = _card_dot_tone(
+        status,
+        colors,
+        accent=accent,
+        spinner_position=spinner_position,
+        animate_running=animate_running,
+    )
+    return Content.styled(f"{glyph} ", tone)
+
+
+def _card_prefix_width(glyph_override: str | None = None) -> int:
+    """Display width of the card header prefix (the dot/glyph plus one space).
+
+    Every body line and tree-branch line must left-align at the right side of
+    this prefix, so card content never extends left of the header text. In
+    ASCII mode the prefix is ``"[*] "`` (4 cols) while the tree gutter glyph
+    ``"L"`` is only 1 col; the body gutter is padded to close that gap.
+    """
+    glyph = glyph_override or get_glyphs().tool_prefix
+    return display_width(glyph) + 1  # +1 for the trailing space
+
+
+def _card_body_gutter(glyph_override: str | None = None) -> str:
+    """Body/tree-branch gutter aligned to the right of the card prefix dot.
+
+    The tree glyph (``⎿`` / ``L``) stays at the left edge of the prefix column;
+    trailing spaces pad the gutter so its display width equals the header
+    prefix width (``glyph + " "``). That makes every card line and tree branch
+    start at the right side of the dot space.
+    """
+    g = get_glyphs()
+    prefix_width = _card_prefix_width(glyph_override)
+    glyph_w = display_width(g.output_prefix)
+    pad = max(0, prefix_width - glyph_w)
+    return f"{g.output_prefix}{' ' * pad}"
+
+
+def _card_item_indent(
+    extra_indent: int = 0,
+    *,
+    glyph_override: str | None = None,
+) -> str:
+    """Plain-space indent for activity item rows (no tree glyph).
+
+    Item rows under a section (tool rows, todo items, notes, "+N more") sit at
+    the card header prefix width plus ``extra_indent`` columns — aligned with
+    the right side of the dot space so they never extend left of the title
+    text, and indented under the section's ``⎿`` label.
+    """
+    prefix_width = _card_prefix_width(glyph_override)
+    return f"{' ' * max(0, prefix_width + extra_indent)}"
+
+
+def _assemble_card_header(
+    widget: object,
+    body_part: str,
+    *,
+    status: str = "running",
+    accent: str | None = None,
+    glyph_override: str | None = None,
+    spinner_position: int = 0,
+    animate_running: bool = False,
+) -> Content:
+    """Build a card title: stateful prefix glyph plus foreground body (no bold).
+
+    Used for Goal, Plan, Step, and tool (including Task) headers. The glyph color
+    reflects lifecycle status; body lines below use the tree gutter returned by
+    :func:`_card_body_gutter`, which aligns to the right of the card prefix dot.
+
+    Args:
+        widget: Mounted widget (or any object accepted by ``get_theme_colors``).
+        body_part: Header text (goal, step description, etc.).
+        status: Card lifecycle phase for glyph color/shape.
+        accent: Optional override tone for the glyph (e.g. skill/error accent).
+        spinner_position: Toggles gray flash while ``animate_running`` is true.
+        animate_running: Flash the glyph gray while running (step/task/assistant cards).
+
+    Returns:
+        Assembled ``Content`` for a ``Static`` header.
+    """
+    try:
+        colors = theme.get_theme_colors(widget)
+    except Exception:  # noqa: BLE001
+        colors = theme.DARK_COLORS
+    return Content.assemble(
+        _card_dot_prefix_content(
+            widget,
+            status,
+            accent=accent,
+            glyph_override=glyph_override,
+            spinner_position=spinner_position,
+            animate_running=animate_running,
+        ),
+        Content.styled(body_part, colors.foreground),
+    )

{soothe_cli-1.0.4 → soothe_cli-1.0.6}/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.6}/src/soothe_cli/tui/app/_clarification.py

@@ -7,19 +7,16 @@ keep the execution mixin focused on agent execution and message routing.
 from __future__ import annotations
 
 _PLAN_REVIEW_ACTIONS = frozenset({"Approve", "Reject", "Refine"})
-_TOOL_APPROVAL_ACTIONS = frozenset({"Approve", "Reject", "Edit"})
+_TOOL_APPROVAL_ACTIONS = frozenset({"Approve", "Reject"})
 
 
 def clarification_wire_content(answers: list[str], *, origin_node: str = "") -> str:
     """Human-readable turn content for a clarification submit (not a new goal).
 
-    Option-selector actions use a stable `<prefix>: …` header so a dropped
-    `clarification_answer` flag cannot turn a bare action into Pass1 TASK.
-    Plan review → `Plan review:` (Refine carries refinement text in
-    `answers[1]`). Tool approval → `Tool approval:` (Edit carries revised
-    instructions in `answers[1]`). When `origin_node` is empty (legacy
-    callers) the action label alone selects the prefix, preserving the safety
-    net for any selector-origin submit.
+    Option-selector actions use a stable ``<prefix>: …`` header so a dropped
+    ``clarification_answer`` flag cannot turn a bare action into Pass1 TASK.
+    Plan review → ``Plan review:`` (Refine carries refinement text in
+    ``answers[1]``). Tool approval → ``Tool approval:``.
     """
     non_empty = [a for a in answers if str(a).strip()]
     if not non_empty:

{soothe_cli-1.0.4 → soothe_cli-1.0.6}/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.6}/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.6}/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.6}/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.6}/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.6}/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;

{soothe_cli-1.0.4 → soothe_cli-1.0.6}/src/soothe_cli/tui/widgets/file_change_preview.py

@@ -11,6 +11,7 @@ from textual.events import Click
 from textual.widgets import Static
 
 from soothe_cli.display import theme
+from soothe_cli.display.card import _assemble_card_header
 from soothe_cli.display.preview_limits import (
     TOOL_APPROVAL_BODY_MAX_LINES,
     TOOL_APPROVAL_DIFF_WIDGET_MAX_LINES,
@@ -19,7 +20,6 @@ from soothe_cli.display.preview_limits import (
 from soothe_cli.settings import get_glyphs
 from soothe_cli.tui.widgets.clipboard import screen_has_text_selection
 from soothe_cli.tui.widgets.diff import DIFF_CODE_GAP, compose_diff_line_list
-from soothe_cli.tui.widgets.messages._helpers import _assemble_card_header
 
 if TYPE_CHECKING:
     from textual.app import ComposeResult