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

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

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

@@ -0,0 +1,103 @@
+"""Config management CLI commands for the soothe daemon."""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import sys
+from typing import Annotated, Any
+
+import typer
+from rich.console import Console
+from rich.panel import Panel
+from soothe_sdk.client import (
+    WebSocketClient,
+    request_daemon_config_reload,
+    websocket_url_from_config,
+)
+
+from soothe_cli.config.loader import load_config
+
+console = Console()
+
+# Create config command group
+config_app = typer.Typer(help="Manage daemon configuration", no_args_is_help=True)
+
+
+async def _trigger_config_reload(ws_url: str, timeout: float = 5.0) -> dict[str, Any]:
+    """Trigger config reload via WebSocket RPC.
+
+    Args:
+        ws_url: WebSocket URL to connect to.
+        timeout: Request timeout in seconds.
+
+    Returns:
+        Response dict from daemon, or error dict on failure.
+    """
+    client = WebSocketClient(url=ws_url)
+    try:
+        await client.connect()
+        return await request_daemon_config_reload(client, timeout=timeout)
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+    finally:
+        await client.close()
+
+
+@config_app.command("reload")
+def config_reload(
+    json_output: Annotated[
+        bool,
+        typer.Option("--json", help="Output as JSON."),
+    ] = False,
+) -> None:
+    """Trigger config hot-reload on the running daemon.
+
+    Sends a config_reload RPC request to the daemon, which triggers immediate
+    reload of watched config files (config.yml and daemon.yml). Requires the
+    daemon to have hot-reload enabled via daemon.enable_config_reload().
+
+    Examples:
+        soothe config reload
+        soothe config reload --json
+    """
+    config = load_config()
+    ws_url = websocket_url_from_config(config)
+
+    # Trigger reload
+    result = asyncio.run(_trigger_config_reload(ws_url, timeout=5.0))
+
+    if json_output:
+        output = {
+            "websocket_url": ws_url,
+            "success": result.get("success", False),
+        }
+        if result.get("error"):
+            output["error"] = result.get("error")
+        if result.get("message"):
+            output["message"] = result.get("message")
+        console.print_json(json.dumps(output))
+        return
+
+    if result.get("success"):
+        console.print(
+            Panel(
+                f"WebSocket URL: {ws_url}\n"
+                f"Status: [green]Reload triggered[/green]\n"
+                f"Message: {result.get('message', 'Config reload initiated')}",
+                title="Config Reload",
+                border_style="green",
+            )
+        )
+    else:
+        error_msg = result.get("error", "Unknown error")
+        if result.get("message"):
+            error_msg = result.get("message")
+        console.print(
+            Panel(
+                f"WebSocket URL: {ws_url}\nStatus: [red]Failed[/red]\nError: {error_msg}",
+                title="Config Reload",
+                border_style="red",
+            )
+        )
+        sys.exit(1)

{soothe_cli-0.7.2 → soothe_cli-0.7.4}/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.4}/src/soothe_cli/cli/commands/loop_cmd.py

@@ -720,6 +720,18 @@ def continue_loop(
     )
 
 
+@loop_app.command("resume")
+def resume_loop(
+    loop_id: Annotated[str | None, typer.Argument(help="Loop identifier to continue")] = None,
+    prompt: Annotated[
+        str | None,
+        typer.Option("--prompt", "-p", help="Optional prompt to send after continuing."),
+    ] = None,
+) -> None:
+    """Alias for ``continue`` — resume execution on existing loop."""
+    continue_loop(loop_id, prompt)
+
+
 @loop_app.command("detach")
 def detach_loop(
     loop_id: Annotated[str, typer.Argument(help="Loop identifier to detach")],
@@ -873,6 +885,7 @@ __all__ = [
     "prune_loop_branches",
     "delete_loop",
     "continue_loop",
+    "resume_loop",
     "detach_loop",
     "attach_loop",
     "new_loop",

{soothe_cli-0.7.2 → soothe_cli-0.7.4}/src/soothe_cli/cli/commands/run_cmd.py

@@ -100,7 +100,7 @@ def run_impl(
             result = get_last_app_result()
             if result is not None and result.loop_id:
                 typer.echo(
-                    f"💡 To continue this loop: soothe loop continue {result.loop_id}",
+                    f"💡 To continue this loop: soothe loop resume {result.loop_id}",
                     err=True,
                 )
 
@@ -113,7 +113,7 @@ def run_impl(
             result = get_last_app_result()
             if result is not None and result.loop_id:
                 typer.echo(
-                    f"💡 To continue this loop: soothe loop continue {result.loop_id}",
+                    f"💡 To continue this loop: soothe loop resume {result.loop_id}",
                     err=True,
                 )
         sys.exit(130)

{soothe_cli-0.7.2 → soothe_cli-0.7.4}/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.4}/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.4}/src/soothe_cli/cli/main.py

@@ -228,6 +228,7 @@ def main(
 # ---------------------------------------------------------------------------
 
 from soothe_cli.cli.commands.autopilot_cmd import app as _autopilot_app  # noqa: E402
+from soothe_cli.cli.commands.config_cmd import config_app as _config_app  # noqa: E402
 from soothe_cli.cli.commands.cron_cmd import app as _cron_app  # noqa: E402
 from soothe_cli.cli.commands.loop_cmd import loop_app as _loop_app  # noqa: E402
 from soothe_cli.cli.commands.status_cmd import status_app as _status_app  # noqa: E402
@@ -237,6 +238,7 @@ for _sub_app, _name in (
     (_loop_app, "loop"),
     (_autopilot_app, "autopilot"),
     (_cron_app, "cron"),
+    (_config_app, "config"),
 ):
     add_help_alias(_sub_app)
     app.add_typer(_sub_app, name=_name)

{soothe_cli-0.7.2 → soothe_cli-0.7.4}/src/soothe_cli/runtime/headless/processor.py

@@ -242,7 +242,7 @@ class EventProcessor:
         """Headless stdout: only RFC-614 loop-tagged finals (IG-343 / IG-345).
 
         Suppresses unphased execute-wave narration on the main graph; ``goal_completion``,
-        ``quiz``, etc. are routed via ``assistant_output_phase`` before this path.
+        ``goal_completion``, ``chitchat``, etc. are routed via ``assistant_output_phase`` before this path.
 
         Subgraph streams without RFC-614 phases are skipped in ``_handle_ai_message`` before
         this runs; loop-tagged subgraph finals use ``_dispatch_loop_tagged_assistant_text``.

{soothe_cli-0.7.2 → soothe_cli-0.7.4}/src/soothe_cli/runtime/parse/tool_call_resolution.py

@@ -152,7 +152,7 @@ def should_ingest_tool_for_step_stats(
     """Whether the TUI should register a tool row for step-card stats.
 
     Main execute-graph tools are tracked as soon as ``tool_call_id`` and ``tool_name``
-    are known; display does not wait for streamed args. Subgraph explore tools often
+    are known; display does not wait for streamed args. Subgraph tools often
     arrive with placeholder kwargs before real args.
     """
     from soothe_sdk.ux.task_namespace import is_step_level_task_tool_id
@@ -165,7 +165,7 @@ def should_ingest_tool_for_step_stats(
         return True
     if is_step_card_scope:
         return not is_step_level_task_tool_id(tcid)
-    # Subgraph explore tools often arrive with ``{"_subgraph_tool": true}`` before real args.
+    # Subgraph tools often arrive with ``{"_subgraph_tool": true}`` before real args.
     return is_task_level_subgraph_tool_call_id(tcid)
 
 
@@ -456,6 +456,11 @@ def materialize_ai_blocks_with_resolved_tools(
     append + backfill + merge passes).
     """
     tool_only = [b for b in expanded_blocks if isinstance(b, dict) and is_toolish_display_block(b)]
+    is_text_only_chunk = (
+        bool(expanded_blocks)
+        and not tool_only
+        and all(isinstance(b, dict) and b.get("type") == "text" for b in expanded_blocks)
+    )
     resolved = resolve_tool_invocations_for_display(
         message,
         tool_only,
@@ -491,6 +496,11 @@ def materialize_ai_blocks_with_resolved_tools(
 
     for r in resolved:
         if r.tool_call_id not in seen_tool_ids:
+            # Plain text stream deltas must not inherit stale ``tool_calls`` from
+            # the LangChain message object — that appended phantom tool blocks and
+            # forced a flush+pop between every text token (weather-style trivial).
+            if is_text_only_chunk:
+                continue
             out.append(
                 {
                     "type": "tool_call",

{soothe_cli-0.7.2 → soothe_cli-0.7.4}/src/soothe_cli/runtime/presentation/engine.py

@@ -49,7 +49,7 @@ class PresentationEngine:
 
     @property
     def final_answer_locked(self) -> bool:
-        """True after a custom final or quiz-phase response was emitted for this turn."""
+        """True after a custom final or chitchat-phase response was emitted for this turn."""
         return self._state.final_answer_locked
 
     def mark_final_answer_locked(self) -> None:

{soothe_cli-0.7.2 → soothe_cli-0.7.4}/src/soothe_cli/runtime/presentation/renderer_protocol.py

@@ -141,7 +141,7 @@ class RendererProtocol(Protocol):
         Catch-all for events not covered by specific callbacks.
 
         Args:
-            event_type: Full event type string (e.g., ``soothe.subagent.explore.started``).
+            event_type: Full event type string (e.g., ``soothe.subagent.tacitus.started``).
             data: Event payload.
             namespace: Subagent namespace tuple (empty for main agent).
             task_scope: When subgraph streams are bound to a Task tool call (IG-334).

soothe_cli-0.7.4/src/soothe_cli/runtime/presentation/subagent_task_display.py

@@ -0,0 +1,112 @@
+"""Format subagent Task-scope assistant blobs for CLI/TUI.
+
+Tacitus emits structured JSON in subgraph assistant streams. Clients show
+user-facing summaries only; internal planning JSON is suppressed.
+"""
+
+from __future__ import annotations
+
+import json
+from collections.abc import Iterator
+from typing import Any
+
+
+def _is_tacitus_internal_json_object(obj: dict[str, Any]) -> bool:
+    """True when ``obj`` is Tacitus engine scratch (not a user-facing report)."""
+    keys = set(obj.keys())
+    if "sub_questions" in keys:
+        return True
+    if "queries" in keys and "query" not in keys:
+        return True
+    if "is_sufficient" in keys or "follow_up_queries" in keys or "knowledge_gap" in keys:
+        return True
+    return False
+
+
+def _iter_embedded_json_objects(raw: str) -> Iterator[dict[str, Any]]:
+    """Yield dict objects embedded anywhere in ``raw`` (prose + concatenated JSON)."""
+    dec = json.JSONDecoder()
+    i = 0
+    s = raw
+    n = len(s)
+    while i < n:
+        brace = s.find("{", i)
+        if brace < 0:
+            break
+        try:
+            obj, end = dec.raw_decode(s, brace)
+        except json.JSONDecodeError:
+            i = brace + 1
+            continue
+        if isinstance(obj, dict):
+            yield obj
+        i = end
+
+
+def _strip_concatenated_json_objects(raw: str, *, predicate) -> str:
+    """Remove JSON objects matching ``predicate``; keep surrounding prose."""
+    stripped = raw.strip()
+    if not stripped:
+        return raw
+
+    dec_objects: list[tuple[int, int, dict[str, Any]]] = []
+    dec = json.JSONDecoder()
+    i = 0
+    n = len(stripped)
+    while i < n:
+        while i < n and stripped[i].isspace():
+            i += 1
+        if i >= n:
+            break
+        try:
+            obj, end = dec.raw_decode(stripped, i)
+        except json.JSONDecodeError:
+            break
+        if isinstance(obj, dict) and predicate(obj):
+            dec_objects.append((i, end, obj))
+        i = end
+
+    if not dec_objects:
+        return raw
+
+    parts: list[str] = []
+    cursor = 0
+    for start, end, _obj in dec_objects:
+        if start > cursor:
+            parts.append(stripped[cursor:start])
+        cursor = end
+    if cursor < n:
+        parts.append(stripped[cursor:])
+    return " ".join("".join(parts).split())
+
+
+def format_subagent_task_assistant_for_display(
+    raw: str,
+    *,
+    subagent_type: str | None = None,
+) -> str:
+    """Return display-safe assistant text for a delegated task namespace.
+
+    Args:
+        raw: Full assistant text from a subgraph namespace.
+        subagent_type: Built-in subagent id when known (``tacitus``, …).
+
+    Returns:
+        Scrubbed one-line text, or ``""`` when only internal payloads remain.
+    """
+    agent = (subagent_type or "").strip().lower()
+    text = raw
+    if agent == "tacitus":
+        stripped = text.strip()
+        internal_present = any(
+            _is_tacitus_internal_json_object(obj) for obj in _iter_embedded_json_objects(stripped)
+        )
+        if internal_present:
+            return ""
+        text = _strip_concatenated_json_objects(text, predicate=_is_tacitus_internal_json_object)
+    return (text or "").strip()
+
+
+__all__ = [
+    "format_subagent_task_assistant_for_display",
+]