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

{soothe_cli-0.7.0 → soothe_cli-0.7.2}/.gitignore

@@ -191,6 +191,15 @@ cython_debug/
 # PyPI configuration file
 .pypirc
 
+# Soothe local runtime data
+.soothe/
+
+# Tool backup files (created by file editing tools)
+.backups/
+
+# Large tool result cache
+large_tool_results/
+
 # Cursor
 #  Cursor is an AI-powered code editor. `.cursorignore` specifies files/directories to
 #  exclude from AI features like autocomplete and code analysis. Recommended for sensitive data
@@ -206,7 +215,6 @@ __marimo__/
 .python-version
 thirdparty/
 .cursor/
-large_tool_results/
 plot_*
 .claude/
 .DS_Store
@@ -216,5 +224,3 @@ manifest.json
 _bmad
 __MACOSX
 .qoder
-.soothe
-.backups/

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: soothe-cli
-Version: 0.7.0
+Version: 0.7.2
 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.2}/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.2}/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.2}/src/soothe_cli/cli/main.py

@@ -15,6 +15,12 @@ from soothe_sdk.client.config import SOOTHE_HOME  # noqa: E402
 
 from soothe_cli.config.cli_config import CLIConfig  # noqa: E402
 from soothe_cli.config.loader import set_runtime_config  # noqa: E402
+from soothe_cli.tui.markdown_theme import (  # noqa: E402
+    DEFAULT_MARKDOWN_THEME,
+    REGISTRY,
+    load_markdown_theme_preference,
+    markdown_theme_help,
+)
 
 app = typer.Typer(
     name="soothe",
@@ -101,6 +107,16 @@ def main(
             help="Render assistant messages as Markdown in the TUI.",
         ),
     ] = True,
+    markdown_theme: Annotated[
+        str | None,
+        typer.Option(
+            "--markdown-theme",
+            help=(
+                "Markdown appearance preset for TUI cards "
+                f"({markdown_theme_help()}). Default: {DEFAULT_MARKDOWN_THEME}."
+            ),
+        ),
+    ] = None,
     soothe_home: Annotated[
         str | None,
         typer.Option("--soothe-home", help="Soothe home directory (default: ~/.soothe)."),
@@ -168,11 +184,22 @@ def main(
     if mode is not None and mode not in ("manual", "auto"):
         typer.echo(f"Invalid --mode {mode!r}; expected 'manual' or 'auto'.", err=True)
         raise typer.Exit(code=2)
+    if markdown_theme is not None and markdown_theme not in REGISTRY:
+        typer.echo(
+            f"Invalid --markdown-theme {markdown_theme!r}; "
+            f"expected one of: {markdown_theme_help()}.",
+            err=True,
+        )
+        raise typer.Exit(code=2)
+    resolved_markdown_theme = (
+        markdown_theme if markdown_theme is not None else load_markdown_theme_preference()
+    )
     cli_cfg = CLIConfig(
         daemon_host=daemon_host,
         daemon_port=daemon_port,
         logging_level=log_level,
         render_markdown=render_markdown,
+        markdown_theme=resolved_markdown_theme,
         output_streaming_enabled=streaming,
         output_streaming_mode=streaming_mode,
         clarification_mode=mode,

{soothe_cli-0.7.0 → soothe_cli-0.7.2}/src/soothe_cli/config/cli_config.py

@@ -29,6 +29,9 @@ class CLIConfig:
     render_markdown: bool = True
     """Render assistant messages as Markdown in TUI (default True)."""
 
+    markdown_theme: str = "match-app"
+    """Markdown appearance preset (``match-app``, ``langchain``, ``standard``, …)."""
+
     # Output streaming overrides (RFC-614)
     output_streaming_enabled: bool | None = None
     """Override daemon streaming enabled setting."""

{soothe_cli-0.7.0 → soothe_cli-0.7.2}/src/soothe_cli/runtime/policy/essential_events.py

@@ -24,12 +24,13 @@ STEP_COMPLETE_EVENT_TYPES: Final[frozenset[str]] = frozenset(
 )
 
 LOOP_REASON_EVENT_TYPE: Final[str] = "soothe.cognition.strange_loop.reasoned"
+INTENT_CLASSIFIED_EVENT_TYPE: Final[str] = "soothe.cognition.intent.classified"
 
 ESSENTIAL_PROGRESS_EVENT_TYPES: Final[frozenset[str]] = frozenset(
     set(GOAL_START_EVENT_TYPES)
     | set(STEP_START_EVENT_TYPES)
     | set(STEP_COMPLETE_EVENT_TYPES)
-    | {LOOP_REASON_EVENT_TYPE}
+    | {LOOP_REASON_EVENT_TYPE, INTENT_CLASSIFIED_EVENT_TYPE}
 )
 
 
@@ -56,6 +57,7 @@ def is_step_complete_event_type(event_type: str) -> bool:
 __all__ = [
     "ESSENTIAL_PROGRESS_EVENT_TYPES",
     "GOAL_START_EVENT_TYPES",
+    "INTENT_CLASSIFIED_EVENT_TYPE",
     "LOOP_REASON_EVENT_TYPE",
     "STEP_COMPLETE_EVENT_TYPES",
     "STEP_START_EVENT_TYPES",

{soothe_cli-0.7.0 → soothe_cli-0.7.2}/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.2}/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
@@ -81,7 +81,6 @@ class TuiDaemonSession:
         self._client = WebSocketClient(url=ws_url)
         self._rpc_client = WebSocketClient(url=ws_url)
         self._loop_id: str | None = None
-        self._autopilot_mode: str | None = None
         self._read_lock = asyncio.Lock()
         self._rpc_lock = asyncio.Lock()
         self._rpc_connected = False
@@ -91,17 +90,13 @@ 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:
         """Active StrangeLoop id for this WebSocket session."""
         return self._loop_id
 
-    @property
-    def autopilot_mode(self) -> str | None:
-        """Active loop Solo/Autopilot mode when known."""
-        return self._autopilot_mode
-
     async def connect(self, *, resume_loop_id: str | None = None) -> dict[str, Any]:
         """Connect and bootstrap a daemon loop session."""
         await connect_websocket_with_retries(self._client)
@@ -122,8 +117,6 @@ class TuiDaemonSession:
         if status_event.get("type") == "error":
             raise RuntimeError(str(status_event.get("message", "daemon bootstrap failed")))
         self._loop_id = status_event.get("loop_id")
-        mode = status_event.get("autopilot_mode")
-        self._autopilot_mode = str(mode) if mode in ("solo", "autopilot") else None
         return status_event
 
     def _resolve_stream_delivery_mode(self) -> str:
@@ -248,6 +241,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 +317,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 +434,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 +661,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