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

{soothe_cli-0.7.1 → soothe_cli-0.7.3}/.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.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: soothe-cli
-Version: 0.7.1
+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.1 → 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.1 → 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.1 → 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.1 → 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.1 → soothe_cli-0.7.3}/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.3}/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.3}/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.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.1 → soothe_cli-0.7.3}/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: