soothe-cli 0.3.5__tar.gz → 0.3.6__tar.gz

{soothe_cli-0.3.5 → soothe_cli-0.3.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: soothe-cli
-Version: 0.3.5
+Version: 0.3.6
 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.3.5 → soothe_cli-0.3.6}/src/soothe_cli/cli/execution/daemon.py

@@ -180,7 +180,7 @@ 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, context='daemon connection')}", err=True)
+        typer.echo(f"Error: {format_cli_error(e)}", err=True)
         return _DAEMON_FALLBACK_EXIT_CODE
     except Exception as e:
         logger.exception("Failed to run via daemon")

{soothe_cli-0.3.5 → soothe_cli-0.3.6}/src/soothe_cli/cli/execution/headless.py

@@ -60,7 +60,7 @@ def run_headless(
             import subprocess
 
             subprocess.Popen(
-                [sys.executable, "-m", "soothe.cli.daemon_main", "start"],
+                [sys.executable, "-m", "soothe.daemon", "--detached"],
                 stdout=subprocess.DEVNULL,
                 stderr=subprocess.DEVNULL,
             )

{soothe_cli-0.3.5 → soothe_cli-0.3.6}/src/soothe_cli/cli/stream/formatter.py

@@ -95,7 +95,7 @@ def format_goal_header(
         DisplayLine for goal header.
     """
     # Add inline symbol for goal marker
-    content = f"🚩 {goal}"
+    content = f"⌯⌲ {goal}"
     return DisplayLine(
         level=1,
         content=content,
@@ -265,13 +265,16 @@ def format_plan_phase_reasoning(
     namespace: tuple[str, ...] = (),
     verbosity_tier: VerbosityTier = VerbosityTier.NORMAL,
 ) -> DisplayLine:
-    """Format a labeled plan-phase reasoning line (assessment vs plan strategy)."""
+    """Format a labeled plan-phase reasoning line (assessment vs plan strategy).
+
+    IG-225: Uses level=2 (flat, no indent) for prominent visibility alongside step headers.
+    """
     content = f"💭 {label}: {text}"
     return DisplayLine(
-        level=3,
+        level=2,
         content=content,
         icon="•",
-        indent=indent_for_level(3),
+        indent=indent_for_level(2),
         source_prefix=_derive_source_prefix(namespace, verbosity_tier),
     )
 

{soothe_cli-0.3.5 → soothe_cli-0.3.6}/src/soothe_cli/tui/app.py

@@ -45,6 +45,12 @@ from soothe_cli.tui._session_stats import (
 # after user interaction begins.
 from soothe_cli.tui._version import CHANGELOG_URL, DOCS_URL
 from soothe_cli.tui.config import is_ascii_mode
+from soothe_cli.tui.message_display_filter import (
+    extract_ai_text_for_display,
+    extract_message_tool_calls,
+    extract_user_text_for_display,
+    normalize_stream_message,
+)
 from soothe_cli.tui.widgets.chat_input import ChatInput
 from soothe_cli.tui.widgets.loading import LoadingWidget
 from soothe_cli.tui.widgets.message_store import (
@@ -714,6 +720,7 @@ class SootheApp(App):
         self._thread_switching = False
 
         self._model_switching = False
+        self._detaching = False
 
         self._deferred_actions: list[DeferredAction] = []
         """Deferred actions executed after the current busy state resolves."""
@@ -1417,6 +1424,19 @@ class SootheApp(App):
         except NoMatches:
             logger.warning("Welcome banner not found during daemon ready transition")
 
+        # IG-228: Start background event reader if thread is already running
+        thread_state = event.status_event.get("state", "")
+        if thread_state == "running" and self._daemon_session is not None:
+            logger.info(
+                "Thread %s is running, starting background event reader",
+                status_thread_id[:8] if status_thread_id else "?",
+            )
+            self.run_worker(
+                self._consume_daemon_events_background(),
+                exclusive=False,
+                group="daemon-event-reader",
+            )
+
         if not self._schedule_initial_submission() and self._lc_thread_id:
             self.call_after_refresh(lambda: asyncio.create_task(self._load_thread_history()))
 
@@ -1543,6 +1563,9 @@ class SootheApp(App):
 
     async def _prewarm_model_caches(self) -> None:
         """Prewarm model discovery and profile caches without blocking startup."""
+        if self._daemon_config is not None and self._daemon_session is None:
+            logger.debug("Skipping model cache prewarm - daemon session not ready")
+            return
         try:
             from soothe_cli.tui.model_config import (
                 get_available_models,
@@ -3283,7 +3306,7 @@ class SootheApp(App):
         Returns:
             Ordered list of `MessageData` ready for `MessageStore.bulk_load`.
         """
-        from langchain_core.messages import AIMessage, HumanMessage, ToolMessage
+        from langchain_core.messages import AIMessage, ToolMessage
 
         from soothe_cli.shared.message_processing import (
             extract_tool_args_dict,
@@ -3295,11 +3318,9 @@ class SootheApp(App):
         pending_tool_indices: dict[str, int] = {}
 
         for msg in messages:
-            if isinstance(msg, HumanMessage):
-                content = msg.content if isinstance(msg.content, str) else str(msg.content)
-                if content.startswith("[SYSTEM]"):
-                    continue
-
+            msg = normalize_stream_message(msg)
+            user_text = extract_user_text_for_display(msg)
+            if user_text is not None:
                 # Detect skill invocations persisted via additional_kwargs
                 skill_meta = (msg.additional_kwargs or {}).get("__skill")
                 if isinstance(skill_meta, dict) and skill_meta.get("name"):
@@ -3311,26 +3332,14 @@ class SootheApp(App):
                             skill_description=str(skill_meta.get("description", "")),
                             skill_source=str(skill_meta.get("source", "")),
                             skill_args=str(skill_meta.get("args", "")),
-                            skill_body=content,
+                            skill_body=user_text,
                         )
                     )
                 else:
-                    result.append(MessageData(type=MessageType.USER, content=content))
+                    result.append(MessageData(type=MessageType.USER, content=user_text))
 
             elif isinstance(msg, AIMessage):
-                # Extract text content
-                content = msg.content
-                text = ""
-                if isinstance(content, str):
-                    text = content.strip()
-                elif isinstance(content, list):
-                    for block in content:
-                        if isinstance(block, dict) and block.get("type") == "text":
-                            text += block.get("text", "")
-                        elif isinstance(block, str):
-                            text += block
-                    text = text.strip()
-
+                text = extract_ai_text_for_display(msg)
                 if text:
                     result.append(MessageData(type=MessageType.ASSISTANT, content=text))
 
@@ -3964,6 +3973,140 @@ class SootheApp(App):
             exclusive=False,
         )
 
