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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: soothe-cli
-Version: 0.6.17
+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.6.17 → soothe_cli-0.7.1}/src/soothe_cli/cli/commands/loop_cmd.py

@@ -17,7 +17,12 @@ from rich.console import Console
 from rich.panel import Panel
 from rich.prompt import Prompt
 from rich.table import Table
-from soothe_sdk.client import WebSocketClient, is_daemon_live, websocket_url_from_config
+from soothe_sdk.client import (
+    ProtocolError,
+    WebSocketClient,
+    is_daemon_live,
+    websocket_url_from_config,
+)
 
 from soothe_cli.runtime import load_config
 
@@ -44,37 +49,50 @@ async def _check_daemon(ws_url: str) -> bool:
 
 async def _rpc(
     ws_url: str,
-    send_fn: str,
-    send_args: dict[str, Any],
-    response_type: str,
+    method: str,
+    params: dict[str, Any] | None = None,
+    *,
+    mode: str = "request",
     timeout: float = 30.0,
 ) -> dict[str, Any]:
-    """Send an RPC request and wait for a matching response.
+    """Send a protocol-1 RPC to the daemon and return the response.
+
+    Uses the protocol-1 client API (RFC-450): ``request()`` for RPC,
+    ``notify()`` for fire-and-forget, ``subscribe()`` for event streams.
+    The wrapper preserves the dict-based error contract used by command
+    handlers — callers check ``if "error" in response``.
 
     Args:
         ws_url: WebSocket URL.
-        send_fn: Name of the WebSocketClient method to call.
-        send_args: Keyword arguments for the send method.
-        response_type: Expected response message type.
+        method: RPC method / notification target / subscription target
+            (e.g. ``"loop_get"``, ``"loop_input"``, ``"loop_events"``).
+        params: Structured parameters object.
+        mode: One of ``"request"`` (blocking RPC), ``"notify"``
+            (fire-and-forget), or ``"subscribe"`` (start a stream).
         timeout: Maximum seconds to wait.
 
     Returns:
