soothe-client-python 0.9.6__tar.gz → 0.9.8__tar.gz

{soothe_client_python-0.9.6 → soothe_client_python-0.9.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: soothe-client-python
-Version: 0.9.6
+Version: 0.9.8
 Summary: WebSocket client + appkit for soothe-daemon (Python)
 Project-URL: Homepage, https://github.com/mirasoth/soothe-client-python
 Project-URL: Documentation, https://soothe.readthedocs.io

{soothe_client_python-0.9.6 → soothe_client_python-0.9.8}/pyproject.toml

@@ -74,6 +74,12 @@ python_version = "3.12"
 warn_return_any = true
 warn_unused_configs = true
 disallow_untyped_defs = true
+packages = ["soothe_client"]
+mypy_path = "src"
+
+[[tool.mypy.overrides]]
+module = ["soothe_sdk", "soothe_sdk.*"]
+ignore_missing_imports = true
 
 [tool.pytest.ini_options]
 asyncio_mode = "auto"

{soothe_client_python-0.9.6 → soothe_client_python-0.9.8}/src/soothe_client/appkit/classifier.py

@@ -155,13 +155,12 @@ class EventClassifier:
             return ChatEventResult(terminal=ChatEventTerminal.CONTINUE)
 
         if typ == "error":
-            err_obj = msg.get("error") if isinstance(msg.get("error"), dict) else {}
-            code = err_obj.get("code") if isinstance(err_obj.get("code"), int) else -32603
-            message = (
-                err_obj.get("message")
-                if isinstance(err_obj.get("message"), str)
-                else "daemon error"
-            )
+            raw_err = msg.get("error")
+            err_obj: dict[str, Any] = raw_err if isinstance(raw_err, dict) else {}
+            raw_code = err_obj.get("code")
+            code = raw_code if isinstance(raw_code, int) else -32603
+            raw_message = err_obj.get("message")
+            message = raw_message if isinstance(raw_message, str) else "daemon error"
             return self._failed_result(DaemonError(code, message, err_obj.get("data")))
 
         if typ == "event":
@@ -174,8 +173,10 @@ class EventClassifier:
         return ChatEventResult(terminal=ChatEventTerminal.CONTINUE)
 
     def _classify_next_envelope(self, env: dict[str, Any]) -> ChatEventResult:
-        payload = env.get("payload") if isinstance(env.get("payload"), dict) else {}
-        inner_data = payload.get("data") if isinstance(payload.get("data"), dict) else None
+        raw_payload = env.get("payload")
+        payload: dict[str, Any] = raw_payload if isinstance(raw_payload, dict) else {}
+        raw_inner = payload.get("data")
+        inner_data: dict[str, Any] | None = raw_inner if isinstance(raw_inner, dict) else None
         if inner_data is not None:
             inner_mode = str(inner_data.get("mode") or "")
             if inner_mode:
@@ -372,8 +373,10 @@ def _first_message_payload(data: Any) -> tuple[str, str, str, bool]:
     msg_map = data[0]
     if not isinstance(msg_map, dict):
         return "", "", "", False
-    msg_type = msg_map.get("type") if isinstance(msg_map.get("type"), str) else ""
-    phase = msg_map.get("phase") if isinstance(msg_map.get("phase"), str) else ""
+    type_raw = msg_map.get("type")
+    msg_type = type_raw if isinstance(type_raw, str) else ""
+    phase_raw = msg_map.get("phase")
+    phase = phase_raw if isinstance(phase_raw, str) else ""
     content = _extract_content_from_message(msg_map)
     return msg_type, content, phase, True
 
@@ -388,7 +391,8 @@ def _loop_ai_message(data: Any) -> dict[str, str] | None:
     phase = phase_raw.strip() if isinstance(phase_raw, str) else ""
     if not phase:
         return None
-    msg_type = msg_map.get("type") if isinstance(msg_map.get("type"), str) else ""
+    type_raw = msg_map.get("type")
+    msg_type = type_raw if isinstance(type_raw, str) else ""
     content = _extract_content_from_message(msg_map)
     return {"type": msg_type, "content": content, "phase": phase}
 

{soothe_client_python-0.9.6 → soothe_client_python-0.9.8}/src/soothe_client/appkit/daemon_session.py

@@ -18,18 +18,18 @@ from soothe_client.appkit.chunk_filter import should_drop_stream_chunk_early
 from soothe_client.appkit.events import unwrap_next
 from soothe_client.appkit.observability import TurnEventStats
 from soothe_client.session import bootstrap_loop_session, connect_websocket_with_retries
+from soothe_client.stream_terminal import (
+    STREAM_END,
+    is_turn_end_custom_data,
+    is_turn_progress_chunk,
+)
+from soothe_client.turn_boundary import frame_seq, frame_turn_id
 from soothe_client.websocket import WebSocketClient
 
 logger = logging.getLogger(__name__)
 
 DEFAULT_POST_IDLE_DRAIN_S = 0.5
 _RPC_HANDSHAKE_TIMEOUT_S = 20.0
-_TURN_END_CUSTOM_TYPES = frozenset(
-    {
-        "soothe.cognition.strange_loop.completed",
-        "soothe.stream.end",
-    }
-)
 
 EarlyDropFn = Callable[[tuple[Any, ...], str, Any], bool]
 StatsFactory = Callable[[], Any]
@@ -67,6 +67,9 @@ class DaemonSession:
         self.last_turn_end_state: str | None = None
         self.last_turn_cancellation_seen: bool = False
         self.last_turn_error_message: str | None = None
+        # IG-659: last completed turn's seq floor (drop stale prior-turn frames).
+        self._last_turn_end_seq: int = 0
+        self._expected_turn_id: str | None = None
 
     @property
     def client(self) -> WebSocketClient:
@@ -315,7 +318,13 @@ class DaemonSession:
         inbound_dropped_baseline = getattr(self._client, "inbound_dropped", 0)
         query_started = False
         expected_loop_id = self._loop_id
+        # Bind turn_id only after this turn's status=running (do not reuse prior).
+        self._expected_turn_id = None
+        expected_turn_id: str | None = None
         stream_payload_seen = False
+        turn_progress_seen = False
+        last_end_seq = int(getattr(self, "_last_turn_end_seq", 0) or 0)
+        self._last_turn_end_seq = last_end_seq
         self._streaming = True
         turn_read_started = time.monotonic()
         first_event_logged = False
@@ -353,9 +362,10 @@ class DaemonSession:
                     if event and not first_event_logged:
                         first_event_logged = True
                         logger.debug(
-                            "First daemon event on turn: type=%s loop_id=%s",
+                            "First daemon event on turn: type=%s loop_id=%s turn_id=%s",
                             event.get("type"),
                             event.get("loop_id"),
+                            frame_turn_id(event),
                         )
                     if not event:
                         if query_started and not self._client.is_connection_alive():
@@ -377,6 +387,27 @@ class DaemonSession:
                     ):
                         continue
 