+    async def _consume_daemon_events_background(self) -> None:
+        """Consume events from daemon when subscribed to a running thread.
+
+        IG-228: This background task reads events from the daemon websocket
+        when the thread is already running passively (not during an active
+        turn). It uses the same event processing pipeline as active queries.
+        """
+        if not self._daemon_session:
+            return
+
+        logger.info("Starting background event consumer for subscribed thread")
+        from langchain_core.messages import AIMessage, AIMessageChunk, ToolMessage
+
+        from soothe_cli.cli.stream.pipeline import StreamDisplayPipeline
+        from soothe_cli.shared.config_loader import load_config
+        from soothe_cli.shared.display_policy import normalize_verbosity
+        from soothe_cli.shared.message_processing import extract_tool_args_dict
+
+        pv = normalize_verbosity(load_config().verbosity)
+        progress_pipeline = StreamDisplayPipeline(verbosity=pv)
+        tool_cards: dict[str, ToolCallMessage] = {}
+        assistant_cards_by_ns: dict[tuple[Any, ...], AssistantMessage] = {}
+        last_user_text_by_ns: dict[tuple[Any, ...], str] = {}
+        last_ai_chunk_by_ns: dict[tuple[Any, ...], str] = {}
+
+        try:
+            # Use iter_turn_chunks to read events (same as active turn execution)
+            chunk_source = self._daemon_session.iter_turn_chunks()
+            async for chunk in chunk_source:
+                if not isinstance(chunk, tuple) or len(chunk) != 3:
+                    logger.debug("Skipping non-3-tuple chunk: %s", type(chunk).__name__)
+                    continue
+
+                namespace, mode, data = chunk
+                ns_key = tuple(namespace) if namespace else ()
+
+                async def _flush_assistant_ns(key: tuple[Any, ...]) -> None:
+                    card = assistant_cards_by_ns.pop(key, None)
+                    if card is not None:
+                        await card.stop_stream()
+
+                if mode == "messages":
+                    if not isinstance(data, tuple) or len(data) != 2:
+                        continue
+                    message, _metadata = data
+                    message = normalize_stream_message(message)
+
+                    user_text = extract_user_text_for_display(message)
+                    if user_text is not None:
+                        # Deduplicate immediate replayed user rows after reconnect/resubscribe.
+                        if last_user_text_by_ns.get(ns_key) == user_text:
+                            continue
+                        await _flush_assistant_ns(ns_key)
+                        await self._mount_message(UserMessage(user_text))
+                        last_user_text_by_ns[ns_key] = user_text
+                        continue
+
+                    if isinstance(message, ToolMessage):
+                        call_id = str(getattr(message, "tool_call_id", "") or "").strip()
+                        if call_id and call_id in tool_cards:
+                            tool_cards[call_id].set_success(
+                                str(getattr(message, "content", "") or "")
+                            )
+                        continue
+
+                    # Render tool calls as cards in background mode too.
+                    for raw_call in extract_message_tool_calls(message):
+                        call_id = str(
+                            raw_call.get("id") or raw_call.get("tool_call_id") or ""
+                        ).strip()
+                        tool_name = str(raw_call.get("name") or "").strip()
+                        if not call_id or not tool_name or call_id in tool_cards:
+                            continue
+                        tool_msg = ToolCallMessage(
+                            tool_name,
+                            extract_tool_args_dict(raw_call),
+                            tool_call_id=call_id,
+                        )
+                        tool_msg.set_running()
+                        await self._mount_message(tool_msg)
+                        tool_cards[call_id] = tool_msg
+
+                    if isinstance(message, (AIMessage, AIMessageChunk)):
+                        extracted = extract_ai_text_for_display(message)
+                        if extracted:
+                            # Deduplicate immediate replayed AI chunks after reconnect/resubscribe.
+                            if last_ai_chunk_by_ns.get(ns_key) == extracted:
+                                if getattr(message, "chunk_position", None) == "last":
+                                    await _flush_assistant_ns(ns_key)
+                                continue
+                            asst = assistant_cards_by_ns.get(ns_key)
+                            if asst is None:
+                                asst = AssistantMessage(id=f"asst-{uuid.uuid4().hex[:8]}")
+                                await self._mount_message(asst)
+                                assistant_cards_by_ns[ns_key] = asst
+                            await asst.append_content(extracted)
+                            last_ai_chunk_by_ns[ns_key] = extracted
+
+                        if getattr(message, "chunk_position", None) == "last":
+                            await _flush_assistant_ns(ns_key)
+                            last_ai_chunk_by_ns.pop(ns_key, None)
+                        continue
+                    continue
+
+                if mode != "updates" or not isinstance(data, dict):
+                    continue
+
+                await _flush_assistant_ns(ns_key)
+                payloads: list[dict[str, Any]] = []
+                if isinstance(data.get("type"), str):
+                    payloads.append(data)
+                for value in data.values():
+                    if isinstance(value, dict) and isinstance(value.get("type"), str):
+                        payloads.append(value)
+
+                for event_payload in payloads:
+                    event_for_pipeline = dict(event_payload)
+                    event_for_pipeline["namespace"] = list(namespace)
+                    lines = progress_pipeline.process(event_for_pipeline)
+                    for line in lines:
+                        rendered = line.format().lstrip("\n").rstrip()
+                        if rendered:
+                            await self._mount_message(AppMessage(rendered))
+
+        except asyncio.CancelledError:
+            logger.info("Background event consumer cancelled")
+        except Exception as exc:
+            logger.warning("Background event consumer error: %s", exc)
+        finally:
+            for card in assistant_cards_by_ns.values():
+                with suppress(Exception):
+                    await card.stop_stream()
+            logger.info("Background event consumer stopped")
+
     async def _load_thread_history(
         self,
         *,
@@ -3972,7 +4115,7 @@ class SootheApp(App):
     ) -> None:
         """Load and render message history when resuming a thread.
 
-        When `preloaded_payload` is provided (e.g., from `_resume_thread`),
+        When `preloaded_payload` is provided (e.g. from `_resume_thread`),
         this reuses that data. Otherwise, it fetches checkpoint state from the
         agent and converts stored messages into lightweight `MessageData`
         objects. The method then bulk-loads into the `MessageStore` and mounts
@@ -4456,11 +4599,31 @@ class SootheApp(App):
             return
         if isinstance(self.screen, DeleteThreadConfirmScreen):
             if self._quit_pending:
-                self.exit()
+                self._detach_or_exit()
                 return
             self._arm_quit_pending("Ctrl+D")
             return
-        self.exit()
+        self._detach_or_exit()
+
+    async def _detach_then_exit(self) -> None:
+        """Detach from daemon, then exit the app."""
+        if self._detaching:
+            return
+        self._detaching = True
+        try:
+            if self._daemon_session is not None:
+                await self._daemon_session.detach()
+            self.exit()
+        finally:
+            self._detaching = False
+
+    def _detach_or_exit(self) -> None:
+        """Exit immediately, or detach first when daemon-backed."""
+        if self._daemon_session is None:
+            self.exit()
+            return
+        self.notify("Detaching from daemon...", severity="info")
+        self.run_worker(self._detach_then_exit(), exclusive=False, group="daemon-detach")
 
     def exit(
         self,
@@ -5304,11 +5467,7 @@ class SootheApp(App):
 
     def action_detach(self) -> None:
         """Exit TUI but leave daemon running."""
-        self.notify("Detaching from daemon...", severity="info")
-        if self._daemon_session is not None:
-            self.run_worker(self._daemon_session.detach(), exclusive=False)
-        # Exit without stopping daemon
-        self.exit()
+        self._detach_or_exit()
 
 
 @dataclass(frozen=True)

{soothe_cli-0.3.5 → soothe_cli-0.3.6}/src/soothe_cli/tui/config.py

@@ -298,6 +298,8 @@ class Glyphs:
     arrow_down: str  # down arrow vs v
     bullet: str  # bullet vs -
     cursor: str  # cursor vs >
+    user: str  # User/human icon
+    assistant: str  # AI/assistant icon
 
     # Box-drawing characters
     box_vertical: str  # │ vs |
@@ -328,6 +330,8 @@ UNICODE_GLYPHS = Glyphs(
     arrow_down="↓",
     bullet="•",
     cursor="›",  # noqa: RUF001  # Intentional Unicode glyph
+    user="👤",  # User/human icon
+    assistant="🤖",  # AI/assistant icon
     # Box-drawing characters
     box_vertical="│",
     box_horizontal="─",
@@ -354,6 +358,8 @@ ASCII_GLYPHS = Glyphs(
     arrow_down="v",
     bullet="-",
     cursor=">",
+    user="[U]",  # User/human icon (ASCII)
+    assistant="[A]",  # AI/assistant icon (ASCII)
     # Box-drawing characters
     box_vertical="|",
     box_horizontal="-",

{soothe_cli-0.3.5 → soothe_cli-0.3.6}/src/soothe_cli/tui/daemon_session.py

@@ -34,9 +34,13 @@ class TuiDaemonSession:
 
     def __init__(self, cfg: Any) -> None:
         self._cfg = cfg
-        self._client = WebSocketClient(url=websocket_url_from_config(cfg))
+        ws_url = websocket_url_from_config(cfg)
+        self._client = WebSocketClient(url=ws_url)
+        self._rpc_client = WebSocketClient(url=ws_url)
         self._thread_id: str | None = None
         self._read_lock = asyncio.Lock()
+        self._rpc_lock = asyncio.Lock()
+        self._rpc_connected = False
         self._streaming = False
 
     @property
@@ -73,6 +77,8 @@ class TuiDaemonSession:
     async def close(self) -> None:
         """Close the daemon websocket."""
         await self._client.close()
+        await self._rpc_client.close()
+        self._rpc_connected = False
 
     async def detach(self) -> None:
         """Detach this client from the daemon."""
@@ -183,8 +189,9 @@ class TuiDaemonSession:
         thread_id = str(config.get("configurable", {}).get("thread_id", "")).strip()
         if not thread_id:
             return DaemonStateSnapshot(values={})
-        async with self._read_lock:
-            response = await self._client.request_response(
+        async with self._rpc_lock:
+            await self._ensure_rpc_connected()
+            response = await self._rpc_client.request_response(
                 {"type": "thread_state", "thread_id": thread_id},
                 response_type="thread_state_response",
             )
@@ -231,8 +238,9 @@ class TuiDaemonSession:
         if include_events:
             payload["include_events"] = True
 
-        async with self._read_lock:
-            response = await self._client.request_response(
+        async with self._rpc_lock:
+            await self._ensure_rpc_connected()
+            response = await self._rpc_client.request_response(
                 payload,
                 response_type="thread_messages_response",
                 timeout=10.0,
@@ -256,8 +264,9 @@ class TuiDaemonSession:
         thread_id = str(config.get("configurable", {}).get("thread_id", "")).strip()
         if not thread_id:
             return
-        async with self._read_lock:
-            await self._client.request_response(
+        async with self._rpc_lock:
+            await self._ensure_rpc_connected()
+            await self._rpc_client.request_response(
                 {
                     "type": "thread_update_state",
                     "thread_id": thread_id,
@@ -269,8 +278,9 @@ class TuiDaemonSession:
 
     async def list_skills(self) -> list[dict[str, Any]]:
         """Return skill rows from the daemon catalog (no filesystem paths)."""
-        async with self._read_lock:
-            response = await self._client.list_skills(timeout=15.0)
+        async with self._rpc_lock:
+            await self._ensure_rpc_connected()
+            response = await self._rpc_client.list_skills(timeout=15.0)
         skills = response.get("skills", [])
         if not isinstance(skills, list):
             return []
@@ -278,10 +288,19 @@ class TuiDaemonSession:
 
     async def list_models(self) -> dict[str, Any]:
         """Return daemon ``models_list_response`` (models + default_model from server config)."""
-        async with self._read_lock:
-            return await self._client.list_models(timeout=15.0)
+        async with self._rpc_lock:
+            await self._ensure_rpc_connected()
+            return await self._rpc_client.list_models(timeout=15.0)
 
     async def invoke_skill(self, skill: str, args: str = "") -> dict[str, Any]:
         """Resolve ``SKILL.md`` on the daemon and receive UI echo before the turn streams."""
-        async with self._read_lock:
-            return await self._client.invoke_skill(skill, args, timeout=120.0)
+        async with self._rpc_lock:
+            await self._ensure_rpc_connected()
+            return await self._rpc_client.invoke_skill(skill, args, timeout=120.0)
+
+    async def _ensure_rpc_connected(self) -> None:
+        """Ensure dedicated RPC client is connected."""
+        if self._rpc_connected:
+            return
+        await connect_websocket_with_retries(self._rpc_client)
+        self._rpc_connected = True

soothe_cli-0.3.6/src/soothe_cli/tui/message_display_filter.py

@@ -0,0 +1,73 @@
+"""Shared message-display filtering for live and recovered TUI rendering."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from soothe_sdk.langchain_wire import envelope_langchain_message_dict
+
+
+def normalize_stream_message(message: Any) -> Any:
+    """Best-effort conversion of wire dict payloads to LangChain message objects."""
+    if not isinstance(message, dict):
+        return message
+    try:
+        from langchain_core.messages import messages_from_dict
+
+        wrapped = envelope_langchain_message_dict(message)
+        restored = messages_from_dict([wrapped])
+        if restored:
+            return restored[0]
+    except Exception:
+        return message
+    return message
+
+
+def extract_user_text_for_display(message: Any) -> str | None:
+    """Return displayable user text, excluding internal system markers."""
+    from langchain_core.messages import HumanMessage
+
+    if not isinstance(message, HumanMessage):
+        return None
+    content = message.content if isinstance(message.content, str) else str(message.content)
+    text = content.strip()
+    if not text or text.startswith("[SYSTEM]"):
+        return None
+    return text
+
+
+def extract_ai_text_for_display(message: Any) -> str:
+    """Extract assistant-visible text from AI message payloads."""
+    try:
+        if hasattr(message, "text"):
+            extracted = str(message.text() or "").strip()
+            if extracted:
+                return extracted
+    except Exception:
+        pass
+
+    content = getattr(message, "content", "")
+    if isinstance(content, str):
+        return content.strip()
+
+    if isinstance(content, list):
+        parts: list[str] = []
+        for block in content:
+            if isinstance(block, dict) and block.get("type") == "text":
+                block_text = str(block.get("text", "")).strip()
+                if block_text:
+                    parts.append(block_text)
+            elif isinstance(block, str):
+                block_text = block.strip()
+                if block_text:
+                    parts.append(block_text)
+        return "".join(parts).strip()
+
+    return ""
+
+
+def extract_message_tool_calls(message: Any) -> list[dict[str, Any]]:
+    """Extract tool call dicts from an AI message/chunk for card rendering."""
+    tool_calls = list(getattr(message, "tool_calls", None) or [])
+    tool_call_chunks = list(getattr(message, "tool_call_chunks", None) or [])
+    return [call for call in [*tool_call_chunks, *tool_calls] if isinstance(call, dict)]

{soothe_cli-0.3.5 → soothe_cli-0.3.6}/src/soothe_cli/tui/model_config.py

@@ -24,6 +24,17 @@ DEFAULT_CONFIG_PATH = Path(SOOTHE_HOME) / "config" / "config.yml"
 _ENV_PREFIX = "SOOTHE_"
 
 
+def _in_running_loop() -> bool:
+    """Return whether current thread is already running an asyncio loop."""
+    import asyncio
+
+    try:
+        asyncio.get_running_loop()
+    except RuntimeError:
+        return False
+    return True
+
+
 # Model configuration error (stub for now)
 class ModelConfigError(Exception):
     """Error in model configuration."""
@@ -234,7 +245,7 @@ def get_credential_env_var(provider: str) -> str | None:
     Per IG-174, fetches provider config from daemon via RPC.
     Falls back to hardcoded env var mapping if daemon not reachable.
     """
-    if provider:
+    if provider and not _in_running_loop():
         # Try to fetch from daemon
         try:
             import asyncio
@@ -518,29 +529,32 @@ def has_provider_credentials(provider: str) -> bool | None:
             return bool(proj and proj.strip())
         return None
 
-    # Try to fetch from daemon
-    try:
-        import asyncio
+    # Try to fetch from daemon only when no event loop is active in this thread.
+    if not _in_running_loop():
+        try:
+            import asyncio
 
-        provider_data = asyncio.run(_fetch_provider_config(provider))
-        if provider_data is not None:
-            provider_type = provider_data.get("provider_type", "")
-            if provider_type in IMPLICIT_AUTH_PROVIDERS or provider_type == "ollama":
-                return None
-            if provider_data.get("api_key"):
-                try:
-                    from soothe_sdk.utils import resolve_provider_env
-
-                    v = resolve_provider_env(
-                        provider_data["api_key"], provider_name=provider, field_name="api_key"
-                    )
-                except Exception:
-                    logger.debug("resolve api_key failed for provider %r", provider, exc_info=True)
+            provider_data = asyncio.run(_fetch_provider_config(provider))
+            if provider_data is not None:
+                provider_type = provider_data.get("provider_type", "")
+                if provider_type in IMPLICIT_AUTH_PROVIDERS or provider_type == "ollama":
                     return None
-                return bool(v and str(v).strip())
-            return False
-    except Exception:
-        logger.debug("Could not fetch provider config from daemon", exc_info=True)
+                if provider_data.get("api_key"):
+                    try:
+                        from soothe_sdk.utils import resolve_provider_env
+
+                        v = resolve_provider_env(
+                            provider_data["api_key"], provider_name=provider, field_name="api_key"
+                        )
+                    except Exception:
+                        logger.debug(
+                            "resolve api_key failed for provider %r", provider, exc_info=True
+                        )
+                        return None
+                    return bool(v and str(v).strip())
+                return False
+        except Exception:
+            logger.debug("Could not fetch provider config from daemon", exc_info=True)
 
     # Fallback to environment variable check
     env_name = PROVIDER_API_KEY_ENV.get(provider)

{soothe_cli-0.3.5 → soothe_cli-0.3.6}/src/soothe_cli/tui/textual_adapter.py

@@ -677,6 +677,8 @@ async def execute_task_textual(
         agent: The LangGraph agent to execute
         daemon_session: Optional daemon-backed session for direct websocket
             streaming. When provided, this becomes the primary execution path.
+            When thread is already running and skip_daemon_send_turn=True,
+            starts event consumption loop for subscribed thread.
         assistant_id: The agent identifier
         session_state: Session state with auto_approve flag
         adapter: The TextualUIAdapter for UI operations
@@ -696,7 +698,8 @@ async def execute_task_textual(
             If `None`, a new instance is created internally.
         skip_daemon_send_turn: When ``True`` with ``daemon_session`` set, skip
             ``send_turn`` and only consume chunks (daemon already queued the
-            prompt, e.g. after ``invoke_skill``).
+            prompt, e.g. after ``invoke_skill``). Also used for consuming
+            events from already-running threads.
 
     Note:
         Progress verbosity (``quiet`` … ``debug``) for tool UI and the stream
@@ -1754,6 +1757,7 @@ async def execute_task_textual(
             adapter=adapter,
             agent=agent,
             config=config,
+            daemon_session=daemon_session,
             pending_text_by_namespace=pending_text_by_namespace,
             captured_input_tokens=captured_input_tokens,
             captured_output_tokens=captured_output_tokens,
@@ -1779,6 +1783,7 @@ async def _handle_interrupt_cleanup(
     adapter: TextualUIAdapter,
     agent: Any,  # noqa: ANN401  # Dynamic agent graph type
     config: RunnableConfig,
+    daemon_session: Any = None,  # noqa: ANN401  # Daemon-backed TUI session
     pending_text_by_namespace: dict[tuple, str],
     captured_input_tokens: int,
     captured_output_tokens: int,
@@ -1791,6 +1796,8 @@ async def _handle_interrupt_cleanup(
         adapter: UI adapter with display callbacks.
         agent: The LangGraph agent.
         config: Runnable config with `thread_id`.
+        daemon_session: Optional daemon-backed session. When provided, sends
+            detach message before disconnect so thread continues running.
         pending_text_by_namespace: Accumulated text per namespace.
         captured_input_tokens: Input tokens captured before interrupt.
         captured_output_tokens: Output tokens captured before interrupt.
@@ -1860,6 +1867,16 @@ async def _handle_interrupt_cleanup(
         approximate=approximate,
     )
 
+    # IG-228: Send detach message to daemon before disconnect (RFC-0013)
+    # This signals the daemon to let the thread continue running in background
+    # instead of cancelling it as an unexpected disconnect.
+    if daemon_session is not None:
+        try:
+            await daemon_session.detach()
+            logger.info("Sent detach message to daemon - thread will continue running")
+        except Exception:
+            logger.warning("Failed to send detach message during interrupt cleanup", exc_info=True)
+
 
 async def _persist_context_tokens(
     agent: Any,  # noqa: ANN401  # Dynamic agent graph type

{soothe_cli-0.3.5 → soothe_cli-0.3.6}/src/soothe_cli/tui/widgets/messages.py

@@ -164,7 +164,7 @@ def _strip_success_exit_line(text: str) -> str:
 
 
 class UserMessage(_TimestampClickMixin, Static):
-    """Widget displaying a user message."""
+    """Widget displaying a user message with enhanced styling."""
 
     can_select = True
     """Enable text selection for copy functionality."""
@@ -173,11 +173,24 @@ class UserMessage(_TimestampClickMixin, Static):
     UserMessage {
         height: auto;
         padding: 0 1;
-        margin: 0 0 1 0;
-        background: transparent;
+        margin: 1 0;
+        background: $surface;
         border-left: wide $primary;
     }
+
+    UserMessage.-mode-shell {
+        border-left: wide $mode-bash;
+    }
+
+    UserMessage.-mode-command {
+        border-left: wide $mode-command;
+    }
+
+    UserMessage:hover {
+        background: $surface-darken-1;
+    }
     """
+    """Enhanced styling with role indicator, background tint, and mode-specific borders."""
 
     def __init__(self, content: str, **kwargs: Any) -> None:
         """Initialize a user message.
@@ -198,15 +211,20 @@ class UserMessage(_TimestampClickMixin, Static):
             self.add_class("-ascii")
 
     def render(self) -> Content:
-        """Render the styled user message.
+        """Render the styled user message with role indicator.
 
         Returns:
-            Styled Content with mode prefix and highlighted mentions.
+            Styled Content with role header, mode prefix, and highlighted mentions.
         """
         colors = theme.get_theme_colors(self)
         parts: list[str | tuple[str, str]] = []
         content = self._content
 
+        # Add "Human" role indicator header
+        glyphs = get_glyphs()
+        role_icon = glyphs.user if not is_ascii_mode() else ">"
+        parts.append((f"{role_icon} Human  ", f"bold {colors.primary}"))
+
         # Use mode-specific prefix indicator when content starts with a
         # mode trigger character (e.g. "!" for shell, "/" for commands).
         # The display glyph may differ from the trigger (e.g. "$" for shell).
@@ -216,7 +234,8 @@ class UserMessage(_TimestampClickMixin, Static):
             parts.append((f"{glyph} ", f"bold {_mode_color(mode, self)}"))
             content = content[1:]
         else:
-            parts.append(("> ", f"bold {colors.primary}"))
+            # Add subtle separator for non-mode messages
+            parts.append(("│ ", f"dim {colors.muted}"))
 
         # Highlight @mentions and /commands in the content
         last_end = 0
@@ -571,7 +590,7 @@ class SkillMessage(Vertical):
 
 
 class AssistantMessage(_TimestampClickMixin, Vertical):
-    """Widget displaying an assistant message with markdown support.
+    """Widget displaying an assistant message with markdown support and enhanced styling.
 
     Uses MarkdownStream for smoother streaming instead of re-rendering
     the full content on each update.
@@ -584,14 +603,26 @@ class AssistantMessage(_TimestampClickMixin, Vertical):
     AssistantMessage {
         height: auto;
         padding: 0 1;
-        margin: 0 0 1 0;
+        margin: 1 0;
+        background: $background-darken-1;
+        border-left: wide $secondary;
+    }
+
+    AssistantMessage .assistant-header {
+        height: auto;
+        margin-bottom: 1;
     }
 
     AssistantMessage Markdown {
         padding: 0;
         margin: 0;
     }
+
+    AssistantMessage:hover {
+        background: $background-darken-2;
+    }
     """
+    """Enhanced styling with role indicator, secondary border, and background tint."""
 
     def __init__(self, content: str = "", **kwargs: Any) -> None:
         """Initialize an assistant message.
@@ -609,8 +640,18 @@ class AssistantMessage(_TimestampClickMixin, Vertical):
         """Compose the assistant message layout.
 
         Yields:
-            Markdown widget for rendering assistant content.
+            Header widget with role indicator and Markdown widget for content.
         """
+        colors = theme.get_theme_colors()
+        glyphs = get_glyphs()
+        is_ascii = is_ascii_mode()
+        role_icon = glyphs.assistant if not is_ascii else "◆"
+
+        # Add role header
+        yield Static(
+            Content.styled(f"{role_icon} AI  ", f"bold {colors.secondary}"),
+            classes="assistant-header",
+        )
         from textual.widgets import Markdown
 
         yield Markdown("", id="assistant-content")