soothe-client-python 1.0.11__tar.gz → 1.0.14__tar.gz

{soothe_client_python-1.0.11 → soothe_client_python-1.0.14}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: soothe-client-python
-Version: 1.0.11
+Version: 1.0.14
 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-1.0.11 → soothe_client_python-1.0.14}/src/soothe_client/__init__.py

@@ -49,7 +49,6 @@ from soothe_client.intent_hints import (
     IMAGE_TO_TEXT,
     OCR,
     TEXT_COMPLETION,
-    validate_loop_input_intent_hint,
 )
 from soothe_client.session import (
     bootstrap_loop_session,
@@ -100,5 +99,4 @@ __all__ = [
     "OCR",
     "EMBED",
     "DEFAULT_DELIVERABLE_PHASES",
-    "validate_loop_input_intent_hint",
 ]

{soothe_client_python-1.0.11 → soothe_client_python-1.0.14}/src/soothe_client/appkit/daemon_session.py

@@ -27,9 +27,10 @@ from soothe_client.stream_terminal import (
 from soothe_client.turn_boundary import (
     frame_seq,
     frame_turn_id,
-    is_idle_terminal_allowed,
+    is_status_terminal_allowed,
     is_turn_terminal_allowed,
     parse_turn_generation,
+    should_bind_running_turn,
     turn_ids_match,
 )
 from soothe_client.websocket import WebSocketClient
@@ -94,7 +95,12 @@ class DaemonSession:
         # Scoped to the current peer seq namespace: reset on reconnect / loop
         # change — daemon seq is per-process and restarts after daemon restart.
         self._last_turn_end_seq: int = 0
+        # Last accepted terminal's turn generation (refuse leftover prior-gen
+        # status=running binds when expected_turn_id is still unset).
+        self._last_completed_turn_gen: int = 0
         self._expected_turn_id: str | None = None
+        # Set by post-idle drain when a successor status=running is re-queued.
+        self._drain_saw_successor_running: bool = False
 
     def _reset_turn_seq_floor(self) -> None:
         """Clear seq/turn filters when the peer seq namespace may have restarted.
@@ -104,8 +110,27 @@ class DaemonSession:
         ``status=running`` — leaving ``query_started=False`` and a silent TUI.
         """
         self._last_turn_end_seq = 0
+        self._last_completed_turn_gen = 0
         self._expected_turn_id = None
 
+    def _note_completed_turn_gen(self, turn_id: str | None) -> None:
+        """Raise the completed-generation floor after an accepted terminal."""
+        floor = int(getattr(self, "_last_completed_turn_gen", 0) or 0)
+        gen = parse_turn_generation(turn_id)
+        if gen is not None and gen > floor:
+            self._last_completed_turn_gen = gen
+
+    def _ensure_turn_floor_attrs(self) -> None:
+        """Initialize turn-floor attrs for partially constructed sessions (tests)."""
+        if not hasattr(self, "_last_completed_turn_gen"):
+            self._last_completed_turn_gen = 0
+        if not hasattr(self, "_last_turn_end_seq"):
+            self._last_turn_end_seq = 0
+        if not hasattr(self, "_drain_saw_successor_running"):
+            self._drain_saw_successor_running = False
+        if not hasattr(self, "_expected_turn_id"):
+            self._expected_turn_id = None
+
     @property
     def client(self) -> WebSocketClient:
         """Subscribed stream WebSocket (loop events)."""
@@ -254,8 +279,6 @@ class DaemonSession:
         self,
         text: str,
         *,
-        autonomous: bool = False,
-        max_iterations: int | None = None,
         preferred_subagent: str | None = None,
         model: str | None = None,
         model_params: dict[str, Any] | None = None,
@@ -276,8 +299,6 @@ class DaemonSession:
         await self._client.send_input(
             self._loop_id,
             text,
-            autonomous=autonomous,
-            max_iterations=max_iterations,
             preferred_subagent=preferred_subagent,
             model=model,
             model_params=model_params,
@@ -302,7 +323,13 @@ class DaemonSession:
         *,
         expected_loop_id: str | None,
     ) -> AsyncIterator[tuple[tuple[Any, ...], str, Any]]:
-        """Yield stream chunks that arrive just after ``idle``."""
+        """Yield stream chunks that arrive just after ``idle``.
+
+        If a successor ``status=running`` (generation above the completed floor)
+        arrives, re-queue it and set ``_drain_saw_successor_running`` so the
+        caller can continue the reader instead of ending the turn.
+        """
+        self._drain_saw_successor_running = False
         loop = asyncio.get_running_loop()
         deadline = loop.time() + self._drain_deadline
         exp = expected_loop_id
@@ -313,6 +340,7 @@ class DaemonSession:
                 break
             if not event:
                 break
+            raw_event = event
             event_type = event.get("type", "")
             if event_type == "next":
                 event = unwrap_next(event) or event
@@ -329,6 +357,21 @@ class DaemonSession:
                 if isinstance(loop_ev, str) and loop_ev:
                     self._loop_id = loop_ev
                     exp = loop_ev
+                state = str(event.get("state") or "").strip().lower()
+                if state == "running":
+                    status_turn = frame_turn_id(event)
+                    new_gen = parse_turn_generation(status_turn)
+                    if new_gen is not None and new_gen > int(
+                        getattr(self, "_last_completed_turn_gen", 0) or 0
+                    ):
+                        push = getattr(self._client, "push_pending_event_front", None)
+                        if callable(push):
+                            push(raw_event)
+                        else:
+                            # Fallback: put unwrapped event if client lacks helper.
+                            self._client._pending_events.appendleft(event)  # noqa: SLF001
+                        self._drain_saw_successor_running = True
+                        return
                 continue
             if event_type != "event":
                 continue
@@ -353,6 +396,7 @@ class DaemonSession:
         self,
         *,
         max_wait_s: float | None = None,
+        idle_timeout_s: float | None = None,
     ) -> AsyncIterator[tuple[tuple[Any, ...], str, Any]]:
         """Yield ``(namespace, mode, data)`` stream chunks until the turn ends.
 
@@ -363,7 +407,15 @@ class DaemonSession:
             max_wait_s: Optional absolute deadline for the whole turn. When set,
                 raises ``TimeoutError`` if the daemon never emits a turn-end
                 signal in time.
+            idle_timeout_s: Optional hard cap on how long to wait for the *first*
+                progress event before giving up. When set and no progress is seen
+                within this many seconds, raises ``TimeoutError`` instead of the
+                default 30s-log-and-reset behavior. Used by attach-only reads
+                (``skip_daemon_send_turn``) so a stale ``live`` probe that turns
+                out to have no real follow-on turn does not spin the thinking
+                row for minutes.
         """
+        self._ensure_turn_floor_attrs()
         self.turn_event_stats = self._new_turn_stats()
         self.last_turn_end_state = None
         self.last_turn_cancellation_seen = False
@@ -382,6 +434,12 @@ class DaemonSession:
         turn_read_started = time.monotonic()
         first_event_logged = False
         progress_seen = False
+        # Wall-clock of the last *real* progress (a yielded chunk). A stale
+        # ``status=running`` frame sets ``progress_seen`` but yields nothing;
+        # for the attach-only idle timeout we need a signal that advances when
+        # the daemon actually streams content, not when it merely re-announces
+        # a (possibly stale) running status.
+        last_real_progress_at = turn_read_started
         absolute_deadline = (
             time.monotonic() + max_wait_s if max_wait_s is not None and max_wait_s > 0 else None
         )
@@ -402,15 +460,31 @@ class DaemonSession:
                             f"Turn timed out after {max_wait_s:.0f}s "
                             f"(loop={expected_loop_id or '?'})"
                         )
