soothe-cli 0.4.1__tar.gz → 0.4.2__tar.gz

{soothe_cli-0.4.1 → soothe_cli-0.4.2}/.gitignore

@@ -218,3 +218,4 @@ plot_*
 checkpoint.json
 manifest.json
 _bmad
+__MACOSX

{soothe_cli-0.4.1 → soothe_cli-0.4.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: soothe-cli
-Version: 0.4.1
+Version: 0.4.2
 Summary: Soothe CLI client - communicates with daemon via WebSocket
 Project-URL: Homepage, https://github.com/OpenSoothe/soothe
 Project-URL: Documentation, https://soothe.readthedocs.io

{soothe_cli-0.4.1 → soothe_cli-0.4.2}/src/soothe_cli/cli/commands/run_cmd.py

@@ -23,6 +23,8 @@ def run_impl(
     autonomous: bool,  # noqa: FBT001
     max_iterations: int | None,
     output_format: str,
+    streaming_enabled: bool | None = None,
+    streaming_mode: str | None = None,
 ) -> None:
     """Core implementation for running Soothe agent.
 
@@ -35,6 +37,8 @@ def run_impl(
         autonomous: Enable autonomous iteration mode
         max_iterations: Max iterations for autonomous mode
         output_format: Output format (text or jsonl)
+        streaming_enabled: Override daemon streaming enabled setting (RFC-614)
+        streaming_mode: Override daemon streaming mode ('streaming' or 'batch')
     """
     startup_start = time.perf_counter()
 
@@ -50,6 +54,12 @@ def run_impl(
             if checkpointer == "postgresql":
                 logger.info("PostgreSQL checkpointer configured; ensure server is running.")
 
+        # Apply CLI streaming overrides (RFC-614)
+        if streaming_enabled is not None:
+            cfg.output_streaming_enabled = streaming_enabled
+        if streaming_mode is not None:
+            cfg.output_streaming_mode = streaming_mode
+
         startup_elapsed_ms = (time.perf_counter() - startup_start) * 1000
         logger.info("[Startup] ✓ Ready (%.1fms)", startup_elapsed_ms)
 

{soothe_cli-0.4.1 → soothe_cli-0.4.2}/src/soothe_cli/cli/execution/daemon.py

@@ -48,6 +48,7 @@ async def run_headless_via_daemon(
     ws_url = websocket_url_from_config(cfg)
     client = WebSocketClient(url=ws_url)
     verbosity = cfg.logging.verbosity
+    final_output_mode = getattr(cfg, "final_output_mode", "streaming")
 
     try:
         await connect_websocket_with_retries(client)
@@ -84,7 +85,12 @@ async def run_headless_via_daemon(
         # for pipeline + message gating (RFC-502).
         presentation = PresentationEngine()
         renderer = CliRenderer(verbosity=verbosity, presentation_engine=presentation)
-        processor = EventProcessor(renderer, verbosity=verbosity, presentation_engine=presentation)
+        processor = EventProcessor(
+            renderer,
+            verbosity=verbosity,
+            final_output_mode=final_output_mode,
+            presentation_engine=presentation,
+        )
 
         has_error = False
         query_started = False  # Track if we've seen the query start running

{soothe_cli-0.4.1 → soothe_cli-0.4.2}/src/soothe_cli/cli/execution/headless.py

@@ -29,7 +29,7 @@ def run_headless(
 ) -> None:
     """Run a single prompt with streaming output and progress events.
 
-    Connects to running daemon via WebSocket if available to avoid RocksDB lock conflicts.
+    Connects to running daemon via WebSocket if available to avoid database lock conflicts.
     Auto-starts daemon if not running (RFC-0013 daemon lifecycle).
 
     Note (RFC-0013): Daemon persists after request completion. Use 'soothed stop'

{soothe_cli-0.4.1 → soothe_cli-0.4.2}/src/soothe_cli/cli/main.py

@@ -74,6 +74,14 @@ def main(
         str,
         typer.Option("--format", "-f", help="Output format for headless mode: text or jsonl."),
     ] = "text",
+    streaming: Annotated[
+        bool | None,
+        typer.Option("--streaming/--no-streaming", help="Enable/disable output streaming."),
+    ] = None,
+    streaming_mode: Annotated[
+        str | None,
+        typer.Option("--streaming-mode", help="Streaming mode: 'streaming' or 'batch'"),
+    ] = None,
     show_help: Annotated[  # noqa: FBT002
         bool,
         typer.Option("--help", "-h", is_flag=True, help="Show this message and exit."),
@@ -117,6 +125,8 @@ def main(
             autonomous=False,
             max_iterations=None,
             output_format=output_format,
+            streaming_enabled=streaming,
+            streaming_mode=streaming_mode,
         )
 
 

{soothe_cli-0.4.1 → soothe_cli-0.4.2}/src/soothe_cli/cli/renderer.py

@@ -20,7 +20,7 @@ from soothe_cli.cli.utils import make_tool_block
 from soothe_cli.shared.display_policy import VerbosityLevel, normalize_verbosity
 from soothe_cli.shared.message_processing import format_tool_call_args
 from soothe_cli.shared.presentation_engine import PresentationEngine
-from soothe_cli.shared.suppression_state import SuppressionState
+from soothe_cli.shared.renderer_base import RendererBase
 
 if TYPE_CHECKING:
     from soothe_sdk.client.schemas import Plan
@@ -36,8 +36,8 @@ class CliRendererState:
     # Track if stderr was just written (to add spacing before next stdout)
     stderr_just_written: bool = False
 
-    # Multi-step/agentic suppression state (IG-143)
-    suppression: SuppressionState = field(default_factory=SuppressionState)
+    # Per-turn assistant output accumulation for diagnostics/tests.
+    full_response: list[str] = field(default_factory=list)
 
     # Track current plan for status display
     current_plan: Plan | None = None
@@ -45,11 +45,14 @@ class CliRendererState:
     # Track tool call start times for duration display (RFC-0020)
     tool_call_start_times: dict[str, float] = field(default_factory=dict)
 
+    # Buffer tool-call line text until result arrives for single-line rendering.
+    pending_tool_call_lines: dict[str, str] = field(default_factory=dict)
+
     # After LLM text on stdout, next stderr icon block gets one leading blank line
     stderr_blank_before_next_icon_block: bool = False
 
 
-class CliRenderer:
+class CliRenderer(RendererBase):
     """CLI renderer for headless stdout/stderr output.
 
     Implements RendererProtocol callbacks for CLI mode:
@@ -58,6 +61,8 @@ class CliRenderer:
     - Progress events -> stderr via StreamDisplayPipeline
     - Errors -> stderr
 
+    Inherits from RendererBase for unified text repair logic.
+
     Spacing: Soothe-originated stderr lines (icons from the pipeline, tools, results,
     errors) call `_stderr_begin_icon_block()`, which inserts one blank stderr line only
     after LLM text was written to stdout, so icon blocks separate from answers without
@@ -80,6 +85,7 @@ class CliRenderer:
             verbosity: Progress visibility level.
             presentation_engine: Shared presentation engine (optional).
         """
+        super().__init__()
         self._verbosity = normalize_verbosity(verbosity)
         self._state = CliRendererState()
         self._presentation = presentation_engine or PresentationEngine()
@@ -99,12 +105,7 @@ class CliRenderer:
     @property
     def full_response(self) -> list[str]:
         """Get accumulated response text."""
-        return self._state.suppression.full_response
-
-    @property
-    def multi_step_active(self) -> bool:
-        """Whether multi-step plan is active."""
-        return self._state.suppression.multi_step_active
+        return self._state.full_response
 
     @property
     def presentation_engine(self) -> PresentationEngine:
@@ -138,38 +139,17 @@ class CliRenderer:
         sys.stderr.flush()
         self._state.stderr_just_written = True
 
-    def _write_stdout_final_report(self, text: str) -> None:
-        """Write aggregated final answer to stdout (multi-step headless mode only)."""
-        stripped = text.strip()
-        if not stripped:
-            return
-
-        self._state.suppression.full_response.append(stripped)
-
-        # Add newline before final report if stderr was just written (goal completion)
-        if self._state.stderr_just_written:
-            sys.stdout.write("\n")
-            self._state.stderr_just_written = False
-
-        sys.stdout.write(stripped)
-        if not stripped.endswith("\n"):
-            sys.stdout.write("\n")
-        sys.stdout.flush()
-        self._state.needs_stdout_newline = True
-        self._state.stderr_blank_before_next_icon_block = True
-        self._presentation.mark_final_answer_locked()
-
     def on_assistant_text(
         self,
         text: str,
         *,
         is_main: bool,
-        is_streaming: bool,  # noqa: ARG002
+        is_streaming: bool,
     ) -> None:
         """Write assistant text to stdout.
 
-        HARD SUPPRESS during multi-step execution to prevent intermediate
-        LLM response text from flooding output (IG-143).
+        Write assistant text directly. Daemon-side output contract decides
+        which assistant text reaches clients.
 
         Args:
             text: Text content to display.
@@ -179,25 +159,41 @@ class CliRenderer:
         if not is_main:
             return  # Subagent text not shown in CLI headless mode
 
-        # HARD BLOCK: No text during multi-step execution (IG-143)
-        if self._state.suppression.should_suppress_output():
-            # Accumulate for final report instead
-            self._state.suppression.accumulate_text(text)
-            return
-
-        # Emit only on final iteration (after flags cleared)
-        self._state.suppression.full_response.append(text)
+        payload = text if is_streaming else self.repair_concatenated_output(text)
+        self._state.full_response.append(payload)
 
         if self._state.stderr_just_written:
             self._state.stderr_just_written = False
 
         # LLM stream: do not inject extra blank lines (spacing before icon stderr
         # is handled in _stderr_begin_icon_block when progress resumes).
-        sys.stdout.write(text)
+        sys.stdout.write(payload)
         sys.stdout.flush()
         self._state.needs_stdout_newline = True
         self._state.stderr_blank_before_next_icon_block = True
 
+    def on_streaming_output(
+        self,
+        event_type: str,
+        text: str,
+        *,
+        is_chunk: bool,
+        namespace: tuple[str, ...],
+    ) -> None:
+        """Handle streaming output from unified framework (RFC-614).
+
+        Default implementation: delegate to on_assistant_text.
+        CLI renderer treats all streaming output as assistant text.
+
+        Args:
+            event_type: Event type string.
+            text: Text content (may be chunk or final).
+            is_chunk: True if partial chunk, False if final.
+            namespace: Namespace tuple for stream context (ignored in CLI headless mode).
+        """
+        # Delegate to on_assistant_text for unified display
+        self.on_assistant_text(text, is_main=True, is_streaming=is_chunk)
+
     def on_tool_call(
         self,
         name: str,
@@ -217,10 +213,6 @@ class CliRenderer:
         if not self._presentation.tier_visible(VerbosityTier.NORMAL, self._verbosity):
             return
 
-        # Multi-step / agentic suppression applies to assistant stdout only (IG-143).
-        # Tool calls and results still stream to stderr at normal+ verbosity so headless
-        # runs show the same tool activity as the TUI.
-
         self._stderr_begin_icon_block()
 
         display_name = get_tool_display_name(name)
@@ -239,10 +231,12 @@ class CliRenderer:
         # Track start time for duration display (RFC-0020)
         if tool_call_id:
             self._state.tool_call_start_times[tool_call_id] = time.time()
+            self._state.pending_tool_call_lines[tool_call_id] = tool_block
+            return
 
+        # No stable ID means we cannot join with result later - keep old behavior.
         sys.stderr.write(f"{tool_block}\n")
         sys.stderr.flush()
-        # Mark that stderr was just written
         self._state.stderr_just_written = True
 
     def on_tool_result(
@@ -266,8 +260,6 @@ class CliRenderer:
         if not self._presentation.tier_visible(VerbosityTier.NORMAL, self._verbosity):
             return
 
-        # See on_tool_call: do not suppress stderr tool results during multi-step runs.
-
         self._stderr_begin_icon_block()
 
         # Calculate duration (RFC-0020)
@@ -287,9 +279,15 @@ class CliRenderer:
         if duration_ms > 0:
             result_line += f" ({duration_ms}ms)"
 
-        # IG-257: Add indentation when inside step context
-        # Unicode U+2514 "└─" (Box Drawings Light Up and Right) for tree branch
-        if self._is_inside_step_context():
+        combined_call_line: str | None = None
+        if tool_call_id:
+            combined_call_line = self._state.pending_tool_call_lines.pop(tool_call_id, None)
+
+        if combined_call_line:
+            result_line = f"{combined_call_line} -> {result_line}"
+        elif self._is_inside_step_context():
+            # IG-257: Add indentation when inside step context
+            # Unicode U+2514 "└─" (Box Drawings Light Up and Right) for tree branch
             result_line = f"  └─ {result_line}"
 
         sys.stderr.write(result_line + "\n")
@@ -323,7 +321,7 @@ class CliRenderer:
         event_type: str,
         data: dict[str, Any],
         *,
-        namespace: tuple[str, ...],  # noqa: ARG002
+        namespace: tuple[str, ...],
     ) -> None:
         """Write progress event to stderr using StreamDisplayPipeline.
 
@@ -332,22 +330,11 @@ class CliRenderer:
             data: Event payload.
             namespace: Subagent namespace.
         """
-        # Track suppression state from event (IG-143)
-        final_stdout = self._state.suppression.track_from_event(event_type, data)
-
-        payload = dict(data)
-        payload.pop("final_stdout_message", None)
-
         # Build event dict for pipeline
-        event = {"type": event_type, **payload}
+        event = {"type": event_type, **data}
         lines = self._pipeline.process(event)
         self.write_lines(lines)
 
-        # Emit final report on loop completion (IG-143)
-        if self._state.suppression.should_emit_final_report(event_type, final_stdout):
-            response = self._state.suppression.get_final_response(final_stdout)
-            self._write_stdout_final_report(response)
-
     def on_plan_created(self, plan: Plan) -> None:
         """Write plan creation to stderr.
 
@@ -355,7 +342,6 @@ class CliRenderer:
             plan: Created plan object.
         """
         self._state.current_plan = plan
-        self._state.suppression.track_from_plan(len(plan.steps))
 
         # Use pipeline for consistent formatting
         event = {
@@ -420,24 +406,10 @@ class CliRenderer:
         self.write_lines(lines)
 
     def on_turn_end(self) -> None:
-        """Finalize output on turn end.
-
-        If multi_step_active was suppressing output, flush the accumulated
-        response to stdout now that the plan is complete.
-        """
-        # Capture state BEFORE resetting
-        was_multi_step = self._state.suppression.multi_step_active
-        accumulated_response = self._state.suppression.full_response
-
-        # Reset state for next turn FIRST (before output logic)
+        """Finalize turn-local renderer state."""
         self._state.needs_stdout_newline = False
-        self._state.suppression.reset_turn()
-
-        # Multi-step mode intentionally suppresses step body output in headless CLI.
-        # For single-step mode, keep existing newline flush behavior.
-        if (not was_multi_step) and accumulated_response:
-            sys.stdout.write("\n")
-            sys.stdout.flush()
+        self._state.full_response.clear()
+        self._state.pending_tool_call_lines.clear()
 
     def _stderr_begin_icon_block(self) -> None:
         """Prepare stderr for Soothe icon lines (progress, tools, tool results).

{soothe_cli-0.4.1 → soothe_cli-0.4.2}/src/soothe_cli/cli/stream/formatter.py

@@ -96,7 +96,7 @@ def format_goal_header(
         DisplayLine for goal header.
     """
     # Add inline symbol for goal marker
-    content = f"{goal}"
+    content = f"📍 {goal}"
     return DisplayLine(
         level=1,
         content=content,
@@ -242,7 +242,6 @@ def format_subagent_milestone(
 def format_subagent_done(
     summary: str,
     duration_s: float,
-    result_preview: str = "",
     *,
     namespace: tuple[str, ...] = (),
     verbosity_tier: VerbosityTier = VerbosityTier.NORMAL,
@@ -250,12 +249,11 @@ def format_subagent_done(
     """Format a subagent completion line with metrics.
 
     IG-256: Restored verbose format with triple success markers and separate result display.
-    Result preview parameter is ignored - results show via separate tool events.
+    Results show via separate tool events.
 
     Args:
         summary: Completion summary with subagent-specific metrics (e.g., "success", "$1.23").
         duration_s: Duration in seconds.
-        result_preview: Ignored (kept for backward compatibility).
         namespace: Event namespace.
         verbosity_tier: Current verbosity tier.
 
@@ -264,9 +262,7 @@ def format_subagent_done(
     """
     duration_ms = int(duration_s * 1000)
 
-    # IG-256: Verbose format restored - triple success markers, result shows separately
-    # Format: "✓ ✅ ✓ {summary}"
-    # result_preview is ignored - let result show via separate tool execution events
+    # IG-256: Verbose format restored - triple success markers
     content = f"✓ ✅ ✓ {summary}"
 
     return DisplayLine(
@@ -307,58 +303,21 @@ def format_plan_phase_reasoning(
     )
 
 
-def format_reasoning(
-    reasoning: str,
-    *,
-    namespace: tuple[str, ...] = (),
-    verbosity_tier: VerbosityTier = VerbosityTier.NORMAL,
-) -> DisplayLine:
-    """Format a reasoning line for LLM decision internal analysis.
-
-    IG-XXX: Shows technical reasoning with "Reasoning:" prefix for clarity.
-    Uses solid bullet ● (matching goal) to indicate reasoning is active phase.
-
-    IG-262: Uses level=2 (flat layout) for consistency with judgement lines.
-    Reasoning is a sibling to judgement, not a child.
-
-    Args:
-        reasoning: Internal technical analysis text.
-        namespace: Event namespace.
-        verbosity_tier: Current verbosity tier.
-
-    Returns:
-        DisplayLine for reasoning.
-    """
-    # Polish: Add "Reasoning:" prefix to make internal analysis visible
-    content = f"💭 {reasoning}"
-
-    return DisplayLine(
-        level=2,  # IG-262: Use level 2 for flat layout (sibling to judgement, not child)
-        content=content,
-        icon="●",  # Solid bullet matching goal icon (polish)
-        indent=indent_for_level(2),
-        source_prefix=_derive_source_prefix(namespace, verbosity_tier),
-    )
-
-
 def format_judgement(
     judgement: str,
     action: str,
     *,
-    plan_action: str | None = None,
     namespace: tuple[str, ...] = (),
     verbosity_tier: VerbosityTier = VerbosityTier.NORMAL,
 ) -> DisplayLine:
     """Format a judgement line for LLM decision reasoning.
 
     IG-089: Shows meaningful judgement info without raw intermediate data.
-    IG-XXX: Prominent reasoning display with "Reason:" prefix for clarity.
     IG-265: Removed [new]/[keep] badge from CLI display (kept in event data for logs).
 
     Args:
         judgement: Human-readable summary of the decision.
         action: Action taken ("continue" or "complete").
-        plan_action: Ignored (kept for backward compatibility, appears in logs only).
         namespace: Event namespace.
         verbosity_tier: Current verbosity tier.
 
@@ -367,7 +326,6 @@ def format_judgement(
     """
     action_icon = "○" if action == "continue" else "●"  # Polish: ○ for continue, ● for complete
 
-    # IG-265: Remove badge from CLI display (plan_action kept in event data for logs)
     content = f"🌟 {judgement}"
 
     return DisplayLine(
@@ -489,7 +447,6 @@ __all__ = [
     "format_goal_header",
     "format_judgement",
     "format_plan_phase_reasoning",
-    "format_reasoning",
     "format_step_done",
     "format_step_header",
     "format_subagent_done",

{soothe_cli-0.4.1 → soothe_cli-0.4.2}/src/soothe_cli/cli/stream/pipeline.py

@@ -16,7 +16,6 @@ from soothe_cli.cli.stream.formatter import (
     format_goal_header,
     format_judgement,
     format_plan_phase_reasoning,
-    format_reasoning,
     format_step_done,
     format_step_header,
     format_subagent_done,
@@ -42,9 +41,6 @@ GOAL_COMPLETE_EVENTS = {
     "soothe.cognition.agent_loop.completed",
 }
 
-# IG-264: Default goal completion message (skip display to avoid redundancy)
-DEFAULT_GOAL_ACHIEVED_MESSAGE = "Goal achieved successfully"
-
 # Verbosity tier mapping
 _VERBOSITY_TO_TIER = {
     "quiet": VerbosityTier.QUIET,
@@ -200,7 +196,7 @@ class StreamDisplayPipeline:
         Returns:
             Display lines for goal header.
         """
-        # IG-262: Prefer friendly_message over goal/goal_description
+        # IG-287: Prefer friendly_message over goal/goal_description
         friendly_message = event.get("friendly_message")
         goal = friendly_message or event.get("goal", event.get("goal_description", ""))
         if not goal:
@@ -400,7 +396,6 @@ class StreamDisplayPipeline:
             format_subagent_done(
                 preview_first(summary, 70),  # Increased from 50 for richer metrics
                 duration_s,
-                result_preview=result_preview,
                 namespace=self._current_namespace,
                 verbosity_tier=self._verbosity_tier,
             )
@@ -615,14 +610,10 @@ class StreamDisplayPipeline:
         # Determine action type
         action = "complete" if status == "done" else "continue"
 
-        raw_plan_action = event.get("plan_action")
-        plan_action_kw: str | None = raw_plan_action if raw_plan_action in ("keep", "new") else None
-
         lines = [
             format_judgement(
                 action_text,
                 action,
-                plan_action=plan_action_kw,
                 namespace=self._current_namespace,
                 verbosity_tier=self._verbosity_tier,
             )
@@ -640,17 +631,6 @@ class StreamDisplayPipeline:
                     verbosity_tier=self._verbosity_tier,
                 )
             )
-        else:
-            reasoning = event.get("reasoning", "").strip()
-            # IG-264: Skip redundant reasoning when it's the default goal message
-            if reasoning and reasoning != DEFAULT_GOAL_ACHIEVED_MESSAGE:
-                lines.append(
-                    format_reasoning(
-                        reasoning,
-                        namespace=self._current_namespace,
-                        verbosity_tier=self._verbosity_tier,
-                    )
-                )
 
         return lines
 

{soothe_cli-0.4.1 → soothe_cli-0.4.2}/src/soothe_cli/config/cli_config.py

@@ -30,6 +30,14 @@ class CLIConfig:
     logging_level: str | None = None
 
     output_format: str = "text"
+    final_output_mode: str = "streaming"
+
+    # Output streaming overrides (RFC-614)
+    output_streaming_enabled: bool | None = None
+    """Override daemon streaming enabled setting."""
+
+    output_streaming_mode: str | None = None
+    """Override daemon streaming mode: 'streaming' or 'batch'."""
 
     # Paths
     soothe_home: Path = field(default_factory=lambda: Path.home() / ".soothe")
@@ -101,16 +109,28 @@ class CLIConfig:
         daemon_section = data.get("daemon", {})
         transports = daemon_section.get("transports", {})
         websocket = transports.get("websocket", {})
+        websocket_legacy = data.get("websocket", {})
+        ui_section = data.get("ui", {})
 
         raw_level = data.get("logging_level")
         if raw_level is not None and not isinstance(raw_level, str):
             raw_level = None
 
+        raw_final_output_mode = data.get("final_output_mode")
+        if raw_final_output_mode is None and isinstance(ui_section, dict):
+            raw_final_output_mode = ui_section.get("final_output_mode")
+        if not isinstance(raw_final_output_mode, str):
+            raw_final_output_mode = "streaming"
+        final_output_mode = raw_final_output_mode.strip().lower()
+        if final_output_mode not in {"streaming", "batch"}:
+            final_output_mode = "streaming"
+
         return cls(
-            daemon_host=websocket.get("host", "127.0.0.1"),
-            daemon_port=websocket.get("port", 8765),
-            verbosity=data.get("verbosity", "normal"),
+            daemon_host=websocket.get("host", websocket_legacy.get("host", "127.0.0.1")),
+            daemon_port=websocket.get("port", websocket_legacy.get("port", 8765)),
+            verbosity=data.get("verbosity", ui_section.get("verbosity", "normal")),
             logging_level=raw_level,
+            final_output_mode=final_output_mode,
             soothe_home=Path(data.get("home", str(Path.home() / ".soothe"))),
         )
 
@@ -135,8 +155,9 @@ class CLIConfig:
         return cls(
             daemon_host=soothe_config.daemon.transports.websocket.host,
             daemon_port=soothe_config.daemon.transports.websocket.port,
-            verbosity=soothe_config.logging.verbosity,
+            verbosity=soothe_config.observability.verbosity,
             logging_level=logging_level,
+            final_output_mode="streaming",
             soothe_home=Path(soothe_config.home),
         )