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

{soothe_cli-0.7.1 → soothe_cli-0.7.2}/.gitignore

@@ -191,6 +191,15 @@ cython_debug/
 # PyPI configuration file
 .pypirc
 
+# Soothe local runtime data
+.soothe/
+
+# Tool backup files (created by file editing tools)
+.backups/
+
+# Large tool result cache
+large_tool_results/
+
 # Cursor
 #  Cursor is an AI-powered code editor. `.cursorignore` specifies files/directories to
 #  exclude from AI features like autocomplete and code analysis. Recommended for sensitive data
@@ -206,7 +215,6 @@ __marimo__/
 .python-version
 thirdparty/
 .cursor/
-large_tool_results/
 plot_*
 .claude/
 .DS_Store
@@ -216,5 +224,3 @@ manifest.json
 _bmad
 __MACOSX
 .qoder
-.soothe
-.backups/

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: soothe-cli
-Version: 0.7.1
+Version: 0.7.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

{soothe_cli-0.7.1 → soothe_cli-0.7.2}/src/soothe_cli/cli/main.py

@@ -15,6 +15,12 @@ from soothe_sdk.client.config import SOOTHE_HOME  # noqa: E402
 
 from soothe_cli.config.cli_config import CLIConfig  # noqa: E402
 from soothe_cli.config.loader import set_runtime_config  # noqa: E402
+from soothe_cli.tui.markdown_theme import (  # noqa: E402
+    DEFAULT_MARKDOWN_THEME,
+    REGISTRY,
+    load_markdown_theme_preference,
+    markdown_theme_help,
+)
 
 app = typer.Typer(
     name="soothe",
@@ -101,6 +107,16 @@ def main(
             help="Render assistant messages as Markdown in the TUI.",
         ),
     ] = True,
+    markdown_theme: Annotated[
+        str | None,
+        typer.Option(
+            "--markdown-theme",
+            help=(
+                "Markdown appearance preset for TUI cards "
+                f"({markdown_theme_help()}). Default: {DEFAULT_MARKDOWN_THEME}."
+            ),
+        ),
+    ] = None,
     soothe_home: Annotated[
         str | None,
         typer.Option("--soothe-home", help="Soothe home directory (default: ~/.soothe)."),
@@ -168,11 +184,22 @@ def main(
     if mode is not None and mode not in ("manual", "auto"):
         typer.echo(f"Invalid --mode {mode!r}; expected 'manual' or 'auto'.", err=True)
         raise typer.Exit(code=2)
+    if markdown_theme is not None and markdown_theme not in REGISTRY:
+        typer.echo(
+            f"Invalid --markdown-theme {markdown_theme!r}; "
+            f"expected one of: {markdown_theme_help()}.",
+            err=True,
+        )
+        raise typer.Exit(code=2)
+    resolved_markdown_theme = (
+        markdown_theme if markdown_theme is not None else load_markdown_theme_preference()
+    )
     cli_cfg = CLIConfig(
         daemon_host=daemon_host,
         daemon_port=daemon_port,
         logging_level=log_level,
         render_markdown=render_markdown,
+        markdown_theme=resolved_markdown_theme,
         output_streaming_enabled=streaming,
         output_streaming_mode=streaming_mode,
         clarification_mode=mode,

{soothe_cli-0.7.1 → soothe_cli-0.7.2}/src/soothe_cli/config/cli_config.py

@@ -29,6 +29,9 @@ class CLIConfig:
     render_markdown: bool = True
     """Render assistant messages as Markdown in TUI (default True)."""
 
+    markdown_theme: str = "match-app"
+    """Markdown appearance preset (``match-app``, ``langchain``, ``standard``, …)."""
+
     # Output streaming overrides (RFC-614)
     output_streaming_enabled: bool | None = None
     """Override daemon streaming enabled setting."""

{soothe_cli-0.7.1 → soothe_cli-0.7.2}/src/soothe_cli/runtime/policy/essential_events.py

@@ -24,12 +24,13 @@ STEP_COMPLETE_EVENT_TYPES: Final[frozenset[str]] = frozenset(
 )
 
 LOOP_REASON_EVENT_TYPE: Final[str] = "soothe.cognition.strange_loop.reasoned"
+INTENT_CLASSIFIED_EVENT_TYPE: Final[str] = "soothe.cognition.intent.classified"
 
 ESSENTIAL_PROGRESS_EVENT_TYPES: Final[frozenset[str]] = frozenset(
     set(GOAL_START_EVENT_TYPES)
     | set(STEP_START_EVENT_TYPES)
     | set(STEP_COMPLETE_EVENT_TYPES)
-    | {LOOP_REASON_EVENT_TYPE}
+    | {LOOP_REASON_EVENT_TYPE, INTENT_CLASSIFIED_EVENT_TYPE}
 )
 
 
@@ -56,6 +57,7 @@ def is_step_complete_event_type(event_type: str) -> bool:
 __all__ = [
     "ESSENTIAL_PROGRESS_EVENT_TYPES",
     "GOAL_START_EVENT_TYPES",
+    "INTENT_CLASSIFIED_EVENT_TYPE",
     "LOOP_REASON_EVENT_TYPE",
     "STEP_COMPLETE_EVENT_TYPES",
     "STEP_START_EVENT_TYPES",

{soothe_cli-0.7.1 → soothe_cli-0.7.2}/src/soothe_cli/runtime/transport/session.py

@@ -81,7 +81,6 @@ class TuiDaemonSession:
         self._client = WebSocketClient(url=ws_url)
         self._rpc_client = WebSocketClient(url=ws_url)
         self._loop_id: str | None = None
-        self._autopilot_mode: str | None = None
         self._read_lock = asyncio.Lock()
         self._rpc_lock = asyncio.Lock()
         self._rpc_connected = False
@@ -98,11 +97,6 @@ class TuiDaemonSession:
         """Active StrangeLoop id for this WebSocket session."""
         return self._loop_id
 
-    @property
-    def autopilot_mode(self) -> str | None:
-        """Active loop Solo/Autopilot mode when known."""
-        return self._autopilot_mode
-
     async def connect(self, *, resume_loop_id: str | None = None) -> dict[str, Any]:
         """Connect and bootstrap a daemon loop session."""
         await connect_websocket_with_retries(self._client)
@@ -123,8 +117,6 @@ class TuiDaemonSession:
         if status_event.get("type") == "error":
             raise RuntimeError(str(status_event.get("message", "daemon bootstrap failed")))
         self._loop_id = status_event.get("loop_id")
-        mode = status_event.get("autopilot_mode")
-        self._autopilot_mode = str(mode) if mode in ("solo", "autopilot") else None
         return status_event
 
     def _resolve_stream_delivery_mode(self) -> str:

{soothe_cli-0.7.1 → soothe_cli-0.7.2}/src/soothe_cli/runtime/turn/pipeline.py

@@ -35,6 +35,7 @@ T = TypeVar("T")
 _SENTINEL = object()
 
 # Lower number = higher priority (matches asyncio.PriorityQueue ordering).
+PRIORITY_CRITICAL = -1  # step lifecycle / plan progress — never evict from queue
 PRIORITY_HIGH = 0
 PRIORITY_NORMAL = 1
 PRIORITY_LOW = 2
@@ -82,7 +83,7 @@ class TurnApplyBatcher(Generic[T]):
         """
         self._pending.append(prepared)
         priority = getattr(prepared, "priority", PRIORITY_LOW)
-        if priority == PRIORITY_HIGH:
+        if priority <= PRIORITY_HIGH:
             self._high_priority_count += 1
 
         now = time.monotonic()
@@ -129,6 +130,7 @@ class TurnEventPipeline(Generic[T]):
             maxsize=outbound_maxsize
         )
         self._outbound_seq = 0
+        self._outbound_dropped = 0
         self._stop = threading.Event()
         self._thread: threading.Thread | None = None
         self._processor_error: BaseException | None = None
@@ -182,13 +184,105 @@ class TurnEventPipeline(Generic[T]):
         self._thread.start()
 
     def _put_outbound(self, priority: int, item: Any) -> None:
-        """Enqueue a prepared chunk from the processor thread (thread-safe, non-blocking)."""
+        """Enqueue a prepared chunk from the processor thread (thread-safe).
+
+        When the outbound queue is full, evict the lowest-priority buffered chunk
+        (streaming text) instead of dropping the incoming chunk. Step lifecycle
+        events use ``PRIORITY_CRITICAL`` and are never evicted.
+        """
         seq = self._outbound_seq
         self._outbound_seq += 1
+        entry = (priority, seq, item)
+        try:
+            self._outbound.put_nowait(entry)
+            return
+        except queue.Full:
+            pass
+
+        if not self._evict_outbound_drop_candidate(incoming_priority=priority):
+            if priority <= PRIORITY_HIGH:
+                # Block briefly so the applier can drain HIGH/CRITICAL backlog.
+                try:
+                    self._outbound.put(entry, block=True, timeout=5.0)
+                    return
+                except queue.Full:
+                    logger.warning(
+                        "Turn outbound queue still full after wait; dropping prepared chunk "
+                        "(priority=%d)",
+                        priority,
+                    )
+                    self._outbound_dropped += 1
+                    return
+            logger.warning(
+                "Turn outbound queue full; dropping low-priority prepared chunk (priority=%d)",
+                priority,
+            )
+            self._outbound_dropped += 1
+            return
+
         try:
-            self._outbound.put_nowait((priority, seq, item))
+            self._outbound.put_nowait(entry)
         except queue.Full:
-            logger.warning("Turn outbound queue full; dropping prepared chunk")
+            if priority <= PRIORITY_HIGH:
+                try:
+                    self._outbound.put(entry, block=True, timeout=5.0)
+                except queue.Full:
+                    logger.warning(
+                        "Turn outbound queue full after eviction; dropping prepared chunk "
+                        "(priority=%d)",
+                        priority,
+                    )
+                    self._outbound_dropped += 1
+            else:
+                logger.warning(
+                    "Turn outbound queue full after eviction; dropping prepared chunk "
+                    "(priority=%d)",
+                    priority,
+                )
+                self._outbound_dropped += 1
+
+    def _evict_outbound_drop_candidate(self, *, incoming_priority: int) -> bool:
+        """Drop one evictable chunk from the outbound queue to make room.
+
+        Returns:
+            True when a chunk was evicted and the caller should retry ``put_nowait``.
+        """
+        temp: list[tuple[int, int, Any]] = []
+        drop_target: tuple[int, int, Any] | None = None
+        drop_priority = PRIORITY_CRITICAL - 1
+
+        while True:
+            try:
+                temp.append(self._outbound.get_nowait())
+            except queue.Empty:
+                break
+
+        for queued in temp:
+            queued_priority = queued[0]
+            if queued_priority > drop_priority:
+                drop_priority = queued_priority
+                drop_target = queued
+
+        # Never evict CRITICAL/HIGH; only drop NORMAL/LOW when admitting progress events.
+        min_evictable = PRIORITY_NORMAL if incoming_priority <= PRIORITY_HIGH else PRIORITY_LOW
+        if drop_target is None or drop_priority < min_evictable:
+            for queued in temp:
+                self._outbound.put_nowait(queued)
+            return False
+
+        self._outbound_dropped += 1
+        if self._outbound_dropped == 1 or self._outbound_dropped % 500 == 0:
+            logger.warning(
+                "Turn outbound queue overflow: evicted buffered chunk (priority=%d, dropped=%d)",
+                drop_priority,
+                self._outbound_dropped,
+            )
+
+        for queued in temp:
+            if queued is drop_target:
+                continue
+            self._outbound.put_nowait(queued)
+        return True
 
     async def iter_prepared(self) -> AsyncIterator[T]:
         """Yield prepared chunk plans until the stream ends."""
@@ -296,6 +390,7 @@ async def run_turn_pipeline(
 
 
 __all__ = [
+    "PRIORITY_CRITICAL",
     "PRIORITY_HIGH",
     "PRIORITY_LOW",
     "PRIORITY_NORMAL",

{soothe_cli-0.7.1 → soothe_cli-0.7.2}/src/soothe_cli/runtime/turn/prepare.py

@@ -24,7 +24,12 @@ from soothe_sdk.ux.stream_tool_wire import STREAM_TOOL_CALL_UPDATE, TOOL_CALL_UP
 
 from soothe_cli.runtime.presentation.engine import PresentationEngine
 from soothe_cli.runtime.state.session_stats import TurnEventStats
-from soothe_cli.runtime.turn.pipeline import PRIORITY_HIGH, PRIORITY_LOW, PRIORITY_NORMAL
+from soothe_cli.runtime.turn.pipeline import (
+    PRIORITY_CRITICAL,
+    PRIORITY_HIGH,
+    PRIORITY_LOW,
+    PRIORITY_NORMAL,
+)
 from soothe_cli.runtime.wire.chunk_filter import (
     message_has_tool_invocation_metadata,
     updates_chunk_is_noop,
@@ -154,6 +159,16 @@ def _prepare_custom_chunk(
         prepared.priority = PRIORITY_HIGH
         return prepared
 
+    if event_type in (
+        STRANGE_LOOP_STEP_STARTED,
+        STRANGE_LOOP_STEP_QUEUED,
+        STRANGE_LOOP_STEP_COMPLETED,
+        STRANGE_LOOP_PLAN_DECISION,
+    ):
+        prepared.priority = PRIORITY_CRITICAL
+        prepared.skip_custom_progress = True
+        return prepared
+
     if event_type in _MAIN_LOOP_CUSTOM_TYPES or event_type == TOOL_CALL_UPDATES_BATCH:
         prepared.priority = PRIORITY_HIGH
         prepared.skip_custom_progress = True

{soothe_cli-0.7.1 → soothe_cli-0.7.2}/src/soothe_cli/tui/app/_app.py

@@ -173,7 +173,6 @@ class SootheApp(
         # Active StrangeLoop id; LangGraph stores it as configurable.thread_id.
         # Named `_lc_loop_id` to avoid colliding with Textual's App._thread_id.
         self._lc_loop_id = resume_loop_id
-        self._loop_autopilot_mode: str = "solo"
 
         self._initial_prompt = initial_prompt
 
@@ -244,6 +243,9 @@ class SootheApp(
 
         self._loading_widget: LoadingWidget | None = None
 
+        self._connect_spinner_start_mono: float | None = None
+        """Monotonic anchor for startup daemon-connect elapsed time in the thinking row."""
+
         self._context_tokens: int = 0
         """Local cache of the last total-context token count.
 

{soothe_cli-0.7.1 → soothe_cli-0.7.2}/src/soothe_cli/tui/app/_execution.py

@@ -578,7 +578,6 @@ class _ExecutionMixin:
                     )
                     self._session_state.loop_id = new_loop_id
                     self._lc_loop_id = new_loop_id
-                    self._apply_loop_autopilot_mode(status_event.get("autopilot_mode"))
                     try:
                         banner = self.query_one("#welcome-banner", WelcomeBanner)
                         banner.update_loop_id(new_loop_id)

{soothe_cli-0.7.1 → soothe_cli-0.7.2}/src/soothe_cli/tui/app/_model.py

@@ -259,15 +259,6 @@ class _ModelMixin:
             return None
         return resp.get("servers")
 
-    def _apply_loop_autopilot_mode(self, mode: str | None) -> None:
-        """Sync local Solo/Autopilot mode from daemon bootstrap or toggle events."""
-        if mode not in ("solo", "autopilot"):
-            return
-        self._loop_autopilot_mode = mode
-        if self._status_bar is not None:
-            label = "Autopilot" if mode == "autopilot" else "Solo"
-            self._status_bar.set_session_tip(f"Mode: {label}")
-
     async def _show_context_viewer(self) -> None:
         """Show context engine goal DAG and status as a modal screen."""
         from soothe_cli.tui.widgets.context_viewer import ContextViewerScreen

{soothe_cli-0.7.1 → soothe_cli-0.7.2}/src/soothe_cli/tui/app/_startup.py

@@ -35,6 +35,11 @@ from soothe_cli.tui.widgets.welcome import WelcomeBanner
 
 logger = logging.getLogger(__name__)
 
+# Cold-start: daemon may bind WebSocket ~30s after PID file (CoreAgent pool warmup).
+_DAEMON_READY_TIMEOUT_S = 60.0
+_DAEMON_CONNECT_MAX_ATTEMPTS = 3
+_DAEMON_CONNECT_RETRY_DELAY_S = 2.0
+
 
 class _StartupMixin:
     """Startup, server/daemon workers, skills discovery, prewarm and update methods."""
@@ -405,51 +410,105 @@ class _StartupMixin:
 
         return await discover_skills_async(daemon_config=self._daemon_config)
 
+    @staticmethod
+    def _daemon_connect_attempt_label(*, phase: str, attempt: int, max_attempts: int) -> str:
+        """Format a daemon-connect spinner label with attempt progress.
+
+        The first try shows only ``phase``; attempt suffixes appear after a
+        timeout or failure triggers a retry.
+        """
+        if max_attempts <= 1 or attempt <= 1:
+            return phase
+        return f"{phase} (attempt {attempt}/{max_attempts})"
+
     async def _connect_daemon_background(self) -> None:
         """Background worker: connect the TUI directly to the daemon."""
         from soothe_cli.tui.textual_adapter import (
-            SPINNER_LABEL_CONNECTING_DAEMON,
             SPINNER_LABEL_WAITING_AGENT_READY,
         )
 
-        await self._set_spinner(SPINNER_LABEL_WAITING_AGENT_READY, show_interrupt_hint=False)
-        try:
-            from soothe_sdk.client import (
-                is_daemon_live,
-                websocket_url_from_config,
+        for attempt in range(1, _DAEMON_CONNECT_MAX_ATTEMPTS + 1):
+            waiting_label = self._daemon_connect_attempt_label(
+                phase=SPINNER_LABEL_WAITING_AGENT_READY,
+                attempt=attempt,
+                max_attempts=_DAEMON_CONNECT_MAX_ATTEMPTS,
             )
+            await self._set_spinner(waiting_label, show_interrupt_hint=False)
+            try:
+                session, status_event = await self._connect_daemon_once(attempt=attempt)
+            except Exception as exc:
+                if attempt < _DAEMON_CONNECT_MAX_ATTEMPTS:
+                    logger.warning(
+                        "Daemon connect attempt %d/%d failed: %s",
+                        attempt,
+                        _DAEMON_CONNECT_MAX_ATTEMPTS,
+                        exc,
+                    )
+                    await asyncio.sleep(_DAEMON_CONNECT_RETRY_DELAY_S)
+                    continue
+                self.post_message(self.ServerStartFailed(error=exc))
+                return
 
-            from soothe_cli.runtime.transport.session import TuiDaemonSession
+            self.post_message(self.DaemonReady(session=session, status_event=status_event))
+            return
 
-            ws_url = websocket_url_from_config(self._daemon_config)
+    async def _connect_daemon_once(
+        self,
+        *,
+        attempt: int,
+    ) -> tuple[Any, dict[str, Any]]:
+        """Wait for daemon readiness and bootstrap one TUI session.
 
-            # Check daemon status via WebSocket RPC (IG-174 Phase 1)
-            # Wait for daemon to be fully ready, not just port-live (IG-489)
-            daemon_live = await is_daemon_live(
-                ws_url, timeout=5.0, wait_for_ready=True, ready_timeout=30.0
-            )
+        Args:
+            attempt: Current connect attempt (1-based).
 
-            if not daemon_live:
-                # CLI does NOT control daemon start/stop per architectural separation (IG-174/IG-175)
-                # Show helpful error message instead
-                raise ConnectionError(
-                    f"Soothe daemon not running at {ws_url}. "
-                    f"Please start the daemon with: soothed start"
-                )
+        Returns:
+            Tuple of ``(TuiDaemonSession, status_event)``.
 
-            await self._set_spinner(SPINNER_LABEL_CONNECTING_DAEMON, show_interrupt_hint=False)
+        Raises:
+            ConnectionError: If the daemon is not reachable or ready in time.
+            Exception: If loop bootstrap fails.
+        """
+        from soothe_sdk.client import (
+            is_daemon_live,
+            websocket_url_from_config,
+        )
+
+        from soothe_cli.runtime.transport.session import TuiDaemonSession
+        from soothe_cli.tui.textual_adapter import SPINNER_LABEL_CONNECTING_DAEMON
+
+        ws_url = websocket_url_from_config(self._daemon_config)
 
-            session = TuiDaemonSession(
-                self._daemon_config,
-                workspace=self._cwd,
-                post_idle_drain_deadline=0.3,
+        # Check daemon status via WebSocket RPC (IG-174 Phase 1)
+        # Wait for daemon to be fully ready, not just port-live (IG-489)
+        daemon_live = await is_daemon_live(
+            ws_url,
+            timeout=5.0,
+            wait_for_ready=True,
+            ready_timeout=_DAEMON_READY_TIMEOUT_S,
+        )
+
+        if not daemon_live:
+            # CLI does NOT control daemon start/stop per architectural separation (IG-174/IG-175)
+            raise ConnectionError(
+                f"Soothe daemon not running at {ws_url}. "
+                f"Please start the daemon with: soothed start"
             )
-            status_event = await session.connect(resume_loop_id=self._lc_loop_id)
-        except Exception as exc:
-            self.post_message(self.ServerStartFailed(error=exc))
-            return
 
-        self.post_message(self.DaemonReady(session=session, status_event=status_event))
+        connecting_label = self._daemon_connect_attempt_label(
+            phase=SPINNER_LABEL_CONNECTING_DAEMON,
+            attempt=attempt,
+            max_attempts=_DAEMON_CONNECT_MAX_ATTEMPTS,
+        )
+        await self._set_spinner(connecting_label, show_interrupt_hint=False)
+
+        session = TuiDaemonSession(
+            self._daemon_config,
+            workspace=self._cwd,
+            post_idle_drain_deadline=0.3,
+        )
+        status_event = await session.connect(resume_loop_id=self._lc_loop_id)
+        return session, status_event
 
     def on_soothe_app_daemon_ready(self, event: DaemonReady) -> None:
         """Handle successful daemon bootstrap for the TUI."""
@@ -463,13 +522,6 @@ class _StartupMixin:
             if self._session_state is not None:
                 self._session_state.loop_id = status_loop_id
 
-        autopilot_mode = event.status_event.get("autopilot_mode")
-        if autopilot_mode not in ("solo", "autopilot") and event.session is not None:
-            autopilot_mode = getattr(event.session, "autopilot_mode", None)
-        self._apply_loop_autopilot_mode(
-            str(autopilot_mode) if autopilot_mode in ("solo", "autopilot") else None
-        )
-
         try:
             banner = self.query_one("#welcome-banner", WelcomeBanner)
             banner.set_connected(self._mcp_tool_count)

{soothe_cli-0.7.1 → soothe_cli-0.7.2}/src/soothe_cli/tui/app/_ui.py

@@ -313,13 +313,20 @@ class _UIMixin:
             if self._loading_widget:
                 await self._loading_widget.remove()
                 self._loading_widget = None
+            self._connect_spinner_start_mono = None
             return
 
         thinking_status = self.query_one("#thinking-status", Container)
 
+        connect_start_mono: float | None = None
+        if not self._agent_running:
+            if self._connect_spinner_start_mono is None:
+                self._connect_spinner_start_mono = _monotonic()
+            connect_start_mono = self._connect_spinner_start_mono
+
         if self._loading_widget is None:
             # Create new
-            turn_mono = self._inflight_turn_start if self._agent_running else None
+            turn_mono = self._inflight_turn_start if self._agent_running else connect_start_mono
             self._loading_widget = LoadingWidget(
                 status,
                 turn_start_mono=turn_mono,
@@ -329,6 +336,12 @@ class _UIMixin:
         else:
             if self._agent_running:
                 self._loading_widget.set_turn_start_mono(self._inflight_turn_start)
+            elif connect_start_mono is not None:
+                self._loading_widget.set_turn_start_mono(connect_start_mono)
+            if self._loading_widget.parent is not thinking_status:
+                if self._loading_widget.is_attached:
+                    await self._loading_widget.remove()
+                await thinking_status.mount(self._loading_widget)
             # Update existing (also clears a clarification pause)
             self._loading_widget.activate_status(status, show_interrupt_hint=show_interrupt_hint)
         # NOTE: Don't call anchor() here - it would re-anchor and drag user back

{soothe_cli-0.7.1 → soothe_cli-0.7.2}/src/soothe_cli/tui/binding.py

@@ -111,7 +111,6 @@ def message_to_widget(data: MessageData) -> Widget:
 
         case MessageType.COGNITION_REASON:
             return CognitionReasonMessage(
-                next_action=data.cognition_plan_next_action or "",
                 status=data.cognition_plan_status or "",
                 iteration=int(data.cognition_plan_iteration or 0),
                 plan_action=data.cognition_plan_action or "",
@@ -198,7 +197,6 @@ def message_from_widget(widget: Widget) -> MessageData:
             type=MessageType.COGNITION_REASON,
             content="",
             id=widget_id,
-            cognition_plan_next_action=widget._next_action,
             cognition_plan_status=widget._status,
             cognition_plan_iteration=widget._iteration,
             cognition_plan_action=widget._plan_action,

{soothe_cli-0.7.1 → soothe_cli-0.7.2}/src/soothe_cli/tui/commands/slash_commands.py

@@ -240,13 +240,6 @@ COMMANDS: dict[str, dict[str, Any]] = {
         "description": "Submit autopilot job (usage: /autopilot <task>)",
         "requires_query": True,
     },
-    "/autopilot-toggle": {
-        "location": "daemon",
-        "type": "rpc",
-        "daemon_command": "autopilot_toggle",
-        "description": "Toggle autopilot mode (solo ↔ autopilot)",
-        "requires_loop": True,
-    },
     # Daemon routing commands (3)
     "/plan": {"location": "daemon", "type": "routing", "description": "Trigger plan mode"},
     "/tacitus": {