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

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

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

{soothe_cli-0.7.3 → soothe_cli-0.7.4}/src/soothe_cli/runtime/state/step_router.py

@@ -445,7 +445,7 @@ class StepTaskRouter:
     ) -> bool:
         """Register one subgraph tool row on an already-resolved parent step card."""
         if _is_task_metadata_subgraph_tool(item):
-            # Inner explore ``task`` chunks are not user-facing tool stats; ingesting
+            # Inner subagent ``task`` chunks are not user-facing tool stats; ingesting
             # them used to rewrite the main ``{step}:s:task:…`` delegation row args.
             return True
         display = str(item.display_key or "").strip()

{soothe_cli-0.7.3 → soothe_cli-0.7.4}/src/soothe_cli/runtime/transport/session.py

@@ -552,6 +552,70 @@ class TuiDaemonSession:
             success=True,
         )
 
+    async def fetch_loop_history(self, loop_id: str) -> SimpleNamespace:
+        """Fetch goal display snapshots plus live card tail (RFC-631).
+
+        Args:
+            loop_id: StrangeLoop id.
+
+        Returns:
+            ``SimpleNamespace`` with ``goals``, ``live_cards``, ``live_goal_index``,
+            ``context_tokens``, and ``success``.
+        """
+        lid = str(loop_id or "").strip()
+        if not lid:
+            return SimpleNamespace(
+                goals=[],
+                live_cards=[],
+                live_goal_index=None,
+                context_tokens=0,
+                success=False,
+            )
+
+        async with self._rpc_lock:
+            await self._ensure_rpc_connected()
+            try:
+                resp = await self._rpc_client.request(
+                    "loop_history_fetch",
+                    {"loop_id": lid},
+                    timeout=30.0,
+                )
+            except Exception:
+                logger.warning(
+                    "loop_history_fetch failed for loop %s",
+                    lid[:16],
+                    exc_info=True,
+                )
+                return SimpleNamespace(
+                    goals=[],
+                    live_cards=[],
+                    live_goal_index=None,
+                    context_tokens=0,
+                    success=False,
+                )
+
+        goals_raw = resp.get("goals")
+        goals = list(goals_raw) if isinstance(goals_raw, list) else []
+        live_raw = resp.get("live_cards")
+        live_cards = list(live_raw) if isinstance(live_raw, list) else []
+        live_goal_index = resp.get("live_goal_index")
+        if live_goal_index is not None and not isinstance(live_goal_index, int):
+            live_goal_index = None
+        context_tokens_raw = resp.get("context_tokens")
+        context_tokens = (
+            context_tokens_raw
+            if isinstance(context_tokens_raw, int) and context_tokens_raw >= 0
+            else 0
+        )
+        success = bool(resp.get("success", True))
+        return SimpleNamespace(
+            goals=goals,
+            live_cards=live_cards,
+            live_goal_index=live_goal_index,
+            context_tokens=context_tokens,
+            success=success,
+        )
+
     async def aget_loop_state(self, loop_id: str) -> Any:
         """Load StrangeLoop state channels from the daemon (``loop_state_get`` RPC).
 

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

@@ -300,6 +300,12 @@ class SootheApp(
         self._message_store = MessageStore()
         """Message virtualization store."""
 
+        self._loop_history_load_lock = asyncio.Lock()
+        """Serialize resume history loads to prevent duplicate widget mounts."""
+
+        self._loop_history_loaded_for: str | None = None
+        """Loop id whose transcript was last painted by ``_load_loop_history``."""
+
         self._hydrate_scheduled = False
         """Whether a hydrate task has been queued via `call_later`."""
 
@@ -355,8 +361,7 @@ class SootheApp(
 
         Most styling uses Textual's built-in variables (`$primary`,
         `$text-muted`, `$error-muted`, etc.).  This override injects the
-        app-specific variables (`$mode-bash`, `$mode-command`, `$skill`,
-        `$skill-hover`, `$tool`, `$tool-hover`, `$cognition`, `$cognition-hover`)
+        app-specific variables (`$mode-bash`, `$mode-command`, `$cognition`)
         that have no Textual equivalent.
 
         Returns:
@@ -378,7 +383,6 @@ class SootheApp(
                 yield WelcomeBanner(
                     loop_id=self._lc_loop_id,
                     mcp_tool_count=self._mcp_tool_count,
-                    workspace_path=self._cwd,
                     id="welcome-banner",
                 )
                 yield Container(id="messages")

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

@@ -494,6 +494,10 @@ class _ExecutionMixin:
         elif cmd == "/help":
             await self._show_help_screen()
 
+        elif cmd == "/goals":
+            await self._mount_message(UserMessage(command))
+            await self._show_goal_history()
+
         elif cmd in {"/changelog", "/docs", "/feedback"}:
             await self._open_url_command(command, cmd)
         elif cmd == "/version":
@@ -889,25 +893,42 @@ class _ExecutionMixin:
         self._inflight_turn_stats = turn_stats
         self._inflight_turn_start = time.monotonic()
         try:
-            await execute_task_textual(
-                user_input=message,
-                daemon_session=self._daemon_session,
-                assistant_id=self._assistant_id,
-                session_state=self._session_state,
-                adapter=self._ui_adapter,
-                image_tracker=self._image_tracker,
-                sandbox_type=self._sandbox_type,
-                workspace=self._cwd,
-                message_kwargs=message_kwargs,
-                context=CLIContext(
-                    model=self._model_override,
-                    model_params=self._model_params_override or {},
-                ),
-                turn_stats=turn_stats,
-                skip_daemon_send_turn=skip_daemon_send_turn,
-                clarification_mode=getattr(self, "_clarification_mode", None),
-                is_shutting_down=lambda: getattr(self, "_exit", False),
-            )
+            for attempt in (1, 2):
+                try:
+                    await execute_task_textual(
+                        user_input=message,
+                        daemon_session=self._daemon_session,
+                        assistant_id=self._assistant_id,
+                        session_state=self._session_state,
+                        adapter=self._ui_adapter,
+                        image_tracker=self._image_tracker,
+                        sandbox_type=self._sandbox_type,
+                        workspace=self._cwd,
+                        message_kwargs=message_kwargs,
+                        context=CLIContext(
+                            model=self._model_override,
+                            model_params=self._model_params_override or {},
+                        ),
+                        turn_stats=turn_stats,
+                        skip_daemon_send_turn=skip_daemon_send_turn,
+                        clarification_mode=getattr(self, "_clarification_mode", None),
+                        is_shutting_down=lambda: getattr(self, "_exit", False),
+                    )
+                    break
+                except Exception as e:
+                    if (
+                        attempt == 1
+                        and self._daemon_session is not None
+                        and is_daemon_connection_error(e)
+                    ):
+                        try:
+                            await self._daemon_session.ensure_connected()
+                            logger.info("Retrying turn after daemon reconnect")
+                            skip_daemon_send_turn = False
+                            continue
+                        except (ConnectionError, OSError, TimeoutError):
+                            pass
+                    raise
         except Exception as e:  # Resilient tool rendering
             logger.exception("Agent execution failed")
             if is_daemon_connection_error(e):