-        Response dict from daemon.
+        Response dict from daemon, or ``{"error": ...}`` on failure. For
+        ``notify`` mode returns ``{}``; for ``subscribe`` mode returns
+        ``{"subscription_id": <id>}``.
     """
     client = WebSocketClient(url=ws_url)
     try:
         await client.connect()
-        method = getattr(client, send_fn)
-        await method(**send_args)
-        async with asyncio.timeout(timeout):
-            while True:
-                event = await client.read_event()
-                if not event:
-                    return {"error": "Connection closed"}
-                if event.get("type") == response_type:
-                    return event
+        if mode == "notify":
+            await asyncio.wait_for(client.notify(method, params or {}), timeout=timeout)
+            return {}
+        if mode == "subscribe":
+            sub_id = await asyncio.wait_for(client.subscribe(method, params or {}), timeout=timeout)
+            return {"subscription_id": sub_id}
+        result = await asyncio.wait_for(client.request(method, params or {}), timeout=timeout)
+        return result if isinstance(result, dict) else {"result": result}
     except TimeoutError:
         return {"error": "Timed out waiting for daemon response"}
+    except ProtocolError as exc:
+        return {"error": str(exc)}
+    except (ConnectionError, OSError) as exc:
+        return {"error": f"Connection error: {exc}"}
     finally:
         await client.close()
 
@@ -91,9 +109,8 @@ def _resolve_continue_loop_id(ws_url: str, loop_id: str | None) -> str:
     response = asyncio.run(
         _rpc(
             ws_url,
-            "send_loop_list",
-            {"filter_dict": None, "limit": 20},
-            "loop_list_response",
+            "loop_list",
+            {"limit": 20},
         )
     )
     if "error" in response:
@@ -153,9 +170,8 @@ def list_loops(
     response = asyncio.run(
         _rpc(
             ws_url,
-            "send_loop_list",
-            {"filter_dict": {"status": status} if status else None, "limit": limit},
-            "loop_list_response",
+            "loop_list",
+            {"filter": {"status": status} if status else None, "limit": limit},
         )
     )
 
@@ -211,9 +227,8 @@ def describe_loop(
     response = asyncio.run(
         _rpc(
             ws_url,
-            "send_loop_get",
+            "loop_get",
             {"loop_id": loop_id, "verbose": verbose},
-            "loop_get_response",
         )
     )
 
@@ -327,9 +342,8 @@ def visualize_loop_tree(
     response = asyncio.run(
         _rpc(
             ws_url,
-            "send_loop_tree",
+            "loop_tree",
             {"loop_id": loop_id, "format": format},
-            "loop_tree_response",
         )
     )
 
@@ -384,9 +398,8 @@ def prune_loop_branches(
     response = asyncio.run(
         _rpc(
             ws_url,
-            "send_loop_prune",
+            "loop_prune",
             {"loop_id": loop_id, "retention_days": retention_days, "dry_run": dry_run},
-            "loop_prune_response",
         )
     )
 
@@ -394,10 +407,13 @@ def prune_loop_branches(
         typer.echo(f"Error: {response['error']}", err=True)
         sys.exit(1)
 
-    result = response.get("result", {})
+    # Protocol-1: request() returns the result dict directly (e.g.
+    # {"pruned": N, "remaining": N, "dry_run": bool}), not wrapped in {"result": ...}.
+    pruned = response.get("pruned", 0)
+    remaining = response.get("remaining", 0)
     console.print("[green]Summary:[/green]")
-    console.print(f"  Branches pruned: {result.get('pruned', 0)}")
-    console.print(f"  Remaining: {result.get('remaining', 0)}")
+    console.print(f"  Branches pruned: {pruned}")
+    console.print(f"  Remaining: {remaining}")
 
 
 @loop_app.command("delete")
@@ -424,9 +440,8 @@ def delete_loop(
     response = asyncio.run(
         _rpc(
             ws_url,
-            "send_loop_get",
+            "loop_get",
             {"loop_id": loop_id, "verbose": False},
-            "loop_get_response",
         )
     )
 
@@ -456,9 +471,8 @@ def delete_loop(
     delete_response = asyncio.run(
         _rpc(
             ws_url,
-            "send_loop_delete",
+            "loop_delete",
             {"loop_id": loop_id},
-            "loop_delete_response",
         )
     )
 
@@ -728,9 +742,9 @@ def detach_loop(
     response = asyncio.run(
         _rpc(
             ws_url,
-            "send_loop_detach",
+            "loop_detach",
             {"loop_id": loop_id},
-            "loop_detach_response",
+            mode="notify",
         )
     )
 
@@ -766,9 +780,9 @@ def attach_loop(
     response = asyncio.run(
         _rpc(
             ws_url,
-            "send_loop_subscribe",
+            "loop_events",
             {"loop_id": loop_id},
-            "loop_subscribe_response",
+            mode="subscribe",
         )
     )
 
@@ -782,9 +796,8 @@ def attach_loop(
     status_response = asyncio.run(
         _rpc(
             ws_url,
-            "send_loop_get",
+            "loop_get",
             {"loop_id": loop_id, "verbose": False},
-            "loop_get_response",
         )
     )
 
@@ -824,9 +837,8 @@ def new_loop(
     response = asyncio.run(
         _rpc(
             ws_url,
-            "send_loop_new",
+            "loop_new",
             {},
-            "loop_new_response",
         )
     )
 
@@ -842,9 +854,9 @@ def new_loop(
         input_response = asyncio.run(
             _rpc(
                 ws_url,
-                "send_loop_input",
+                "loop_input",
                 {"loop_id": loop_id, "content": prompt},
-                "loop_input_response",
+                mode="notify",
             )
         )
         if "error" in input_response:

{soothe_cli-0.6.17 → soothe_cli-0.7.1}/src/soothe_cli/cli/commands/status_cmd.py

@@ -15,7 +15,12 @@ import typer
 from rich.console import Console
 from rich.panel import Panel
 from rich.table import Table
-from soothe_sdk.client import WebSocketClient, is_daemon_live, websocket_url_from_config
+from soothe_sdk.client import (
+    WebSocketClient,
+    check_daemon_status,
+    is_daemon_live,
+    websocket_url_from_config,
+)
 
 from soothe_cli.config.loader import load_config
 
@@ -38,8 +43,7 @@ async def _fetch_status(ws_url: str, timeout: float = 5.0) -> dict[str, Any]:
     client = WebSocketClient(url=ws_url)
     try:
         await client.connect()
-        status = await client.fetch_daemon_status(timeout=timeout)
-        return status
+        return await check_daemon_status(client, timeout=timeout)
     except Exception as e:
         return {"error": str(e)}
     finally:
@@ -47,28 +51,41 @@ async def _fetch_status(ws_url: str, timeout: float = 5.0) -> dict[str, Any]:
 
 
 async def _fetch_ready_state(ws_url: str, timeout: float = 5.0) -> dict[str, Any] | None:
-    """Fetch daemon readiness state via WebSocket handshake.
+    """Fetch daemon readiness state via WebSocket connection_init/ack handshake.
 
-    The daemon sends a daemon_ready message on connect with its state.
+    Sends ``connection_init`` and waits for ``connection_ack`` which carries
+    the daemon's ``readiness_state``.
 
     Args:
         ws_url: WebSocket URL.
         timeout: Timeout for handshake.
 
     Returns:
-        daemon_ready message dict or None.
+        ``connection_ack`` result dict (containing ``readiness_state``) or None.
     """
     import websockets
 
+    init_msg = json.dumps(
+        {
+            "proto": "1",
+            "type": "connection_init",
+            "params": {
+                "client_version": "0.5.0",
+                "accept_proto": ["1"],
+                "capabilities": ["streaming"],
+            },
+        }
+    )
+
     try:
         async with asyncio.timeout(timeout):
             async with websockets.connect(ws_url) as ws:
-                # Read initial messages - daemon sends status then daemon_ready
+                await ws.send(init_msg)
                 for _ in range(3):
                     msg = await ws.recv()
                     data = json.loads(msg)
-                    if data.get("type") == "daemon_ready":
-                        return data
+                    if data.get("type") == "connection_ack":
+                        return data.get("result", data)
     except Exception:
         pass
     return None

{soothe_cli-0.6.17 → soothe_cli-0.7.1}/src/soothe_cli/cli/execution/daemon.py

@@ -39,9 +39,41 @@ _HEADLESS_WORKER_LOST_RETRIES = 1
 _CANCEL_SEND_TIMEOUT_S = 3.0
 
 
+def _unwrap_next(event: dict[str, Any] | None) -> dict[str, Any] | None:
+    """Unwrap a protocol-1 ``next`` envelope to its inner streaming frame.
+
+    Under protocol-1 (RFC-450 §9.3) the daemon wraps free-form streaming
+    frames (``event``/``command_response``/card replay) in a
+    ``{proto, type:"next", payload:{namespace, mode, data}}`` envelope. This
+    helper returns the inner ``data`` dict (the legacy frame) so the headless
+    loop and EventProcessor can branch on the same fields as before.
+    ``status``/``error``/``response``/``complete`` are sent raw and pass
+    through unchanged.
+    """
+    if not isinstance(event, dict):
+        return event
+    if event.get("type") != "next":
+        return event
+    payload = event.get("payload")
+    if not isinstance(payload, dict):
+        return event
+    data = payload.get("data")
+    return data if isinstance(data, dict) else event
+
+
 def _is_loop_scoped_event(event: dict[str, Any], *, active_loop_id: str) -> bool:
-    """Return whether a daemon frame belongs to the active StrangeLoop session."""
+    """Return whether a daemon frame belongs to the active StrangeLoop session.
+
+    Unwraps protocol-1 ``next`` envelopes first, then checks ``loop_id`` on the
+    inner streaming frame. Non-scoped types (``response``, ``error``,
+    ``complete``, etc.) are always considered in-scope.
+    """
     event_type = event.get("type", "")
+    if event_type == "next":
+        inner = _unwrap_next(event)
+        if isinstance(inner, dict):
+            event_type = inner.get("type", "")
+            return event_type not in {"status", "event"} or (inner.get("loop_id") == active_loop_id)
     if event_type not in {"status", "event"}:
         return True
     return event.get("loop_id") == active_loop_id
@@ -55,7 +87,10 @@ def _emit_headless_error(message: str) -> None:
 async def _send_cancel_to_daemon(client: WebSocketClient) -> None:
     """Send /cancel to the daemon with a short timeout."""
     try:
-        await asyncio.wait_for(client.send_command("/cancel"), timeout=_CANCEL_SEND_TIMEOUT_S)
+        await asyncio.wait_for(
+            client.notify("slash_command", {"cmd": "/cancel"}),
+            timeout=_CANCEL_SEND_TIMEOUT_S,
+        )
     except Exception:
         logger.warning("Failed to send /cancel to daemon", exc_info=True)
 
@@ -216,8 +251,18 @@ async def _run_headless_session_once(
             if not _is_loop_scoped_event(event, active_loop_id=active_loop_id):
                 continue
 
+            # Unwrap protocol-1 ``next`` envelopes to the inner streaming frame
+            # (RFC-450 §9.3). ``status``/``error`` arrive raw and pass through.
+            if event_type == "next":
+                inner = _unwrap_next(event)
+                if isinstance(inner, dict):
+                    event = inner
+                    event_type = event.get("type", "")
+
             if event_type == "error":
-                raw = str(event.get("message", "unknown"))
+                # Protocol-1 error envelope: {type:'error', error:{code, message, data}}
+                err_obj = event.get("error") or {}
+                raw = str(err_obj.get("message") or event.get("message") or "unknown")
                 _emit_headless_error(friendly_daemon_execution_error(raw))
                 return 1, is_daemon_worker_subprocess_lost(raw)
 
@@ -235,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)
@@ -245,6 +290,12 @@ async def _run_headless_session_once(
                             break
                         if not _is_loop_scoped_event(nxt, active_loop_id=active_loop_id):
                             continue
+                        # Unwrap ``next`` envelopes before handing to the
+                        # processor so it sees the legacy frame shape.
+                        if nxt.get("type") == "next":
+                            inner = _unwrap_next(nxt)
+                            if isinstance(inner, dict):
+                                nxt = inner
                         processor.process_event(nxt)
 
                     processor.process_event(event)

{soothe_cli-0.6.17 → 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.6.17 → soothe_cli-0.7.1}/src/soothe_cli/runtime/headless/processor.py

@@ -465,9 +465,20 @@ class EventProcessor:
             self._handle_custom_event(data, namespace)
 
     def _handle_error_event(self, event: dict[str, Any]) -> None:
-        """Handle error events."""
-        error = event.get("message", event.get("error", "Unknown error"))
-        context = event.get("code")
+        """Handle error events.
+
+        Supports both legacy flat errors (``{type:'error', message:...}``) and
+        protocol-1 error envelopes (``{type:'error', error:{code, message, data}}``).
+        """
+        err_obj = event.get("error")
+        if isinstance(err_obj, dict):
+            # Protocol-1 error envelope.
+            error = str(err_obj.get("message", "Unknown error"))
+            context = err_obj.get("code")
+        else:
+            # Legacy flat error or bare string.
+            error = str(event.get("message", err_obj or "Unknown error"))
+            context = event.get("code")
         self._renderer.on_error(error, context=context)
 
     def _handle_messages(

{soothe_cli-0.6.17 → 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))