soothe-cli 0.5.28__tar.gz → 0.5.29__tar.gz

{soothe_cli-0.5.28 → soothe_cli-0.5.29}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: soothe-cli
-Version: 0.5.28
+Version: 0.5.29
 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.5.28 → soothe_cli-0.5.29}/src/soothe_cli/cli/commands/autopilot_cmd.py

@@ -91,7 +91,7 @@ def run(
         detail = client.get_goal(goal_id)
         goal = detail.get("goal") or {}
         status = goal.get("status", "unknown")
-        if status in ("completed", "failed", "suspended"):
+        if status in ("completed", "failed", "cancelled", "suspended"):
             typer.echo(f"Goal {goal_id[:8]}: {status}")
             if status == "failed":
                 sys.exit(1)

soothe_cli-0.5.29/src/soothe_cli/runtime/parse/_utils.py

@@ -0,0 +1,14 @@
+"""Re-export shim for ``soothe_sdk.display._text_utils`` (RFC-413).
+
+These utilities live in the SDK so the daemon-resident ``CardBinder`` can
+reuse them. This module preserves the original CLI import path.
+"""
+
+from __future__ import annotations
+
+from soothe_sdk.display._text_utils import (
+    normalize_tool_name,
+    text_looks_like_error,
+)
+
+__all__ = ["normalize_tool_name", "text_looks_like_error"]

soothe_cli-0.5.29/src/soothe_cli/runtime/parse/message_processing.py

@@ -0,0 +1,51 @@
+"""Re-export shim for ``soothe_sdk.display.message_processing`` (RFC-413).
+
+These helpers live in the SDK so the daemon-resident ``CardBinder`` can
+reuse them. This module preserves the original CLI import path used
+across the runtime, TUI, and tests.
+"""
+
+from __future__ import annotations
+
+# Underscore-prefixed names below are re-exported intentionally — they are
+# imported by other CLI modules (tool_call_resolution, widgets/messages, etc.)
+# and CLI tests. Keep them in __all__ to keep `ruff` from stripping them.
+from soothe_sdk.display.message_processing import (
+    _normalize_tool_name_for_arg_map,
+    _pending_or_overlay_id_matches_lookup,
+    _resolve_pending_lookup_tool_name,
+    accumulate_tool_call_chunks,
+    coerce_tool_call_args_to_dict,
+    coerce_tool_call_entry_to_dict,
+    extract_tool_args_dict,
+    extract_tool_brief,
+    finalize_pending_tool_call,
+    ingest_tool_call_stream_state,
+    normalize_tool_calls_list,
+    richest_pending_args_for_lookup,
+    seed_pending_tool_calls_from_message,
+    tool_calls_have_any_arg_dict,
+    tool_ids_touched_by_stream_message,
+    tool_lookup_step_id,
+    try_parse_pending_tool_call_args,
+)
+
+__all__ = [
+    "_normalize_tool_name_for_arg_map",
+    "_pending_or_overlay_id_matches_lookup",
+    "_resolve_pending_lookup_tool_name",
+    "accumulate_tool_call_chunks",
+    "coerce_tool_call_args_to_dict",
+    "coerce_tool_call_entry_to_dict",
+    "extract_tool_args_dict",
+    "extract_tool_brief",
+    "finalize_pending_tool_call",
+    "ingest_tool_call_stream_state",
+    "normalize_tool_calls_list",
+    "richest_pending_args_for_lookup",
+    "seed_pending_tool_calls_from_message",
+    "tool_calls_have_any_arg_dict",
+    "tool_ids_touched_by_stream_message",
+    "tool_lookup_step_id",
+    "try_parse_pending_tool_call_args",
+]

soothe_cli-0.5.29/src/soothe_cli/runtime/parse/tool_message_format.py

@@ -0,0 +1,17 @@
+"""Re-export shim for ``soothe_sdk.display.tool_message_format`` (RFC-413)."""
+
+from __future__ import annotations
+
+from soothe_sdk.display.tool_message_format import (
+    format_content_block_for_tool_display,
+    format_tool_message_content,
+    run_python_envelope_indicates_failure,
+    try_parse_run_python_result_envelope,
+)
+
+__all__ = [
+    "format_content_block_for_tool_display",
+    "format_tool_message_content",
+    "run_python_envelope_indicates_failure",
+    "try_parse_run_python_result_envelope",
+]

soothe_cli-0.5.29/src/soothe_cli/runtime/parse/tool_result.py

@@ -0,0 +1,15 @@
+"""Re-export shim for ``soothe_sdk.display.tool_result`` (RFC-413)."""
+
+from __future__ import annotations
+
+from soothe_sdk.display.tool_result import (
+    ToolResultPayload,
+    extract_tool_result_payload,
+    infer_tool_output_suggests_error,
+)
+
+__all__ = [
+    "ToolResultPayload",
+    "extract_tool_result_payload",
+    "infer_tool_output_suggests_error",
+]

soothe_cli-0.5.29/src/soothe_cli/runtime/state/transcript.py

@@ -0,0 +1,24 @@
+"""Transcript message models for TUI display.
+
+These types live in ``soothe_sdk.display.transcript_types`` so they can be
+shared with the daemon-resident ``CardBinder`` (RFC-413). This module
+re-exports them to preserve the CLI's existing import paths.
+
+DOM virtualization lives in ``soothe_cli.tui.widgets.message_store``.
+"""
+
+from __future__ import annotations
+
+from soothe_sdk.display.transcript_types import (
+    UPDATABLE_FIELDS,
+    MessageData,
+    MessageType,
+    ToolStatus,
+)
+
+__all__ = [
+    "UPDATABLE_FIELDS",
+    "MessageData",
+    "MessageType",
+    "ToolStatus",
+]

{soothe_cli-0.5.28 → soothe_cli-0.5.29}/src/soothe_cli/runtime/transport/session.py

@@ -381,6 +381,57 @@ class TuiDaemonSession:
         await connect_websocket_with_retries(self._rpc_client)
         self._rpc_connected = True
 
+    async def fetch_loop_cards(self, loop_id: str) -> SimpleNamespace:
+        """Fetch the daemon's bound display-card snapshot for a loop.
+
+        RFC-413: returns a populated ledger (eagerly backfilled if the loop
+        has no ``cards.jsonl`` yet) so resume can render through the same
+        binder that produced the original cards.
+
+        Args:
+            loop_id: AgentLoop id.
+
+        Returns:
+            ``SimpleNamespace`` with ``cards: list[dict]``, ``seq: int``,
+            ``success: bool``. On error, ``cards=[]`` and ``success=False`` so
+            the caller can fall back to the legacy resume path.
+        """
+        lid = str(loop_id or "").strip()
+        if not lid:
+            return SimpleNamespace(cards=[], seq=0, success=False)
+
+        async with self._rpc_lock:
+            await self._ensure_rpc_connected()
+            try:
+                resp = await self._rpc_client.request_response(
+                    {"type": "loop_cards_fetch", "loop_id": lid},
+                    response_type="loop_cards_fetch_response",
+                    timeout=30.0,
+                )
+            except Exception:
+                logger.warning(
+                    "loop_cards_fetch failed for loop %s",
+                    lid[:16],
+                    exc_info=True,
+                )
+                return SimpleNamespace(cards=[], seq=0, success=False)
+
+        raw_cards = resp.get("cards")
+        cards = list(raw_cards) if isinstance(raw_cards, list) else []
+        seq = int(resp.get("seq") or 0)
+        context_tokens_raw = resp.get("context_tokens")
+        context_tokens = (
+            context_tokens_raw
+            if isinstance(context_tokens_raw, int) and context_tokens_raw >= 0
+            else 0
+        )
+        return SimpleNamespace(
+            cards=cards,
+            seq=seq,
+            context_tokens=context_tokens,
+            success=True,
+        )
+
     async def aget_loop_state(self, loop_id: str) -> Any:
         """Load agent-loop state channels from the daemon (``loop_state_get`` RPC).
 

soothe_cli-0.5.29/src/soothe_cli/runtime/wire/display_text.py

@@ -0,0 +1,15 @@
+"""Re-export shim for ``soothe_sdk.display.text_extract`` (RFC-413)."""
+
+from __future__ import annotations
+
+from soothe_sdk.display.text_extract import (
+    extract_ai_text_for_display,
+    extract_user_text_for_display,
+    normalize_stream_message,
+)
+
+__all__ = [
+    "extract_ai_text_for_display",
+    "extract_user_text_for_display",
+    "normalize_stream_message",
+]

{soothe_cli-0.5.28 → soothe_cli-0.5.29}/src/soothe_cli/runtime/wire/message_text.py

@@ -25,7 +25,7 @@ def extract_text_from_message_content(content: Any) -> str:
                 parts.append(block)
             elif isinstance(block, dict) and "text" in block:
                 parts.append(str(block["text"]))
-        return "".join(parts)
+        return "\n".join(parts)
     return ""
 
 
@@ -41,7 +41,7 @@ def extract_plain_text_from_stream_message(msg: Any) -> str:
                 if text:
                     texts.append(str(text))
         if texts:
-            return "".join(texts)
+            return "\n".join(texts)
     if hasattr(msg, "content"):
         return extract_text_from_message_content(getattr(msg, "content", None))
     if isinstance(msg, dict):
@@ -54,7 +54,7 @@ def extract_plain_text_from_stream_message(msg: Any) -> str:
                     text = block.get("text", "")
                     if text:
                         texts.append(str(text))
-            return "".join(texts)
+            return "\n".join(texts)
         content = body.get("content", "")
         if isinstance(content, str):
             return content

{soothe_cli-0.5.28 → soothe_cli-0.5.29}/src/soothe_cli/tui/app/_app.py

@@ -224,6 +224,9 @@ class SootheApp(
 
         self._agent_running = False
 
+        self._bg_event_worker: Worker[None] | None = None
+        """Background daemon event consumer worker (cancelled on active turn start)."""
+
         self._server_startup_error: str | None = None
         """Set when daemon bootstrap fails; persists for the session lifetime."""
 

{soothe_cli-0.5.28 → soothe_cli-0.5.29}/src/soothe_cli/tui/app/_execution.py

@@ -246,7 +246,12 @@ class _ExecutionMixin:
         # the wire ``clarification_answer`` flag plus the ``clarification_answers``
         # list, then clears the persisted flag so a follow-up turn is treated
         # as a new goal.
-        await self._run_agent_task(payload_text)
+        #
+        # Use ``_send_to_agent`` (not a direct ``await _run_agent_task``) so the
+        # resumed turn runs in a Textual worker. Awaiting the task inline blocks
+        # the message handler — and therefore the event loop — until the loop
+        # next pauses, which freezes scrolling and chat-input focus.
+        await self._send_to_agent(payload_text)
 
     async def _handle_shell_command(self, command: str) -> None:
         """Handle a shell command (! prefix).
@@ -488,7 +493,7 @@ class _ExecutionMixin:
                 "Commands: /quit, /clear, /editor, /autopilot, /mcp, "
                 "/model [--model-params JSON] [--default], /notifications, "
                 "/reload, /skill:<name>, /theme, "
-                "/tokens, /loops, "
+                "/tokens, /resume, "
                 "/research, /explore, /plan, /«subagent» (when configured), "
                 "/update, /auto-update, /changelog, /docs, /feedback, /help\n\n"
                 "Interactive Features:\n"
@@ -571,7 +576,7 @@ class _ExecutionMixin:
                     await self._mount_message(AppMessage(f"Started new loop: {new_loop_id}"))
         elif cmd == "/editor":
             await self.action_open_editor()
-        elif cmd == "/loops":
+        elif cmd == "/resume":
             await self._show_loop_selector()
         elif cmd == "/update":
             await self._handle_update_command()
@@ -813,6 +818,12 @@ class _ExecutionMixin:
                     return
             self._agent_running = True
 
+            # Cancel background event consumer so it doesn't compete for
+            # WebSocket reads with the active turn's iter_turn_chunks().
+            if self._bg_event_worker is not None:
+                self._bg_event_worker.cancel()
+                self._bg_event_worker = None
+
             if self._chat_input:
                 self._chat_input.set_cursor_active(active=False)
 

soothe_cli-0.5.29/src/soothe_cli/tui/app/_history.py

@@ -0,0 +1,335 @@
+"""Conversation history loading, daemon event consumption, and thin binder delegation.
+
+Pure event → card binding logic lives in ``soothe_sdk.display.card_binder``
+(RFC-413). The static methods on ``_HistoryMixin`` are kept as thin
+wrappers so the existing ``SootheApp._convert_messages_to_data(...)`` API
+(used by tests and other mixins) continues to work.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+import uuid
+from contextlib import suppress
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from datetime import datetime
+
+    from textual.content import Content
+
+from soothe_sdk.display import card_binder as _binder
+from soothe_sdk.display.text_extract import (
+    extract_ai_text_for_display,
+    extract_user_text_for_display,
+    normalize_stream_message,
+)
+from soothe_sdk.display.transcript_types import MessageData
+from textual.content import Content
+
+from soothe_cli.tui.app._module_init import _LoopHistoryPayload
+from soothe_cli.tui.widgets.messages import (
+    AppMessage,
+    AssistantMessage,
+    UserMessage,
+)
+
+logger = logging.getLogger(__name__)
+
+
+class _HistoryMixin:
+    """History conversion, loading, and daemon WebSocket event consumption."""
+
+    # ------------------------------------------------------------------
+    # Binder delegation (RFC-413).
+    # Pure logic lives in `soothe_sdk.display.card_binder`; these wrappers
+    # preserve the existing SootheApp API so tests and callers stay unchanged.
+    # ------------------------------------------------------------------
+
+    @staticmethod
+    def _is_loop_internal_checkpoint_message(msg: Any) -> bool:
+        """Delegate to ``soothe_sdk.display.card_binder.is_loop_internal_checkpoint_message``."""
+        return _binder.is_loop_internal_checkpoint_message(msg)
+
+    @staticmethod
+    def _merge_visible_messages_with_cognition_cards(
+        visible: list[MessageData],
+        cognition: list[MessageData],
+    ) -> list[MessageData]:
+        """Delegate to ``soothe_sdk.display.card_binder.merge_visible_messages_with_cognition_cards``."""
+        return _binder.merge_visible_messages_with_cognition_cards(visible, cognition)
+
+    @staticmethod
+    def _convert_messages_to_data(
+        messages: list[Any],
+        *,
+        cognition_card_replay: list[MessageData] | None = None,
+    ) -> list[MessageData]:
+        """Delegate to ``soothe_sdk.display.card_binder.convert_messages_to_data``."""
+        return _binder.convert_messages_to_data(
+            messages,
+            cognition_card_replay=cognition_card_replay,
+        )
+
+    @staticmethod
+    def _conversation_rows_to_langchain_messages(rows: list[dict[str, Any]]) -> list[Any]:
+        """Delegate to ``soothe_sdk.display.card_binder.conversation_rows_to_langchain_messages``."""
+        return _binder.conversation_rows_to_langchain_messages(rows)
+
+    @staticmethod
+    def _parse_loop_event_timestamp(timestamp: Any) -> datetime | None:
+        """Delegate to ``soothe_sdk.display.card_binder.parse_loop_event_timestamp``."""
+        return _binder.parse_loop_event_timestamp(timestamp)
+
+    @staticmethod
+    def _convert_event_to_message_data(event: dict[str, Any]) -> MessageData | None:
+        """Delegate to ``soothe_sdk.display.card_binder.convert_event_to_message_data``."""
+        return _binder.convert_event_to_message_data(event)
+
+    @staticmethod
+    def _collect_cognition_card_replay(events: list[dict[str, Any]]) -> list[MessageData]:
+        """Delegate to ``soothe_sdk.display.card_binder.collect_cognition_card_replay``."""
+        return _binder.collect_cognition_card_replay(events)
+
+    @staticmethod
+    def _merge_step_progress(prior: MessageData, later: MessageData) -> MessageData:
+        """Delegate to ``soothe_sdk.display.card_binder.merge_step_progress``."""
+        return _binder.merge_step_progress(prior, later)
+
+    def _convert_loop_events_to_data(self, events: list[dict[str, Any]]) -> list[MessageData]:
+        """Delegate to ``soothe_sdk.display.card_binder.convert_loop_events_to_data``."""
+        return _binder.convert_loop_events_to_data(events)
+
+    def _merge_history_sources(
+        self,
+        checkpoint_messages: list[Any],
+        activity_events: list[dict[str, Any]],
+    ) -> list[tuple[str, Any]]:
+        """Delegate to ``soothe_sdk.display.card_binder.merge_history_sources``."""
+        return _binder.merge_history_sources(checkpoint_messages, activity_events)
+
+    def _convert_combined_to_data(self, combined: list[tuple[str, Any]]) -> list[MessageData]:
+        """Delegate to ``soothe_sdk.display.card_binder.convert_combined_to_data``."""
+        return _binder.convert_combined_to_data(combined)
+
+    # ------------------------------------------------------------------
+    # I/O: resume reads from the daemon's bound card ledger (RFC-413).
+    # Legacy checkpoint + activity-log readers were removed when RFC-411
+    # was superseded — the daemon now owns derivation and exposes a single
+    # ``loop_cards_fetch`` RPC.
+    # ------------------------------------------------------------------
+
+    async def _fetch_loop_history_data(self, loop_id: str) -> _LoopHistoryPayload:
+        """Fetch conversation history from the daemon's bound card ledger.
+
+        RFC-413: this is the only resume path. The daemon's
+        ``loop_cards_fetch`` RPC returns the cards plus the persisted
+        context-token count in one round-trip; the daemon eagerly
+        backfills the ledger for legacy loops on first access.
+
+        Args:
+            loop_id: Loop id.
+
+        Returns:
+            Payload containing converted message data and the persisted
+            context-token count. Empty payload on error or when the daemon
+            session is unavailable; the caller mounts an "Could not load
+            history" message via the surrounding error path.
+        """
+        if self._daemon_session is None:
+            return _LoopHistoryPayload([], 0)
+
+        try:
+            response = await self._daemon_session.fetch_loop_cards(loop_id)
+        except Exception:
+            logger.warning("loop_cards_fetch failed for %s", loop_id, exc_info=True)
+            return _LoopHistoryPayload([], 0)
+
+        if not getattr(response, "success", False):
+            return _LoopHistoryPayload([], 0)
+
+        raw_cards = list(getattr(response, "cards", []) or [])
+        context_tokens = int(getattr(response, "context_tokens", 0) or 0)
+        if not raw_cards:
+            return _LoopHistoryPayload([], context_tokens)
+
+        try:
+            from soothe_sdk.display.card_ledger import card_from_wire_dict
+
+            data = [card_from_wire_dict(c) for c in raw_cards]
+        except Exception:
+            logger.warning(
+                "Failed to deserialize loop_cards_fetch payload for %s",
+                loop_id,
+                exc_info=True,
+            )
+            return _LoopHistoryPayload([], context_tokens)
+
+        return _LoopHistoryPayload(data, context_tokens)
+
+    async def _upgrade_loop_message_link(
+        self,
+        widget: AppMessage,
+        *,
+        prefix: str,
+        loop_id: str,
+    ) -> None:
+        """Upgrade a plain status message to a linked one when URL resolves.
+
+        Args:
+            widget: The already-mounted app message.
+            prefix: Text prefix before the loop id.
+            loop_id: Loop id.
+        """
+        try:
+            loop_msg = await self._build_loop_status_line(prefix, loop_id)
+            if not isinstance(loop_msg, Content):
+                logger.debug(
+                    "Skipping loop link upgrade for %s: URL did not resolve",
+                    loop_id,
+                )
+                return
+            if widget.parent is None:
+                logger.debug(
+                    "Skipping loop link upgrade for %s: widget no longer mounted",
+                    loop_id,
+                )
+                return
+            # Keep serialized content in sync with the rendered content.
+            widget._content = loop_msg
+            widget.update(loop_msg)
+        except Exception:
+            logger.warning(
+                "Failed to upgrade loop message link for %s",
+                loop_id,
+                exc_info=True,
+            )
+
+    def _schedule_loop_message_link(
+        self,
+        widget: AppMessage,
+        *,
+        prefix: str,
+        loop_id: str,
+    ) -> None:
+        """Schedule loop URL link resolution and apply updates in the background.
+
+        Args:
+            widget: The message widget to update.
+            prefix: Text prefix before the loop id.
+            loop_id: Loop id.
+        """
+        self.run_worker(
+            self._upgrade_loop_message_link(
+                widget,
+                prefix=prefix,
+                loop_id=loop_id,
+            ),
+            exclusive=False,
+        )
+
+    async def _consume_daemon_events_background(self) -> None:
+        """Consume daemon websocket events for an already-running loop subscription.
+
+        IG-228: Reads passively when the loop is running without an active local turn,
+        using the same processing pipeline as streaming queries.
+        """
+        if not self._daemon_session:
+            return
+
+        logger.info("Starting background event consumer for subscribed loop")
+        from langchain_core.messages import AIMessage, AIMessageChunk, ToolMessage
+
+        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, (list, tuple)) or len(chunk) != 3:
+                    logger.debug("Skipping invalid stream 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 == "status":
+                    continue
+
+                if mode == "messages":
+                    if not isinstance(data, (list, 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):
+                        continue
+
+                    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)
+
+        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()
+            self._bg_event_worker = None
+            # If an agent turn was active (e.g. the loop completed while the
+            # background consumer was reading), perform the same cleanup that
+            # _run_agent_task's finally block would: re-enable input, clear
+            # spinner, drain deferred actions, and process queued messages.
+            if self._agent_running:
+                with suppress(Exception):
+                    await self._cleanup_agent_task()
+            logger.info("Background event consumer stopped")

{soothe_cli-0.5.28 → soothe_cli-0.5.29}/src/soothe_cli/tui/app/_model.py

@@ -369,8 +369,13 @@ class _ModelMixin:
                 warn_if_missing=False,
             )
 
+            # Render historical transcript before live events start arriving on the
+            # new subscription (RFC-413). Awaiting (rather than scheduling) guarantees
+            # painting order: prior history first, then live frames.
+            await self._load_loop_history(loop_id=loop_id)
+
             # Start consuming daemon events for this loop
-            self.run_worker(
+            self._bg_event_worker = self.run_worker(
                 self._consume_daemon_events_background(),
                 exclusive=False,
                 group="daemon-event-reader",
@@ -389,7 +394,7 @@ class _ModelMixin:
                 warn_if_missing=True,
             )
             await self._mount_message(
-                AppMessage(f"Failed to attach to loop {loop_id}: {exc}. Use /loops to try again.")
+                AppMessage(f"Failed to attach to loop {loop_id}: {exc}. Use /resume to try again.")
             )
         finally:
             self._loop_switching = False

{soothe_cli-0.5.28 → soothe_cli-0.5.29}/src/soothe_cli/tui/app/_startup.py

@@ -488,7 +488,7 @@ class _StartupMixin:
                 "Loop %s is running, starting background event reader",
                 status_loop_id[:8] if status_loop_id else "?",
             )
-            self.run_worker(
+            self._bg_event_worker = self.run_worker(
                 self._consume_daemon_events_background(),
                 exclusive=False,
                 group="daemon-event-reader",