soothe-cli 0.7.0__tar.gz → 0.7.1__tar.gz

{soothe_cli-0.7.0 → soothe_cli-0.7.1}/PKG-INFO

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

@@ -280,7 +280,7 @@ async def _run_headless_session_once(
                     query_started = True
                 elif (state == "idle" and query_started) or state == "stopped":
                     loop_clock = asyncio.get_event_loop()
-                    drain_deadline = loop_clock.time() + 2.5
+                    drain_deadline = loop_clock.time() + 30.0
                     while loop_clock.time() < drain_deadline:
                         try:
                             nxt = await asyncio.wait_for(client.read_event(), timeout=0.25)

{soothe_cli-0.7.0 → soothe_cli-0.7.1}/src/soothe_cli/cli/execution/daemon_errors.py

@@ -5,11 +5,19 @@ 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"
 
+# Partial match for thread_runner RuntimeError when a worker thread dies mid-turn.
+DAEMON_WORKER_THREAD_LOST = "Worker thread 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."
 )
 
+_FRIENDLY_WORKER_THREAD_LOST = (
+    "The daemon execution worker stopped unexpectedly during your request. "
+    "Send your message again, or use /resume to recover the loop."
+)
+
 _FRIENDLY_DAEMON_CONNECTION_LOST = (
     "Daemon connection lost (the daemon may have restarted). "
     "Send your message again to reconnect and continue this loop."
@@ -45,9 +53,13 @@ def friendly_daemon_execution_error(exc: BaseException | str) -> str:
         return _FRIENDLY_DAEMON_CONNECTION_LOST
     if isinstance(exc, RuntimeError) and DAEMON_WORKER_SUBPROCESS_LOST in str(exc):
         return _FRIENDLY_WORKER_SUBPROCESS_LOST
+    if isinstance(exc, RuntimeError) and DAEMON_WORKER_THREAD_LOST in str(exc):
+        return _FRIENDLY_WORKER_THREAD_LOST
     text = str(exc)
     if DAEMON_WORKER_SUBPROCESS_LOST in text:
         return _FRIENDLY_WORKER_SUBPROCESS_LOST
+    if DAEMON_WORKER_THREAD_LOST in text:
+        return _FRIENDLY_WORKER_THREAD_LOST
     return text if isinstance(exc, str) else str(exc)
 
 
@@ -55,3 +67,9 @@ 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
+
+
+def is_daemon_worker_thread_lost(exc: BaseException | str) -> bool:
+    """Return whether an error indicates a pool worker thread exited mid-query."""
+    text = str(exc)
+    return DAEMON_WORKER_THREAD_LOST in text

{soothe_cli-0.7.0 → soothe_cli-0.7.1}/src/soothe_cli/runtime/state/session_stats.py

@@ -8,6 +8,7 @@ config, no widget imports) so that `app.py` can import `SessionStats` and
 
 from __future__ import annotations
 
+import time
 from dataclasses import dataclass, field
 
 SpinnerStatus = str | None
@@ -106,6 +107,52 @@ class SessionStats:
             self.event_stats.merge(other.event_stats)
 
 
+@dataclass
+class TurnLatencyStats:
+    """IG-534 Phase 3: end-to-end turn latency observability.
+
+    Attributes:
+        turn_start_monotonic: Monotonic timestamp when the turn began.
+        time_to_first_chunk_ms: Milliseconds from turn start to first applied chunk.
+        synthesis_visible_ms: Milliseconds from turn start to first goal_completion apply.
+        goal_completion_applied: Whether a goal_completion chunk was applied.
+    """
+
+    turn_start_monotonic: float = 0.0
+    time_to_first_chunk_ms: float | None = None
+    synthesis_visible_ms: float | None = None
+    goal_completion_applied: bool = False
+
+    def record_first_chunk(self) -> None:
+        """Record time-to-first-chunk once per turn."""
+        if self.time_to_first_chunk_ms is not None or self.turn_start_monotonic <= 0:
+            return
+        self.time_to_first_chunk_ms = (time.monotonic() - self.turn_start_monotonic) * 1000.0
+
+    def record_goal_completion(self) -> None:
+        """Record synthesis-visible latency once per turn."""
+        if self.goal_completion_applied or self.turn_start_monotonic <= 0:
+            return
+        self.goal_completion_applied = True
+        self.synthesis_visible_ms = (time.monotonic() - self.turn_start_monotonic) * 1000.0
+
+    def merge(self, other: TurnLatencyStats) -> None:
+        """Merge another stats object (keeps earliest first-chunk / synthesis times)."""
+        if other.time_to_first_chunk_ms is not None:
+            if (
+                self.time_to_first_chunk_ms is None
+                or other.time_to_first_chunk_ms < self.time_to_first_chunk_ms
+            ):
+                self.time_to_first_chunk_ms = other.time_to_first_chunk_ms
+        if other.synthesis_visible_ms is not None:
+            if (
+                self.synthesis_visible_ms is None
+                or other.synthesis_visible_ms < self.synthesis_visible_ms
+            ):
+                self.synthesis_visible_ms = other.synthesis_visible_ms
+        self.goal_completion_applied = self.goal_completion_applied or other.goal_completion_applied
+
+
 @dataclass
 class TurnEventStats:
     """Event counts accumulated over a single daemon turn.
@@ -139,6 +186,8 @@ class TurnEventStats:
     text_chunks: int = 0
     heartbeats_dropped: int = 0
     post_idle_drained: int = 0
+    inbound_dropped: int = 0
+    latency: TurnLatencyStats | None = None
 
     def record(
         self,
@@ -187,6 +236,11 @@ class TurnEventStats:
         self.heartbeats_dropped += other.heartbeats_dropped
         self.post_idle_drained += other.post_idle_drained
         self.filtered_early += other.filtered_early
+        self.inbound_dropped += other.inbound_dropped
+        if other.latency is not None:
+            if self.latency is None:
+                self.latency = TurnLatencyStats()
+            self.latency.merge(other.latency)
 
     def summary_line(self) -> str:
         """Return a one-line summary suitable for structured logging.
@@ -220,6 +274,12 @@ class TurnEventStats:
             detail_parts.append(f"{self.heartbeats_dropped} hb-drop")
         if self.post_idle_drained:
             detail_parts.append(f"{self.post_idle_drained} post-idle")
+        if self.inbound_dropped:
+            detail_parts.append(f"{self.inbound_dropped} inbound-drop")
+        if self.latency is not None and self.latency.time_to_first_chunk_ms is not None:
+            detail_parts.append(f"ttfc={self.latency.time_to_first_chunk_ms:.0f}ms")
+        if self.latency is not None and self.latency.synthesis_visible_ms is not None:
+            detail_parts.append(f"synth={self.latency.synthesis_visible_ms:.0f}ms")
         if detail_parts:
             parts.append("; ".join(detail_parts))
 

{soothe_cli-0.7.0 → soothe_cli-0.7.1}/src/soothe_cli/runtime/transport/session.py

@@ -26,7 +26,7 @@ logger = logging.getLogger(__name__)
 
 # Match headless daemon client: brief read window after ``idle`` so stream events
 # that arrive slightly after status are not dropped (``cli/execution/daemon.py``).
-_POST_IDLE_DRAIN_DEADLINE_S = 2.5
+_POST_IDLE_DRAIN_DEADLINE_S = 30.0
 
 # Align with ``bootstrap_loop_session`` daemon-ready wait (RFC-450 §8.2).
 _RPC_HANDSHAKE_TIMEOUT_S = 20.0
@@ -91,6 +91,7 @@ class TuiDaemonSession:
         self.turn_event_stats = TurnEventStats()
         self.last_turn_end_state: str | None = None
         self.last_turn_cancellation_seen: bool = False
+        self.last_turn_error_message: str | None = None
 
     @property
     def loop_id(self) -> str | None:
@@ -248,6 +249,14 @@ class TuiDaemonSession:
         """Ask the daemon to cancel the in-flight query (same wire path as ``/cancel``)."""
         await self._client.notify("slash_command", {"cmd": "/cancel"})
 
+    async def cancel_active_turn(self) -> None:
+        """Cancel the in-flight query on the active loop (IG-533 ordering contract).
+
+        Call before switching ``loop_id`` (e.g. ``/clear``) so synthesis on the
+        prior loop is torn down server-side instead of filtered client-side.
+        """
+        await self.cancel_remote_query()
+
     async def _drain_stream_events_after_idle(
         self,
         *,
@@ -316,6 +325,8 @@ class TuiDaemonSession:
         self.turn_event_stats = TurnEventStats()
         self.last_turn_end_state = None
         self.last_turn_cancellation_seen = False
+        self.last_turn_error_message = None
+        inbound_dropped_baseline = getattr(self._client, "inbound_dropped", 0)
         query_started = False
         expected_loop_id = self._loop_id
         self._streaming = True
@@ -431,8 +442,15 @@ class TuiDaemonSession:
                     # Graph auto-resumes LangGraph interrupts server-side; keep consuming events.
                     if mode == "updates" and isinstance(data, dict) and "__interrupt__" in data:
                         continue
+            except Exception as exc:
+                self.last_turn_error_message = str(exc)
+                raise
             finally:
                 self._streaming = False
+                self.turn_event_stats.inbound_dropped = max(
+                    0,
+                    getattr(self._client, "inbound_dropped", 0) - inbound_dropped_baseline,
+                )
 
     async def list_skills(self) -> list[dict[str, Any]]:
         """Return skill rows from the daemon catalog (no filesystem paths)."""
@@ -651,5 +669,16 @@ class TuiDaemonSession:
             return []
         return [m for m in raw if isinstance(m, dict)]
 
+    async def fetch_goal_completion_text(self, loop_id: str) -> str | None:
+        """Return the latest persisted ``goal_completion`` body for a loop, if any."""
+        rows = await self.fetch_conversation_log(loop_id, limit=200, include_events=False)
+        for row in reversed(rows):
+            if row.get("phase") != "goal_completion":
+                continue
+            text = row.get("text") or row.get("content") or ""
+            if isinstance(text, str) and text.strip():
+                return text.strip()
+        return None
+
 
 DaemonSession = TuiDaemonSession

soothe_cli-0.7.1/src/soothe_cli/runtime/turn/pipeline.py

@@ -0,0 +1,309 @@
+"""Decouple daemon stream ingestion from chunk processing and UI application.
+
+Three stages run concurrently during a TUI turn:
+
+1. **Reader** (async, main event loop): pulls ``(namespace, mode, data)`` tuples from the
+   daemon and enqueues them.
+2. **Processor** (dedicated thread): runs CPU-heavy parsing / routing without blocking
+   Textual rendering.
+3. **Applier** (async, main event loop): consumes prepared plans and performs widget
+   updates.
+
+The websocket client stays on the main asyncio loop; only synchronous work moves off it.
+High-priority chunks (tool wire, loop step events) are applied before low-priority text.
+
+IG-535 Optimization 2: Added batched apply mode to reduce DOM mutations per chunk.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+import queue
+import threading
+import time
+from collections.abc import AsyncIterator, Callable
+from typing import Any, Generic, TypeVar
+
+from soothe_sdk.ux.loop_stream import assistant_output_phase
+
+from soothe_cli.runtime.state.session_stats import TurnLatencyStats
+
+logger = logging.getLogger(__name__)
+
+T = TypeVar("T")
+_SENTINEL = object()
+
+# Lower number = higher priority (matches asyncio.PriorityQueue ordering).
+PRIORITY_HIGH = 0
+PRIORITY_NORMAL = 1
+PRIORITY_LOW = 2
+
+# IG-535: Batching defaults for TUI apply path optimization
+_DEFAULT_BATCH_SIZE = 10
+_DEFAULT_BATCH_DELAY_MS = 50
+
+# IG-535: Queue sizes tuned for 32 concurrent loops with dense streaming
+# Inbound: daemon→TUI chunks; Outbound: processed→UI apply plans
+_DEFAULT_INBOUND_MAXSIZE = 2048  # IG-535: Increased from 1024 for multi-loop throughput
+_DEFAULT_OUTBOUND_MAXSIZE = 1024  # IG-535: Increased from 512 for batched apply backlog
+
+
+class TurnApplyBatcher(Generic[T]):
+    """IG-535 Optimization 2: Accumulate prepared chunks for batched apply.
+
+    Reduces DOM mutations per chunk by batching up to N chunks before applying.
+    HIGH priority items trigger immediate flush for responsiveness.
+
+    Args:
+        max_batch_size: Maximum chunks per batch (default 10).
+        max_batch_delay_ms: Maximum delay before forced flush (default 50ms).
+    """
+
+    def __init__(
+        self,
+        *,
+        max_batch_size: int = _DEFAULT_BATCH_SIZE,
+        max_batch_delay_ms: int = _DEFAULT_BATCH_DELAY_MS,
+    ) -> None:
+        self._max_batch_size = max_batch_size
+        self._max_batch_delay_s = max_batch_delay_ms / 1000.0
+        self._pending: list[T] = []
+        self._high_priority_count: int = 0
+        self._last_flush_monotonic: float = time.monotonic()
+
+    def add(self, prepared: T) -> bool:
+        """Add chunk to batch. Returns True if batch should flush now.
+
+        Flush triggers:
+        1. Batch size threshold reached
+        2. HIGH priority item present (immediate for responsiveness)
+        3. Time threshold elapsed
+        """
+        self._pending.append(prepared)
+        priority = getattr(prepared, "priority", PRIORITY_LOW)
+        if priority == PRIORITY_HIGH:
+            self._high_priority_count += 1
+
+        now = time.monotonic()
+        if len(self._pending) >= self._max_batch_size:
+            return True
+        if self._high_priority_count > 0:
+            return True
+        if now - self._last_flush_monotonic >= self._max_batch_delay_s:
+            return True
+        return False
+
+    def flush(self) -> list[T]:
+        """Return accumulated batch and reset state."""
+        batch = list(self._pending)
+        self._pending.clear()
+        self._high_priority_count = 0
+        self._last_flush_monotonic = time.monotonic()
+        return batch
+
+    def has_pending(self) -> bool:
+        """Return True if there are pending items."""
+        return bool(self._pending)
+
+    @property
+    def pending_count(self) -> int:
+        """Return number of pending items."""
+        return len(self._pending)
+
+
+class TurnEventPipeline(Generic[T]):
+    """Bridge daemon chunk ingestion, background processing, and UI application."""
+
+    def __init__(
+        self,
+        loop: asyncio.AbstractEventLoop,
+        *,
+        inbound_maxsize: int = _DEFAULT_INBOUND_MAXSIZE,
+        outbound_maxsize: int = _DEFAULT_OUTBOUND_MAXSIZE,
+    ) -> None:
+        self._loop = loop
+        self._inbound: queue.Queue[Any] = queue.Queue(maxsize=inbound_maxsize)
+        # Thread-safe outbound bridge: processor puts without blocking the event loop.
+        self._outbound: queue.PriorityQueue[tuple[int, int, Any]] = queue.PriorityQueue(
+            maxsize=outbound_maxsize
+        )
+        self._outbound_seq = 0
+        self._stop = threading.Event()
+        self._thread: threading.Thread | None = None
+        self._processor_error: BaseException | None = None
+
+    async def feed_chunks(self, chunk_source: AsyncIterator[Any]) -> None:
+        """Read all chunks from *chunk_source* into the inbound queue."""
+        try:
+            async for chunk in chunk_source:
+                if self._stop.is_set():
+                    break
+                await asyncio.to_thread(self._inbound.put, chunk)
+        finally:
+            await asyncio.to_thread(self._inbound.put, _SENTINEL)
+
+    def start_processor(
+        self,
+        process_fn: Callable[[Any], T],
+    ) -> None:
+        """Start the background processor thread.
+
+        Args:
+            process_fn: Synchronous function mapping one raw chunk to a prepared plan.
+        """
+
+        def _worker() -> None:
+            while not self._stop.is_set():
+                try:
+                    item = self._inbound.get(timeout=0.25)
+                except queue.Empty:
+                    continue
+                if item is _SENTINEL:
+                    self._put_outbound(PRIORITY_LOW, _SENTINEL)
+                    break
+                try:
+                    prepared = process_fn(item)
+                except Exception as exc:
+                    logger.exception("Turn chunk processor failed")
+                    self._processor_error = exc
+                    self._put_outbound(PRIORITY_LOW, _SENTINEL)
+                    break
+                if prepared is None:
+                    continue
+                priority = getattr(prepared, "priority", PRIORITY_LOW)
+                self._put_outbound(int(priority), prepared)
+
+        self._thread = threading.Thread(
+            target=_worker,
+            name="soothe-tui-turn-processor",
+            daemon=True,
+        )
+        self._thread.start()
+
+    def _put_outbound(self, priority: int, item: Any) -> None:
+        """Enqueue a prepared chunk from the processor thread (thread-safe, non-blocking)."""
+        seq = self._outbound_seq
+        self._outbound_seq += 1
+        try:
+            self._outbound.put_nowait((priority, seq, item))
+        except queue.Full:
+            logger.warning("Turn outbound queue full; dropping prepared chunk")
+
+    async def iter_prepared(self) -> AsyncIterator[T]:
+        """Yield prepared chunk plans until the stream ends."""
+        while True:
+            _priority, _seq, item = await asyncio.to_thread(self._outbound.get)
+            if item is _SENTINEL:
+                if self._processor_error is not None:
+                    raise self._processor_error
+                break
+            yield item
+
+    def shutdown(self) -> None:
+        """Signal the processor thread to stop (best-effort)."""
+        self._stop.set()
+        if self._thread is not None and self._thread.is_alive():
+            self._thread.join(timeout=2.0)
+
+
+def _record_apply_latency(prepared: Any, latency: TurnLatencyStats | None) -> None:
+    """IG-534 Phase 3: record first-chunk and synthesis-visible timings."""
+    if latency is None or getattr(prepared, "skip", False):
+        return
+    latency.record_first_chunk()
+    if getattr(prepared, "mode", None) == "messages":
+        message = getattr(prepared, "normalized_message", None)
+        if message is not None and assistant_output_phase(message) == "goal_completion":
+            latency.record_goal_completion()
+
+
+async def run_turn_pipeline(
+    chunk_source: AsyncIterator[Any],
+    process_fn: Callable[[Any], T],
+    apply_fn: Callable[[T], Any],
+    *,
+    batch_size: int = _DEFAULT_BATCH_SIZE,
+    batch_delay_ms: int = _DEFAULT_BATCH_DELAY_MS,
+    batching_enabled: bool = True,
+    latency_stats: TurnLatencyStats | None = None,
+) -> None:
+    """Run reader, processor thread, and applier coroutine to completion.
+
+    IG-535: Added batched apply mode to reduce DOM mutations per chunk.
+
+    Args:
+        chunk_source: Async iterator of daemon stream chunks.
+        process_fn: Sync chunk processor (runs in background thread).
+        apply_fn: Async callable applied on the main loop for each prepared plan.
+        batch_size: Maximum chunks per batch when batching enabled (default 10).
+        batch_delay_ms: Maximum delay before forced flush (default 50ms).
+        batching_enabled: Enable batching for performance (default True; disable for debug).
+        latency_stats: Optional per-turn latency recorder (IG-534 Phase 3).
+    """
+    loop = asyncio.get_running_loop()
+    if latency_stats is not None and latency_stats.turn_start_monotonic <= 0:
+        latency_stats.turn_start_monotonic = time.monotonic()
+    pipeline: TurnEventPipeline[T] = TurnEventPipeline(loop)
+    pipeline.start_processor(process_fn)
+
+    async def _apply_with_latency(prepared: T) -> None:
+        _record_apply_latency(prepared, latency_stats)
+        await apply_fn(prepared)
+
+    if batching_enabled:
+        batcher: TurnApplyBatcher[T] = TurnApplyBatcher(
+            max_batch_size=batch_size,
+            max_batch_delay_ms=batch_delay_ms,
+        )
+
+        async def _apply_batched() -> None:
+            """Apply chunks in batches with single yield per batch."""
+            async for prepared in pipeline.iter_prepared():
+                if batcher.add(prepared):
+                    batch = batcher.flush()
+                    # Apply all items in batch
+                    for p in batch:
+                        await _apply_with_latency(p)
+                    # Single yield to event loop per batch (IG-535)
+                    await asyncio.sleep(0)
+
+            # Final flush for remaining items
+            if batcher.has_pending():
+                for p in batcher.flush():
+                    await _apply_with_latency(p)
+
+        try:
+            await asyncio.gather(
+                pipeline.feed_chunks(chunk_source),
+                _apply_batched(),
+            )
+        finally:
+            pipeline.shutdown()
+    else:
+        # Original non-batched path (for debugging or high-frequency streams)
+        async def _apply_all() -> None:
+            async for prepared in pipeline.iter_prepared():
+                await _apply_with_latency(prepared)
+
+        try:
+            await asyncio.gather(
+                pipeline.feed_chunks(chunk_source),
+                _apply_all(),
+            )
+        finally:
+            pipeline.shutdown()
+
+
+__all__ = [
+    "PRIORITY_HIGH",
+    "PRIORITY_LOW",
+    "PRIORITY_NORMAL",
+    "TurnApplyBatcher",
+    "TurnEventPipeline",
+    "run_turn_pipeline",
+    "_DEFAULT_BATCH_SIZE",
+    "_DEFAULT_BATCH_DELAY_MS",
+    "_DEFAULT_INBOUND_MAXSIZE",
+    "_DEFAULT_OUTBOUND_MAXSIZE",
+]

{soothe_cli-0.7.0 → soothe_cli-0.7.1}/src/soothe_cli/tui/app/_app.py

@@ -192,6 +192,14 @@ class SootheApp(
         self._daemon_skills_wire: list[dict[str, Any]] = []
         """Cached ``skills_list_response`` rows when the TUI uses ``TuiDaemonSession``."""
 
+        self._preloaded_model_data: (
+            tuple[list[tuple[str, str]], str | None, dict[str, dict[str, Any]]] | None
+        ) = None
+        """Cached ``/model`` selector data from startup ``models_list`` prewarm."""
+
+        self._wire_credential_map: dict[str, bool | None] | None = None
+        """Provider credential flags paired with ``_preloaded_model_data``."""
+
         self._connecting = True
 
         self._sandbox_type: str | None = None
@@ -360,7 +368,6 @@ class SootheApp(
                     loop_id=self._lc_loop_id,
                     mcp_tool_count=self._mcp_tool_count,
                     workspace_path=self._cwd,
-                    connecting=self._connecting,
                     id="welcome-banner",
                 )
                 yield Container(id="messages")

{soothe_cli-0.7.0 → soothe_cli-0.7.1}/src/soothe_cli/tui/app/_execution.py

@@ -565,6 +565,13 @@ class _ExecutionMixin:
                         AppMessage("Not connected to the daemon; cannot start a new loop.")
                     )
                 else:
+                    if self._agent_running:
+                        await self._interrupt_daemon_agent_turn()
+                        worker = self._agent_worker
+                        if worker is not None:
+                            with suppress(Exception):
+                                await asyncio.wait_for(worker.wait(), timeout=5.0)
+                        await self._cleanup_agent_task()
                     status_event = await self._daemon_session.new_loop()
                     new_loop_id = (
                         str(status_event.get("loop_id", "")) or self._session_state.reset_loop()
@@ -937,6 +944,7 @@ class _ExecutionMixin:
             if self._ui_adapter:
                 self._ui_adapter.finalize_pending_tools_with_error(f"{error_title}: {display_err}")
                 self._ui_adapter.finalize_pending_steps_with_error(f"{error_title}: {display_err}")
+            await self._try_recover_goal_completion_from_ledger()
             try:
                 await self._mount_message(ErrorMessage(f"{error_title}. {display_err}"))
             except Exception:
@@ -990,6 +998,35 @@ class _ExecutionMixin:
         if not busy and self._pending_messages:
             await self._process_next_from_queue()
 
+    async def _try_recover_goal_completion_from_ledger(self) -> None:
+        """Mount persisted goal_completion when the stream aborted before the report card."""
+        adapter = self._ui_adapter
+        session = self._daemon_session
+        if adapter is None or session is None or self._session_state is None:
+            return
+        if getattr(adapter, "_goal_completion_mounted_this_turn", False):
+            return
+        loop_id = self._session_state.loop_id
+        if not loop_id:
+            return
+        try:
+            from soothe_cli.tui.widgets.messages.assistant import AssistantMessage
+
+            text = await session.fetch_goal_completion_text(loop_id)
+            if not text:
+                return
+            msg = AssistantMessage(text, id=f"asst-recovered-{loop_id[:8]}")
+            await self._mount_message(msg)
+            await msg.write_initial_content()
+            adapter._goal_completion_mounted_this_turn = True
+            logger.info(
+                "Recovered goal_completion from ledger for loop %s (%d chars)",
+                loop_id[:8],
+                len(text),
+            )
+        except Exception:
+            logger.debug("goal_completion ledger recovery failed", exc_info=True)
+
     async def _cleanup_agent_task(self) -> None:
         """Clean up after agent task completes or is cancelled."""
         self._agent_running = False