-                    if not progress_seen and time.monotonic() - turn_read_started > 30.0:
-                        logger.warning(
-                            "No daemon stream progress after %.0fs (loop=%s, "
-                            "query_started=%s); check daemon sender / WebSocket reader",
-                            time.monotonic() - turn_read_started,
-                            (expected_loop_id or "?")[:16],
-                            query_started,
+                    if not progress_seen:
+                        elapsed = time.monotonic() - turn_read_started
+                        if elapsed > 30.0:
+                            logger.warning(
+                                "No daemon stream progress after %.0fs (loop=%s, "
+                                "query_started=%s); check daemon sender / WebSocket reader",
+                                elapsed,
+                                (expected_loop_id or "?")[:16],
+                                query_started,
+                            )
+                            turn_read_started = time.monotonic()
+                    # Attach-only idle timeout: even after a stale
+                    # ``status=running`` sets ``progress_seen``, no real content
+                    # may ever arrive (the runner already exited). Bound the wait
+                    # for the first yielded chunk so the TUI falls back instead
+                    # of spinning the thinking row for minutes.
+                    if (
+                        idle_timeout_s is not None
+                        and idle_timeout_s > 0
+                        and time.monotonic() - last_real_progress_at > idle_timeout_s
+                    ):
+                        raise TimeoutError(
+                            f"No daemon stream progress within {idle_timeout_s:.0f}s "
+                            f"attach window (loop={expected_loop_id or '?'})"
                         )
-                        turn_read_started = time.monotonic()
                     event = await self._client.read_event()
                     if event and not first_event_logged:
                         first_event_logged = True
@@ -495,61 +569,73 @@ class DaemonSession:
                             expected_loop_id = loop_ev
                         state = event.get("state", "")
                         if state == "running":
-                            query_started = True
-                            progress_seen = True
                             status_turn = frame_turn_id(event)
                             # Bind only from running frames that carry turn_id.
                             # Pre-admit early running omits turn_id and must not
                             # unlock terminals or poison the expected id.
                             if status_turn:
-                                new_gen = parse_turn_generation(status_turn)
-                                old_gen = parse_turn_generation(expected_turn_id)
-                                if expected_turn_id is None or (
-                                    new_gen is not None and (old_gen is None or new_gen >= old_gen)
+                                completed_gen = int(
+                                    getattr(self, "_last_completed_turn_gen", 0) or 0
+                                )
+                                if not should_bind_running_turn(
+                                    status_turn=status_turn,
+                                    expected_turn_id=expected_turn_id,
+                                    last_completed_turn_gen=completed_gen,
                                 ):
-                                    if expected_turn_id and status_turn != expected_turn_id:
-                                        # Successor turn admitted while this reader
-                                        # still held a stale/early binding.
-                                        turn_progress_seen = False
-                                    expected_turn_id = status_turn
-                                    self._expected_turn_id = status_turn
-                        elif query_started and state == "stopped":
-                            stop_turn = frame_turn_id(event)
-                            if expected_turn_id and not turn_ids_match(expected_turn_id, stop_turn):
-                                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,
-                            ):
-                                yield chunk
-                            break
-                        elif query_started and state == "idle":
-                            idle_turn = frame_turn_id(event)
-                            if not is_idle_terminal_allowed(
+                                    logger.debug(
+                                        "Ignoring stale/older status=running "
+                                        "(loop=%s turn=%s expected=%s completed_gen=%s)",
+                                        (expected_loop_id or "?")[:16],
+                                        status_turn[-24:],
+                                        (expected_turn_id or "<none>")[-24:],
+                                        completed_gen,
+                                    )
+                                    continue
+                                if expected_turn_id and status_turn != expected_turn_id:
+                                    # Successor turn admitted while this reader
+                                    # still held a stale/early binding.
+                                    turn_progress_seen = False
+                                expected_turn_id = status_turn
+                                self._expected_turn_id = status_turn
+                                query_started = True
+                                progress_seen = True
+                            else:
+                                # Pre-admit early running: query start, no bind.
+                                query_started = True
+                                progress_seen = True
+                        elif query_started and state in {"stopped", "idle"}:
+                            status_turn = frame_turn_id(event)
+                            if not is_status_terminal_allowed(
                                 expected_turn_id=expected_turn_id,
-                                frame_turn_id=idle_turn,
+                                frame_turn_id=status_turn,
                                 query_started=query_started,
                                 turn_progress_seen=turn_progress_seen,
                                 cancellation_seen=self.last_turn_cancellation_seen,
                             ):
                                 logger.debug(
-                                    "Ignoring premature idle "
-                                    "(loop=%s bound=%s idle_turn=%s progress=%s)",
+                                    "Ignoring premature %s "
+                                    "(loop=%s bound=%s status_turn=%s progress=%s)",
+                                    state,
                                     (expected_loop_id or "?")[:16],
                                     bool(expected_turn_id),
-                                    (idle_turn or "<absent>")[-24:],
+                                    (status_turn or "<absent>")[-24:],
                                     turn_progress_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)
+                            self._note_completed_turn_gen(expected_turn_id)
                             async for chunk in self._drain_stream_events_after_idle(
                                 expected_loop_id=expected_loop_id,
                             ):
                                 yield chunk
+                            if self._drain_saw_successor_running:
+                                # Successor turn already re-queued; continue reading.
+                                turn_progress_seen = False
+                                expected_turn_id = None
+                                self._expected_turn_id = None
+                                continue
                             break
                         continue
 
@@ -597,6 +683,7 @@ class DaemonSession:
                             continue
 
                     progress_seen = True
+                    last_real_progress_at = time.monotonic()
                     if is_turn_progress_chunk(mode, data):
                         turn_progress_seen = True
                     yield (namespace, mode, data)
@@ -612,10 +699,16 @@ class DaemonSession:
                             self.last_turn_end_state = "completed"
                         if ev_seq is not None:
                             self._last_turn_end_seq = max(self._last_turn_end_seq, ev_seq)
+                        self._note_completed_turn_gen(expected_turn_id)
                         async for chunk in self._drain_stream_events_after_idle(
                             expected_loop_id=expected_loop_id,
                         ):
                             yield chunk
+                        if self._drain_saw_successor_running:
+                            turn_progress_seen = False
+                            expected_turn_id = None
+                            self._expected_turn_id = None
+                            continue
                         break
                     if mode == "updates" and isinstance(data, dict) and "__interrupt__" in data:
                         continue
@@ -633,7 +726,7 @@ class DaemonSession:
         """Return skill rows from the daemon catalog."""
         async with self._rpc_lock:
             await self._ensure_rpc_connected()
-            response = await self._rpc_client.list_skills(timeout=15.0)
+            response = await self._rpc_client.list_skills(workspace=self._workspace, timeout=15.0)
         skills = response.get("skills", [])
         if not isinstance(skills, list):
             return []
@@ -782,9 +875,10 @@ class DaemonSession:
         """Fetch execution-progress snapshot (plan, step_index, iteration, status).
 
         Returns a namespace with ``plan``, ``step_index``, ``iteration``,
-        ``status`` for the loop's bound checkpoint thread. On RPC failure the
-        fields degrade gracefully (``step_index=0``, ``iteration=0``,
-        ``status=None``, ``plan=None``) so a resume gate can still proceed.
+        ``status``, and ``active_runner`` for the loop's bound checkpoint
+        thread. On RPC failure the fields degrade gracefully (``step_index=0``,
+        ``iteration=0``, ``status=None``, ``plan=None``, ``active_runner=False``)
+        so a resume gate can still proceed.
         """
         lid = str(loop_id or "").strip()
         empty = SimpleNamespace(
@@ -792,6 +886,7 @@ class DaemonSession:
             step_index=0,
             iteration=0,
             status=None,
+            active_runner=False,
             loop_id=lid or None,
             success=False,
         )
@@ -819,12 +914,21 @@ class DaemonSession:
         iteration = iteration_raw if isinstance(iteration_raw, int) else 0
         status_raw = resp.get("status")
         status = status_raw if isinstance(status_raw, str) else None
+        # ``active_runner`` is absent on daemons older than this field; treat
+        # absence as unknown (None) so callers can fall back to status only.
+        active_runner_raw = resp.get("active_runner")
+        active_runner: bool | None
+        if isinstance(active_runner_raw, bool):
+            active_runner = active_runner_raw
+        else:
+            active_runner = None
         success = bool(resp.get("success", True))
         return SimpleNamespace(
             plan=plan,
             step_index=step_index,
             iteration=iteration,
             status=status,
+            active_runner=active_runner,
             loop_id=resp.get("loop_id", lid),
             success=success,
         )

{soothe_client_python-1.0.11 → soothe_client_python-1.0.14}/src/soothe_client/appkit/turn_boundary.py

@@ -16,10 +16,10 @@ from soothe_client.stream_terminal import (
 )
 from soothe_client.turn_boundary import (
     frame_turn_id,
-    is_idle_terminal_allowed,
+    is_status_terminal_allowed,
     is_turn_terminal_allowed,
     parse_turn_generation,
-    turn_ids_match,
+    should_bind_running_turn,
 )
 
 TURN_END_STREAM_END = STREAM_END
@@ -35,6 +35,7 @@ class TurnLifecycleGate:
     saw_turn_progress: bool = False
     expected_turn_id: str | None = None
     cancellation_seen: bool = False
+    last_completed_turn_gen: int = 0
 
     def observe(self, msg: Any) -> None:
         frame = _normalize_frame(msg)
@@ -43,17 +44,24 @@ class TurnLifecycleGate:
         typ = str(frame.get("type") or "")
         if typ == "status":
             if str(frame.get("state") or "").strip().lower() == "running":
-                self.saw_running = True
                 status_turn = frame_turn_id(frame)
                 if status_turn:
-                    new_gen = parse_turn_generation(status_turn)
-                    old_gen = parse_turn_generation(self.expected_turn_id)
-                    if self.expected_turn_id is None or (
-                        new_gen is not None and (old_gen is None or new_gen >= old_gen)
+                    if not should_bind_running_turn(
+                        status_turn=status_turn,
+                        expected_turn_id=self.expected_turn_id,
+                        last_completed_turn_gen=self.last_completed_turn_gen,
                     ):
-                        if self.expected_turn_id and status_turn != self.expected_turn_id:
-                            self.saw_turn_progress = False
-                        self.expected_turn_id = status_turn
+                        return
+                    if self.expected_turn_id and status_turn != self.expected_turn_id:
+                        # Successor turn admitted while this reader
+                        # still held a stale/early binding.
+                        self.saw_turn_progress = False
+                    self.expected_turn_id = status_turn
+                    self.saw_running = True
+                else:
+                    # Pre-admit early running omits turn_id — mark query start
+                    # without binding (DaemonSession parity).
+                    self.saw_running = True
             return
         if typ == "event":
             mode = str(frame.get("mode") or "")
@@ -68,8 +76,8 @@ class TurnLifecycleGate:
             turn_progress_seen=self.saw_turn_progress,
         )
 
-    def allow_idle_complete(self, frame_turn: str | None) -> bool:
-        return is_idle_terminal_allowed(
+    def allow_status_complete(self, frame_turn: str | None) -> bool:
+        return is_status_terminal_allowed(
             expected_turn_id=self.expected_turn_id,
             frame_turn_id=frame_turn,
             query_started=self.saw_running,
@@ -77,6 +85,15 @@ class TurnLifecycleGate:
             cancellation_seen=self.cancellation_seen,
         )
 
+    def allow_idle_complete(self, frame_turn: str | None) -> bool:
+        return self.allow_status_complete(frame_turn)
+
+    def note_completed_turn(self, turn_id: str | None) -> None:
+        """Raise the completed-generation floor after an accepted terminal."""
+        gen = parse_turn_generation(turn_id)
+        if gen is not None and gen > self.last_completed_turn_gen:
+            self.last_completed_turn_gen = gen
+
 
 @dataclass
 class TurnBoundary:
@@ -98,14 +115,9 @@ class TurnBoundary:
         if typ == "status":
             state = str(frame.get("state") or "").strip().lower()
             frame_turn = frame_turn_id(frame)
-            if state == "stopped" and self.gate.saw_running:
-                if self.gate.expected_turn_id and not turn_ids_match(
-                    self.gate.expected_turn_id, frame_turn
-                ):
-                    return False, ""
-                return self._mark(TURN_END_STOPPED)
-            if state == "idle" and self.gate.allow_idle_complete(frame_turn):
-                return self._mark(TURN_END_IDLE)
+            if state in {"stopped", "idle"} and self.gate.allow_status_complete(frame_turn):
+                self.gate.note_completed_turn(self.gate.expected_turn_id)
+                return self._mark(TURN_END_STOPPED if state == "stopped" else TURN_END_IDLE)
             return False, ""
 
         if typ == "event":
@@ -119,6 +131,7 @@ class TurnBoundary:
                 and is_turn_end_custom_data(data)
                 and self.gate.allow_stream_end(data_turn)
             ):
+                self.gate.note_completed_turn(self.gate.expected_turn_id)
                 return self._mark(TURN_END_STREAM_END)
         return False, ""
 

{soothe_client_python-1.0.11 → soothe_client_python-1.0.14}/src/soothe_client/appkit/turn_runner.py

@@ -25,7 +25,6 @@ from soothe_client.appkit.loop_session_store import LoopSessionStore, SessionMes
 from soothe_client.appkit.pool import ConnectionPool, PooledConn
 from soothe_client.appkit.query_gate import QueryGate
 from soothe_client.appkit.turn_boundary import TurnBoundary, is_daemon_turn_end_event
-from soothe_client.intent_hints import validate_loop_input_intent_hint
 
 Attachment = dict[str, Any]
 OnComplete = Callable[[str, str, str, str, float], None]
@@ -82,6 +81,7 @@ class InputOpts:
 
     intent_hint: str | None = None
     preferred_subagent: str | None = None
+    intake_scope: str | None = None
     response_schema: dict[str, Any] | None = None
     response_schema_name: str | None = None
     response_schema_strict: bool | None = None
@@ -101,12 +101,11 @@ def input_message_for_loop(
         msg["attachments"] = attachments
     if opts is not None:
         if opts.intent_hint and opts.intent_hint.strip():
-            hint_err = validate_loop_input_intent_hint(opts.intent_hint)
-            if hint_err:
-                raise ValueError(hint_err)
             msg["intent_hint"] = opts.intent_hint.strip()
         if opts.preferred_subagent and opts.preferred_subagent.strip():
             msg["preferred_subagent"] = opts.preferred_subagent.strip()
+        if opts.intake_scope and opts.intake_scope.strip():
+            msg["intake_scope"] = opts.intake_scope.strip()
         if opts.response_schema:
             msg["response_schema"] = opts.response_schema
         if opts.response_schema_name and opts.response_schema_name.strip():

{soothe_client_python-1.0.11 → soothe_client_python-1.0.14}/src/soothe_client/command_client.py

@@ -331,18 +331,12 @@ class AsyncCommandClient:
         goal: str,
         *,
         workspace: str | None = None,
-        autonomous: bool = False,
-        max_iterations: int | None = None,
         guidance: str | None = None,
     ) -> dict[str, Any]:
         """Create a background job (root goal). Returns ``job_id`` + status."""
         payload: dict[str, Any] = {"goal": goal}
         if workspace:
             payload["workspace"] = workspace
-        if autonomous:
-            payload["autonomous"] = autonomous
-        if max_iterations:
-            payload["max_iterations"] = max_iterations
         if guidance:
             payload["guidance"] = guidance
         return await self._send_command("job_create", payload)
@@ -518,8 +512,6 @@ class CommandClient:
         goal: str,
         *,
         workspace: str | None = None,
-        autonomous: bool = False,
-        max_iterations: int | None = None,
         guidance: str | None = None,
     ) -> dict[str, Any]:
         """Create a background job (root goal)."""
@@ -529,8 +521,6 @@ class CommandClient:
                 self._client.job_create(
                     goal,
                     workspace=workspace,
-                    autonomous=autonomous,
-                    max_iterations=max_iterations,
                     guidance=guidance,
                 )
             ),

soothe_client_python-1.0.14/src/soothe_client/intent_hints.py

@@ -0,0 +1,23 @@
+"""``loop_input.intent_hint`` constants."""
+
+from __future__ import annotations
+
+from typing import Final
+
+TEXT_COMPLETION: Final = "text_completion"
+IMAGE_TO_TEXT: Final = "image_to_text"
+OCR: Final = "ocr"
+EMBED: Final = "embed"
+
+# Default deliverable phases for turn-ending replies (excludes plan_direct narration).
+DEFAULT_DELIVERABLE_PHASES: frozenset[str] = frozenset(
+    {
+        "quiz",
+        "goal_completion",
+        "chitchat",
+        "text_completion",
+        "image_to_text",
+        "ocr",
+        "embed",
+    }
+)

{soothe_client_python-1.0.11 → soothe_client_python-1.0.14}/src/soothe_client/protocol_params.py

@@ -194,9 +194,8 @@ class LoopInputParams(ParamsBase):
     Attributes:
         loop_id: Loop identifier (required).
         content: User input text or structured content (required).
-        autonomous: Enable autonomous mode.
-        max_iterations: Max iterations for autonomous mode.
         preferred_subagent: Routing hint.
+        intake_scope: Forced StrangeLoop scope (``trivial``|``simple``|``complex``).
         model: Provider:model override.
         model_params: Additional model parameters.
         router_profile: Named ``router_profiles`` overlay for chat roles this turn.
@@ -212,9 +211,8 @@ class LoopInputParams(ParamsBase):
 
     loop_id: str = Field(..., min_length=1)
     content: str | dict[str, Any] = Field(..., description="User input text or structured content")
-    autonomous: bool = False
-    max_iterations: int | None = Field(default=None, gt=0)
     preferred_subagent: str | None = None
+    intake_scope: str | None = None
     model: str | None = None
     model_params: dict[str, Any] | None = None
     router_profile: str | None = None
@@ -424,8 +422,6 @@ class JobCreateParams(ParamsBase):
         goal: Root goal description (required).
         workspace: Optional workspace path.
         user_id: Optional user identifier.
-        autonomous: Enable autonomous mode.
-        max_iterations: Max iterations.
         guidance: Initial guidance.
         intent_hint: Daemon intent_hint (text_completion, image_to_text, ocr, embed).
     """
@@ -433,8 +429,6 @@ class JobCreateParams(ParamsBase):
     goal: str = Field(..., min_length=1, description="Root goal text")
     workspace: str | None = None
     user_id: str | None = None
-    autonomous: bool = False
-    max_iterations: int | None = Field(default=None, gt=0)
     guidance: str | None = None
     intent_hint: str | None = None
 

{soothe_client_python-1.0.11 → soothe_client_python-1.0.14}/src/soothe_client/session.py

@@ -21,9 +21,6 @@ _CONNECT_TIMEOUT_S = 5.0
 _DAEMON_READY_TIMEOUT_S = 20.0
 _SESSION_BOOTSTRAP_TIMEOUT_S = 30.0
 
-# Wire-compat: interactive loops are always solo; daemon jobs use AutopilotService.
-_LEGACY_LOOP_AUTOPILOT_MODE = "solo"
-
 
 async def connect_websocket_with_retries(client: Any) -> None:
     """Connect a ``WebSocketClient`` with retries (daemon cold-start safe)."""
@@ -181,8 +178,6 @@ async def bootstrap_loop_session(
         "type": "session_ready",
         "loop_id": loop_id,
         "success": True,
-        # Deprecated wire field: interactive loops are always solo.
-        "autopilot_mode": _LEGACY_LOOP_AUTOPILOT_MODE,
     }
     if mapping_data and mapping_data.get("host_root"):
         result["workspace_mapping"] = mapping_data

{soothe_client_python-1.0.11 → soothe_client_python-1.0.14}/src/soothe_client/stream_terminal.py

@@ -105,6 +105,14 @@ def stale_pending_frame_label(event: dict[str, Any]) -> str | None:
     if event_type in STALE_TURN_PENDING_TYPES:
         return event_type
 
+    # Leftover terminal status from the prior turn must not bind/kill the next
+    # reader. Keep ``status=running`` — attach / live-query paths need it.
+    if event_type == "status":
+        state = str(event.get("state") or "").strip().lower()
+        if state in {"idle", "stopped"}:
+            return f"status.{state}"
+        return None
+
     if event_type == "next":
         payload = event.get("payload")
         if not isinstance(payload, dict):
@@ -115,6 +123,10 @@ def stale_pending_frame_label(event: dict[str, Any]) -> str | None:
         inner = payload.get("data")
         if isinstance(inner, dict):
             return stale_pending_frame_label(inner)
+        # Bare status nested under next.payload
+        nested_type = str(payload.get("type") or "")
+        if nested_type == "status":
+            return stale_pending_frame_label(payload)
         return None
 
     if event_type == "event":

{soothe_client_python-1.0.11 → soothe_client_python-1.0.14}/src/soothe_client/turn_boundary.py

@@ -90,7 +90,7 @@ def is_turn_terminal_allowed(
     return turn_ids_match(expected_turn_id, frame_turn_id)
 
 
-def is_idle_terminal_allowed(
+def is_status_terminal_allowed(
     *,
     expected_turn_id: str | None,
     frame_turn_id: str | None,
@@ -98,11 +98,14 @@ def is_idle_terminal_allowed(
     turn_progress_seen: bool,
     cancellation_seen: bool = False,
 ) -> bool:
-    """Gate for ``status=idle`` soft-complete.
+    """Gate for ``status=idle`` / ``status=stopped`` soft-complete.
 
     Requires a bound turn. Matching ``turn_id`` needs progress or cancel.
-    Absent idle ``turn_id`` is allowed only when cancellation was already seen
+    Absent status ``turn_id`` is allowed only when cancellation was already seen
     (legacy cancel finalize); mismatched ids are always rejected.
+
+    ``stopped`` must use the same progress gate as ``idle`` so leftover prior-turn
+    ``stopped`` cannot end a reader that only bound a stale ``status=running``.
     """
     if not query_started or not str(expected_turn_id or "").strip():
         return False
@@ -111,16 +114,63 @@ def is_idle_terminal_allowed(
         if not turn_ids_match(expected_turn_id, cand):
             return False
         return bool(turn_progress_seen or cancellation_seen)
-    # Absent idle turn_id: never end a healthy turn; cancel path only.
+    # Absent status turn_id: never end a healthy turn; cancel path only.
     return bool(cancellation_seen)
 
 
+def is_idle_terminal_allowed(
+    *,
+    expected_turn_id: str | None,
+    frame_turn_id: str | None,
+    query_started: bool,
+    turn_progress_seen: bool,
+    cancellation_seen: bool = False,
+) -> bool:
+    """Gate for ``status=idle`` soft-complete (alias of status terminal rules)."""
+    return is_status_terminal_allowed(
+        expected_turn_id=expected_turn_id,
+        frame_turn_id=frame_turn_id,
+        query_started=query_started,
+        turn_progress_seen=turn_progress_seen,
+        cancellation_seen=cancellation_seen,
+    )
+
+
+def should_bind_running_turn(
+    *,
+    status_turn: str | None,
+    expected_turn_id: str | None,
+    last_completed_turn_gen: int = 0,
+) -> bool:
+    """True when a stamped ``status=running`` may bind/rebind ``expected_turn_id``.
+
+    Refuses generations at or below the last completed floor (leftover prior-turn
+    ``running`` when ``expected`` is still unset) and older gens than the current
+    bind.
+    """
+    if not status_turn:
+        return False
+    new_gen = parse_turn_generation(status_turn)
+    if new_gen is not None and last_completed_turn_gen > 0 and new_gen <= last_completed_turn_gen:
+        return False
+    if expected_turn_id is None:
+        return True
+    old_gen = parse_turn_generation(expected_turn_id)
+    if new_gen is None:
+        return old_gen is None
+    if old_gen is None:
+        return True
+    return new_gen >= old_gen
+
+
 __all__ = [
     "format_turn_id",
     "frame_seq",
     "frame_turn_id",
     "is_idle_terminal_allowed",
+    "is_status_terminal_allowed",
     "is_turn_terminal_allowed",
     "parse_turn_generation",
+    "should_bind_running_turn",
     "turn_ids_match",
 ]

{soothe_client_python-1.0.11 → soothe_client_python-1.0.14}/src/soothe_client/websocket.py

@@ -17,7 +17,6 @@ from soothe_sdk.ux.loop_stream import is_stream_terminal_wire_dict
 from soothe_sdk.wire.protocol import decode_websocket_text, encode_websocket_text
 
 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__)
@@ -939,9 +938,8 @@ class WebSocketClient:
         loop_id: str,
         text: str,
         *,
-        autonomous: bool = False,
-        max_iterations: int | None = None,
         preferred_subagent: str | None = None,
+        intake_scope: str | None = None,
         model: str | None = None,
         model_params: dict[str, Any] | None = None,
         router_profile: str | None = None,
@@ -959,9 +957,10 @@ class WebSocketClient:
         Args:
             loop_id: Loop identifier for the subscribed loop.
             text: User input text.
-            autonomous: Enable autonomous iteration mode.
-            max_iterations: Maximum iterations for autonomous mode.
             preferred_subagent: Preferred subagent hint for routing.
+            intake_scope: Forced StrangeLoop intake scope
+                (``trivial``|``simple``|``complex``). When set, the daemon skips
+                Pass 1 and Pass 2 LLM intake.
             model: Provider:model override string.
             model_params: Additional model parameters.
             router_profile: Named router profile for chat-role overlay this turn.
@@ -974,11 +973,6 @@ class WebSocketClient:
                 ``response_schema`` is supported for ``text_completion`` and
                 ``image_to_text``. Agent-path pass-through hints (e.g.
                 ``resume_clarification``, ``skill:foo``) are forwarded unchanged.
-                Legacy ``direct_llm``, ``quiz``, and ``direct_model`` are rejected
-                before send.
-
-        Raises:
-            ValueError: When ``intent_hint`` is a removed legacy value.
             clarification_mode: clarification relay mode for this turn
                 (``"auto"`` / ``"manual"``). ``None`` lets the daemon fall back
                 to its configured default.
@@ -998,12 +992,10 @@ class WebSocketClient:
             "loop_id": loop_id,
             "content": text,
         }
-        if autonomous:
-            params["autonomous"] = True
-            if max_iterations is not None:
-                params["max_iterations"] = max_iterations
         if preferred_subagent is not None:
             params["preferred_subagent"] = preferred_subagent
+        if intake_scope:
+            params["intake_scope"] = intake_scope
         if model:
             params["model"] = model
         if model_params:
@@ -1013,9 +1005,6 @@ class WebSocketClient:
         if attachments:
             params["attachments"] = attachments
         if intent_hint:
-            hint_error = validate_loop_input_intent_hint(intent_hint)
-            if hint_error is not None:
-                raise ValueError(hint_error)
             params["intent_hint"] = intent_hint
         if response_schema:
             params["response_schema"] = response_schema
@@ -1243,9 +1232,14 @@ class WebSocketClient:
         except Exception as exc:
             raise StaleLoopError(lid, exc) from exc
 
-    async def list_skills(self, *, timeout: float = 15.0) -> dict[str, Any]:
+    async def list_skills(
+        self, *, workspace: str | None = None, timeout: float = 15.0
+    ) -> dict[str, Any]:
         """Request wire-safe skill metadata from the daemon."""
-        return await self.request("skills_list", {}, timeout=timeout)
+        params: dict[str, Any] = {}
+        if workspace:
+            params["workspace"] = str(workspace).strip()
+        return await self.request("skills_list", params, timeout=timeout)
 
     async def list_models(self, *, timeout: float = 15.0) -> dict[str, Any]:
         """Request model catalog rows from the daemon host ``SootheConfig``."""
@@ -1550,6 +1544,10 @@ class WebSocketClient:
         """
         self._pending_events.clear()
 
+    def push_pending_event_front(self, event: dict[str, Any]) -> None:
+        """Re-queue ``event`` at the front of ``_pending_events`` (successor bind)."""
+        self._pending_events.appendleft(event)
+
     def peel_stale_pending_control_events(self) -> list[str]:
         """Remove stale handshake/terminal frames left in ``_pending_events`` before a turn.
 

soothe_client_python-1.0.11/src/soothe_client/intent_hints.py

@@ -1,44 +0,0 @@
-"""``loop_input.intent_hint`` constants and client-side validation."""
-
-from __future__ import annotations
-
-from typing import Final
-
-TEXT_COMPLETION: Final = "text_completion"
-IMAGE_TO_TEXT: Final = "image_to_text"
-OCR: Final = "ocr"
-EMBED: Final = "embed"
-
-# Default deliverable phases for turn-ending replies (excludes plan_direct narration).
-DEFAULT_DELIVERABLE_PHASES: frozenset[str] = frozenset(
-    {
-        "quiz",
-        "goal_completion",
-        "chitchat",
-        "text_completion",
-        "image_to_text",
-        "ocr",
-        "embed",
-    }
-)
-
-_REMOVED_INTENT_HINT_MESSAGES: dict[str, str] = {
-    "direct_llm": (
-        "intent_hint direct_llm is removed; "
-        "use text_completion (text-only) or image_to_text (with attachments)"
-    ),
-    "quiz": "intent_hint quiz is removed; omit intent_hint and let intake classify the turn",
-    "direct_model": (
-        "intent_hint direct_model is removed; use text_completion, image_to_text, ocr, or embed"
-    ),
-}
-
-
-def validate_loop_input_intent_hint(hint: str) -> str | None:
-    """Return an error message when ``hint`` is a removed legacy value.
-
-    Intent-hint values and agent-path pass-through values (e.g.
-    ``resume_clarification``, ``skill:foo``) are allowed.
-    """
-    key = hint.strip().lower()
-    return _REMOVED_INTENT_HINT_MESSAGES.get(key)