soothe-cli 0.5.6__tar.gz → 0.5.8__tar.gz

{soothe_cli-0.5.6 → soothe_cli-0.5.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: soothe-cli
-Version: 0.5.6
+Version: 0.5.8
 Summary: Soothe CLI client - communicates with daemon via WebSocket
 Project-URL: Homepage, https://github.com/OpenSoothe/soothe
 Project-URL: Documentation, https://soothe.readthedocs.io

{soothe_cli-0.5.6 → soothe_cli-0.5.8}/src/soothe_cli/cli/execution/daemon.py

@@ -22,12 +22,17 @@ from soothe_cli.cli.execution.headless_renderer import HeadlessCliRenderer
 from soothe_cli.shared import EventProcessor
 from soothe_cli.shared.commands.subagent_routing import parse_subagent_from_input
 from soothe_cli.shared.core.presentation_engine import PresentationEngine
+from soothe_cli.shared.daemon_errors import (
+    friendly_daemon_execution_error,
+    is_daemon_worker_subprocess_lost,
+)
 
 logger = logging.getLogger(__name__)
 
 _DAEMON_FALLBACK_EXIT_CODE = 42
 _SESSION_BOOTSTRAP_TIMEOUT_S = 30.0
 _QUERY_START_TIMEOUT_S = 20.0
+_HEADLESS_WORKER_LOST_RETRIES = 1
 
 
 def _is_loop_scoped_event(event: dict[str, Any], *, active_loop_id: str) -> bool:
@@ -38,19 +43,20 @@ def _is_loop_scoped_event(event: dict[str, Any], *, active_loop_id: str) -> bool
     return event.get("loop_id") == active_loop_id
 
 
-async def run_headless_via_daemon(
+def _emit_headless_error(message: str) -> None:
+    """Write a user-facing error line to stderr (headless renderer convention)."""
+    typer.echo(f"ERROR: {message}", err=True)
+
+
+async def _run_headless_session_once(
     cfg: Any,
     prompt: str,
     *,
     resume_loop_id: str | None = None,
     autonomous: bool = False,
     max_iterations: int | None = None,
-) -> int:
-    """Run a single prompt by connecting to a running daemon.
-
-    Uses WebSocket transport for all connections (RFC-0013).
-    Headless output is RFC-614 loop-tagged main-graph assistant text only (IG-343).
-    """
+) -> tuple[int, bool]:
+    """Run one headless daemon session; return ``(exit_code, retry_on_worker_loss)``."""
     from soothe_sdk.client import WebSocketClient
 
     ws_url = websocket_url_from_config(cfg)
@@ -67,20 +73,22 @@ async def run_headless_via_daemon(
             subscribe_timeout_s=_SESSION_BOOTSTRAP_TIMEOUT_S,
         )
         if status_event.get("type") == "error":
-            typer.echo(f"Daemon error: {status_event.get('message', 'unknown')}", err=True)
-            return 1
+            raw = str(status_event.get("message", "unknown"))
+            _emit_headless_error(friendly_daemon_execution_error(raw))
+            return 1, is_daemon_worker_subprocess_lost(raw)
 
         active_loop_id = status_event.get("loop_id")
         if not active_loop_id:
-            typer.echo("Error: No loop_id after session bootstrap", err=True)
-            return 1
+            _emit_headless_error("No loop_id after session bootstrap")
+            return 1, False
 
         subagent_name, cleaned_prompt = parse_subagent_from_input(prompt)
+        effective_prompt = cleaned_prompt if subagent_name else prompt
 
         await asyncio.wait_for(
             client.send_input(
                 active_loop_id,
-                cleaned_prompt if subagent_name else prompt,
+                effective_prompt,
                 autonomous=autonomous,
                 max_iterations=max_iterations,
                 preferred_subagent=subagent_name,
@@ -107,7 +115,7 @@ async def run_headless_via_daemon(
                         client.read_event(), timeout=_QUERY_START_TIMEOUT_S
                     )
             except TimeoutError:
-                return _DAEMON_FALLBACK_EXIT_CODE
+                return _DAEMON_FALLBACK_EXIT_CODE, False
             if not event:
                 break
 
@@ -116,17 +124,17 @@ async def run_headless_via_daemon(
                 continue
 
             if event_type == "error":
-                typer.echo(f"Daemon error: {event.get('message', 'unknown')}", err=True)
-                return 1
+                raw = str(event.get("message", "unknown"))
+                _emit_headless_error(friendly_daemon_execution_error(raw))
+                return 1, is_daemon_worker_subprocess_lost(raw)
 
             ev_data = event.get("data")
-            if (
-                not query_started
-                and isinstance(ev_data, dict)
-                and str(ev_data.get("type", "")).startswith("soothe.error")
+            if isinstance(ev_data, dict) and str(ev_data.get("type", "")).startswith(
+                "soothe.error"
             ):
-                typer.echo(f"Daemon error: {ev_data.get('error', 'unknown')}", err=True)
-                return 1
+                raw = str(ev_data.get("error", "unknown"))
+                _emit_headless_error(friendly_daemon_execution_error(raw))
+                return 1, is_daemon_worker_subprocess_lost(raw)
 
             if event_type == "status":
                 state = event.get("state", "")
@@ -155,15 +163,48 @@ async def run_headless_via_daemon(
         logger.exception("Daemon connection failed")
         from soothe_sdk.utils import format_cli_error
 
-        typer.echo(f"Error: {format_cli_error(e)}", err=True)
-        return _DAEMON_FALLBACK_EXIT_CODE
+        _emit_headless_error(format_cli_error(e))
+        return _DAEMON_FALLBACK_EXIT_CODE, False
     except Exception as e:
         logger.exception("Failed to run via daemon")
-        from soothe_sdk.utils import format_cli_error
-
-        typer.echo(f"Error: {format_cli_error(e)}", err=True)
-        return 1
+        friendly = friendly_daemon_execution_error(e)
+        _emit_headless_error(friendly)
+        return 1, is_daemon_worker_subprocess_lost(e)
     else:
-        return 0
+        return 0, False
     finally:
         await client.close()
+
+
+async def run_headless_via_daemon(
+    cfg: Any,
+    prompt: str,
+    *,
+    resume_loop_id: str | None = None,
+    autonomous: bool = False,
+    max_iterations: int | None = None,
+) -> int:
+    """Run a single prompt by connecting to a running daemon.
+
+    Uses WebSocket transport for all connections (RFC-0013).
+    Headless output is RFC-614 loop-tagged main-graph assistant text only (IG-343).
+
+    Retries once when the worker pool loses a subprocess mid-query (common idle-timeout
+    race or transient worker recycle).
+    """
+    last_code = 1
+    for attempt in range(_HEADLESS_WORKER_LOST_RETRIES + 1):
+        last_code, retryable = await _run_headless_session_once(
+            cfg,
+            prompt,
+            resume_loop_id=resume_loop_id,
+            autonomous=autonomous,
+            max_iterations=max_iterations,
+        )
+        if last_code == 0:
+            return 0
+        if retryable and attempt < _HEADLESS_WORKER_LOST_RETRIES:
+            logger.warning("Headless query failed after worker subprocess exit; retrying once")
+            continue
+        return last_code
+    return last_code

{soothe_cli-0.5.6 → soothe_cli-0.5.8}/src/soothe_cli/cli/stream/formatter.py

@@ -111,7 +111,7 @@ def format_subagent_done(
         duration_s: Duration in seconds.
         task_scope: Optional ``(task_tool_call_id, subagent_type)`` for delegated rows.
         task_description: Original brief (e.g. explore ``search_target``) when available.
-        task_done_success: False for delegated failures (e.g. Claude subagent error).
+        task_done_success: False for delegated failures (e.g. optional plugin delegate error).
         answer_summary: Optional one-line answer tail after metrics (IG-344).
 
     Returns:

{soothe_cli-0.5.6 → soothe_cli-0.5.8}/src/soothe_cli/cli/stream/pipeline.py

@@ -301,11 +301,7 @@ class StreamDisplayPipeline:
 
         answer_tail: str | None = None
         raw_summary = event.get("summary")
-        if (
-            isinstance(raw_summary, str)
-            and raw_summary.strip()
-            and subagent_name in ("claude", "browser", "research")
-        ):
+        if isinstance(raw_summary, str) and raw_summary.strip() and subagent_name:
             answer_tail = preview_first(raw_summary.strip(), 120)
 
         return [
@@ -323,7 +319,7 @@ class StreamDisplayPipeline:
 
         Args:
             event: Event dictionary.
-            subagent_name: Subagent name (explore, browser, claude, research).
+            subagent_name: Subagent id (e.g. explore, plan, research, or a plugin id).
 
         Returns:
             Formatted summary string with key metrics.
@@ -342,7 +338,7 @@ class StreamDisplayPipeline:
                 return summary
             return "done"
 
-        # Claude: cost_usd, claude_session_id
+        # Optional plugin session: cost_usd + opaque session id field
         if subagent_name == "claude":
             cost = event.get("cost_usd", 0.0)
             session_id = event.get("claude_session_id")
@@ -353,7 +349,7 @@ class StreamDisplayPipeline:
                 return summary
             return "done"
 
-        # Browser: success status
+        # Optional web automation plugin: boolean success in payload
         if subagent_name == "browser":
             success = event.get("success", True)
             return "✓ success" if success else "✗ failed"

{soothe_cli-0.5.6 → soothe_cli-0.5.8}/src/soothe_cli/config/cli_config.py

@@ -27,6 +27,10 @@ class CLIConfig:
     # logging_level: DEBUG/INFO/… for ~/.soothe/logs/cli.log; None = default INFO.
     logging_level: str | None = None
 
+    # TUI rendering options
+    render_markdown: bool = True
+    """Render assistant messages as Markdown in TUI (default True)."""
+
     # Output streaming overrides (RFC-614)
     output_streaming_enabled: bool | None = None
     """Override daemon streaming enabled setting."""
@@ -110,10 +114,17 @@ class CLIConfig:
         if raw_level is not None and not isinstance(raw_level, str):
             raw_level = None
 
+        # TUI options from 'tui' section
+        tui_section = data.get("tui", {})
+        render_markdown = tui_section.get("render_markdown", True)
+        if not isinstance(render_markdown, bool):
+            render_markdown = True
+
         return cls(
             daemon_host=websocket.get("host", websocket_legacy.get("host", "127.0.0.1")),
             daemon_port=websocket.get("port", websocket_legacy.get("port", 8765)),
             logging_level=raw_level,
+            render_markdown=render_markdown,
             soothe_home=Path(data.get("home", str(Path.home() / ".soothe"))),
         )
 

{soothe_cli-0.5.6 → soothe_cli-0.5.8}/src/soothe_cli/shared/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., "/browser AI trends")
+        input_text: Full user input (e.g., "/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-404).
 
     Args:
-        cmd_input: Full command input (e.g., "/memory", "/browser AI trends")
+        cmd_input: Full command input (e.g., "/memory", "/research topic")
         console: Rich console for rendering
         client: WebSocket client for daemon communication
 
@@ -243,12 +243,12 @@ async def handle_routing_command(
 ) -> None:
     """Handle daemon routing command by sending input with optional subagent (RFC-404).
 
-    For ``/browser``, ``/claude``, ``/research``, and ``/explore``, sets the WebSocket
-    ``preferred_subagent`` field so the daemon merges a subagent hint into AgentLoop (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. ``/research``, ``/explore``),
+    sets the WebSocket ``preferred_subagent`` field so the daemon merges a subagent hint into
+    AgentLoop (IG-349). Other routing commands (e.g. ``/plan``) are sent as plain text unchanged.
 
     Args:
-        cmd_input: Full command input (e.g., "/browser AI trends")
+        cmd_input: Full command input (e.g., "/research topic summary")
         console: Rich console
         client: WebSocket client
         loop_id: Subscribed loop to target (required for ``loop_input``)

{soothe_cli-0.5.6 → soothe_cli-0.5.8}/src/soothe_cli/shared/commands/slash_commands.py

@@ -160,7 +160,7 @@ KEYBOARD_SHORTCUTS: dict[str, str] = {
     "Ctrl+D": "Detach TUI: Leave the loop running (confirm) and exit client",
     "Ctrl+C": "Cancel running job, press twice within 1s to quit",
     "Ctrl+E": "Focus chat input",
-    "Ctrl+Y": "Copy last message to clipboard",
+    "Ctrl+Y": "Copy selected text to clipboard (or show hint if none)",
 }
 
 
@@ -266,20 +266,8 @@ COMMANDS: dict[str, dict[str, Any]] = {
         "requires_loop": True,
         "handler": show_autopilot_dashboard,
     },
-    # Daemon routing commands (5)
+    # Daemon routing commands (3)
     "/plan": {"location": "daemon", "type": "routing", "description": "Trigger plan mode"},
-    "/browser": {
-        "location": "daemon",
-        "type": "routing",
-        "description": "Route query to Browser subagent",
-        "requires_query": True,
-    },
-    "/claude": {
-        "location": "daemon",
-        "type": "routing",
-        "description": "Route query to Claude subagent",
-        "requires_query": True,
-    },
     "/research": {
         "location": "daemon",
         "type": "routing",

{soothe_cli-0.5.6 → soothe_cli-0.5.8}/src/soothe_cli/shared/commands/subagent_routing.py

@@ -3,13 +3,14 @@
 from __future__ import annotations
 
 SUBAGENT_DISPLAY_NAMES: dict[str, str] = {
-    "browser": "Browser",
-    "claude": "Claude",
     "research": "Research",
     "explore": "Explore",
 }
 
-BUILTIN_SUBAGENT_NAMES: list[str] = list(SUBAGENT_DISPLAY_NAMES.keys())
+# Lowercase ids matched after ``/`` for preferred_subagent routing (core only).
+SUBAGENT_SLASH_ROUTE_IDS: tuple[str, ...] = ("research", "explore")
+
+BUILTIN_SUBAGENT_NAMES: list[str] = list(SUBAGENT_SLASH_ROUTE_IDS)
 
 
 def get_subagent_display_name(technical_name: str) -> str:
@@ -19,18 +20,18 @@ def get_subagent_display_name(technical_name: str) -> str:
         technical_name: Internal subagent name.
 
     Returns:
-        PascalCase display name.
+        Title-cased label for first-party ids; otherwise the raw id string.
     """
-    return SUBAGENT_DISPLAY_NAMES.get(
-        technical_name,
-        technical_name.replace("_", " ").title().replace(" ", ""),
-    )
+    key = (technical_name or "").strip()
+    if key.lower() in SUBAGENT_DISPLAY_NAMES:
+        return SUBAGENT_DISPLAY_NAMES[key.lower()]
+    return key
 
 
 def parse_subagent_from_input(user_input: str) -> tuple[str | None, str]:
     """Parse subagent subcommand from user input.
 
-    Detects subagent subcommands (e.g., /browser, /claude) anywhere in the text
+    Detects subagent routing commands (e.g. ``/research``, ``/explore``)
     and extracts the subagent name along with the cleaned input text.
 
     Args:
@@ -42,13 +43,13 @@ def parse_subagent_from_input(user_input: str) -> tuple[str | None, str]:
         The subcommand is removed from ``cleaned_text``.
 
     Examples:
-        ``"/browser check this"`` -> ``("browser", "check this")``
-        ``"Can you /claude analyze this"`` -> ``("claude", "Can you analyze this")``
+        ``"/research check this"`` -> ``("research", "check this")``
+        ``"/explore map the repo"`` -> ``("explore", "map the repo")``
         ``"hello world"`` -> ``(None, "hello world")``
     """
     first_match: tuple[int, str] | None = None
 
-    for subagent_name in BUILTIN_SUBAGENT_NAMES:
+    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]):

{soothe_cli-0.5.6 → soothe_cli-0.5.8}/src/soothe_cli/shared/core/event_processor.py

@@ -137,12 +137,17 @@ class EventProcessor:
             namespace,
         )
 
-    def _resolve_task_scope(self, namespace: tuple[str, ...]) -> tuple[str, str] | None:
-        """Return ``(task_tool_call_id, subagent_type)`` for this stream namespace."""
+    def _resolve_task_scope(self, namespace: tuple[str, ...]) -> tuple[str, str, str] | None:
+        """Return task scope ``(task_tool_call_id, subagent_type, step_id)`` for namespace."""
         return resolve_task_scope_for_namespace(self._state.namespace_task_bindings, namespace)
 
     def _enqueue_task_spawn_if_needed(
-        self, name: str, args: dict[str, Any], tool_call_id: str, *, is_main: bool
+        self,
+        name: str,
+        args: dict[str, Any],
+        tool_call_id: str,
+        *,
+        is_main: bool,
     ) -> None:
         """Record main-graph ``task`` tool calls so subgraph streams can resolve labels."""
         enqueue_task_spawn(
@@ -229,7 +234,7 @@ class EventProcessor:
         """Headless stdout: only RFC-614 loop-tagged finals (IG-343 / IG-345).
 
         Suppresses unphased execute-wave narration on the main graph; ``goal_completion``,
-        ``chitchat``, etc. are routed via ``assistant_output_phase`` before this path.
+        ``quiz``, etc. are routed via ``assistant_output_phase`` before this path.
 
         Subgraph streams without RFC-614 phases are skipped in ``_handle_ai_message`` before
         this runs; loop-tagged subgraph finals use ``_dispatch_loop_tagged_assistant_text``.
@@ -536,10 +541,11 @@ class EventProcessor:
 
         # Accumulate streaming tool args (IG-053)
         tool_call_chunks = getattr(msg, "tool_call_chunks", None) or []
-        accumulate_tool_call_chunks(
+        self._state.last_active_tool_call_id = accumulate_tool_call_chunks(
             self._state.pending_tool_calls,
             tool_call_chunks,
             is_main=is_main,
+            last_active_id=self._state.last_active_tool_call_id,
         )
 
         # Emit pending tool calls with complete args
@@ -777,10 +783,11 @@ class EventProcessor:
         # Accumulate streaming tool args from tool_call_chunks (IG-053)
         tool_call_chunks = msg.get("tool_call_chunks", [])
         if isinstance(tool_call_chunks, list) and tool_call_chunks:
-            accumulate_tool_call_chunks(
+            self._state.last_active_tool_call_id = accumulate_tool_call_chunks(
                 self._state.pending_tool_calls,
                 tool_call_chunks,
                 is_main=is_main,
+                last_active_id=self._state.last_active_tool_call_id,
             )
 
         self._emit_pending_tool_calls(namespace)

{soothe_cli-0.5.6 → soothe_cli-0.5.8}/src/soothe_cli/shared/core/presentation_engine.py

@@ -49,7 +49,7 @@ class PresentationEngine:
 
     @property
     def final_answer_locked(self) -> bool:
-        """True after a custom final/chitchat response was emitted for this turn."""
+        """True after a custom final or quiz-phase response was emitted for this turn."""
         return self._state.final_answer_locked
 
     def mark_final_answer_locked(self) -> None:

{soothe_cli-0.5.6 → soothe_cli-0.5.8}/src/soothe_cli/shared/core/processor_state.py

@@ -32,6 +32,9 @@ class ProcessorState:
     # Maps tool_call_id -> {'name': str, 'args_str': str, 'emitted': bool, 'is_main': bool}
     pending_tool_calls: dict[str, dict[str, Any]] = field(default_factory=dict)
 
+    # Last active tool_call_id for orphan chunk attachment (chunks without explicit id)
+    last_active_tool_call_id: str = ""
+
     # Namespace -> display name mapping for subagents
     name_map: dict[str, str] = field(default_factory=dict)
 
@@ -65,8 +68,10 @@ class ProcessorState:
     """(phase, namespace) pairs that already emitted final loop-tagged output this turn."""
 
     # Task tool spawn queue → bind first subgraph namespace (FIFO; IG-334)
-    task_spawn_queue: deque[tuple[str, str]] = field(default_factory=deque)
-    namespace_task_bindings: dict[tuple[str, ...], tuple[str, str]] = field(default_factory=dict)
+    task_spawn_queue: deque[tuple[str, str, str]] = field(default_factory=deque)
+    namespace_task_bindings: dict[tuple[str, ...], tuple[str, str, str]] = field(
+        default_factory=dict
+    )
 
     def reset_turn(self) -> None:
         """Reset per-turn state.
@@ -75,6 +80,7 @@ class ProcessorState:
         Clears streaming buffers but preserves session state.
         """
         self.pending_tool_calls.clear()
+        self.last_active_tool_call_id = ""
         self.tool_call_start_times.clear()
         self.emitted_tool_call_ids.clear()
         self.emitted_tool_result_ids.clear()

{soothe_cli-0.5.6 → soothe_cli-0.5.8}/src/soothe_cli/shared/core/renderer_protocol.py

@@ -141,7 +141,7 @@ class RendererProtocol(Protocol):
         Catch-all for events not covered by specific callbacks.
 
         Args:
-            event_type: Full event type string (e.g., ``soothe.subagent.browser.started``).
+            event_type: Full event type string (e.g., ``soothe.subagent.explore.started``).
             data: Event payload.
             namespace: Subagent namespace tuple (empty for main agent).
             task_scope: When subgraph streams are bound to a Task tool call (IG-334).

soothe_cli-0.5.8/src/soothe_cli/shared/daemon_errors.py

@@ -0,0 +1,27 @@
+"""Shared daemon execution error presentation for CLI and TUI."""
+
+from __future__ import annotations
+
+# Partial match for pool_runner RuntimeError when an OS worker exits mid-turn.
+DAEMON_WORKER_SUBPROCESS_LOST = "Worker subprocess exited unexpectedly during query execution"
+
+_FRIENDLY_WORKER_SUBPROCESS_LOST = (
+    "The daemon execution worker stopped unexpectedly (for example after the pool "
+    "recycled an idle subprocess). Send your message again."
+)
+
+
+def friendly_daemon_execution_error(exc: BaseException | str) -> str:
+    """Map known daemon failures to concise, actionable copy."""
+    if isinstance(exc, RuntimeError) and DAEMON_WORKER_SUBPROCESS_LOST in str(exc):
+        return _FRIENDLY_WORKER_SUBPROCESS_LOST
+    text = str(exc)
+    if DAEMON_WORKER_SUBPROCESS_LOST in text:
+        return _FRIENDLY_WORKER_SUBPROCESS_LOST
+    return text if isinstance(exc, str) else str(exc)
+
+
+def is_daemon_worker_subprocess_lost(exc: BaseException | str) -> bool:
+    """Return whether an error indicates a pool worker process exited mid-query."""
+    text = str(exc)
+    return DAEMON_WORKER_SUBPROCESS_LOST in text

{soothe_cli-0.5.6 → soothe_cli-0.5.8}/src/soothe_cli/shared/rendering/async_renderer_protocol.py

@@ -140,7 +140,7 @@ class AsyncRendererProtocol(Protocol):
         Catch-all for events not covered by specific callbacks.
 
         Args:
-            event_type: Full event type string (e.g., ``soothe.subagent.browser.started``).
+            event_type: Full event type string (e.g., ``soothe.subagent.explore.started``).
             data: Event payload.
             namespace: Subagent namespace tuple (empty for main agent).
             task_scope: When subgraph streams are bound to a Task tool call (IG-334).

{soothe_cli-0.5.6 → soothe_cli-0.5.8}/src/soothe_cli/shared/tools/__init__.py

@@ -15,7 +15,6 @@ from soothe_cli.shared.tools.message_processing import (
 from soothe_cli.shared.tools.rendering import update_name_map_from_tool_calls
 from soothe_cli.shared.tools.tool_call_resolution import (
     build_streaming_args_overlay,
-    infer_tool_name_from_call_id,
     materialize_ai_blocks_with_resolved_tools,
     tool_args_meaningful,
 )
@@ -64,7 +63,6 @@ __all__ = [
     "update_name_map_from_tool_calls",
     # Tool call resolution
     "build_streaming_args_overlay",
-    "infer_tool_name_from_call_id",
     "materialize_ai_blocks_with_resolved_tools",
     "tool_args_meaningful",
     # Tool card payload