soothe-cli 0.8.0__tar.gz → 0.8.2__tar.gz

{soothe_cli-0.8.0 → soothe_cli-0.8.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: soothe-cli
-Version: 0.8.0
+Version: 0.8.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
@@ -22,6 +22,7 @@ Requires-Dist: pillow<12.0.0,>=10.0.0
 Requires-Dist: python-dotenv<2.0.0,>=1.0.0
 Requires-Dist: pyyaml<7.0.0,>=6.0.0
 Requires-Dist: rich<15.0.0,>=13.0.0
+Requires-Dist: soothe-client-python<1.0.0,>=0.10.0
 Requires-Dist: soothe-sdk<1.0.0,>=0.5.25
 Requires-Dist: textual<10.0.0,>=8.0.0
 Requires-Dist: typer<2.0.0,>=0.9.0

{soothe_cli-0.8.0 → soothe_cli-0.8.2}/pyproject.toml

@@ -23,7 +23,8 @@ classifiers = [
     "Topic :: Software Development :: Libraries :: Python Modules",
 ]
 dependencies = [
-    "soothe-sdk>=0.5.25,<1.0.0",    # Subagent wire helpers (types owned by soothe subagents)
+    "soothe-sdk>=0.5.25,<1.0.0",    # events/display/wire contracts
+    "soothe-client-python>=0.10.0,<1.0.0",  # WebSocket transport client
     "typer>=0.9.0,<2.0.0",          # CLI framework
     "textual>=8.0.0,<10.0.0",       # TUI framework
     "rich>=13.0.0,<15.0.0",         # Console output

{soothe_cli-0.8.0 → soothe_cli-0.8.2}/src/soothe_cli/cli/commands/autopilot_cmd.py

@@ -14,12 +14,12 @@ from collections import Counter
 from pathlib import Path
 
 import typer
-from soothe_sdk.client import (
+from soothe_client import (
+    command_client_from_config,
     is_daemon_live,
     websocket_url_from_config,
-    ws_command_client_from_config,
 )
-from soothe_sdk.client.protocol import preview_first
+from soothe_sdk.wire.protocol import preview_first
 
 app = typer.Typer(help="Autopilot mode — long-running autonomous agent control.")
 
@@ -46,7 +46,7 @@ def _require_daemon_ws():
             err=True,
         )
         sys.exit(1)
-    return ws_command_client_from_config(cfg)
+    return command_client_from_config(cfg)
 
 
 @app.command("run")
@@ -325,10 +325,41 @@ def show_goal(
 
 @app.command("cancel")
 def cancel_goal(
-    goal_id: str = typer.Argument(..., help="Goal ID to cancel."),
+    goal_id: str | None = typer.Argument(
+        None,
+        help="Goal ID to cancel (omit when using --all or --job).",
+    ),
+    cancel_all: bool = typer.Option(
+        False,
+        "--all",
+        help="Cancel every open (non-terminal) autopilot goal.",
+    ),
+    job_id: str | None = typer.Option(
+        None,
+        "--job",
+        help="Cancel a job root and all descendant goals.",
+    ),
 ) -> None:
-    """Cancel a goal via the daemon."""
+    """Cancel a goal, a job subtree, or all open goals via the daemon."""
+    modes = sum(1 for flag in (bool(goal_id), cancel_all, bool(job_id)) if flag)
+    if modes != 1:
+        typer.echo(
+            "Specify exactly one of: GOAL_ID, --all, or --job <id>.",
+            err=True,
+        )
+        raise typer.Exit(1)
+
     client = _require_daemon_ws()
+    if cancel_all:
+        result = client.autopilot_cancel_all()
+        count = result.get("cancelled_count", 0)
+        typer.echo(f"Cancelled {count} open goal(s).")
+        return
+    if job_id:
+        result = client.job_cancel(job_id)
+        typer.echo(f"Cancel job result: {result.get('status', result)}")
+        return
+    assert goal_id is not None
     result = client.autopilot_cancel_goal(goal_id)
     typer.echo(f"Cancel result: {result.get('status', result)}")
 

{soothe_cli-0.8.0 → soothe_cli-0.8.2}/src/soothe_cli/cli/commands/config_cmd.py

@@ -10,8 +10,8 @@ from typing import Annotated, Any
 import typer
 from rich.console import Console
 from rich.panel import Panel
-from soothe_sdk.client import (
-    WebSocketClient,
+from soothe_client import (
+    connected_websocket,
     request_daemon_config_reload,
     websocket_url_from_config,
 )
@@ -34,14 +34,11 @@ async def _trigger_config_reload(ws_url: str, timeout: float = 5.0) -> dict[str,
     Returns:
         Response dict from daemon, or error dict on failure.
     """
-    client = WebSocketClient(url=ws_url)
     try:
-        await client.connect()
-        return await request_daemon_config_reload(client, timeout=timeout)
+        async with connected_websocket(ws_url, timeout=timeout) as client:
+            return await request_daemon_config_reload(client, timeout=timeout)
     except Exception as e:
         return {"success": False, "error": str(e)}
-    finally:
-        await client.close()
 
 
 @config_app.command("reload")

{soothe_cli-0.8.0 → soothe_cli-0.8.2}/src/soothe_cli/cli/commands/cron_cmd.py

@@ -21,10 +21,10 @@ import typer
 from rich.console import Console
 from rich.panel import Panel
 from rich.table import Table
-from soothe_sdk.client import (
+from soothe_client import (
+    command_client_from_config,
     is_daemon_live,
     websocket_url_from_config,
-    ws_command_client_from_config,
 )
 
 from soothe_cli.runtime import load_config
@@ -44,7 +44,7 @@ def _require_cron_client():
             err=True,
         )
         sys.exit(1)
-    return ws_command_client_from_config(cfg)
+    return command_client_from_config(cfg)
 
 
 def _format_next_run(next_run: str) -> str:

{soothe_cli-0.8.0 → soothe_cli-0.8.2}/src/soothe_cli/cli/commands/loop_cmd.py

@@ -17,10 +17,9 @@ 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 (
-    ProtocolError,
-    WebSocketClient,
+from soothe_client import (
     is_daemon_live,
+    protocol1_rpc,
     websocket_url_from_config,
 )
 
@@ -47,64 +46,8 @@ async def _check_daemon(ws_url: str) -> bool:
     return await is_daemon_live(ws_url, timeout=5.0)
 
 
-async def _rpc(
-    ws_url: str,
-    method: str,
-    params: dict[str, Any] | None = None,
-    *,
-    mode: str = "request",
-    timeout: float = 30.0,
-) -> dict[str, Any]:
-    """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.
-        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, or ``{"error": ...}`` on failure. For
-        ``notify`` mode returns ``{}``; for ``subscribe`` mode returns
-        ``{"subscription_id": <id>}``.
-    """
-    client = WebSocketClient(url=ws_url)
-    try:
-        await client.connect()
-        await asyncio.wait_for(client.request_connection_init(), timeout=timeout)
-        await asyncio.wait_for(
-            client.wait_for_connection_ack(ack_timeout_s=timeout), timeout=timeout
-        )
-        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),
-                timeout=timeout,
-            )
-            return {"subscription_id": sub_id}
-        result = await asyncio.wait_for(
-            client.request(method, params or {}, timeout=timeout),
-            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()
+# Back-compat alias for tests and internal callers.
+_rpc = protocol1_rpc
 
 
 def _resolve_continue_loop_id(ws_url: str, loop_id: str | None) -> str:

{soothe_cli-0.8.0 → soothe_cli-0.8.2}/src/soothe_cli/cli/commands/run_cmd.py

@@ -4,10 +4,9 @@ import logging
 import sys
 import time
 from pathlib import Path
-from typing import Any
 
 import typer
-from soothe_sdk.client.config import SOOTHE_HOME
+from soothe_sdk.paths import SOOTHE_HOME
 from soothe_sdk.utils.logging import resolve_cli_log_level
 
 from soothe_cli.cli.execution import run_headless, run_tui
@@ -37,7 +36,8 @@ def run_impl(
         autonomous: Enable autonomous iteration mode
         max_iterations: Max iterations for autonomous mode
         tui_with_prompt: When True with a prompt, open the TUI instead of headless.
-        mcp_config: Path to additional MCP server config (JSON/YAML) to merge.
+        mcp_config: Deprecated. MCP servers must be configured on the daemon;
+            passing this flag only emits a warning.
     """
     startup_start = time.perf_counter()
     use_headless: bool | None = None  # Track execution mode for exit tip
@@ -45,9 +45,13 @@ def run_impl(
     try:
         cfg = load_config()
 
-        # Merge --mcp-config file into SootheConfig.mcp_servers
+        # MCP servers are owned by the daemon config; CLI cannot merge them post-split.
         if mcp_config:
-            _merge_mcp_config(cfg, mcp_config)
+            typer.echo(
+                "--mcp-config is ignored in the CLI; configure MCP servers on the daemon "
+                f"(~/.soothe/config). Requested file: {mcp_config}",
+                err=True,
+            )
         log_level = resolve_cli_log_level(logging_level=cfg.logging_level)
         log_file = Path(SOOTHE_HOME) / "logs" / "cli.log"
         setup_logging(log_level, log_file=log_file)
@@ -123,60 +127,3 @@ def run_impl(
 
         typer.echo(f"Error: {format_cli_error(e)}", err=True)
         sys.exit(1)
-
-
-def _merge_mcp_config(cfg: Any, mcp_config_path: str) -> None:
-    """Load MCP server config from a JSON/YAML file and merge into SootheConfig.
-
-    Args:
-        cfg: SootheConfig instance.
-        mcp_config_path: Path to MCP config file (JSON or YAML).
-    """
-    import json
-
-    path = Path(mcp_config_path).expanduser().resolve()
-    if not path.is_file():
-        typer.echo(f"--mcp-config: file not found: {path}", err=True)
-        return
-
-    try:
-        raw = path.read_text(encoding="utf-8")
-        if path.suffix in (".yml", ".yaml"):
-            try:
-                import yaml
-
-                data = yaml.safe_load(raw)
-            except ImportError:
-                typer.echo("--mcp-config: PyYAML not installed; use JSON format", err=True)
-                return
-        else:
-            data = json.loads(raw)
-    except Exception as e:
-        typer.echo(f"--mcp-config: failed to parse {path}: {e}", err=True)
-        return
-
-    servers = data.get("mcp_servers") or data.get("servers") or []
-    if not isinstance(servers, list):
-        typer.echo("--mcp-config: expected 'mcp_servers' or 'servers' list", err=True)
-        return
-
-    from soothe.config.models import MCPServerConfig
-
-    new_servers: list[MCPServerConfig] = []
-    for entry in servers:
-        if isinstance(entry, dict):
-            try:
-                new_servers.append(MCPServerConfig(**entry))
-            except Exception as e:
-                logger.warning("Skipping invalid MCP server entry: %s", e)
-
-    if new_servers:
-        existing = list(cfg.mcp_servers) if cfg.mcp_servers else []
-        existing_names = {s.name for s in existing}
-        for s in new_servers:
-            if s.name in existing_names:
-                logger.warning("--mcp-config: server '%s' already in config, skipping", s.name)
-            else:
-                existing.append(s)
-        cfg.mcp_servers = existing
-        logger.info("--mcp-config: merged %d MCP server(s)", len(new_servers))

{soothe_cli-0.8.0 → soothe_cli-0.8.2}/src/soothe_cli/cli/commands/status_cmd.py

@@ -15,9 +15,9 @@ import typer
 from rich.console import Console
 from rich.panel import Panel
 from rich.table import Table
-from soothe_sdk.client import (
-    WebSocketClient,
+from soothe_client import (
     check_daemon_status,
+    connected_websocket,
     is_daemon_live,
     websocket_url_from_config,
 )
@@ -40,14 +40,11 @@ async def _fetch_status(ws_url: str, timeout: float = 5.0) -> dict[str, Any]:
     Returns:
         Status dict from daemon, or error dict on failure.
     """
-    client = WebSocketClient(url=ws_url)
     try:
-        await client.connect()
-        return await check_daemon_status(client, timeout=timeout)
+        async with connected_websocket(ws_url, timeout=timeout) as client:
+            return await check_daemon_status(client, timeout=timeout)
     except Exception as e:
         return {"error": str(e)}
-    finally:
-        await client.close()
 
 
 def _render_unified_status_table(

{soothe_cli-0.8.0 → soothe_cli-0.8.2}/src/soothe_cli/cli/execution/daemon.py

@@ -1,7 +1,7 @@
 """Daemon-based execution for headless mode.
 
-Uses RFC-0019 EventProcessor with HeadlessCliRenderer (stdout: loop-tagged answers only).
-Uses WebSocket transport (RFC-0013).
+Uses EventProcessor with HeadlessCliRenderer (stdout: loop-tagged answers only).
+Session lifecycle goes through ``soothe_client.appkit.DaemonSession``.
 """
 
 from __future__ import annotations
@@ -12,13 +12,12 @@ import signal
 from typing import Any
 
 import typer
-from soothe_sdk.client import (
-    WebSocketClient,
-    async_ws_command_client_from_config,
-    bootstrap_loop_session,
-    connect_websocket_with_retries,
+from soothe_client import (
+    async_command_client_from_config,
     websocket_url_from_config,
 )
+from soothe_client.appkit import DaemonSession
+from soothe_client.appkit.events import is_loop_scoped_event, unwrap_next
 
 from soothe_cli.cli.execution.daemon_errors import (
     friendly_daemon_execution_error,
@@ -39,56 +38,16 @@ _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.
-
-    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
-
-
 def _emit_headless_error(message: str) -> None:
     """Write a user-facing error line to stderr (headless renderer convention)."""
     typer.echo(f"ERROR: {message}", err=True)
 
 
-async def _send_cancel_to_daemon(client: WebSocketClient) -> None:
+async def _send_cancel_to_daemon(session: DaemonSession) -> None:
     """Send /cancel to the daemon with a short timeout."""
     try:
         await asyncio.wait_for(
-            client.notify("slash_command", {"cmd": "/cancel"}),
+            session.cancel_remote_query(),
             timeout=_CANCEL_SEND_TIMEOUT_S,
         )
     except Exception:
@@ -120,16 +79,12 @@ async def _run_headless_session_once(
     max_iterations: int | None = None,
 ) -> tuple[int, bool]:
     """Run one headless daemon session; return ``(exit_code, retry_on_worker_loss)``."""
-    from soothe_sdk.client import WebSocketClient
-
-    ws_url = websocket_url_from_config(cfg)
-    client = WebSocketClient(url=ws_url)
-
     # Track whether the daemon was notified of cancellation.
     cancel_sent = False
     sigint_received = False
     sigint_count = 0
     original_sigint: Any = None
+    session: DaemonSession | None = None
 
     cron_text = _parse_cron_slash_prompt(prompt)
     if cron_text is not None:
@@ -137,7 +92,7 @@ async def _run_headless_session_once(
             _emit_headless_error("Usage: /cron <natural language schedule>")
             return 1, False
         try:
-            ws_client = async_ws_command_client_from_config(cfg)
+            ws_client = async_command_client_from_config(cfg)
             result = await ws_client.cron_add(cron_text)
         except RuntimeError as exc:
             _emit_headless_error(str(exc))
@@ -150,27 +105,34 @@ async def _run_headless_session_once(
         return 0, False
 
     try:
-        await connect_websocket_with_retries(client)
         cli_ws = resolve_cli_loop_workspace()
-        # IG-441: three first-class modes (batch / adaptive / streaming).
+        # Three first-class modes (batch / adaptive / streaming).
         # Default is ``adaptive`` for headless runs as well — it gives smooth
         # progress on long synthesis while keeping wire traffic bounded.
         override = getattr(cfg, "output_streaming_mode", None)
         stream_delivery = override if override in ("batch", "adaptive", "streaming") else "adaptive"
 
-        status_event = await bootstrap_loop_session(
-            client,
-            resume_loop_id=resume_loop_id,
-            stream_delivery=stream_delivery,
+        session = DaemonSession(
+            websocket_url_from_config(cfg),
             workspace=cli_ws,
-            subscribe_timeout_s=_SESSION_BOOTSTRAP_TIMEOUT_S,
+            stream_delivery=stream_delivery,
         )
+        try:
+            status_event = await asyncio.wait_for(
+                session.connect(resume_loop_id=resume_loop_id),
+                timeout=_SESSION_BOOTSTRAP_TIMEOUT_S,
+            )
+        except RuntimeError as exc:
+            raw = str(exc)
+            _emit_headless_error(friendly_daemon_execution_error(raw))
+            return 1, is_daemon_worker_subprocess_lost(raw)
+
         if status_event.get("type") == "error":
             raw = str(status_event.get("message", "unknown"))
             _emit_headless_error(friendly_daemon_execution_error(raw))
             return 1, is_daemon_worker_subprocess_lost(raw)
 
-        active_loop_id = status_event.get("loop_id")
+        active_loop_id = session.loop_id or status_event.get("loop_id")
         if not active_loop_id:
             _emit_headless_error("No loop_id after session bootstrap")
             return 1, False
@@ -179,8 +141,7 @@ async def _run_headless_session_once(
         effective_prompt = cleaned_prompt if subagent_name else prompt
 
         await asyncio.wait_for(
-            client.send_input(
-                active_loop_id,
+            session.send_turn(
                 effective_prompt,
                 autonomous=autonomous,
                 max_iterations=max_iterations,
@@ -223,13 +184,14 @@ async def _run_headless_session_once(
         )
 
         query_started = False
+        client = session.client
 
         while True:
             # Check if SIGINT fired and send /cancel to the daemon.
             if sigint_received and not cancel_sent:
                 cancel_sent = True
                 logger.info("Headless query interrupted; sending /cancel to daemon")
-                await _send_cancel_to_daemon(client)
+                await _send_cancel_to_daemon(session)
                 # After notifying the daemon, cancel the main task so
                 # asyncio.run() can unwind cleanly.
                 if main_task is not None and not main_task.done():
@@ -248,13 +210,13 @@ async def _run_headless_session_once(
                 break
 
             event_type = event.get("type", "")
-            if not _is_loop_scoped_event(event, active_loop_id=active_loop_id):
+            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.
+            # Unwrap protocol-1 ``next`` envelopes to the inner streaming frame.
+            # ``status``/``error`` arrive raw and pass through.
             if event_type == "next":
-                inner = _unwrap_next(event)
+                inner = unwrap_next(event)
                 if isinstance(inner, dict):
                     event = inner
                     event_type = event.get("type", "")
@@ -288,12 +250,12 @@ async def _run_headless_session_once(
                             break
                         if not nxt:
                             break
-                        if not _is_loop_scoped_event(nxt, active_loop_id=active_loop_id):
+                        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)
+                            inner = unwrap_next(nxt)
                             if isinstance(inner, dict):
                                 nxt = inner
                         processor.process_event(nxt)
@@ -304,18 +266,18 @@ async def _run_headless_session_once(
             processor.process_event(event)
 
     except KeyboardInterrupt:
-        if not cancel_sent:
+        if session is not None and not cancel_sent:
             cancel_sent = True
             logger.info("Headless query interrupted by user; sending /cancel to daemon")
-            await _send_cancel_to_daemon(client)
+            await _send_cancel_to_daemon(session)
         return 1, False
     except asyncio.CancelledError:
-        if not cancel_sent:
+        if session is not None and not cancel_sent:
             cancel_sent = True
             logger.info("Headless query cancelled; sending /cancel to daemon")
             # Best-effort: the task is being cancelled so awaiting may fail.
             try:
-                await asyncio.shield(_send_cancel_to_daemon(client))
+                await asyncio.shield(_send_cancel_to_daemon(session))
             except (asyncio.CancelledError, Exception):
                 pass
         raise
@@ -341,7 +303,8 @@ async def _run_headless_session_once(
                 signal.signal(signal.SIGINT, original_sigint)
         except (ValueError, OSError, RuntimeError):
             pass
-        await client.close()
+        if session is not None:
+            await session.close()
 
 
 async def run_headless_via_daemon(
@@ -354,8 +317,8 @@ async def run_headless_via_daemon(
 ) -> int:
     """Run a single prompt by connecting to a running daemon.
 
-    Uses WebSocket transport for all connections (RFC-0013).
-    Headless output is RFC-614 loop-tagged main-graph assistant text only (IG-343).
+    Uses WebSocket transport for all connections.
+    Headless output is loop-tagged main-graph assistant text only.
 
     Retries once when the worker pool loses a subprocess mid-query (common idle-timeout
     race or transient worker recycle).

{soothe_cli-0.8.0 → soothe_cli-0.8.2}/src/soothe_cli/cli/execution/headless.py

@@ -4,8 +4,8 @@ import asyncio
 import sys
 
 import typer
-from soothe_sdk.client import (
-    WebSocketClient,
+from soothe_client import (
+    connected_websocket,
     is_daemon_live,
     request_daemon_shutdown,
     websocket_url_from_config,
@@ -49,10 +49,8 @@ def run_headless(
         if not daemon_live:
             # Attempt cleanup if stale daemon (connection exists but daemon not responsive)
             try:
-                client = WebSocketClient(url=ws_url)
-                await client.connect()
-                await request_daemon_shutdown(client, timeout=10.0)
-                await client.close()
+                async with connected_websocket(ws_url, timeout=10.0) as client:
+                    await request_daemon_shutdown(client, timeout=10.0)
             except Exception:
                 pass  # No daemon running or already stopped
 

{soothe_cli-0.8.0 → soothe_cli-0.8.2}/src/soothe_cli/cli/main.py

@@ -10,7 +10,7 @@ from pathlib import Path  # noqa: E402
 from typing import Annotated  # noqa: E402
 
 import typer  # noqa: E402
-from soothe_sdk.client.config import SOOTHE_HOME  # noqa: E402
+from soothe_sdk.paths 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

{soothe_cli-0.8.0 → soothe_cli-0.8.2}/src/soothe_cli/config/cli_config.py

@@ -5,7 +5,7 @@ from __future__ import annotations
 from dataclasses import dataclass, field
 from pathlib import Path
 
-from soothe_sdk.client.config import SOOTHE_HOME
+from soothe_sdk.paths import SOOTHE_HOME
 
 
 @dataclass

{soothe_cli-0.8.0 → soothe_cli-0.8.2}/src/soothe_cli/runtime/headless/processor.py

@@ -35,7 +35,7 @@ from soothe_cli.runtime.policy.tui_trace_log import log_tui_trace
 from soothe_cli.runtime.presentation.engine import PresentationEngine
 
 if TYPE_CHECKING:
-    from soothe_sdk.client.schemas import Plan
+    from soothe_client.schemas import Plan
 
     from soothe_cli.runtime.presentation.renderer_protocol import RendererProtocol
 
@@ -962,7 +962,7 @@ class EventProcessor:
 
     def _handle_plan_created(self, data: dict[str, Any]) -> None:
         """Handle plan creation event."""
-        from soothe_sdk.client.schemas import Plan, PlanStep
+        from soothe_client.schemas import Plan, PlanStep
 
         steps = [
             PlanStep(