+                    # IG-659 phase 5: drop frames at or before prior turn end seq.
+                    ev_seq = frame_seq(event)
+                    if ev_seq is not None and last_end_seq > 0 and ev_seq <= last_end_seq:
+                        continue
+
+                    # IG-659 phases 1–2: drop mismatched turn_id once bound.
+                    ev_turn_id = frame_turn_id(event)
+                    if (
+                        expected_turn_id
+                        and ev_turn_id
+                        and ev_turn_id != expected_turn_id
+                        and event_type in {"event", "status"}
+                    ):
+                        logger.debug(
+                            "Ignoring mismatched turn_id frame type=%s got=%s expected=%s",
+                            event_type,
+                            ev_turn_id[-24:],
+                            expected_turn_id[-24:],
+                        )
+                        continue
+
                     if event_type == "error":
                         err_obj = event.get("error") or {}
                         err_msg = str(
@@ -393,8 +424,14 @@ class DaemonSession:
                         if state == "running":
                             query_started = True
                             progress_seen = True
+                            status_turn = frame_turn_id(event)
+                            if status_turn:
+                                expected_turn_id = status_turn
+                                self._expected_turn_id = status_turn
                         elif query_started and state == "stopped":
                             self.last_turn_end_state = state
+                            if ev_seq is not None:
+                                self._last_turn_end_seq = max(self._last_turn_end_seq, ev_seq)
                             async for chunk in self._drain_stream_events_after_idle(
                                 expected_loop_id=expected_loop_id,
                             ):
@@ -404,6 +441,8 @@ class DaemonSession:
                             if not stream_payload_seen and not self.last_turn_cancellation_seen:
                                 continue
                             self.last_turn_end_state = state
+                            if ev_seq is not None:
+                                self._last_turn_end_seq = max(self._last_turn_end_seq, ev_seq)
                             async for chunk in self._drain_stream_events_after_idle(
                                 expected_loop_id=expected_loop_id,
                             ):
@@ -426,25 +465,46 @@ class DaemonSession:
                     if self._should_drop(namespace, mode, data):
                         self.turn_event_stats.filtered_early += 1
                         continue
+
+                    # Prefer turn_id match when present; else IG-658 progress gate.
+                    if mode == "custom" and is_turn_end_custom_data(data):
+                        data_turn = (
+                            frame_turn_id(data if isinstance(data, dict) else None) or ev_turn_id
+                        )
+                        turn_ok = (
+                            not expected_turn_id or not data_turn or data_turn == expected_turn_id
+                        )
+                        if not turn_ok or not query_started or not turn_progress_seen:
+                            logger.debug(
+                                "Ignoring premature turn-end frame %s "
+                                "(loop=%s query_started=%s progress=%s turn_ok=%s)",
+                                str(data.get("type", "")).strip()
+                                if isinstance(data, dict)
+                                else "?",
+                                (expected_loop_id or "?")[:16],
+                                query_started,
+                                turn_progress_seen,
+                                turn_ok,
+                            )
+                            continue
+
                     progress_seen = True
                     stream_payload_seen = True
+                    if is_turn_progress_chunk(mode, data):
+                        turn_progress_seen = True
                     yield (namespace, mode, data)
-                    if mode == "custom" and isinstance(data, dict):
+                    if mode == "custom" and is_turn_end_custom_data(data):
                         custom_type = str(data.get("type", "")).strip()
-                        if custom_type in _TURN_END_CUSTOM_TYPES:
-                            # stream.end may be scope-tagged; treat blank / turn as end.
-                            if custom_type == "soothe.stream.end":
-                                scope = str(data.get("scope") or "turn").strip().lower()
-                                if scope not in {"", "turn"}:
-                                    continue
-                            self.last_turn_end_state = (
-                                "stream_end" if custom_type == "soothe.stream.end" else "completed"
-                            )
-                            async for chunk in self._drain_stream_events_after_idle(
-                                expected_loop_id=expected_loop_id,
-                            ):
-                                yield chunk
-                            break
+                        self.last_turn_end_state = (
+                            "stream_end" if custom_type == STREAM_END else "completed"
+                        )
+                        if ev_seq is not None:
+                            self._last_turn_end_seq = max(self._last_turn_end_seq, ev_seq)
+                        async for chunk in self._drain_stream_events_after_idle(
+                            expected_loop_id=expected_loop_id,
+                        ):
+                            yield chunk
+                        break
                     if mode == "updates" and isinstance(data, dict) and "__interrupt__" in data:
                         continue
             except Exception as exc:

{soothe_client_python-0.9.6 → soothe_client_python-0.9.8}/src/soothe_client/appkit/managed_client.py

@@ -7,7 +7,7 @@ Wraps ``WebSocketClient`` and upgrades flat appkit payloads
 from __future__ import annotations
 
 from collections.abc import AsyncIterator, Awaitable, Callable
-from typing import Any, Protocol, runtime_checkable
+from typing import Any, Protocol, cast, runtime_checkable
 
 from soothe_client.errors import DisconnectCause
 from soothe_client.websocket import WebSocketClient
@@ -60,23 +60,29 @@ def _coerce_appkit_wire_message(msg: dict[str, Any], client: WebSocketClient) ->
     }
 
     if msg_type in _NOTIFICATION_METHODS:
-        return WireEnvelope(
-            proto="1",
-            type=MessageType.NOTIFICATION.value,
-            method=msg_type,
-            params=params,
-        ).to_wire_dict()
+        return cast(
+            dict[str, Any],
+            WireEnvelope(
+                proto="1",
+                type=MessageType.NOTIFICATION.value,
+                method=msg_type,
+                params=params,
+            ).to_wire_dict(),
+        )
 
     if msg_type in _REQUEST_METHOD_ALIASES or msg_type:
         request_method = _REQUEST_METHOD_ALIASES.get(msg_type, msg_type)
         req_id = str(msg.get("request_id") or msg.get("id") or client._next_request_id())
-        return WireEnvelope(
-            proto="1",
-            type=MessageType.REQUEST.value,
-            method=request_method,
-            params=params,
-            id=req_id,
-        ).to_wire_dict()
+        return cast(
+            dict[str, Any],
+            WireEnvelope(
+                proto="1",
+                type=MessageType.REQUEST.value,
+                method=request_method,
+                params=params,
+                id=req_id,
+            ).to_wire_dict(),
+        )
 
     return msg
 

{soothe_client_python-0.9.6 → soothe_client_python-0.9.8}/src/soothe_client/appkit/turn_runner.py

@@ -241,23 +241,23 @@ class TurnRunner:
             input_msg = self._build_input(message, loop_id, atts, opts)
             try:
                 await conn.client.send_message(input_msg)
-            except Exception as err:
-                await self._persist_failed(session_id, loop_id, err)
-                self._broadcast_error(session_id, err)
+            except Exception as send_err:
+                await self._persist_failed(session_id, loop_id, send_err)
+                self._broadcast_error(session_id, send_err)
                 if self._on_error is not None:
-                    self._on_error(session_id, loop_id, err)
+                    self._on_error(session_id, loop_id, send_err)
                 raise
 
             event_stream = conn.event_stream
             if event_stream is None:
-                err = RuntimeError(
+                missing = RuntimeError(
                     f"missing event stream for session {session_id} (loop {loop_id})"
                 )
-                await self._persist_failed(session_id, loop_id, err)
-                self._broadcast_error(session_id, err)
+                await self._persist_failed(session_id, loop_id, missing)
+                self._broadcast_error(session_id, missing)
                 if self._on_error is not None:
-                    self._on_error(session_id, loop_id, err)
-                raise err
+                    self._on_error(session_id, loop_id, missing)
+                raise missing
 
             assistant_content = ""
             started_at = time.time()
@@ -266,9 +266,9 @@ class TurnRunner:
 
             while True:
                 if cancel_event is not None and cancel_event.is_set():
-                    err = RuntimeError("aborted")
-                    await self._fail_turn(session_id, loop_id, err)
-                    raise err
+                    aborted = RuntimeError("aborted")
+                    await self._fail_turn(session_id, loop_id, aborted)
+                    raise aborted
 
                 if query_timed_out.is_set():
                     with contextlib.suppress(Exception):
@@ -298,7 +298,10 @@ class TurnRunner:
                     )
                     return
 
-                next_task = asyncio.create_task(agen.__anext__())
+                async def _pull_next() -> Any:
+                    return await agen.__anext__()
+
+                next_task: asyncio.Task[Any] = asyncio.create_task(_pull_next())
                 waiters: list[asyncio.Task[Any]] = [
                     next_task,
                     asyncio.create_task(query_timed_out.wait()),
@@ -350,9 +353,9 @@ class TurnRunner:
                     return
 
                 if caller_wait is not None and caller_wait in done:
-                    err = RuntimeError("aborted")
-                    await self._fail_turn(session_id, loop_id, err)
-                    raise err
+                    aborted = RuntimeError("aborted")
+                    await self._fail_turn(session_id, loop_id, aborted)
+                    raise aborted
 
                 try:
                     msg = next_task.result()
@@ -369,9 +372,9 @@ class TurnRunner:
                             "stream_closed",
                         )
                         return
-                    err = RuntimeError("event stream closed")
-                    await self._fail_turn(session_id, loop_id, err)
-                    raise err from None
+                    closed = RuntimeError("event stream closed")
+                    await self._fail_turn(session_id, loop_id, closed)
+                    raise closed from None
 
                 arm_idle()
 

{soothe_client_python-0.9.6 → soothe_client_python-0.9.8}/src/soothe_client/helpers.py

@@ -7,7 +7,7 @@ import contextlib
 import logging
 from collections.abc import AsyncIterator
 from contextlib import asynccontextmanager
-from typing import Any
+from typing import Any, cast
 
 from soothe_sdk.wire.codec import ProtocolError
 
@@ -310,20 +310,20 @@ async def is_daemon_live(
 
     # Standard liveness check without waiting
     for attempt in range(attempts):
-        client: WebSocketClient | None = None
+        probe: WebSocketClient | None = None
         try:
-            client = WebSocketClient(url=ws_url)
-            await client.connect()
-            status = await check_daemon_status(client, timeout=timeout)
+            probe = WebSocketClient(url=ws_url)
+            await probe.connect()
+            status = await check_daemon_status(probe, timeout=timeout)
             return _daemon_status_indicates_live(status)
         except Exception as exc:
             last_error = exc
             if attempt < attempts - 1:
                 await asyncio.sleep(delay_s)
         finally:
-            if client is not None:
+            if probe is not None:
                 with contextlib.suppress(Exception):
-                    await client.close()
+                    await probe.close()
 
     if last_error is not None:
         logger.debug("Daemon health check failed for %s: %s", ws_url, last_error)
@@ -383,7 +383,8 @@ async def fetch_skills_catalog(client: WebSocketClient, timeout: float = 15.0) -
         ConnectionError: If daemon not reachable
     """
     response = await client.request("skills_list", {}, timeout=timeout)
-    return response.get("skills", [])
+    skills = response.get("skills", [])
+    return cast(list[dict[Any, Any]], skills if isinstance(skills, list) else [])
 
 
 async def fetch_config_section(client: WebSocketClient, section: str, timeout: float = 5.0) -> dict:
@@ -405,7 +406,8 @@ async def fetch_config_section(client: WebSocketClient, section: str, timeout: f
     """
     await _ensure_handshake(client, timeout=timeout)
     response = await client.request("config_get", {"section": section}, timeout=timeout)
-    return response.get(section, {})
+    section_data = response.get(section, {})
+    return cast(dict[Any, Any], section_data if isinstance(section_data, dict) else {})
 
 
 async def fetch_loop_history(

soothe_client_python-0.9.8/src/soothe_client/stream_terminal.py

@@ -0,0 +1,113 @@
+"""Shared stream/turn terminal frame helpers for WebSocket and DaemonSession.
+
+Keeps peel-at-turn-start and turn-end detection on one vocabulary so leftover
+prior-goal terminals cannot blank the next TUI query.
+"""
+
+from __future__ import annotations
+
+from typing import Any, TypeGuard
+
+from soothe_sdk.core.events import (
+    PLAN_CREATED,
+    STRANGE_LOOP_COMPLETED,
+    STRANGE_LOOP_STEP_COMPLETED,
+    STRANGE_LOOP_STEP_QUEUED,
+    STRANGE_LOOP_STEP_STARTED,
+    STREAM_END,
+)
+
+TURN_END_CUSTOM_TYPES = frozenset({STREAM_END, STRANGE_LOOP_COMPLETED})
+
+# Customs that prove this turn has real work (not mere intake plan.phase).
+# Intake-only phases must not unlock turn-end — prior-goal stream.end can still
+# arrive after status=running (loop 3e43).
+_TURN_PROGRESS_CUSTOM_TYPES = frozenset(
+    {
+        PLAN_CREATED,
+        STRANGE_LOOP_STEP_STARTED,
+        STRANGE_LOOP_STEP_QUEUED,
+        STRANGE_LOOP_STEP_COMPLETED,
+    }
+)
+
+# Handshake / card-replay / subscription leftovers safe to drop at turn start.
+STALE_TURN_PENDING_TYPES = frozenset(
+    {
+        "connection_ack",
+        "card.replay_begin",
+        "card.replay_end",
+        "card.created",
+        "complete",
+    }
+)
+
+
+def is_turn_end_custom_data(data: Any) -> TypeGuard[dict[str, Any]]:
+    """True when ``data`` is a turn-scoped terminal custom payload."""
+    if not isinstance(data, dict):
+        return False
+    custom_type = str(data.get("type", "")).strip()
+    if custom_type not in TURN_END_CUSTOM_TYPES:
+        return False
+    if custom_type == STREAM_END:
+        scope = str(data.get("scope") or "turn").strip().lower()
+        return scope in {"", "turn"}
+    return True
+
+
+def is_turn_progress_chunk(mode: str, data: Any) -> bool:
+    """True when a chunk proves the active turn has non-intake progress.
+
+    Used so late prior-goal ``stream.end`` cannot close a turn that has only
+    seen intake lifecycle (e.g. plan.phase "Interpreting goal").
+    """
+    if mode in {"messages", "updates"}:
+        return True
+    if mode != "custom" or not isinstance(data, dict):
+        return False
+    if is_turn_end_custom_data(data):
+        return False
+    custom_type = str(data.get("type", "")).strip()
+    if custom_type in _TURN_PROGRESS_CUSTOM_TYPES:
+        return True
+    if custom_type.startswith("soothe.cognition.strange_loop.step"):
+        return True
+    return False
+
+
+def stale_pending_frame_label(event: dict[str, Any]) -> str | None:
+    """Return a peel label when ``event`` is safe to drop at turn start."""
+    event_type = str(event.get("type") or "")
+    if event_type in STALE_TURN_PENDING_TYPES:
+        return event_type
+
+    if event_type == "next":
+        payload = event.get("payload")
+        if not isinstance(payload, dict):
+            return None
+        stale_mode = str(payload.get("mode") or "")
+        if stale_mode in STALE_TURN_PENDING_TYPES:
+            return stale_mode
+        inner = payload.get("data")
+        if isinstance(inner, dict):
+            return stale_pending_frame_label(inner)
+        return None
+
+    if event_type == "event":
+        mode = str(event.get("mode") or "")
+        data = event.get("data")
+        if mode == "custom" and is_turn_end_custom_data(data):
+            return str(data.get("type") or "").strip()
+    return None
+
+
+__all__ = [
+    "STALE_TURN_PENDING_TYPES",
+    "STREAM_END",
+    "STRANGE_LOOP_COMPLETED",
+    "TURN_END_CUSTOM_TYPES",
+    "is_turn_end_custom_data",
+    "is_turn_progress_chunk",
+    "stale_pending_frame_label",
+]

soothe_client_python-0.9.8/src/soothe_client/turn_boundary.py

@@ -0,0 +1,54 @@
+"""Turn / stream boundary helpers (IG-659).
+
+``turn_id`` correlates a user turn across status, events, and terminals.
+``seq`` is a daemon-assigned monotonic counter per loop for drop-stale filtering.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+
+def format_turn_id(loop_id: str, generation: int) -> str:
+    """Return wire ``turn_id`` for ``loop_id`` + admit generation."""
+    lid = str(loop_id or "").strip()
+    gen = int(generation)
+    if not lid or gen <= 0:
+        return ""
+    return f"{lid}:{gen}"
+
+
+def frame_turn_id(frame: dict[str, Any] | None) -> str | None:
+    """Return ``turn_id`` from a status/event frame or nested custom data."""
+    if not isinstance(frame, dict):
+        return None
+    tid = frame.get("turn_id")
+    if isinstance(tid, str) and tid.strip():
+        return tid.strip()
+    data = frame.get("data")
+    if isinstance(data, dict):
+        inner = data.get("turn_id")
+        if isinstance(inner, str) and inner.strip():
+            return inner.strip()
+    return None
+
+
+def frame_seq(frame: dict[str, Any] | None) -> int | None:
+    """Return non-negative ``seq`` from a wire frame, or None."""
+    if not isinstance(frame, dict):
+        return None
+    raw = frame.get("seq")
+    if isinstance(raw, bool):
+        return None
+    if isinstance(raw, int) and raw >= 0:
+        return raw
+    if isinstance(raw, float) and raw >= 0 and raw == int(raw):
+        return int(raw)
+    return None
+
+
+__all__ = [
+    "format_turn_id",
+    "frame_seq",
+    "frame_turn_id",
+]

{soothe_client_python-0.9.6 → soothe_client_python-0.9.8}/src/soothe_client/websocket.py

@@ -9,7 +9,7 @@ import time
 import uuid
 from collections import deque
 from collections.abc import AsyncGenerator, Callable
-from typing import Any
+from typing import Any, cast
 
 import websockets.asyncio.client
 import websockets.exceptions
@@ -18,6 +18,7 @@ from soothe_sdk.wire.protocol import decode_websocket_text, encode_websocket_tex
 
 from soothe_client.errors import DisconnectCause, ReconnectError, StaleLoopError
 from soothe_client.intent_hints import validate_loop_input_intent_hint
+from soothe_client.stream_terminal import TURN_END_CUSTOM_TYPES, stale_pending_frame_label
 
 logger = logging.getLogger(__name__)
 
@@ -115,9 +116,7 @@ def _inbound_frame_drop_priority(event: dict[str, Any] | None) -> int:
             data = event.get("data")
             if isinstance(data, dict):
                 custom_type = data.get("type", "")
-                if custom_type == "soothe.stream.end":
-                    return _DROP_PRIORITY_CRITICAL
-                if custom_type == "soothe.cognition.strange_loop.completed":
+                if custom_type in TURN_END_CUSTOM_TYPES:
                     return _DROP_PRIORITY_CRITICAL
                 # Cognition events (step started/completed) - prefer keep
                 if custom_type.startswith("soothe.cognition."):
@@ -181,11 +180,7 @@ def _inbound_needs_delivery_ack(event: dict[str, Any]) -> bool:
                 body = data[0]
                 return isinstance(body, dict) and is_stream_terminal_wire_dict(body)
             if inner_mode == "custom" and isinstance(data, dict):
-                ctype = data.get("type", "")
-                return ctype in (
-                    "soothe.cognition.strange_loop.completed",
-                    "soothe.stream.end",
-                )
+                return data.get("type", "") in TURN_END_CUSTOM_TYPES
     if event.get("type") == "event":
         mode = event.get("mode", "")
         data = event.get("data")
@@ -193,11 +188,7 @@ def _inbound_needs_delivery_ack(event: dict[str, Any]) -> bool:
             body = data[0]
             return isinstance(body, dict) and is_stream_terminal_wire_dict(body)
         if mode == "custom" and isinstance(data, dict):
-            ctype = data.get("type", "")
-            return ctype in (
-                "soothe.cognition.strange_loop.completed",
-                "soothe.stream.end",
-            )
+            return data.get("type", "") in TURN_END_CUSTOM_TYPES
     return False
 
 
@@ -931,7 +922,7 @@ class WebSocketClient:
         from soothe_sdk.wire.codec import MessageType
 
         if self._pending_events:
-            event = self._pending_events.popleft()
+            event: dict[str, Any] | None = self._pending_events.popleft()
         else:
             event = await self._read_inbound_event()
 
@@ -1552,31 +1543,14 @@ class WebSocketClient:
         """
         self._pending_events.clear()
 
-    # Handshake / RPC responses that must not count as turn progress (TUI stall detection).
-    # ``card.replay_*`` / ``card.created`` are emitted by the daemon during
-    # ``loop_subscribe`` for non-TUI clients. The TUI consumes its
-    # cards via the synchronous ``loop_cards_fetch`` RPC so these frames are
-    # peeled silently here. Under protocol-1, RPC responses arrive as
-    # ``type:"response"`` correlated by ``id`` (peeled by the reader loop), so
-    # the legacy ``*_response`` type entries are gone. Under protocol-1 (
-    # §9.3) card replay frames arrive wrapped in ``next`` envelopes with
-    # ``payload.mode`` set to the originating frame type; the peel logic below
-    # inspects both the raw ``type`` and the wrapped ``payload.mode``.
-    _STALE_TURN_PENDING_TYPES = frozenset(
-        {
-            "connection_ack",
-            "card.replay_begin",
-            "card.replay_end",
-            "card.created",
-        }
-    )
-
     def peel_stale_pending_control_events(self) -> list[str]:
-        """Remove stale handshake/RPC frames left in ``_pending_events`` before a turn.
+        """Remove stale handshake/terminal frames left in ``_pending_events`` before a turn.
 
         ``request`` queues unrelated inbound frames while waiting for a matching
         ``id``. If a handshake/control frame remains at turn start, the TUI can
-        mistake it for live progress and never log a stalled stream.
+        mistake it for live progress and never log a stalled stream. Leftover
+        prior-goal terminal frames must also be peeled so they cannot end the
+        next turn before ``status=running``.
 
         Returns:
             List of removed frame types (in order).
@@ -1588,20 +1562,9 @@ class WebSocketClient:
         removed: list[str] = []
         while self._pending_events:
             event = self._pending_events.popleft()
-            event_type = str(event.get("type") or "")
-            # Protocol-1 wraps card replay frames in ``next`` envelopes; peel
-            # them by inspecting ``payload.mode`` so they don't masquerade as
-            # live progress at turn start.
-            stale_mode = ""
-            if event_type == "next":
-                payload = event.get("payload")
-                if isinstance(payload, dict):
-                    stale_mode = str(payload.get("mode") or "")
-            if event_type in self._STALE_TURN_PENDING_TYPES:
-                removed.append(event_type)
-                continue
-            if stale_mode and stale_mode in self._STALE_TURN_PENDING_TYPES:
-                removed.append(stale_mode)
+            label = stale_pending_frame_label(event)
+            if label is not None:
+                removed.append(label)
                 continue
             kept.append(event)
         self._pending_events = kept
@@ -1617,7 +1580,7 @@ class WebSocketClient:
             message = await self._ws.recv()
             if isinstance(message, bytes):
                 message = message.decode("utf-8")
-            return decode_websocket_text(message)
+            return cast(dict[str, Any] | None, decode_websocket_text(message))
         except websockets.exceptions.ConnectionClosed:
             return None
         except Exception:

{soothe_client_python-0.9.6 → soothe_client_python-0.9.8}/src/soothe_client/ws_command_client.py

@@ -9,7 +9,7 @@ from __future__ import annotations
 
 import asyncio
 import logging
-from typing import Any
+from typing import Any, cast
 from uuid import uuid4
 
 from soothe_sdk.wire.codec import (
@@ -241,7 +241,10 @@ class WsCommandClient:
                         if response.get("id") != req_id:
                             # Not our response; keep waiting for the match.
                             continue
-                        return response.get("result") or {}
+                        result = response.get("result") or {}
+                        if not isinstance(result, dict):
+                            raise RuntimeError(f"Unexpected result payload: {result!r}")
+                        return cast(dict[str, Any], result)
 
                     # Other message types (next/complete/etc.) are unexpected
                     # for a blocking request; keep reading.
@@ -266,7 +269,7 @@ class WsCommandClient:
         self, description: str, *, priority: int = 50, workspace: str | None = None
     ) -> dict[str, Any]:
         """Submit a new autopilot task."""
-        payload = {"description": description, "priority": priority}
+        payload: dict[str, Any] = {"description": description, "priority": priority}
         if workspace:
             payload["workspace"] = workspace
         return await self._send_command("autopilot_submit", payload)
@@ -334,7 +337,7 @@ class WsCommandClient:
         Returns:
             Dict with job_id and status.
         """
-        payload = {"goal": goal}
+        payload: dict[str, Any] = {"goal": goal}
         if workspace:
             payload["workspace"] = workspace
         if autonomous:
@@ -413,7 +416,7 @@ class WsCommandClient:
         Returns:
             Dict with job_id, goal_id, absorbed.
         """
-        payload = {"job_id": job_id, "content": content}
+        payload: dict[str, Any] = {"job_id": job_id, "content": content}
         if goal_id:
             payload["goal_id"] = goal_id
         return await self._send_command("job_guidance", payload)
@@ -422,7 +425,7 @@ class WsCommandClient:
 
     async def cron_add(self, text: str, *, priority: int | None = None) -> dict[str, Any]:
         """Submit a natural-language scheduled job."""
-        payload = {"text": text}
+        payload: dict[str, Any] = {"text": text}
         if priority is not None:
             payload["priority"] = priority
         result = await self._send_command("cron_add", payload)
@@ -441,7 +444,7 @@ class WsCommandClient:
         Returns:
             Dict with jobs list.
         """
-        payload = {}
+        payload: dict[str, Any] = {}
         if status:
             payload["status"] = status
         return await self._send_command("cron_list", payload)
@@ -492,55 +495,61 @@ class SyncWsCommandClient:
 
     def autopilot_status(self) -> dict[str, Any]:
         """Get autopilot status (sync)."""
-        return self._run_async(self._client.autopilot_status())
+        return cast(dict[str, Any], self._run_async(self._client.autopilot_status()))
 
     def autopilot_submit(
         self, description: str, *, priority: int = 50, workspace: str | None = None
     ) -> dict[str, Any]:
         """Submit a new autopilot task (sync)."""
-        return self._run_async(
-            self._client.autopilot_submit(description, priority=priority, workspace=workspace)
+        return cast(
+            dict[str, Any],
+            self._run_async(
+                self._client.autopilot_submit(description, priority=priority, workspace=workspace)
+            ),
         )
 
     def autopilot_list_goals(self) -> dict[str, Any]:
         """List all goals (sync)."""
-        return self._run_async(self._client.autopilot_list_goals())
+        return cast(dict[str, Any], self._run_async(self._client.autopilot_list_goals()))
 
     def autopilot_get_goal(self, goal_id: str) -> dict[str, Any]:
         """Get goal details (sync)."""
-        return self._run_async(self._client.autopilot_get_goal(goal_id))
+        return cast(dict[str, Any], self._run_async(self._client.autopilot_get_goal(goal_id)))
 
     def autopilot_cancel_goal(self, goal_id: str) -> dict[str, Any]:
         """Cancel a goal (sync)."""
-        return self._run_async(self._client.autopilot_cancel_goal(goal_id))
+        return cast(dict[str, Any], self._run_async(self._client.autopilot_cancel_goal(goal_id)))
 
     def autopilot_wake(self) -> dict[str, Any]:
         """Exit dreaming mode (sync)."""
-        return self._run_async(self._client.autopilot_wake())
+        return cast(dict[str, Any], self._run_async(self._client.autopilot_wake()))
 
     def autopilot_dream(self) -> dict[str, Any]:
         """Force dreaming mode (sync)."""
-        return self._run_async(self._client.autopilot_dream())
+        return cast(dict[str, Any], self._run_async(self._client.autopilot_dream()))
 
     def autopilot_resume(self, goal_id: str) -> dict[str, Any]:
         """Resume a suspended/blocked goal (sync)."""
-        return self._run_async(self._client.autopilot_resume(goal_id))
+        return cast(dict[str, Any], self._run_async(self._client.autopilot_resume(goal_id)))
 
     def autopilot_list_jobs(self) -> dict[str, Any]:
         """List root goals (jobs) only (sync)."""
-        return self._run_async(self._client.autopilot_list_jobs())
+        return cast(dict[str, Any], self._run_async(self._client.autopilot_list_jobs()))
 
     def autopilot_get_job(self, job_id: str) -> dict[str, Any]:
         """Get job status with DAG snapshot (sync)."""
-        return self._run_async(self._client.autopilot_get_job(job_id))
+        return cast(dict[str, Any], self._run_async(self._client.autopilot_get_job(job_id)))
 
     def job_pause(self, job_id: str) -> dict[str, Any]:
         """Pause a running autopilot job (sync)."""
-        return self._run_async(self._client.job_pause(job_id))
+        return cast(dict[str, Any], self._run_async(self._client.job_pause(job_id)))
 
     def job_guidance(self, job_id: str, text: str, *, goal_id: str | None = None) -> dict[str, Any]:
         """Send guidance to an autopilot job or specific goal (sync)."""
-        return self._run_async(self._client.job_guidance(job_id, text, goal_id=goal_id))
+        return cast(
+            dict[str, Any],
+            self._run_async(self._client.job_guidance(job_id, text, goal_id=goal_id)),
+        )
 
     def job_create(
         self,
@@ -552,59 +561,62 @@ class SyncWsCommandClient:
         guidance: str | None = None,
     ) -> dict[str, Any]:
         """Create a new autopilot job."""
-        return self._run_async(
-            self._client.job_create(
-                goal,
-                workspace=workspace,
-                autonomous=autonomous,
-                max_iterations=max_iterations,
-                guidance=guidance,
-            )
+        return cast(
+            dict[str, Any],
+            self._run_async(
+                self._client.job_create(
+                    goal,
+                    workspace=workspace,
+                    autonomous=autonomous,
+                    max_iterations=max_iterations,
+                    guidance=guidance,
+                )
+            ),
         )
 
     def job_status(self, job_id: str) -> dict[str, Any]:
         """Get job status with goal counts and workers."""
-        return self._run_async(self._client.job_status(job_id))
+        return cast(dict[str, Any], self._run_async(self._client.job_status(job_id)))
 
     def job_resume(self, job_id: str) -> dict[str, Any]:
         """Resume a paused autopilot job."""
-        return self._run_async(self._client.job_resume(job_id))
+        return cast(dict[str, Any], self._run_async(self._client.job_resume(job_id)))
 
     def job_cancel(self, job_id: str) -> dict[str, Any]:
         """Cancel an autopilot job."""
-        return self._run_async(self._client.job_cancel(job_id))
+        return cast(dict[str, Any], self._run_async(self._client.job_cancel(job_id)))
 
     def job_dag(self, job_id: str) -> dict[str, Any]:
         """Get job DAG snapshot for visualization."""
-        return self._run_async(self._client.job_dag(job_id))
+        return cast(dict[str, Any], self._run_async(self._client.job_dag(job_id)))
 
     def autopilot_subscribe(self) -> dict[str, Any]:
         """Subscribe to autopilot worker events (sync)."""
-        return self._run_async(self._client.autopilot_subscribe())
+        return cast(dict[str, Any], self._run_async(self._client.autopilot_subscribe()))
 
     def autopilot_unsubscribe(self) -> dict[str, Any]:
         """Unsubscribe from autopilot worker events (sync)."""
-        return self._run_async(self._client.autopilot_unsubscribe())
+        return cast(dict[str, Any], self._run_async(self._client.autopilot_unsubscribe()))
 
     def cron_add(self, text: str, *, priority: int | None = None) -> dict[str, Any]:
         """Submit a natural-language scheduled job (sync)."""
-        return self._run_async(self._client.cron_add(text, priority=priority))
+        return cast(dict[str, Any], self._run_async(self._client.cron_add(text, priority=priority)))
 
     def cron_list(self, *, status: str | None = None) -> dict[str, Any]:
         """List scheduled jobs (sync)."""
-        return self._run_async(self._client.cron_list(status=status))
+        return cast(dict[str, Any], self._run_async(self._client.cron_list(status=status)))
 
     def cron_show(self, job_id: str) -> dict[str, Any]:
         """Get job details (sync)."""
-        return self._run_async(self._client.cron_show(job_id))
+        return cast(dict[str, Any], self._run_async(self._client.cron_show(job_id)))
 
     def cron_cancel(self, job_id: str) -> dict[str, Any]:
         """Cancel a scheduled job (sync)."""
-        return self._run_async(self._client.cron_cancel(job_id))
+        return cast(dict[str, Any], self._run_async(self._client.cron_cancel(job_id)))
 
     def memory_stats(self, mode: str = "daemon") -> dict[str, Any]:
         """Query daemon memory profiling stats (sync)."""
-        return self._run_async(self._client.memory_stats(mode))
+        return cast(dict[str, Any], self._run_async(self._client.memory_stats(mode)))
 
 
 def ws_command_client_from_config(cfg: Any) -> SyncWsCommandClient: