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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: soothe-cli
-Version: 0.8.1
+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,7 +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.5.25
+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.1 → soothe_cli-0.8.2}/pyproject.toml

@@ -24,7 +24,7 @@ classifiers = [
 ]
 dependencies = [
     "soothe-sdk>=0.5.25,<1.0.0",    # events/display/wire contracts
-    "soothe-client-python>=0.5.25,<1.0.0",  # WebSocket transport client
+    "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.1 → soothe_cli-0.8.2}/src/soothe_cli/cli/commands/autopilot_cmd.py

@@ -15,9 +15,9 @@ from pathlib import Path
 
 import typer
 from soothe_client import (
+    command_client_from_config,
     is_daemon_live,
     websocket_url_from_config,
-    ws_command_client_from_config,
 )
 from soothe_sdk.wire.protocol import preview_first
 
@@ -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.1 → soothe_cli-0.8.2}/src/soothe_cli/cli/commands/config_cmd.py

@@ -11,7 +11,7 @@ import typer
 from rich.console import Console
 from rich.panel import Panel
 from soothe_client import (
-    WebSocketClient,
+    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.1 → soothe_cli-0.8.2}/src/soothe_cli/cli/commands/cron_cmd.py

@@ -22,9 +22,9 @@ from rich.console import Console
 from rich.panel import Panel
 from rich.table import Table
 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.1 → soothe_cli-0.8.2}/src/soothe_cli/cli/commands/loop_cmd.py

@@ -18,13 +18,10 @@ from rich.panel import Panel
 from rich.prompt import Prompt
 from rich.table import Table
 from soothe_client import (
-    WebSocketClient,
     is_daemon_live,
+    protocol1_rpc,
     websocket_url_from_config,
 )
-from soothe_sdk.client import (
-    ProtocolError,
-)
 
 from soothe_cli.runtime import load_config
 
@@ -49,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.1 → soothe_cli-0.8.2}/src/soothe_cli/cli/commands/status_cmd.py

@@ -16,8 +16,8 @@ from rich.console import Console
 from rich.panel import Panel
 from rich.table import Table
 from soothe_client import (
-    WebSocketClient,
     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.1 → 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
@@ -13,13 +13,11 @@ from typing import Any
 
 import typer
 from soothe_client import (
-    WebSocketClient,
-    async_ws_command_client_from_config,
-    bootstrap_loop_session,
-    connect_websocket_with_retries,
+    async_command_client_from_config,
     websocket_url_from_config,
 )
-from soothe_client.appkit import is_loop_scoped_event, unwrap_next
+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,
@@ -45,11 +43,11 @@ def _emit_headless_error(message: str) -> None:
     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:
@@ -81,14 +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)``."""
-    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:
@@ -96,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))
@@ -109,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
@@ -138,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,
@@ -182,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():
@@ -210,8 +213,8 @@ 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.
+            # 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)
                 if isinstance(inner, dict):
@@ -263,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
@@ -300,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(
@@ -313,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.1 → soothe_cli-0.8.2}/src/soothe_cli/cli/execution/headless.py

@@ -5,7 +5,7 @@ import sys
 
 import typer
 from soothe_client import (
-    WebSocketClient,
+    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.1 → soothe_cli-0.8.2}/src/soothe_cli/runtime/transport/session.py

@@ -12,12 +12,6 @@ from typing import Any
 from soothe_client.appkit import DaemonSession
 from soothe_client.helpers import websocket_url_from_config
 
-# Re-exported for test monkeypatches / historical import sites.
-from soothe_client.session import (  # noqa: F401
-    bootstrap_loop_session,
-    connect_websocket_with_retries,
-)
-
 from soothe_cli.runtime.state.session_stats import TurnEventStats
 from soothe_cli.runtime.wire.chunk_filter import should_drop_stream_chunk_early
 
@@ -49,7 +43,7 @@ class TuiDaemonSession(DaemonSession):
         )
 
     def _resolve_stream_delivery_mode(self) -> str:
-        """Determine stream delivery mode from config (RFC-614).
+        """Determine stream delivery mode from config.
 
         Returns one of ``batch`` | ``adaptive`` | ``streaming``. CLI override
         wins, then config; defaults to ``adaptive``.
@@ -68,13 +62,7 @@ class TuiDaemonSession(DaemonSession):
         return "adaptive"
 
 
-# Historical alias used by some call sites / docs.
-DaemonSession = TuiDaemonSession  # noqa: F811
-
 __all__ = [
-    "DaemonSession",
     "TUI_EXIT_HANDSHAKE_TIMEOUT_S",
     "TuiDaemonSession",
-    "bootstrap_loop_session",
-    "connect_websocket_with_retries",
 ]

{soothe_cli-0.8.1 → soothe_cli-0.8.2}/src/soothe_cli/tui/app/_model.py

@@ -310,7 +310,7 @@ class _ModelMixin:
             task: Task description for autonomous execution.
         """
         from soothe_client import (
-            async_ws_command_client_from_config,
+            async_command_client_from_config,
             is_daemon_live,
             websocket_url_from_config,
         )
@@ -333,7 +333,7 @@ class _ModelMixin:
         workspace = self._cwd if hasattr(self, "_cwd") else os.getcwd()
 
         try:
-            client = async_ws_command_client_from_config(cfg)
+            client = async_command_client_from_config(cfg)
             result = await client.autopilot_submit(task, workspace=workspace)
         except RuntimeError as exc:
             await self._mount_message(ErrorMessage(str(exc)))
@@ -358,7 +358,7 @@ class _ModelMixin:
             slash_input: Original slash command for chat display.
         """
         from soothe_client import (
-            async_ws_command_client_from_config,
+            async_command_client_from_config,
             is_daemon_live,
             websocket_url_from_config,
         )
@@ -378,7 +378,7 @@ class _ModelMixin:
             return
 
         try:
-            client = async_ws_command_client_from_config(cfg)
+            client = async_command_client_from_config(cfg)
             result = await client.cron_add(text)
         except RuntimeError as exc:
             message = str(exc)

{soothe_cli-0.8.1 → soothe_cli-0.8.2}/src/soothe_cli/tui/app/_startup.py

@@ -416,7 +416,12 @@ class _StartupMixin:
         """
         from soothe_cli.tui.skills.invocation import discover_skills_async
 
-        return await discover_skills_async(daemon_config=self._daemon_config)
+        session = getattr(self, "_daemon_session", None)
+        client = getattr(session, "client", None) if session is not None else None
+        return await discover_skills_async(
+            daemon_config=self._daemon_config,
+            client=client,
+        )
 
     @staticmethod
     def _daemon_connect_hint_extra(*, attempt: int, max_attempts: int) -> str | None:

{soothe_cli-0.8.1 → soothe_cli-0.8.2}/src/soothe_cli/tui/commands/command_router.py

@@ -112,22 +112,35 @@ def parse_command_params(entry: dict[str, Any], query: str) -> dict[str, Any]:
 async def route_slash_command(
     cmd_input: str,
     console: Console,
-    client: WebSocketClient,
+    client: WebSocketClient | None = None,
     *,
     loop_id: str | None = None,
+    session: Any | None = None,
 ) -> bool:
-    """Route slash command based on registry metadata (RFC-454).
+    """Route slash command based on registry metadata.
 
     Args:
         cmd_input: Full command input (e.g., "/memory", "/deep_research topic")
         console: Rich console for rendering
         client: WebSocket client for daemon communication
+        loop_id: Active StrangeLoop id
+        session: Optional ``DaemonSession``; when set, uses ``session.client`` and
+            ``session.loop_id`` unless overridden.
 
     Returns:
         True if command was handled, False if unknown command
     """
     from soothe_cli.tui.commands.slash_commands import COMMANDS
 
+    if session is not None:
+        client = client or getattr(session, "client", None)
+        if loop_id is None:
+            loop_id = getattr(session, "loop_id", None)
+
+    if client is None:
+        console.print("[red]Error: No daemon connection[/red]")
+        return True
+
     command, query = parse_slash_command(cmd_input)
 
     # Not a slash command

{soothe_cli-0.8.1 → soothe_cli-0.8.2}/src/soothe_cli/tui/model_config.py

@@ -73,7 +73,7 @@ async def _fetch_provider_config(provider_name: str) -> dict[str, Any] | None:
     """
     try:
         from soothe_client import (
-            WebSocketClient,
+            connected_websocket,
             fetch_config_section,
         )
 
@@ -82,13 +82,12 @@ async def _fetch_provider_config(provider_name: str) -> dict[str, Any] | None:
         cli_cfg = load_config()
         ws_url = cli_cfg.websocket_url()
 
-        client = WebSocketClient(url=ws_url)
-        await client.connect()
-        try:
-            providers_data = await fetch_config_section(client, "providers", timeout=5.0)
-            return providers_data.get(provider_name)
-        finally:
-            await client.close()
+        async def _fetch() -> dict | None:
+            async with connected_websocket(ws_url, timeout=5.0) as client:
+                providers_data = await fetch_config_section(client, "providers", timeout=5.0)
+                return providers_data.get(provider_name)
+
+        return await _fetch()
     except Exception:
         logger.debug("Could not fetch provider config from daemon", exc_info=True)
         return None
@@ -484,7 +483,7 @@ def get_available_models() -> list[ModelProfileEntry]:
         import asyncio
 
         from soothe_client import (
-            WebSocketClient,
+            connected_websocket,
             fetch_config_section,
         )
 
@@ -494,15 +493,9 @@ def get_available_models() -> list[ModelProfileEntry]:
         cli_cfg = load_config()
         ws_url = cli_cfg.websocket_url()
 
-        # Fetch providers section from daemon
-        client = WebSocketClient(url=ws_url)
-
         async def _fetch_providers() -> dict:
-            await client.connect()
-            try:
+            async with connected_websocket(ws_url, timeout=5.0) as client:
                 return await fetch_config_section(client, "providers", timeout=5.0)
-            finally:
-                await client.close()
 
         providers_data = asyncio.run(_fetch_providers())
 

{soothe_cli-0.8.1 → soothe_cli-0.8.2}/src/soothe_cli/tui/skills/invocation.py

@@ -4,9 +4,10 @@ from __future__ import annotations
 
 import logging
 from collections import OrderedDict
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Any
 
 from soothe_client import (
+    connected_websocket,
     fetch_skills_catalog,
     websocket_url_from_config,
 )
@@ -14,6 +15,8 @@ from soothe_client import (
 from soothe_cli.tui.skills.load import ExtendedSkillMetadata
 
 if TYPE_CHECKING:
+    from soothe_client import WebSocketClient
+
     from soothe_cli.config.cli_config import CLIConfig
 
 logger = logging.getLogger(__name__)
@@ -21,44 +24,47 @@ logger = logging.getLogger(__name__)
 
 async def discover_skills_async(
     daemon_config: CLIConfig | None = None,
+    *,
+    client: WebSocketClient | None = None,
 ) -> list[ExtendedSkillMetadata]:
-    """Discover skills from daemon RPC (IG-174 Phase 2).
+    """Discover skills from daemon RPC.
 
-    Fetches wire-safe skill metadata from daemon via WebSocket RPC.
-    Daemon handles all skill discovery (built-in, user, project, etc.)
-    and returns wire-safe metadata. No local filesystem access.
+    Prefers an already-connected ``client`` (e.g. ``DaemonSession.client``) so the
+    TUI does not open a second WebSocket. Falls back to a one-shot connection
+    when only ``daemon_config`` is provided.
 
     Args:
-        daemon_config: Daemon config for WebSocket URL construction.
+        daemon_config: Daemon config for WebSocket URL construction (oneshot path).
+        client: Optional live WebSocket client to reuse.
 
     Returns:
         List of skill metadata dicts sorted by ascending precedence
         (built-in first, winning entry last). Empty list if daemon
         unavailable.
     """
-    from soothe_client import WebSocketClient
-
-    if daemon_config is None:
-        logger.warning("No daemon_config provided for skills discovery; returning empty catalog")
-        return []
-
-    ws_url = websocket_url_from_config(daemon_config)
-    client = WebSocketClient(url=ws_url)
-
     by_name: OrderedDict[str, ExtendedSkillMetadata] = OrderedDict()
 
-    try:
-        await client.connect()
-        skills_wire = await fetch_skills_catalog(client, timeout=15.0)
-        await client.close()
-
-        # Build by_name mapping from wire-safe metadata
+    async def _load(ws: Any) -> None:
+        skills_wire = await fetch_skills_catalog(ws, timeout=15.0)
         for skill_meta in skills_wire:
             name = skill_meta.get("name")
             if name:
                 by_name[name] = skill_meta
+
+    try:
+        if client is not None:
+            await _load(client)
+        elif daemon_config is not None:
+            ws_url = websocket_url_from_config(daemon_config)
+            async with connected_websocket(ws_url, timeout=15.0) as ws:
+                await _load(ws)
+        else:
+            logger.warning(
+                "No daemon_config or client provided for skills discovery; returning empty catalog"
+            )
+            return []
     except Exception as e:
-        logger.warning(f"Failed to fetch skills from daemon: {e}")
+        logger.warning("Skills discovery failed: %s", e, exc_info=True)
         return []
 
     return list(by_name.values())