soothe-cli 0.5.26__tar.gz → 0.5.28__tar.gz

{soothe_cli-0.5.26 → soothe_cli-0.5.28}/.gitignore

@@ -217,3 +217,4 @@ _bmad
 __MACOSX
 .qoder
 .soothe
+deploy/config.yml

{soothe_cli-0.5.26 → soothe_cli-0.5.28}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: soothe-cli
-Version: 0.5.26
+Version: 0.5.28
 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.5.26 → soothe_cli-0.5.28}/src/soothe_cli/cli/execution/daemon.py

@@ -91,7 +91,6 @@ async def _run_headless_session_once(
         status_event = await bootstrap_loop_session(
             client,
             resume_loop_id=resume_loop_id,
-            verbosity="normal",
             stream_delivery=stream_delivery,
             workspace=cli_ws,
             subscribe_timeout_s=_SESSION_BOOTSTRAP_TIMEOUT_S,

{soothe_cli-0.5.26 → soothe_cli-0.5.28}/src/soothe_cli/cli/main.py

@@ -120,6 +120,17 @@ def main(
             help="Path to additional MCP server config (JSON/YAML) to merge into daemon config.",
         ),
     ] = None,
+    mode: Annotated[
+        str | None,
+        typer.Option(
+            "--mode",
+            help=(
+                "Clarification mode: 'manual' (relay AI questions to you) or "
+                "'auto' (veritas auto-answers). Default: 'manual' when stdin is "
+                "a TTY, 'auto' otherwise."
+            ),
+        ),
+    ] = None,
     show_help: Annotated[  # noqa: FBT002
         bool,
         typer.Option("--help", "-h", is_flag=True, help="Show this message and exit."),
@@ -154,6 +165,9 @@ def main(
         raise typer.Exit
 
     home_path = Path(soothe_home).expanduser() if soothe_home else Path(SOOTHE_HOME)
+    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)
     cli_cfg = CLIConfig(
         daemon_host=daemon_host,
         daemon_port=daemon_port,
@@ -161,6 +175,7 @@ def main(
         render_markdown=render_markdown,
         output_streaming_enabled=streaming,
         output_streaming_mode=streaming_mode,
+        clarification_mode=mode,
         soothe_home=home_path,
     )
     set_runtime_config(cli_cfg)

{soothe_cli-0.5.26 → soothe_cli-0.5.28}/src/soothe_cli/config/cli_config.py

@@ -37,6 +37,10 @@ class CLIConfig:
     output_streaming_mode: str | None = None
     """Override daemon streaming mode: 'streaming' or 'batch'."""
 
+    # RFC-622: clarification relay mode
+    clarification_mode: str | None = None
+    """'manual' (relay to human) or 'auto' (veritas auto-answer). None = auto-detect from TTY."""
+
     # Paths
     soothe_home: Path = field(default_factory=lambda: Path(SOOTHE_HOME))
 

{soothe_cli-0.5.26 → soothe_cli-0.5.28}/src/soothe_cli/runtime/headless/processor.py

@@ -273,8 +273,6 @@ class EventProcessor:
         """Display logic for RFC-614 loop-tagged assistant messages (IG-317 / IG-343)."""
         if phase not in LOOP_ASSISTANT_OUTPUT_PHASES:
             return
-        if not self._presentation.tier_visible(VerbosityTier.QUIET):
-            return
 
         accum_key = _loop_msg_accum_event_key(phase)
         streaming_config = self._get_effective_streaming_config()
@@ -925,8 +923,7 @@ class EventProcessor:
         etype = data.get("type", "")
 
         if self._headless_output:
-            category = classify_event_to_tier(etype, namespace)
-            if category == VerbosityTier.QUIET and "error" in etype:
+            if etype.startswith("soothe.error."):
                 error_text = data.get("error", data.get("message", str(etype)))
                 self._renderer.on_error(error_text)
             return
@@ -938,7 +935,7 @@ class EventProcessor:
         # Update plan state and call specific hooks
         if etype == PLAN_CREATED:
             self._handle_plan_created(data)
-        elif category == VerbosityTier.QUIET and "error" in etype:
+        elif etype.startswith("soothe.error."):
             error_text = data.get("error", data.get("message", str(etype)))
             self._renderer.on_error(error_text)
         elif self._presentation.tier_visible(category):

{soothe_cli-0.5.26 → soothe_cli-0.5.28}/src/soothe_cli/runtime/policy/display_policy.py

@@ -38,13 +38,10 @@ from soothe_sdk.ux import classify_event_to_tier
 # Event types that should NEVER be shown (internal implementation details)
 INTERNAL_EVENT_TYPES: frozenset[str] = frozenset()
 
-# Event types to skip in progress display (handled by plan update mechanism or not rendered)
-SKIP_EVENT_TYPES = frozenset(
-    {
-        # Plan events handled by renderer's plan update mechanism
-        "soothe.cognition.plan.batch.started",
-    }
-)
+# Event types to skip in progress display (handled by plan update mechanism or not rendered).
+# `soothe.cognition.plan.batch.started` was moved to `soothe.internal.plan.batch.started`
+# and is now filtered automatically by `is_internal_event`.
+SKIP_EVENT_TYPES: frozenset[str] = frozenset()
 
 PLAN_EVENT_TYPES = frozenset(
     {
@@ -152,7 +149,7 @@ class DisplayPolicy:
 
     def is_internal_event(self, event_type: str) -> bool:
         """Check if this is an internal (never-shown) event."""
-        return event_type in INTERNAL_EVENT_TYPES or "internal" in event_type
+        return event_type in INTERNAL_EVENT_TYPES or event_type.startswith("soothe.internal.")
 
 
 # =============================================================================

{soothe_cli-0.5.26 → soothe_cli-0.5.28}/src/soothe_cli/runtime/transport/session.py

@@ -64,7 +64,6 @@ class TuiDaemonSession:
         status_event = await bootstrap_loop_session(
             self._client,
             resume_loop_id=resume_loop_id,
-            verbosity="normal",
             stream_delivery=stream_delivery,
             workspace=self._workspace,
         )
@@ -147,6 +146,9 @@ class TuiDaemonSession:
         model: str | None = None,
         model_params: dict[str, Any] | None = None,
         attachments: list[dict[str, str]] | None = None,
+        clarification_mode: str | None = None,
+        clarification_answer: bool = False,
+        clarification_answers: list[str] | None = None,
     ) -> None:
         """Send a new user turn to the daemon."""
         if not self._loop_id:
@@ -160,6 +162,9 @@ class TuiDaemonSession:
             model=model,
             model_params=model_params,
             attachments=attachments,
+            clarification_mode=clarification_mode,
+            clarification_answer=clarification_answer,
+            clarification_answers=clarification_answers,
         )
 
     async def cancel_remote_query(self) -> None:
@@ -343,16 +348,31 @@ class TuiDaemonSession:
             await self._ensure_rpc_connected()
             return await self._rpc_client.get_mcp_status(timeout=15.0)
 
-    async def invoke_skill(self, skill: str, args: str = "") -> dict[str, Any]:
+    async def invoke_skill(
+        self,
+        skill: str,
+        args: str = "",
+        *,
+        clarification_mode: str | None = None,
+    ) -> dict[str, Any]:
         """Resolve ``SKILL.md`` on the daemon and receive UI echo before the turn streams.
 
         Uses the loop WebSocket (``_client``), not the metadata RPC socket. The daemon
         enqueues the composed prompt on ``_client_subscribed_loop_id``; the RPC-only
         connection never receives ``loop_subscribe``, so skill turns would otherwise
         never start (no ``loop_input`` queue entry).
+
+        ``clarification_mode`` is forwarded so slash-skill turns honor the
+        TUI's Manual/Auto badge instead of always falling back to the daemon's
+        configured default (RFC-622).
         """
         async with self._read_lock:
-            return await self._client.invoke_skill(skill, args, timeout=120.0)
+            return await self._client.invoke_skill(
+                skill,
+                args,
+                timeout=120.0,
+                clarification_mode=clarification_mode,
+            )
 
     async def _ensure_rpc_connected(self) -> None:
         """Ensure dedicated RPC client is connected."""
@@ -404,6 +424,7 @@ class TuiDaemonSession:
         values: dict[str, Any],
         *,
         timeout: float = 10.0,
+        as_node: str | None = None,
     ) -> None:
         """Merge partial state into the loop on the daemon host (``loop_state_update`` RPC).
 
@@ -411,6 +432,9 @@ class TuiDaemonSession:
             loop_id: AgentLoop id.
             values: Channel updates (e.g. ``messages``) in JSON-serializable form.
             timeout: RPC wait budget in seconds.
+            as_node: Optional LangGraph node to attribute the write to. When
+                omitted, the daemon picks a sensible default for the underlying
+                agent graph.
         """
         lid = str(loop_id or "").strip()
         if not lid:
@@ -420,14 +444,18 @@ class TuiDaemonSession:
         if not isinstance(payload_values, dict):
             return
 
+        payload: dict[str, Any] = {
+            "type": "loop_state_update",
+            "loop_id": lid,
+            "values": payload_values,
+        }
+        if as_node:
+            payload["as_node"] = as_node
+
         async with self._rpc_lock:
             await self._ensure_rpc_connected()
             await self._rpc_client.request_response(
-                {
-                    "type": "loop_state_update",
-                    "loop_id": lid,
-                    "values": payload_values,
-                },
+                payload,
                 response_type="loop_state_update_response",
                 timeout=timeout,
             )

{soothe_cli-0.5.26 → soothe_cli-0.5.28}/src/soothe_cli/runtime/turn/prepare.py

@@ -18,7 +18,6 @@ from soothe_sdk.core.events import (
     AGENT_LOOP_STEP_QUEUED,
     AGENT_LOOP_STEP_STARTED,
 )
-from soothe_sdk.core.verbosity import VerbosityTier
 from soothe_sdk.ux.classification import classify_event_to_tier
 from soothe_sdk.ux.loop_stream import assistant_output_phase
 from soothe_sdk.ux.stream_tool_wire import STREAM_TOOL_CALL_UPDATE, TOOL_CALL_UPDATES_BATCH
@@ -165,7 +164,8 @@ def _prepare_custom_chunk(
         prepared.skip = True
         return prepared
 
-    if category == VerbosityTier.QUIET and "error" not in event_type:
+    # Output events have a dedicated renderer path; drop the generic copy.
+    if event_type.startswith("soothe.output."):
         prepared.skip = True
         return prepared
 

{soothe_cli-0.5.26 → soothe_cli-0.5.28}/src/soothe_cli/tui/app/_app.py

@@ -203,6 +203,10 @@ class SootheApp(
 
         self._model_params_override: dict[str, Any] | None = None
 
+        # RFC-622: clarification relay mode. Seeded from --mode flag (CLIConfig);
+        # default to Auto so loops keep moving when the user hasn't opted in.
+        self._clarification_mode: str = getattr(daemon_config, "clarification_mode", None) or "auto"
+
         self._mcp_tool_count = sum(len(s.tools) for s in (mcp_server_info or []))
 
         self._status_bar: StatusBar | None = None
@@ -352,6 +356,4 @@ class SootheApp(
                 image_tracker=self._image_tracker,
                 id="input-area",
             )
-
-        # Status bar at bottom
-        yield StatusBar(cwd=self._cwd, id="status-bar")
+            yield StatusBar(cwd=self._cwd, id="status-bar")

{soothe_cli-0.5.26 → soothe_cli-0.5.28}/src/soothe_cli/tui/app/_execution.py

@@ -40,6 +40,7 @@ from soothe_cli.tui.widgets.chat_input import ChatInput
 from soothe_cli.tui.widgets.messages import (
     AppMessage,
     AssistantMessage,
+    ClarificationInputMessage,
     ErrorMessage,
     QueuedUserMessage,
     UserMessage,
@@ -188,6 +189,65 @@ class _ExecutionMixin:
         if self._status_bar:
             self._status_bar.set_mode(event.mode)
 
+    async def on_clarification_input_message_submitted(
+        self,
+        event: ClarificationInputMessage.Submitted,
+    ) -> None:
+        """Forward a clarification answer to the daemon and refresh the step card.
+
+        Wired to ``ClarificationInputMessage.Submitted`` (RFC-622). The inline
+        widget collects per-question answers; here we render them on the
+        matching step card and trigger ``_run_agent_task`` with the answer
+        text. ``execute_task_textual`` reads ``adapter._clarification_pending``
+        and attaches ``clarification_answer=True`` to the wire so the daemon
+        resumes the suspended loop graph rather than starting a new turn.
+        """
+        event.stop()
+        adapter = self._ui_adapter
+        if adapter is None:
+            return
+
+        # Render answers on the corresponding step card so the user sees
+        # confirmation in-place. ``set_clarification_details`` handles styling
+        # and the detail-area layout.
+        step_widget = adapter._current_step_messages.get(event.step_id)
+        if step_widget is not None:
+            try:
+                step_widget.set_clarification_details(
+                    questions=list(event.questions),
+                    answers=list(event.answers),
+                    source="human",
+                    confidence=None,
+                )
+            except Exception:  # noqa: BLE001
+                logger.debug("Failed to render clarification answers on step card", exc_info=True)
+
+        # Drop tracking; the inline widget itself stays mounted (disabled) so
+        # the user can still see what they answered.
+        adapter._clarification_input_by_step.pop(event.step_id, None)
+
+        non_empty = [a for a in event.answers if a.strip()]
+        if not non_empty:
+            return
+        # Send the answers as a structured list so the daemon resumes the
+        # graph with one answer per question instead of broadcasting a single
+        # concatenated string. ``content`` carries a human-readable summary
+        # for clients that look at it; the authoritative payload is the
+        # ``clarification_answers`` wire field.
+        payload_text = (
+            non_empty[0]
+            if len(non_empty) == 1
+            else " | ".join(f"A{i + 1}: {a}" for i, a in enumerate(event.answers) if a.strip())
+        )
+        adapter._clarification_answers_pending = list(event.answers)
+
+        # Hand off to the standard turn pipeline. ``execute_task_textual``
+        # snapshots ``adapter._clarification_pending`` (still True) and sets
+        # the wire ``clarification_answer`` flag plus the ``clarification_answers``
+        # list, then clears the persisted flag so a follow-up turn is treated
+        # as a new goal.
+        await self._run_agent_task(payload_text)
+
     async def _handle_shell_command(self, command: str) -> None:
         """Handle a shell command (! prefix).
 
@@ -821,6 +881,7 @@ class _ExecutionMixin:
                 ),
                 turn_stats=turn_stats,
                 skip_daemon_send_turn=skip_daemon_send_turn,
+                clarification_mode=getattr(self, "_clarification_mode", None),
             )
         except Exception as e:  # Resilient tool rendering
             logger.exception("Agent execution failed")

{soothe_cli-0.5.26 → soothe_cli-0.5.28}/src/soothe_cli/tui/app/_messages_mixin.py

@@ -396,17 +396,14 @@ class _MessagesMixin:
         """Handle Ctrl+C - interrupt agent or quit on double press.
 
         Priority order:
-        0. If text is selected, copy it (Textual screen.copy_text semantics)
         1. If shell command is running, kill it
         2. If agent is running, interrupt it (preserve input)
         3. If double press (quit_pending), quit
         4. Otherwise clear draft input and show quit hint
-        """
-        from soothe_cli.tui.widgets.clipboard import copy_selection_to_clipboard
 
-        if copy_selection_to_clipboard(self):
-            self._quit_pending = False
-            return
+        Note: Copying selected text is bound to Ctrl+Y (`action_copy_selection`)
+        so Ctrl+C is reserved for interrupt/quit only.
+        """
         # If shell command is running, cancel the worker
         if self._shell_running and self._shell_worker:
             self._cancel_worker(self._shell_worker)
@@ -572,11 +569,34 @@ class _MessagesMixin:
         super().exit(result=result, return_code=return_code, message=message)
 
     def action_shift_tab(self) -> None:
-        """Shift+Tab: navigate loop selector filters."""
+        """Shift+Tab: navigate loop selector when active, otherwise flip relay mode.
+
+        - In the LoopSelectorScreen, defer to its filter navigation.
+        - On the main screen, toggle the clarification relay mode
+          (Auto ↔ Manual) so users can switch between the veritas
+          auto-answerer and human-in-the-loop relay at any point (RFC-622).
+        """
         from soothe_cli.tui.widgets.loop_selector import LoopSelectorScreen
 
         if isinstance(self.screen, LoopSelectorScreen):
             self.screen.action_focus_previous_filter()
+            return
+        self.toggle_clarification_mode()
+
+    def toggle_clarification_mode(self) -> None:
+        """Flip clarification mode between Auto and Manual and refresh the badge.
+
+        The new mode is held on the app (``self._clarification_mode``) and
+        attached to every subsequent ``send_turn`` via the
+        ``clarification_mode`` field of the daemon's ``loop_input`` payload
+        (RFC-622). The status-bar badge updates immediately; no toast is
+        emitted because the badge itself is the visual feedback.
+        """
+        current = getattr(self, "_clarification_mode", "auto")
+        new_mode = "manual" if current == "auto" else "auto"
+        self._clarification_mode = new_mode
+        if self._status_bar is not None:
+            self._status_bar.set_clarification_mode(new_mode)
 
     def action_toggle_tool_output(self) -> None:
         """Toggle expand/collapse of the most recent skill or tool card."""
@@ -648,16 +668,30 @@ class _MessagesMixin:
         When the user opens a link via `webbrowser.open`, OS focus shifts to
         the browser. On returning to the terminal, Textual fires `AppFocus`
         (requires a terminal that supports FocusIn events). Re-focusing the chat
-        input here keeps it ready for typing.
+        input here keeps it ready for typing — but only when no other focusable
+        widget (e.g., an inline clarification Input) currently owns focus, so
+        the user does not lose an in-progress answer to a tab-out and back.
         """
         if not self._chat_input:
             return
         if self.screen.is_modal:
             return
+        focused = self.focused
+        if focused is not None and not self._is_input_focused():
+            return
         self._chat_input.focus_input()
 
     def on_click(self, _event: Click) -> None:
-        """Handle clicks anywhere in the terminal to focus on the command line."""
+        """Focus the chat input when the click landed on non-focusable chrome.
+
+        Original intent: clicking the dead transcript area should drop the
+        caret back in the prompt. But this handler bubbles for *every* click,
+        so an unconditional refocus also steals focus from inline focusable
+        widgets (e.g., the ClarificationInputMessage answer field) on the same
+        click that Textual just used to focus them. Skip the refocus whenever
+        the click landed on a focusable widget — Textual's default focus
+        handling already does the right thing there.
+        """
         if not self._chat_input:
             return
         # Preserve an active text selection (focus would clear highlight for copy).
@@ -665,8 +699,31 @@ class _MessagesMixin:
 
         if screen_has_text_selection(self.screen):
             return
+        if self._click_landed_on_focusable(_event):
+            return
         self.call_after_refresh(self._chat_input.focus_input)
 
+    def _click_landed_on_focusable(self, event: Click) -> bool:
+        """Return True if the click target (or any ancestor) is focusable.
+
+        Walks up from `event.widget` toward the screen. Stops at the screen
+        so non-focusable container chrome (Containers, Statics) does not
+        suppress the dead-area refocus behavior.
+        """
+        widget = getattr(event, "widget", None)
+        if widget is None:
+            return False
+        node: Any = widget
+        screen = self.screen
+        while node is not None and node is not screen:
+            try:
+                if getattr(node, "can_focus", False):
+                    return True
+            except Exception:  # noqa: BLE001
+                pass
+            node = getattr(node, "parent", None)
+        return False
+
     def on_text_selected(self, _event: TextSelected) -> None:
         """Copy selected transcript text on mouse release.
 

{soothe_cli-0.5.26 → soothe_cli-0.5.28}/src/soothe_cli/tui/app/_startup.py

@@ -119,6 +119,9 @@ class _StartupMixin:
         self._status_bar = self.query_one("#status-bar", StatusBar)
         self._chat_input = self.query_one("#input-area", ChatInput)
 
+        # Seed the badge from the app-level clarification mode (CLI flag, default Auto).
+        self._status_bar.set_clarification_mode(self._clarification_mode)
+
         with suppress(NoMatches):
             banner = self.query_one("#welcome-banner", WelcomeBanner)
             self._status_bar.set_session_tip(banner.session_tip)
@@ -378,7 +381,11 @@ class _StartupMixin:
             )
             return
         try:
-            resp = await self._daemon_session.invoke_skill(skill_name, args)
+            resp = await self._daemon_session.invoke_skill(
+                skill_name,
+                args,
+                clarification_mode=getattr(self, "_clarification_mode", None),
+            )
         except RuntimeError as exc:
             await self._mount_message(UserMessage(command))
             await self._mount_message(AppMessage(str(exc)))

{soothe_cli-0.5.26 → soothe_cli-0.5.28}/src/soothe_cli/tui/app/app.tcss

@@ -52,10 +52,11 @@ Screen {
     height: auto;
 }
 
-/* Bottom app container - holds ChatInput (now inside scroll) */
+/* Bottom app container - holds thinking row, ChatInput, and status bar. */
 #bottom-app-container {
     height: auto;
     margin-top: 0;
+    margin-bottom: 1;
     padding: 0 1;
 }
 
@@ -73,11 +74,15 @@ Screen {
     max-height: 25;
 }
 
-/* Status bar */
+/* Status bar lives inside #bottom-app-container — share its padding only. */
 #status-bar {
     height: 1;
-    dock: bottom;
-    margin-bottom: 1;
+    padding: 0;
+}
+
+#status-bar ClarificationModeBadge {
+    margin-left: 1;
+    margin-right: 1;
 }
 
 /* Non-blocking filesystem change previews (write / edit / delete) */

{soothe_cli-0.5.26 → soothe_cli-0.5.28}/src/soothe_cli/tui/preview_limits.py

@@ -15,10 +15,10 @@ from typing import Final
 STEP_CARD_SHOW_TOOL_ROW_DETAILS: Final[bool] = False
 
 # Latest per-tool invocation lines shown per scope (task branch vs main-agent branch).
-STEP_CARD_TOOL_ACTIVITY_PREVIEW_COUNT: Final[int] = 3
+STEP_CARD_TOOL_ACTIVITY_PREVIEW_COUNT: Final[int] = 5
 
 # When estimated body lines exceed this count, the card auto-collapses (strict `>`).
-STEP_TASK_CARD_COLLAPSE_LINE_THRESHOLD: Final[int] = 3
+STEP_TASK_CARD_COLLAPSE_LINE_THRESHOLD: Final[int] = 5
 
 # --- Skill invocation cards (`SkillMessage` collapsed SKILL.md body) ---
 SKILL_CARD_PREVIEW_LINES: Final[int] = 4