soothe-cli 0.7.18__tar.gz → 0.8.0__tar.gz

{soothe_cli-0.7.18 → soothe_cli-0.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: soothe-cli
-Version: 0.7.18
+Version: 0.8.0
 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.18 → soothe_cli-0.8.0}/src/soothe_cli/cli/commands/loop_cmd.py

@@ -79,13 +79,23 @@ async def _rpc(
     client = WebSocketClient(url=ws_url)
     try:
         await client.connect()
+        await asyncio.wait_for(client.request_connection_init(), timeout=timeout)
+        await asyncio.wait_for(
+            client.wait_for_connection_ack(ack_timeout_s=timeout), timeout=timeout
+        )
         if mode == "notify":
             await asyncio.wait_for(client.notify(method, params or {}), timeout=timeout)
             return {}
         if mode == "subscribe":
-            sub_id = await asyncio.wait_for(client.subscribe(method, params or {}), timeout=timeout)
+            sub_id = await asyncio.wait_for(
+                client.subscribe(method, params or {}, timeout=timeout),
+                timeout=timeout,
+            )
             return {"subscription_id": sub_id}
-        result = await asyncio.wait_for(client.request(method, params or {}), timeout=timeout)
+        result = await asyncio.wait_for(
+            client.request(method, params or {}, timeout=timeout),
+            timeout=timeout,
+        )
         return result if isinstance(result, dict) else {"result": result}
     except TimeoutError:
         return {"error": "Timed out waiting for daemon response"}

{soothe_cli-0.7.18 → soothe_cli-0.8.0}/src/soothe_cli/runtime/state/step_router.py

@@ -24,6 +24,7 @@ from soothe_sdk.ux.task_namespace import (
     resolve_task_parent_lookup,
     resolve_task_scope_for_namespace,
     row_key_for_subgraph_tool,
+    step_level_parent_task_call_id,
     task_scope_step_id,
     try_bind_namespace_from_tool_call_id,
 )
@@ -93,6 +94,10 @@ class StepTaskRouter:
     _spawns_by_task_id: dict[str, TaskScope] = field(default_factory=dict, repr=False)
     _pending_unscoped_namespaces: deque[tuple[str, ...]] = field(default_factory=deque, repr=False)
     _spawn_recorded: set[tuple[str, str]] = field(default_factory=set, repr=False)
+    _task_index_by_step_and_call: dict[tuple[str, str], int] = field(
+        default_factory=dict, repr=False
+    )
+    _next_task_index_by_step: dict[str, int] = field(default_factory=dict, repr=False)
     _pending_main_tools: dict[str, PendingMainTool] = field(default_factory=dict, repr=False)
     _pending_subgraph_tools: dict[tuple[tuple[str, ...], str], PendingSubgraphTool] = field(
         default_factory=dict,
@@ -108,6 +113,8 @@ class StepTaskRouter:
         self._spawns_by_task_id.clear()
         self._pending_unscoped_namespaces.clear()
         self._spawn_recorded.clear()
+        self._task_index_by_step_and_call.clear()
+        self._next_task_index_by_step.clear()
         self._pending_main_tools.clear()
         self._pending_subgraph_tools.clear()
 
@@ -220,6 +227,11 @@ class StepTaskRouter:
             ]
             for tcid in drop_tcid:
                 self._spawns_by_task_id.pop(tcid, None)
+            # Cleanse per-step synthetic task-index state once the step is done.
+            self._next_task_index_by_step.pop(sid, None)
+            stale_index_keys = [key for key in self._task_index_by_step_and_call if key[0] == sid]
+            for key in stale_index_keys:
+                self._task_index_by_step_and_call.pop(key, None)
 
     def step_id_for_tool(self, tool_call_id: str) -> str:
         """Return execute step id encoded in a unified root tool_call_id."""
@@ -287,7 +299,10 @@ class StepTaskRouter:
             sid = str(step_id).strip()
         if not sid:
             return False
-        normalized_tcid = normalize_main_task_delegation_id(sid, tcid, tool_name="task")
+        normalized_tcid = self.normalize_task_delegation_id(
+            step_id=sid,
+            tool_call_id=tcid,
+        )
         spawn_key = (sid, normalized_tcid)
         if spawn_key in self._spawn_recorded:
             return False
@@ -311,6 +326,42 @@ class StepTaskRouter:
         )
         return True
 
+    def normalize_task_delegation_id(self, *, step_id: str, tool_call_id: str) -> str:
+        """Return canonical ``{step}:s:task:{idx}`` for main ``task`` delegations.
+
+        Some providers emit unified ids like ``{step}:s:call_<uuid>`` that do not
+        encode a task index. In that case allocate a stable per-step synthetic
+        index so task activity rows and standalone SubAgent cards stay 1:1.
+        """
+        sid = str(step_id).strip()
+        tcid = str(tool_call_id).strip()
+        if not sid or not tcid:
+            return tcid
+
+        normalized = normalize_main_task_delegation_id(sid, tcid, tool_name="task")
+        _, type_code, _, tool_info = parse_unified_tool_call_id(normalized)
+        if type_code == "s" and isinstance(tool_info, str):
+            parts = tool_info.split(":")
+            if parts and parts[0] == "task":
+                tail = parts[-1] if parts else ""
+                if tail.isdigit():
+                    idx = int(tail)
+                    key = (sid, tcid)
+                    self._task_index_by_step_and_call[key] = idx
+                    next_idx = self._next_task_index_by_step.get(sid, 0)
+                    if idx >= next_idx:
+                        self._next_task_index_by_step[sid] = idx + 1
+                    return normalized
+
+        key = (sid, tcid)
+        if key in self._task_index_by_step_and_call:
+            idx = self._task_index_by_step_and_call[key]
+        else:
+            idx = self._next_task_index_by_step.get(sid, 0)
+            self._task_index_by_step_and_call[key] = idx
+            self._next_task_index_by_step[sid] = idx + 1
+        return step_level_parent_task_call_id(sid, idx)
+
     def resolve_task_scope(self, namespace: tuple[str, ...]) -> TaskScope | None:
         """Task scope for a stream namespace, if bound."""
         return resolve_task_scope_for_namespace(self._namespace_bindings, namespace)

{soothe_cli-0.7.18 → soothe_cli-0.8.0}/src/soothe_cli/runtime/transport/session.py

@@ -30,6 +30,9 @@ _POST_IDLE_DRAIN_DEADLINE_S = 0.5
 
 # Align with ``bootstrap_loop_session`` daemon-ready wait (RFC-450 §8.2).
 _RPC_HANDSHAKE_TIMEOUT_S = 20.0
+_TURN_END_CUSTOM_TYPES = {
+    "soothe.cognition.strange_loop.completed",
+}
 
 # Brief close handshake on TUI exit — the daemon cleans up on disconnect anyway.
 TUI_EXIT_HANDSHAKE_TIMEOUT_S = 0.3
@@ -448,6 +451,19 @@ class TuiDaemonSession:
                     progress_seen = True
                     stream_payload_seen = True
                     yield (namespace, mode, data)
+                    if mode == "custom" and isinstance(data, dict):
+                        custom_type = str(data.get("type", "")).strip()
+                        if custom_type in _TURN_END_CUSTOM_TYPES:
+                            # Some turns can miss the trailing status=idle/stopped
+                            # despite emitting terminal custom events. Treat these
+                            # as explicit turn completion and briefly drain late
+                            # frames to preserve post-terminal payloads.
+                            self.last_turn_end_state = "completed"
+                            async for chunk in self._drain_stream_events_after_idle(
+                                expected_loop_id=expected_loop_id,
+                            ):
+                                yield chunk
+                            break
                     # Graph auto-resumes LangGraph interrupts server-side; keep consuming events.
                     if mode == "updates" and isinstance(data, dict) and "__interrupt__" in data:
                         continue

{soothe_cli-0.7.18 → soothe_cli-0.8.0}/src/soothe_cli/tui/app/_app.py

@@ -6,11 +6,13 @@ import asyncio
 import logging
 import time
 from collections import deque
+from contextlib import suppress
 from pathlib import Path
 from typing import TYPE_CHECKING, Any, ClassVar
 
 if TYPE_CHECKING:
     from textual.app import ComposeResult
+    from textual.timer import Timer
     from textual.worker import Worker
 
     from soothe_cli.tui.skills.load import ExtendedSkillMetadata
@@ -222,12 +224,13 @@ class SootheApp(
         self._mcp_tool_count = sum(len(s.tools) for s in (mcp_server_info or []))
 
         self._status_bar: StatusBar | None = None
+        self._default_session_tip: str = ""
+        self._status_notification_timer: Timer | None = None
+        self._status_notification_active = False
 
         self._chat_input: ChatInput | None = None
         self._plan_quick_view_overlay: PlanQuickViewOverlay | None = None
 
-        self._quit_pending = False
-
         self._session_state: TextualSessionState | None = None
 
         self._ui_adapter: TextualUIAdapter | None = None
@@ -361,6 +364,55 @@ class SootheApp(
         """Return whether the app has a connected daemon session."""
         return self._daemon_session is not None
 
+    def set_default_session_tip(self, tip: str) -> None:
+        """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)
+
+    def _set_status_notification(self, message: str, *, timeout: float | None = None) -> None:
+        """Render a transient notification in the status-tip area."""
+        text = (message or "").strip()
+        if not text:
+            return
+        if self._status_notification_timer is not None:
+            with suppress(Exception):
+                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)
+
+        duration = timeout if timeout and timeout > 0 else 3.0
+        self._status_notification_timer = self.set_timer(duration, self._clear_status_notification)
+
+    def _clear_status_notification(self) -> None:
+        """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)
+
+    def notify(  # type: ignore[override]
+        self,
+        message: Any,
+        *,
+        title: str = "",
+        severity: str = "information",
+        timeout: float | None = None,
+        markup: bool = True,  # noqa: ARG002
+    ) -> None:
+        """Display notifications in the status-tip area instead of toast bubbles."""
+        text = str(message or "").strip()
+        if not text:
+            return
+        if title:
+            text = f"{title}: {text}"
+        if severity and severity.lower() in {"warning", "error"}:
+            text = f"{severity.title()}: {text}"
+        self._set_status_notification(text, timeout=timeout)
+
     def get_theme_variable_defaults(self) -> dict[str, str]:
         """Return custom CSS variable defaults for the current theme.
 

{soothe_cli-0.7.18 → soothe_cli-0.8.0}/src/soothe_cli/tui/app/_execution.py

@@ -148,9 +148,6 @@ class _ExecutionMixin:
         value = event.value
         mode: InputMode = event.mode  # type: ignore[assignment]  # Textual event mode is str at type level but InputMode at runtime
 
-        # Reset quit pending state on any input
-        self._quit_pending = False
-
         await dispatch_hook("user.prompt", {})
 
         # /quit and /q always execute immediately, even mid-loop-switch.
@@ -465,10 +462,10 @@ class _ExecutionMixin:
         )
         from soothe_cli.tui.commands.slash_commands import COMMANDS as _RFC404_COMMANDS
 
-        # RFC-454 daemon *routing* commands (/research, /plan, optional /«id»):
+        # RFC-454 daemon *routing* commands (/deep_research, /plan, /browser_use, …):
         # send the full line as a normal user turn so ``parse_subagent_from_input``
         # runs in the daemon adapter (same as headless CLI). Without this branch,
-        # ``cmd == "/research …"`` never matches the bare single-token handlers below.
+        # ``cmd == "/deep_research …"`` never matches the bare single-token handlers below.
         full_stripped = command.strip()
         first_word, query = parse_slash_command(full_stripped)
         if first_word:
@@ -747,7 +744,6 @@ class _ExecutionMixin:
         self,
         message: str,
         *,
-        message_kwargs: dict[str, Any] | None = None,
         skip_daemon_send_turn: bool = False,
     ) -> None:
         """Send a message to the agent and start execution.
@@ -758,8 +754,6 @@ class _ExecutionMixin:
 
         Args:
             message: The prompt to send to the agent.
-            message_kwargs: Extra fields merged into the stream input message
-                dict (e.g., `additional_kwargs` for skill metadata).
             skip_daemon_send_turn: When using a daemon session, only attach to
                 the in-flight stream (prompt already queued on the daemon).
         """
@@ -792,7 +786,6 @@ class _ExecutionMixin:
             self._agent_worker = self.run_worker(
                 self._run_agent_task(
                     message,
-                    message_kwargs=message_kwargs,
                     skip_daemon_send_turn=skip_daemon_send_turn,
                 ),
                 exclusive=False,
@@ -808,7 +801,6 @@ class _ExecutionMixin:
         self,
         message: str,
         *,
-        message_kwargs: dict[str, Any] | None = None,
         skip_daemon_send_turn: bool = False,
     ) -> None:
         """Run the agent task in a background worker.
@@ -817,8 +809,6 @@ class _ExecutionMixin:
 
         Args:
             message: The prompt to send to the agent.
-            message_kwargs: Extra fields merged into the stream input message
-                dict (e.g., `additional_kwargs` for skill metadata).
             skip_daemon_send_turn: When ``True`` with a daemon session, only
                 consume the daemon stream (prompt already queued server-side).
         """
@@ -847,7 +837,6 @@ class _ExecutionMixin:
                         image_tracker=self._image_tracker,
                         sandbox_type=self._sandbox_type,
                         workspace=self._cwd,
-                        message_kwargs=message_kwargs,
                         context=CLIContext(
                             model=self._model_override,
                             model_params=self._model_params_override or {},

{soothe_cli-0.7.18 → soothe_cli-0.8.0}/src/soothe_cli/tui/app/_messages_mixin.py

@@ -104,7 +104,6 @@ class _MessagesMixin:
                 group="interrupt-ui",
             )
             self._cancel_worker(self._agent_worker, discard_queue=False)
-        self._quit_pending = False
         return True
 
     async def _load_loop_history(
@@ -554,18 +553,16 @@ class _MessagesMixin:
         copy_selection_to_clipboard(self, notify_if_empty=True)
 
     def action_quit_or_interrupt(self) -> None:
-        """Handle Ctrl+C - clear input, interrupt agent, or quit on double press.
+        """Handle Ctrl+C - clear input or interrupt running work.
 
         Priority order when 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 (second Ctrl+C)
+        2. If input is empty, interrupt the running task
 
-        Priority order when idle:
-        1. If double press (quit_pending), quit
-        2. Otherwise clear pending input and show quit hint
+        When idle, Ctrl+C never exits the TUI. Use `/quit` (or `/q`) to exit.
 
         Note: Copying selected text is bound to Ctrl+Y (`action_copy_selection`)
-        so Ctrl+C is reserved for interrupt/quit only.
+        so Ctrl+C is reserved for interrupt behavior.
         """
         # Check if input has pending content (text, mode, or completion)
         has_pending_input = self._has_pending_chat_input()
@@ -574,39 +571,22 @@ class _MessagesMixin:
         if self._shell_running and self._shell_worker:
             if has_pending_input:
                 self._chat_input.clear_input()
-                self._quit_pending = False
                 return
             self._cancel_worker(self._shell_worker, discard_queue=False)
-            self._quit_pending = False
             return
 
         # If agent is running: clear input first, then interrupt
         if self._agent_running and self._agent_worker:
             if has_pending_input:
                 self._chat_input.clear_input()
-                self._quit_pending = False
                 return
             self._interrupt_running_goal_preserving_queue()
             return
 
-        # Double Ctrl+C to quit (same detach path as Ctrl+D and /quit)
-        if self._quit_pending:
-            self._detach_or_exit()
-        else:
-            self._arm_quit_pending("Ctrl+C")
-
-    def _arm_quit_pending(self, shortcut: str) -> None:
-        """Set the pending-quit flag, clear pending input, and show a matching hint.
-
-        Args:
-            shortcut: The key chord to show in the quit hint.
-        """
+        # Idle path: clear any pending draft, but never quit via keyboard shortcut.
         if self._chat_input:
             self._chat_input.clear_input()
-        self._quit_pending = True
-        quit_timeout = 3
-        self.notify(f"Press {shortcut} again to quit", timeout=quit_timeout, markup=False)
-        self.set_timer(quit_timeout, lambda: setattr(self, "_quit_pending", False))
+        self.notify("Use /quit (or /q) to exit the TUI", timeout=2, markup=False)
 
     def action_dismiss_ui(self) -> None:
         """Handle Escape — dismiss overlays and optionally cancel queued goals.
@@ -661,14 +641,8 @@ class _MessagesMixin:
         self.action_dismiss_ui()
 
     def action_quit_app(self) -> None:
-        """Handle quit action (Ctrl+D)."""
-        from soothe_cli.tui.widgets.loop_selector import LoopSelectorScreen
-
-        if isinstance(self.screen, LoopSelectorScreen):
-            # Loop selector doesn't have delete confirmation - just detach
-            self._detach_or_exit()
-            return
-        self._detach_or_exit()
+        """Handle Ctrl+D by hinting explicit slash-command exit."""
+        self.notify("Use /quit (or /q) to exit the TUI", timeout=2, markup=False)
 
     async def _detach_then_exit(self) -> None:
         """Detach from daemon, then exit the app."""

{soothe_cli-0.7.18 → soothe_cli-0.8.0}/src/soothe_cli/tui/app/_startup.py

@@ -139,7 +139,7 @@ class _StartupMixin:
 
         with suppress(NoMatches):
             banner = self.query_one("#welcome-banner", WelcomeBanner)
-            self._status_bar.set_session_tip(banner.session_tip)
+            self.set_default_session_tip(banner.session_tip)
 
         # Focus the input immediately so the cursor is visible on first paint
         self._chat_input.focus_input()
@@ -535,7 +535,7 @@ class _StartupMixin:
             if self._lc_loop_id:
                 banner.update_loop_id(self._lc_loop_id)
             if self._status_bar is not None:
-                self._status_bar.set_session_tip(banner.session_tip)
+                self.set_default_session_tip(banner.session_tip)
         except NoMatches:
             logger.warning("Welcome banner not found during daemon ready transition")
 

{soothe_cli-0.7.18 → soothe_cli-0.8.0}/src/soothe_cli/tui/command_registry.py

@@ -130,6 +130,12 @@ COMMANDS: tuple[SlashCommand, ...] = (
         description="Route prompt to academic_research subagent (usage: /academic_research <query>)",
         bypass_tier=BypassTier.QUEUED,
     ),
+    SlashCommand(
+        name="/browser_use",
+        description="Route prompt to browser_use subagent (usage: /browser_use <task>)",
+        bypass_tier=BypassTier.QUEUED,
+        hidden_keywords="browser automation web",
+    ),
     SlashCommand(
         name="/plan",
         description="Send input in plan mode (usage: /plan or /plan <prompt>)",

{soothe_cli-0.7.18 → soothe_cli-0.8.0}/src/soothe_cli/tui/commands/__init__.py

@@ -10,15 +10,15 @@ from soothe_cli.tui.commands.command_router import (
     validate_command,
 )
 from soothe_cli.tui.commands.subagent_routing import (
-    BUILTIN_SUBAGENT_NAMES,
     SUBAGENT_DISPLAY_NAMES,
+    SUBAGENT_SLASH_ROUTE_IDS,
     get_subagent_display_name,
     parse_subagent_from_input,
 )
 
 __all__ = [
-    "BUILTIN_SUBAGENT_NAMES",
     "SUBAGENT_DISPLAY_NAMES",
+    "SUBAGENT_SLASH_ROUTE_IDS",
     "find_command_by_daemon_command",
     "get_subagent_display_name",
     "handle_rpc_command",

{soothe_cli-0.7.18 → soothe_cli-0.8.0}/src/soothe_cli/tui/commands/command_router.py

@@ -25,7 +25,7 @@ def parse_slash_command(input_text: str) -> tuple[str, str | None]:
     """Parse slash command and extract command + query.
 
     Args:
-        input_text: Full user input (e.g., "/research topic summary")
+        input_text: Full user input (e.g., "/deep_research topic summary")
 
     Returns:
         Tuple of (command, query) where query may be None
@@ -119,7 +119,7 @@ async def route_slash_command(
     """Route slash command based on registry metadata (RFC-454).
 
     Args:
-        cmd_input: Full command input (e.g., "/memory", "/research topic")
+        cmd_input: Full command input (e.g., "/memory", "/deep_research topic")
         console: Rich console for rendering
         client: WebSocket client for daemon communication
 
@@ -237,12 +237,13 @@ async def handle_routing_command(
 ) -> None:
     """Handle daemon routing command by sending input with optional subagent (RFC-454).
 
-    For routing commands that map to a configured subagent id (e.g. ``/research``, ``/plan``),
-    sets the WebSocket ``preferred_subagent`` field so the daemon merges a subagent hint into
-    StrangeLoop (IG-349). Other routing commands (e.g. ``/plan``) are sent as plain text unchanged.
+    For routing commands that map to a configured subagent id (e.g. ``/deep_research``,
+    ``/browser_use``), sets the WebSocket ``preferred_subagent`` field so the daemon merges a
+    subagent hint into StrangeLoop (IG-349). Other routing commands (e.g. ``/plan``) are sent
+    as plain text unchanged.
 
     Args:
-        cmd_input: Full command input (e.g., "/research topic summary")
+        cmd_input: Full command input (e.g., "/deep_research topic summary")
         console: Rich console
         client: WebSocket client
         loop_id: Subscribed loop to target (required for ``loop_input``)

{soothe_cli-0.7.18 → soothe_cli-0.8.0}/src/soothe_cli/tui/commands/slash_commands.py

@@ -154,8 +154,8 @@ def show_cron_add(console: Console, data: dict[str, Any]) -> None:
 
 KEYBOARD_SHORTCUTS: dict[str, str] = {
     "Esc": "Dismiss modal, plan overlay, or autocomplete",
-    "Ctrl+D": "Quit and detach from the daemon",
-    "Ctrl+C": "Clear input, interrupt agent/shell, or quit when pressed twice while idle",
+    "Ctrl+D": "Use /quit (or /q) to exit the TUI",
+    "Ctrl+C": "Clear input or interrupt running agent/shell",
     "Ctrl+X": "Open prompt in external editor ($VISUAL/$EDITOR)",
     "Ctrl+Y": "Copy selected text to clipboard (or show hint if none)",
     "Ctrl+T": "Toggle plan quick-view overlay",
@@ -272,7 +272,7 @@ COMMANDS: dict[str, dict[str, Any]] = {
         "requires_query": True,
         "handler": show_cron_add,
     },
-    # Daemon routing commands (3)
+    # Daemon routing commands
     "/plan": {"location": "daemon", "type": "routing", "description": "Trigger plan mode"},
     "/deep_research": {
         "location": "daemon",
@@ -286,6 +286,12 @@ COMMANDS: dict[str, dict[str, Any]] = {
         "description": "Route query to Academic Research subagent",
         "requires_query": True,
     },
+    "/browser_use": {
+        "location": "daemon",
+        "type": "routing",
+        "description": "Route query to Browser Use subagent",
+        "requires_query": True,
+    },
 }
 
 

{soothe_cli-0.7.18 → soothe_cli-0.8.0}/src/soothe_cli/tui/commands/subagent_routing.py

@@ -11,9 +11,13 @@ SUBAGENT_DISPLAY_NAMES: dict[str, str] = {
 }
 
 # Lowercase ids matched after ``/`` for preferred_subagent routing (core only).
-SUBAGENT_SLASH_ROUTE_IDS: tuple[str, ...] = ("deep_research", "academic_research")
-
-BUILTIN_SUBAGENT_NAMES: list[str] = list(SUBAGENT_SLASH_ROUTE_IDS)
+# Longest-first so a shorter id never shadows a longer prefix match.
+# Intake-only specialists (IG-600/601) must stay here so slash sets preferred_subagent.
+SUBAGENT_SLASH_ROUTE_IDS: tuple[str, ...] = (
+    "academic_research",
+    "deep_research",
+    "browser_use",
+)
 
 
 def get_subagent_display_name(technical_name: str) -> str:
@@ -34,7 +38,7 @@ def get_subagent_display_name(technical_name: str) -> str:
 def parse_subagent_from_input(user_input: str) -> tuple[str | None, str]:
     """Parse subagent subcommand from user input.
 
-    Detects subagent routing commands (e.g. ``/deep_research``)
+    Detects subagent routing commands (e.g. ``/deep_research``, ``/browser_use``)
     and extracts the subagent name along with the cleaned input text.
 
     Args:
@@ -47,14 +51,22 @@ def parse_subagent_from_input(user_input: str) -> tuple[str | None, str]:
 
     Examples:
         ``"/deep_research check this"`` -> ``("deep_research", "check this")``
+        ``"/browser_use open example.com"`` -> ``("browser_use", "open example.com")``
         ``"hello world"`` -> ``(None, "hello world")``
     """
     first_match: tuple[int, str] | None = None
+    lowered = user_input.lower()
 
     for subagent_name in SUBAGENT_SLASH_ROUTE_IDS:
         subcommand = f"/{subagent_name}"
-        idx = user_input.lower().find(subcommand)
-        if idx != -1 and (first_match is None or idx < first_match[0]):
+        idx = lowered.find(subcommand)
+        if idx == -1:
+            continue
+        end = idx + len(subcommand)
+        # Require end-of-string or whitespace so ``/browser`` does not match ``/browser_use``.
+        if end < len(lowered) and not lowered[end].isspace():
+            continue
+        if first_match is None or idx < first_match[0]:
             first_match = (idx, subagent_name)
 
     if first_match:

{soothe_cli-0.7.18 → soothe_cli-0.8.0}/src/soothe_cli/tui/spinner_labels.py

@@ -17,6 +17,7 @@ SPINNER_LABEL_RETRYING = "Retrying"
 SPINNER_LABEL_INPUT = "Input"
 SPINNER_LABEL_WAITING = "Waiting"
 SPINNER_LABEL_CONNECTING = "Connecting"
+SPINNER_LABEL_DELEGATING = "Delegating"
 
 # Backend plan_phase_status labels (orchestrator nodes) → display word.
 _PLAN_PHASE_TO_SPINNER: dict[str, str] = {
@@ -38,7 +39,13 @@ def map_plan_phase_spinner_label(label: str) -> str:
     key = label.strip()
     if not key:
         return SPINNER_LABEL_THINKING
-    return _PLAN_PHASE_TO_SPINNER.get(key, SPINNER_LABEL_THINKING)
+    mapped = _PLAN_PHASE_TO_SPINNER.get(key)
+    if mapped:
+        return mapped
+    # Intake-only wire: «Delegating to {subagent}» (RFC-630 / IG-602).
+    if key.lower().startswith("delegating"):
+        return SPINNER_LABEL_DELEGATING
+    return SPINNER_LABEL_THINKING
 
 
 def retry_spinner_hint(*, attempt: int, max_attempts: int) -> str | None: