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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: soothe-cli
-Version: 0.7.2
+Version: 0.7.3
 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.2 → soothe_cli-0.7.3}/src/soothe_cli/cli/commands/autopilot_cmd.py

@@ -55,7 +55,7 @@ def run(
     max_iterations: int | None = typer.Option(
         None,
         "--max-iterations",
-        help="Ignored — use daemon config agent.autonomous.max_iterations.",
+        help="Ignored — use daemon config agent.autopilot.max_iterations.",
     ),
     workspace: str | None = typer.Option(
         None,
@@ -333,36 +333,6 @@ def cancel_goal(
     typer.echo(f"Cancel result: {result.get('status', result)}")
 
 
-@app.command("approve")
-def approve_goal(
-    goal_id: str = typer.Argument(
-        ..., help="Confirmation ID to approve (use 'inbox' to list pending)."
-    ),
-) -> None:
-    """Approve a MUST-confirmation goal."""
-    client = _require_daemon_ws()
-    try:
-        result = client.autopilot_approve(goal_id)
-    except RuntimeError as exc:
-        typer.echo(str(exc), err=True)
-        raise typer.Exit(1) from exc
-    typer.echo(f"Confirmation approved: {result.get('goal_id', goal_id)}")
-
-
-@app.command("reject")
-def reject_goal(
-    goal_id: str = typer.Argument(..., help="Confirmation ID to reject."),
-) -> None:
-    """Reject a proposed goal."""
-    client = _require_daemon_ws()
-    try:
-        result = client.autopilot_reject(goal_id)
-    except RuntimeError as exc:
-        typer.echo(str(exc), err=True)
-        raise typer.Exit(1) from exc
-    typer.echo(f"Confirmation rejected: {result.get('goal_id', goal_id)}")
-
-
 @app.command("resume")
 def resume_goal(
     goal_id: str = typer.Argument(..., help="Goal ID to resume."),

{soothe_cli-0.7.2 → soothe_cli-0.7.3}/src/soothe_cli/cli/commands/cron_cmd.py

@@ -85,11 +85,16 @@ def add_job(
     try:
         result = client.cron_add(text, priority=priority)
     except RuntimeError as exc:
-        typer.echo(f"Error: {exc}", err=True)
+        message = str(exc)
+        if "Autopilot is disabled" in message:
+            console.print(f"[yellow]{message}[/yellow]")
+        else:
+            typer.echo(f"Error: {message}", err=True)
         sys.exit(1)
 
     job = result.get("job") or {}
     job_id = job.get("id", "?")
+    is_duplicate = bool(result.get("duplicate"))
     console.print(
         Panel(
             "\n".join(
@@ -101,10 +106,14 @@ def add_job(
                     f"[bold]Status:[/bold] [green]{job.get('status', 'pending')}[/green]",
                 ]
             ),
-            title="Scheduled Job Created",
-            border_style="green",
+            title="Scheduled Job Already Exists" if is_duplicate else "Scheduled Job Created",
+            border_style="yellow" if is_duplicate else "green",
         )
     )
+    if is_duplicate:
+        console.print(
+            "[yellow]An identical active job is already scheduled; no new job was created.[/yellow]"
+        )
 
 
 @app.command("list")
@@ -128,7 +137,7 @@ def list_jobs(
     """
     client = _require_cron_client()
     try:
-        result = client.cron_list_jobs(status=status)
+        result = client.cron_list(status=status)
     except RuntimeError as exc:
         typer.echo(f"Error: {exc}", err=True)
         sys.exit(1)

{soothe_cli-0.7.2 → soothe_cli-0.7.3}/src/soothe_cli/cli/commands/status_cmd.py

@@ -50,47 +50,6 @@ async def _fetch_status(ws_url: str, timeout: float = 5.0) -> dict[str, Any]:
         await client.close()
 
 
-async def _fetch_ready_state(ws_url: str, timeout: float = 5.0) -> dict[str, Any] | None:
-    """Fetch daemon readiness state via WebSocket connection_init/ack handshake.
-
-    Sends ``connection_init`` and waits for ``connection_ack`` which carries
-    the daemon's ``readiness_state``.
-
-    Args:
-        ws_url: WebSocket URL.
-        timeout: Timeout for handshake.
-
-    Returns:
-        ``connection_ack`` result dict (containing ``readiness_state``) or None.
-    """
-    import websockets
-
-    init_msg = json.dumps(
-        {
-            "proto": "1",
-            "type": "connection_init",
-            "params": {
-                "client_version": "0.5.0",
-                "accept_proto": ["1"],
-                "capabilities": ["streaming"],
-            },
-        }
-    )
-
-    try:
-        async with asyncio.timeout(timeout):
-            async with websockets.connect(ws_url) as ws:
-                await ws.send(init_msg)
-                for _ in range(3):
-                    msg = await ws.recv()
-                    data = json.loads(msg)
-                    if data.get("type") == "connection_ack":
-                        return data.get("result", data)
-    except Exception:
-        pass
-    return None
-
-
 def _render_unified_status_table(
     config: Any,
     ws_url: str,
@@ -156,10 +115,6 @@ def daemon_status(
         bool,
         typer.Option("--json", help="Output as JSON."),
     ] = False,
-    verbose: Annotated[
-        bool,
-        typer.Option("--verbose", "-v", help="Show detailed status."),
-    ] = False,
 ) -> None:
     """Check daemon status from client side.
 
@@ -168,7 +123,6 @@ def daemon_status(
     Examples:
         soothe status daemon
         soothe status daemon --json
-        soothe status daemon -v
     """
     config = load_config()
     ws_url = websocket_url_from_config(config)
@@ -217,11 +171,6 @@ def daemon_status(
             )
         sys.exit(1)
 
-    # Get readiness state for verbose mode
-    ready_state = None
-    if verbose:
-        ready_state = asyncio.run(_fetch_ready_state(ws_url, timeout=5.0))
-
     if json_output:
         output = {
             "status": "running",
@@ -232,10 +181,10 @@ def daemon_status(
             "daemon_pid": status.get("daemon_pid"),
             "daemon_version": status.get("daemon_version"),
             "core_version": status.get("core_version"),
+            "readiness_state": status.get("readiness_state", "unknown"),
         }
-        if ready_state:
-            output["readiness_state"] = ready_state.get("state", "unknown")
-            output["readiness_message"] = ready_state.get("message")
+        if status.get("readiness_message"):
+            output["readiness_message"] = status.get("readiness_message")
         console.print_json(json.dumps(output))
         return
 
@@ -246,6 +195,15 @@ def daemon_status(
     daemon_pid = status.get("daemon_pid")
     daemon_version = status.get("daemon_version")
     core_version = status.get("core_version")
+    # Use readiness_state from daemon_status RPC (already includes state + message)
+    readiness_state_from_status = (
+        {
+            "state": status.get("readiness_state", "unknown"),
+            "message": status.get("readiness_message"),
+        }
+        if status.get("readiness_state")
+        else None
+    )
 
     table = _render_unified_status_table(
         config,
@@ -254,7 +212,7 @@ def daemon_status(
         port_live,
         active_threads,
         daemon_pid,
-        ready_state,
+        readiness_state_from_status,
         daemon_live=True,
         daemon_version=daemon_version,
         core_version=core_version,
@@ -349,6 +307,9 @@ def status_main(
                 output["daemon"]["daemon_pid"] = status.get("daemon_pid")
                 output["daemon"]["daemon_version"] = status.get("daemon_version")
                 output["daemon"]["core_version"] = status.get("core_version")
+                output["daemon"]["readiness_state"] = status.get("readiness_state", "unknown")
+                if status.get("readiness_message"):
+                    output["daemon"]["readiness_message"] = status.get("readiness_message")
         console.print_json(json.dumps(output))
         return
 
@@ -378,6 +339,15 @@ def status_main(
     daemon_pid = status.get("daemon_pid")
     daemon_version = status.get("daemon_version")
     core_version = status.get("core_version")
+    # Use readiness_state from daemon_status RPC (already includes state + message)
+    readiness_state_from_status = (
+        {
+            "state": status.get("readiness_state", "unknown"),
+            "message": status.get("readiness_message"),
+        }
+        if status.get("readiness_state")
+        else None
+    )
 
     table = _render_unified_status_table(
         config,
@@ -386,6 +356,7 @@ def status_main(
         port_live,
         active_threads,
         daemon_pid,
+        readiness_state_from_status,
         daemon_live=True,
         daemon_version=daemon_version,
         core_version=core_version,

{soothe_cli-0.7.2 → soothe_cli-0.7.3}/src/soothe_cli/cli/execution/daemon.py

@@ -8,7 +8,6 @@ from __future__ import annotations
 
 import asyncio
 import logging
-import os
 import signal
 from typing import Any
 
@@ -28,6 +27,7 @@ from soothe_cli.cli.execution.daemon_errors import (
 from soothe_cli.cli.execution.headless_renderer import HeadlessCliRenderer
 from soothe_cli.runtime import EventProcessor
 from soothe_cli.runtime.presentation.engine import PresentationEngine
+from soothe_cli.tui._env_vars import resolve_cli_loop_workspace
 from soothe_cli.tui.commands.subagent_routing import parse_subagent_from_input
 
 logger = logging.getLogger(__name__)
@@ -151,7 +151,7 @@ async def _run_headless_session_once(
 
     try:
         await connect_websocket_with_retries(client)
-        cli_ws = os.environ.get("SOOTHE_CLI_WORKSPACE", "").strip() or os.getcwd()
+        cli_ws = resolve_cli_loop_workspace()
         # IG-441: three first-class modes (batch / adaptive / streaming).
         # Default is ``adaptive`` for headless runs as well — it gives smooth
         # progress on long synthesis while keeping wire traffic bounded.

{soothe_cli-0.7.2 → soothe_cli-0.7.3}/src/soothe_cli/runtime/state/session_stats.py

@@ -8,14 +8,16 @@ config, no widget imports) so that `app.py` can import `SessionStats` and
 
 from __future__ import annotations
 
+import json
 import time
 from dataclasses import dataclass, field
+from typing import Any
 
 SpinnerStatus = str | None
 """Spinner line label, or `None` to hide.
 
-Common values include ``Thinking``, ``Offloading``, ``Writing`` (assistant streaming),
-``Tools`` (tool execution), and ``Synthesizing`` (goal-completion stream).
+Common single-word values include ``Thinking``, ``Planning``, ``Executing``,
+``Tools``, ``Offloading``, ``Writing``, and ``Synthesizing``.
 """
 
 
@@ -242,48 +244,91 @@ class TurnEventStats:
                 self.latency = TurnLatencyStats()
             self.latency.merge(other.latency)
 
-    def summary_line(self) -> str:
-        """Return a one-line summary suitable for structured logging.
-
-        Returns:
-            Compact string like ``847 total (612 msg, 89 upd, 146 custom; …)``.
-        """
-        parts = [f"{self.total} total"]
-        mode_parts = []
-        if self.messages:
-            mode_parts.append(f"{self.messages} msg")
-        if self.updates:
-            mode_parts.append(f"{self.updates} upd")
-        if self.custom:
-            mode_parts.append(f"{self.custom} custom")
-        if mode_parts:
-            parts.append(f"({', '.join(mode_parts)})")
-
-        detail_parts = []
-        if self.tool_calls:
-            detail_parts.append(f"{self.tool_calls} tools")
-        if self.tool_results:
-            detail_parts.append(f"{self.tool_results} results")
-        if self.text_chunks:
-            detail_parts.append(f"{self.text_chunks} text")
-        if self.skipped:
-            detail_parts.append(f"{self.skipped} skipped")
-        if self.filtered_early:
-            detail_parts.append(f"{self.filtered_early} filtered-early")
-        if self.heartbeats_dropped:
-            detail_parts.append(f"{self.heartbeats_dropped} hb-drop")
-        if self.post_idle_drained:
-            detail_parts.append(f"{self.post_idle_drained} post-idle")
-        if self.inbound_dropped:
-            detail_parts.append(f"{self.inbound_dropped} inbound-drop")
-        if self.latency is not None and self.latency.time_to_first_chunk_ms is not None:
-            detail_parts.append(f"ttfc={self.latency.time_to_first_chunk_ms:.0f}ms")
-        if self.latency is not None and self.latency.synthesis_visible_ms is not None:
-            detail_parts.append(f"synth={self.latency.synthesis_visible_ms:.0f}ms")
-        if detail_parts:
-            parts.append("; ".join(detail_parts))
-
-        return " ".join(parts)
+    @staticmethod
+    def _nonzero_fields(**fields: int) -> dict[str, int]:
+        return {key: value for key, value in fields.items() if value}
+
+    def to_log_dict(self) -> dict[str, Any]:
+        """Return structured event counters for ``cli.log`` JSON lines."""
+        payload: dict[str, Any] = {"total": self.total}
+
+        modes = self._nonzero_fields(
+            messages=self.messages,
+            updates=self.updates,
+            custom=self.custom,
+        )
+        if modes:
+            payload["modes"] = modes
+
+        activity = self._nonzero_fields(
+            tool_calls=self.tool_calls,
+            tool_results=self.tool_results,
+            text_chunks=self.text_chunks,
+        )
+        if activity:
+            payload["activity"] = activity
+
+        degradation = self._nonzero_fields(
+            skipped=self.skipped,
+            filtered_early=self.filtered_early,
+            heartbeats_dropped=self.heartbeats_dropped,
+            post_idle_drained=self.post_idle_drained,
+            inbound_dropped=self.inbound_dropped,
+        )
+        if degradation:
+            payload["degradation"] = degradation
+
+        if self.latency is not None:
+            latency: dict[str, int] = {}
+            if self.latency.time_to_first_chunk_ms is not None:
+                latency["ttfc_ms"] = round(self.latency.time_to_first_chunk_ms)
+            if self.latency.synthesis_visible_ms is not None:
+                latency["synthesis_ms"] = round(self.latency.synthesis_visible_ms)
+            if latency:
+                payload["latency"] = latency
+
+        return payload
+
+
+def build_goal_completed_log_event(
+    ev_stats: TurnEventStats,
+    *,
+    status: str,
+    goal_progress: str,
+    total_steps: int,
+    elapsed_seconds: float,
+) -> dict[str, Any]:
+    """Build a structured goal-completion record for ``cli.log``."""
+    event: dict[str, Any] = {
+        "event": "goal_completed",
+        "elapsed_s": round(elapsed_seconds, 1),
+        "events": ev_stats.to_log_dict(),
+    }
+    if status.strip():
+        event["status"] = status.strip()
+    if goal_progress.strip():
+        event["progress"] = goal_progress.strip()
+    if total_steps > 0:
+        event["steps"] = total_steps
+    return event
+
+
+def build_turn_finished_log_event(
+    ev_stats: TurnEventStats,
+    *,
+    wall_seconds: float,
+) -> dict[str, Any]:
+    """Build a structured turn-finished record for ``cli.log``."""
+    return {
+        "event": "turn_finished",
+        "wall_s": round(wall_seconds, 1),
+        "events": ev_stats.to_log_dict(),
+    }
+
+
+def format_cli_log_event(payload: dict[str, Any]) -> str:
+    """Serialize a structured CLI log event as compact JSON."""
+    return json.dumps(payload, separators=(",", ":"), sort_keys=True)
 
 
 def format_token_count(count: int) -> str:

{soothe_cli-0.7.2 → soothe_cli-0.7.3}/src/soothe_cli/tui/_env_vars.py

@@ -61,3 +61,31 @@ TUI_REFRESH_INTERVAL_MS = "SOOTHE_CLI_TUI_REFRESH_INTERVAL_MS"
 Set to throttle frequent refreshes during streaming, reducing UI lag.
 Lower values = more responsive but more CPU load; higher values = smoother.
 """
+
+WORKSPACE = "SOOTHE_CLI_WORKSPACE"
+"""Explicit project directory sent to the daemon on ``loop_new`` (defaults to cwd)."""
+
+OMIT_WORKSPACE = "SOOTHE_CLI_OMIT_WORKSPACE"
+"""Optional: when ``1``/``true``/``yes``, omit ``workspace`` on ``loop_new`` (default: send cwd)."""
+
+
+def resolve_cli_loop_workspace() -> str | None:
+    """Return the workspace path to send on ``loop_new``, or ``None`` to omit it.
+
+    By default sends ``cwd``. The daemon ignores host paths that are not present
+    on the daemon filesystem (falls back to persisted layout) unless
+    ``workspace_mount`` is configured (RFC-621). ``SOOTHE_CLI_OMIT_WORKSPACE`` is
+    optional — use it only to skip sending ``workspace`` on the wire.
+    """
+    import os
+
+    omit = os.environ.get(OMIT_WORKSPACE, "").strip().lower()
+    if omit in ("1", "true", "yes", "on"):
+        return None
+
+    explicit = os.environ.get(WORKSPACE, "").strip()
+    if explicit.lower() in ("none", "-", "omit"):
+        return None
+    if explicit:
+        return explicit
+    return os.getcwd()

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

@@ -43,6 +43,7 @@ from soothe_cli.tui.widgets.messages import (
     AssistantMessage,
     QueuedUserMessage,
 )
+from soothe_cli.tui.widgets.plan_quick_view_overlay import PlanQuickViewOverlay
 from soothe_cli.tui.widgets.status import StatusBar
 from soothe_cli.tui.widgets.welcome import WelcomeBanner
 
@@ -79,7 +80,7 @@ class SootheApp(
     """Vertical scroll speed (reduced from Textual default for finer control)."""
 
     BINDINGS: ClassVar[list[BindingType]] = [
-        Binding("escape", "interrupt", "Interrupt", show=False, priority=True),
+        Binding("escape", "dismiss_ui", "Dismiss", show=False, priority=True),
         Binding(
             "ctrl+c",
             "quit_or_interrupt",
@@ -115,8 +116,15 @@ class SootheApp(
             "Copy Selection",
             show=False,
         ),
+        Binding(
+            "ctrl+t",
+            "toggle_plan_quick_view",
+            "Plan View",
+            show=False,
+            priority=True,
+        ),
     ]
-    """App-level keybindings for interrupt, quit, and navigation."""
+    """App-level keybindings for dismiss, quit, and navigation."""
 
     class ServerStartFailed(Message):
         """Posted when daemon bootstrap or background connection fails."""
@@ -216,6 +224,7 @@ class SootheApp(
         self._status_bar: StatusBar | None = None
 
         self._chat_input: ChatInput | None = None
+        self._plan_quick_view_overlay: PlanQuickViewOverlay | None = None
 
         self._quit_pending = False
 
@@ -374,6 +383,7 @@ class SootheApp(
                 )
                 yield Container(id="messages")
         with Container(id="bottom-app-container"):
+            yield PlanQuickViewOverlay(id="plan-quick-view-overlay")
             yield Container(id="thinking-status")
             yield ChatInput(
                 cwd=self._cwd,

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

@@ -28,7 +28,6 @@ from soothe_cli.cli.execution.daemon_errors import (
 from soothe_cli.runtime.state.session_stats import SessionStats, format_token_count
 from soothe_cli.tui import theme
 from soothe_cli.tui._cli_context import CLIContext
-from soothe_cli.tui._version import DOCS_URL
 from soothe_cli.tui.app._module_init import (
     _COMMAND_URLS,
     DeferredAction,
@@ -36,6 +35,7 @@ from soothe_cli.tui.app._module_init import (
     _extract_model_params_flag,
 )
 from soothe_cli.tui.hooks import dispatch_hook
+from soothe_cli.tui.shell_color import shell_subprocess_env, wrap_shell_command_for_color
 from soothe_cli.tui.widgets.chat_input import ChatInput
 from soothe_cli.tui.widgets.messages import (
     AppMessage,
@@ -288,10 +288,11 @@ class _ExecutionMixin:
         """
         try:
             proc = await asyncio.create_subprocess_shell(
-                command,
+                wrap_shell_command_for_color(command),
                 stdout=asyncio.subprocess.PIPE,
                 stderr=asyncio.subprocess.PIPE,
                 cwd=self._cwd,
+                env=shell_subprocess_env(),
                 start_new_session=(sys.platform != "win32"),
             )
             self._shell_process = proc
@@ -312,7 +313,7 @@ class _ExecutionMixin:
                 output += f"\n[stderr]\n{stderr_text}"
 
             if output:
-                msg = AssistantMessage(f"```\n{output}\n```")
+                msg = AssistantMessage(output, render_markdown=False, render_ansi=True)
                 await self._mount_message(msg)
                 await msg.write_initial_content()
             else:
@@ -461,7 +462,7 @@ class _ExecutionMixin:
         )
         from soothe_cli.tui.commands.slash_commands import COMMANDS as _RFC404_COMMANDS
 
-        # RFC-454 daemon *routing* commands (/research, /explore, /plan, optional /«id»):
+        # RFC-454 daemon *routing* commands (/research, /plan, optional /«id»):
         # send the full line as a normal user turn so ``parse_subagent_from_input``
         # runs in the daemon adapter (same as headless CLI). Without this branch,
         # ``cmd == "/research …"`` never matches the bare single-token handlers below.
@@ -484,37 +485,14 @@ class _ExecutionMixin:
                     self.query_one("#chat", VerticalScroll).anchor()
                 return
 
-        from soothe_cli.tui.config import newline_shortcut, settings
+        from soothe_cli.tui.config import settings
 
         cmd = command.lower().strip()
 
         if cmd in {"/quit", "/q"}:
             self._detach_or_exit()
         elif cmd == "/help":
-            await self._mount_message(UserMessage(command))
-            help_body = (
-                "Commands: /quit, /clear, /editor, /autopilot <task>, /cron <schedule>, "
-                "/context, /mcp, "
-                "/model [--model-params JSON] [--default], /notifications, "
-                "/reload, /skill:<name>, /theme, "
-                "/tokens, /resume, "
-                "/research, /explore, /plan, /«subagent» (when configured), "
-                "/update, /auto-update, /changelog, /docs, /feedback, /help\n\n"
-                "Interactive Features:\n"
-                "  Enter           Submit your message\n"
-                f"  {newline_shortcut():<15} Insert newline\n"
-                "  Ctrl+X          Open prompt in external editor\n"
-                "  Shift+Tab       Cycle loop selector\n"
-                "  @filename       Auto-complete files and inject content\n"
-                "  /command        Slash commands (/help, /clear, /quit)\n"
-                "  !command        Run shell commands directly\n\n"
-                "Docs: "
-            )
-            help_text = Content.assemble(
-                (help_body, "dim italic"),
-                (DOCS_URL, TStyle(dim=True, italic=True, link=DOCS_URL)),
-            )
-            await self._mount_message(AppMessage(help_text))
+            await self._show_help_screen()
 
         elif cmd in {"/changelog", "/docs", "/feedback"}:
             await self._open_url_command(command, cmd)
@@ -1031,9 +1009,11 @@ class _ExecutionMixin:
         self._agent_running = False
         self._agent_worker = None
 
-        # Restore input focus FIRST so the user can start typing immediately
+        # Restore input focus first so the user can type immediately
         # while remaining cleanup (spinner, tokens, deferred) runs.
-        if self._chat_input:
+        if self._primary_text_input() is not None:
+            self.focus_primary_input()
+        elif self._chat_input:
             self._chat_input.set_cursor_active(active=True)
 
         # Remove spinner if present