soothe-cli 0.9.6__tar.gz → 0.9.7__tar.gz

{soothe_cli-0.9.6 → soothe_cli-0.9.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: soothe-cli
-Version: 0.9.6
+Version: 0.9.7
 Summary: Soothe CLI client - communicates with daemon via WebSocket
 Project-URL: Homepage, https://github.com/mirasoth/soothe
 Project-URL: Documentation, https://soothe.readthedocs.io
@@ -22,8 +22,9 @@ Requires-Dist: pillow<12.0.0,>=10.0.0
 Requires-Dist: python-dotenv<2.0.0,>=1.0.0
 Requires-Dist: pyyaml<7.0.0,>=6.0.0
 Requires-Dist: rich<15.0.0,>=13.0.0
-Requires-Dist: soothe-client-python<2.0.0,>=1.0.4
-Requires-Dist: soothe-sdk<2.0.0,>=1.0.2
+Requires-Dist: soothe-client-python<2.0.0,>=1.0.5
+Requires-Dist: soothe-sdk<2.0.0,>=1.0.7
+Requires-Dist: termaid<1.0.0,>=0.7.1
 Requires-Dist: textual<10.0.0,>=8.0.0
 Requires-Dist: typer<2.0.0,>=0.9.0
 Requires-Dist: websockets<16.0,>=12.0

{soothe_cli-0.9.6 → soothe_cli-0.9.7}/pyproject.toml

@@ -23,11 +23,12 @@ classifiers = [
     "Topic :: Software Development :: Libraries :: Python Modules",
 ]
 dependencies = [
-    "soothe-sdk>=1.0.2,<2.0.0",    # events/display/wire contracts
-    "soothe-client-python>=1.0.4,<2.0.0",  # WebSocket transport client
+    "soothe-sdk>=1.0.7,<2.0.0",    # events/display/wire contracts
+    "soothe-client-python>=1.0.5,<2.0.0",  # WebSocket transport client
     "typer>=0.9.0,<2.0.0",          # CLI framework
     "textual>=8.0.0,<10.0.0",       # TUI framework
     "rich>=13.0.0,<15.0.0",         # Console output
+    "termaid>=0.7.1,<1.0.0",        # Mermaid → terminal diagram (goal-completion reports)
     "pyyaml>=6.0.0,<7.0.0",         # Config loading
     "python-dotenv>=1.0.0,<2.0.0",  # .env loading
     "websockets>=12.0,<16.0",       # WebSocket transport

{soothe_cli-0.9.6 → soothe_cli-0.9.7}/src/soothe_cli/cli/commands/loop_cmd.py

@@ -9,6 +9,7 @@ All loop operations use daemon WebSocket RPC; the daemon must be running.
 from __future__ import annotations
 
 import asyncio
+import logging
 import sys
 from typing import Annotated, Any
 
@@ -26,6 +27,7 @@ from soothe_client import (
 from soothe_cli.runtime import load_config
 
 console = Console()
+logger = logging.getLogger(__name__)
 
 # Create loop command group
 loop_app = typer.Typer(help="Manage StrangeLoop instances")
@@ -636,11 +638,19 @@ def continue_loop(
         str | None,
         typer.Option("--prompt", "-p", help="Optional prompt to send after continuing."),
     ] = None,
+    resume: Annotated[
+        bool,
+        typer.Option(
+            "--resume",
+            help="Resume from the daemon's last execution step index.",
+        ),
+    ] = False,
 ) -> None:
     """Continue execution on existing loop.
 
     Behavior:
     - Resolve target loop (explicit `LOOP_ID` or most-recent loop)
+    - When resuming, fetch execution state (iteration/step/status) from daemon
     - Launch TUI on that loop
     - Optionally submit initial prompt in the resumed session
 
@@ -648,6 +658,7 @@ def continue_loop(
         soothe loop continue
         soothe loop continue loop_abc123
         soothe loop continue loop_abc123 --prompt "translate to chinese"
+        soothe loop continue loop_abc123 --resume
     """
     config = load_config()
     ws_url = websocket_url_from_config(config)
@@ -658,6 +669,31 @@ def continue_loop(
     if loop_id:
         console.print(f"[info]Continuing loop: {resolved_loop_id}[/info]")
 
+    # Fetch execution state to show where the loop will pick up.
+    # Best-effort: non-fatal if the daemon cannot answer (older daemon, etc.)
+    if resume:
+        try:
+            state = asyncio.run(
+                protocol1_rpc(
+                    ws_url,
+                    "loop_execution_state_fetch",
+                    {"loop_id": resolved_loop_id},
+                )
+            )
+            if "error" not in state:
+                step_index = state.get("step_index", 0)
+                iteration = state.get("iteration", 0)
+                status = state.get("status", "unknown")
+                plan = state.get("plan")
+                console.print(
+                    f"[info]Resuming from iteration {iteration}, "
+                    f"step {step_index} ({status})[/info]"
+                )
+                if plan:
+                    console.print(f"[dim]  Plan: {plan}[/dim]")
+        except Exception:
+            logger.warning("Failed to fetch execution state for loop %s", resolved_loop_id[:16])
+
     from soothe_cli.cli.commands.run_cmd import run_impl
 
     run_impl(
@@ -677,8 +713,8 @@ def resume_loop(
         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)
+    """Resume execution on existing loop from the daemon's last step index."""
+    continue_loop(loop_id, prompt, resume=True)
 
 
 @loop_app.command("detach")

{soothe_cli-0.9.6 → soothe_cli-0.9.7}/src/soothe_cli/cli/commands/status_cmd.py

@@ -58,12 +58,13 @@ def _render_unified_status_table(
     daemon_live: bool = True,
     daemon_version: str | None = None,
     core_version: str | None = None,
+    started_at: str | None = None,
 ) -> Table:
     """Render unified status table without duplicated info.
 
     Sections:
     - Connection: WebSocket URL, Soothe Home
-    - Daemon: Running, Threads, PID, Versions (only when daemon is live)
+    - Daemon: Running, Threads, PID, Versions, Started (only when daemon is live)
     """
     table = Table(title="Soothe Status")
     table.add_column("Section", style="dim", width=12)
@@ -82,6 +83,8 @@ def _render_unified_status_table(
     table.add_row("Daemon", "Status", "[green]Running[/green]")
     if daemon_pid:
         table.add_row("", "PID", str(daemon_pid))
+    if started_at:
+        table.add_row("", "Started", started_at)
     if active_threads is not None:
         table.add_row("", "Active Threads", str(active_threads))
     if daemon_version:
@@ -176,6 +179,7 @@ def daemon_status(
             "port_live": status.get("port_live", True),
             "active_threads": status.get("active_threads", 0),
             "daemon_pid": status.get("daemon_pid"),
+            "started_at": status.get("started_at"),
             "daemon_version": status.get("daemon_version"),
             "core_version": status.get("core_version"),
             "readiness_state": status.get("readiness_state", "unknown"),
@@ -192,6 +196,7 @@ def daemon_status(
     daemon_pid = status.get("daemon_pid")
     daemon_version = status.get("daemon_version")
     core_version = status.get("core_version")
+    started_at = status.get("started_at")
     # Use readiness_state from daemon_status RPC (already includes state + message)
     readiness_state_from_status = (
         {
@@ -213,6 +218,7 @@ def daemon_status(
         daemon_live=True,
         daemon_version=daemon_version,
         core_version=core_version,
+        started_at=started_at,
     )
     console.print(table)
 
@@ -302,6 +308,7 @@ def status_main(
                 output["daemon"]["port_live"] = status.get("port_live", True)
                 output["daemon"]["active_threads"] = status.get("active_threads", 0)
                 output["daemon"]["daemon_pid"] = status.get("daemon_pid")
+                output["daemon"]["started_at"] = status.get("started_at")
                 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")
@@ -357,6 +364,7 @@ def status_main(
         daemon_live=True,
         daemon_version=daemon_version,
         core_version=core_version,
+        started_at=status.get("started_at"),
     )
     console.print(table)
 

{soothe_cli-0.9.6 → soothe_cli-0.9.7}/src/soothe_cli/cli/execution/headless_renderer.py

@@ -3,6 +3,9 @@
 Emits RFC-614 loop-tagged assistant text for the main graph (empty LangGraph namespace)
 and loop-tagged finals (including replayed ``goal_completion`` from IG-355). Subgraph
 namespaced prose is suppressed unless loop-tagged. Stderr is used for errors.
+
+UI transcript SoT is ``soothe.card.*`` (TUI / appkit); headless keeps raw ``messages``
+phases for stdout and does not project card frames.
 """
 
 from __future__ import annotations

soothe_cli-0.9.7/src/soothe_cli/cli/execution/launcher.py

@@ -0,0 +1,130 @@
+"""TUI execution mode."""
+
+import asyncio
+import sys
+from typing import Any
+
+import typer
+from soothe_client import protocol1_rpc, websocket_url_from_config
+
+from soothe_cli.config import CLIConfig
+
+# Module-level storage for the last TUI result (for post-exit tip display)
+# Use Any to avoid circular import issues at module load time
+_last_app_result: Any = None
+
+
+def get_last_app_result() -> Any:
+    """Return the result from the most recent TUI run.
+
+    Returns:
+        The AppResult from the last TUI session, or None if TUI hasn't run.
+    """
+    return _last_app_result
+
+
+def _resume_gate(cfg: CLIConfig, resume_loop_id: str) -> dict[str, Any] | None:
+    """Fetch execution state for a resumed loop before launching the TUI.
+
+    Returns the ``{plan, step_index, iteration, status}`` snapshot on success,
+    or ``None`` when the daemon is unreachable or the RPC fails (non-fatal —
+    resume proceeds regardless).
+    """
+    try:
+        ws_url = websocket_url_from_config(cfg)
+        response = asyncio.run(
+            protocol1_rpc(
+                ws_url,
+                "loop_execution_state_fetch",
+                {"loop_id": resume_loop_id},
+            )
+        )
+    except Exception:
+        return None
+
+    if isinstance(response, dict) and "error" not in response:
+        return response
+    return None
+
+
+def _prompt_resume(resume_loop_id: str, state: dict[str, Any]) -> bool:
+    """Prompt the user to confirm resume of an active loop.
+
+    Returns ``True`` if the user confirms (Enter / y), ``False`` to discard
+    (n / any other input). Non-interactive stdin (no TTY) defaults to resuming.
+    """
+    step_index = state.get("step_index", 0)
+    iteration = state.get("iteration", 0)
+    status = state.get("status", "unknown")
+    typer.echo(
+        f"Active loop found: {resume_loop_id} (iteration {iteration}, step {step_index}, {status})"
+    )
+
+    if not sys.stdin.isatty():
+        # Non-interactive: auto-resume.
+        typer.echo("Non-interactive stdin — resuming.")
+        return True
+
+    try:
+        answer = typer.prompt(
+            "Resume this loop?",
+            default="y",
+            show_default=True,
+        )
+    except (EOFError, KeyboardInterrupt):
+        return False
+
+    return answer.strip().lower() in ("y", "yes", "")
+
+
+def run_tui(
+    cfg: CLIConfig,
+    *,
+    resume_loop_id: str | None = None,
+    initial_prompt: str | None = None,
+) -> None:
+    """Launch the Textual TUI (with daemon auto-start)."""
+    global _last_app_result
+
+    # Resume gate: surface where the loop will pick up from the daemon's
+    # execution state before the TUI attaches.
+    if resume_loop_id:
+        state = _resume_gate(cfg, resume_loop_id)
+        if state is not None:
+            status = state.get("status", "unknown")
+            # Auto-resume loops in running/paused state only; terminal/idle
+            # states fall through to normal startup.
+            if status in ("running", "paused"):
+                should_resume = cfg.auto_resume or _prompt_resume(resume_loop_id, state)
+                if not should_resume:
+                    typer.echo("Loop discarded. Starting fresh session.")
+                    resume_loop_id = None
+                else:
+                    step_index = state.get("step_index", 0)
+                    iteration = state.get("iteration", 0)
+                    plan = state.get("plan")
+                    typer.echo(
+                        f"Resuming loop {resume_loop_id}: "
+                        f"iteration {iteration}, step {step_index} ({status})"
+                    )
+                    if plan:
+                        typer.echo(f"  Plan: {plan}")
+            else:
+                typer.echo(f"Loop {resume_loop_id} is {status} — starting fresh session.")
+                resume_loop_id = None
+
+    try:
+        from soothe_cli.tui import run_textual_tui
+
+        result = run_textual_tui(
+            config=cfg,
+            resume_loop_id=resume_loop_id,
+            initial_prompt=initial_prompt,
+        )
+        _last_app_result = result
+    except ImportError:
+        typer.echo(
+            "Error: Textual is required for the TUI. Install: pip install 'textual>=0.40.0'",
+            err=True,
+        )
+        sys.exit(1)

{soothe_cli-0.9.6 → soothe_cli-0.9.7}/src/soothe_cli/cli/main.py

@@ -147,6 +147,16 @@ def main(
             ),
         ),
     ] = None,
+    auto_resume: Annotated[
+        bool,
+        typer.Option(
+            "--auto-resume/--no-auto-resume",
+            help=(
+                "Auto-resume an active loop on startup without prompting. "
+                "Default: prompt ([Enter] to resume / n to discard)."
+            ),
+        ),
+    ] = False,
     show_help: Annotated[  # noqa: FBT002
         bool,
         typer.Option("--help", "-h", is_flag=True, help="Show this message and exit."),
@@ -203,6 +213,7 @@ def main(
         output_streaming_enabled=streaming,
         output_streaming_mode=streaming_mode,
         clarification_mode=mode,
+        auto_resume=auto_resume,
         soothe_home=home_path,
     )
     set_runtime_config(cli_cfg)

{soothe_cli-0.9.6 → soothe_cli-0.9.7}/src/soothe_cli/config/cli_config.py

@@ -43,6 +43,11 @@ class CLIConfig:
     clarification_mode: str | None = None
     """'manual' (relay to human) or 'auto' (veritas auto-answer). None = auto-detect from TTY."""
 
+    # Resume behavior: when the launcher finds an active loop on startup,
+    # auto-resume it (True) or prompt the user (False, default).
+    auto_resume: bool = False
+    """Auto-resume active loops on CLI startup without prompting (default: prompt)."""
+
     # Paths
     soothe_home: Path = field(default_factory=lambda: Path(SOOTHE_HOME))
 

{soothe_cli-0.9.6 → soothe_cli-0.9.7}/src/soothe_cli/runtime/state/step_router.py

@@ -11,6 +11,7 @@ this module adds TUI-oriented buffers and lifecycle for multiple concurrent step
 from __future__ import annotations
 
 from collections import deque
+from collections.abc import Callable
 from dataclasses import dataclass, field
 from typing import Any, TypeAlias
 
@@ -331,7 +332,7 @@ class StepTaskRouter:
 
         Some providers emit unified ids like ``{step}:s:call_<uuid>`` that do not
         encode a task index. In that case allocate a stable per-step synthetic
-        index so task activity rows and standalone SubAgent cards stay 1:1.
+        index so task activity rows stay 1:1 with delegated task markers.
         """
         sid = str(step_id).strip()
         tcid = str(tool_call_id).strip()
@@ -407,6 +408,23 @@ class StepTaskRouter:
             )
         )
 
+    def take_pending_main_tools_matching(
+        self,
+        predicate: Callable[[PendingMainTool], bool],
+    ) -> list[PendingMainTool]:
+        """Remove and return buffered main tools for which ``predicate`` is true."""
+        if not self._pending_main_tools:
+            return []
+        taken: list[PendingMainTool] = []
+        still: dict[str, PendingMainTool] = {}
+        for key, item in self._pending_main_tools.items():
+            if predicate(item):
+                taken.append(item)
+            else:
+                still[key] = item
+        self._pending_main_tools = still
+        return taken
+
     def route_pending_main_tools(
         self,
         step_cards: dict[str, StepWidget],
@@ -697,7 +715,7 @@ class StepTaskRouter:
         return list(self._pending_subgraph_tools.values())
 
     def discard_pending_subgraph_tool(self, ns_key: tuple[str, ...], lookup_id: str) -> None:
-        """Drop a buffered subgraph tool after routing it to a SubAgent card."""
+        """Drop a buffered subgraph tool after routing it to a step/orphan card."""
         self._pending_subgraph_tools.pop(_subgraph_pending_key(ns_key, lookup_id), None)
 
     @property

{soothe_cli-0.9.6 → soothe_cli-0.9.7}/src/soothe_cli/tui/app/_app.py

@@ -37,6 +37,7 @@ from soothe_cli.tui.app._module_init import (
 )
 from soothe_cli.tui.app._startup import _StartupMixin
 from soothe_cli.tui.app._ui import _UIMixin
+from soothe_cli.tui.tips import TipRotator
 from soothe_cli.tui.widgets.chat_input import ChatInput
 from soothe_cli.tui.widgets.loading import LoadingWidget
 from soothe_cli.tui.widgets.message_store import MessageStore
@@ -227,6 +228,9 @@ class SootheApp(
         self._default_session_tip: str = ""
         self._status_notification_timer: Timer | None = None
         self._status_notification_active = False
+        # Rotating tip source + interval timer for the status footer.
+        self._tip_rotator: TipRotator = TipRotator()
+        self._tip_rotation_timer: Timer | None = None
 
         self._chat_input: ChatInput | None = None
         self._plan_quick_view_overlay: PlanQuickViewOverlay | None = None
@@ -371,6 +375,32 @@ class SootheApp(
         if self._status_bar is not None and not self._status_notification_active:
             self._status_bar.set_session_tip(cleaned)
 
+    def start_tip_rotation(self, interval: float = 12.0) -> None:
+        """Cycle through rotating tips in the status footer at a fixed interval.
+
+        Args:
+            interval: Seconds between tip rotations.
+        """
+        self.stop_tip_rotation()
+        self._tip_rotation_timer = self.set_interval(interval, self._rotate_session_tip)
+
+    def stop_tip_rotation(self) -> None:
+        """Cancel the rotating-tip interval timer if one is running."""
+        if self._tip_rotation_timer is not None:
+            with suppress(Exception):
+                self._tip_rotation_timer.stop()
+            self._tip_rotation_timer = None
+
+    def _rotate_session_tip(self) -> None:
+        """Advance to the next tip and push it to the status footer.
+
+        Transient notifications take precedence: rotation is skipped while a
+        notification is active so it can run its timeout uninterrupted.
+        """
+        if self._status_notification_active:
+            return
+        self.set_default_session_tip(self._tip_rotator.next_tip())
+
     def _set_status_notification(self, message: str, *, timeout: float | None = None) -> None:
         """Render a transient notification in the status-tip area."""
         text = (message or "").strip()

{soothe_cli-0.9.6 → soothe_cli-0.9.7}/src/soothe_cli/tui/app/_execution.py

@@ -53,6 +53,28 @@ InputMode = Literal["normal", "shell", "command"]
 
 logger = logging.getLogger(__name__)
 
+_PLAN_REVIEW_ACTIONS = frozenset({"Approve", "Reject", "More comments"})
+
+
+def clarification_wire_content(answers: list[str]) -> str:
+    """Human-readable turn content for a clarification submit (not a new goal).
+
+    Plan-review actions use a stable ``Plan review: …`` prefix so a dropped
+    ``clarification_answer`` flag cannot turn bare ``Reject`` into Pass1 TASK.
+    """
+    non_empty = [a for a in answers if str(a).strip()]
+    if not non_empty:
+        return ""
+    first = str(answers[0]).strip() if answers else ""
+    if first in _PLAN_REVIEW_ACTIONS:
+        comments = str(answers[1]).strip() if len(answers) > 1 else ""
+        if comments:
+            return f"Plan review: {first} — {comments}"
+        return f"Plan review: {first}"
+    if len(non_empty) == 1:
+        return non_empty[0]
+    return " | ".join(f"A{i + 1}: {a}" for i, a in enumerate(answers) if str(a).strip())
+
 
 class _ExecutionMixin:
     """Agent execution, message routing, queue, shell commands, and daemon events."""
@@ -229,6 +251,23 @@ class _ExecutionMixin:
         # the user can still see what they answered.
         adapter._clarification_input_by_step.pop(event.step_id, None)
 
+        # A stale empty remount (resume re-emit) can leave another interactive
+        # plan-review card. Disable extras so a second click cannot fire a
+        # "Reject" turn after clarification_answered cleared the pending flag.
+        for sid, other in list(adapter._clarification_input_by_step.items()):
+            if sid == event.step_id:
+                continue
+            try:
+                other._submitted = True  # noqa: SLF001
+                other.add_class("is-submitted")
+                for btn in getattr(other, "_action_buttons", {}).values():
+                    btn.disabled = True
+                for inp in getattr(other, "_inputs", []) or []:
+                    inp.disabled = True
+            except Exception:  # noqa: BLE001
+                logger.debug("Failed to disarm leftover clarification widget", exc_info=True)
+            adapter._clarification_input_by_step.pop(sid, None)
+
         non_empty = [a for a in event.answers if a.strip()]
         if not non_empty:
             return
@@ -237,16 +276,16 @@ class _ExecutionMixin:
         # concatenated string. ``content`` carries a human-readable summary
         # for clients that look at it; the authoritative payload is the
         # ``clarification_answers`` wire field.
-        payload_text = (
-            non_empty[0]
-            if len(non_empty) == 1
-            else " | ".join(f"A{i + 1}: {a}" for i, a in enumerate(event.answers) if a.strip())
-        )
+        payload_text = clarification_wire_content(list(event.answers))
         adapter._clarification_answers_pending = list(event.answers)
+        # Always resume clarification from a widget submit — even if a prior
+        # clarification_answered cleared ``_clarification_pending`` (empty
+        # remount / race). Without this, "Reject" is treated as a new goal.
+        adapter._clarification_pending = True
 
         # Hand off to the standard turn pipeline. ``execute_task_textual``
-        # snapshots ``adapter._clarification_pending`` (still True) and sets
-        # the wire ``clarification_answer`` flag plus the ``clarification_answers``
+        # snapshots ``adapter._clarification_pending`` and sets the wire
+        # ``clarification_answer`` flag plus the ``clarification_answers``
         # list, then clears the persisted flag so a follow-up turn is treated
         # as a new goal.
         #
@@ -469,8 +508,7 @@ class _ExecutionMixin:
 
         # RFC-454 daemon *routing* commands (/deep_research, /plan, /browser_use, …):
         # 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 == "/deep_research …"`` never matches the bare single-token handlers below.
+        # strips the slash token and sets preferred_subagent (same as headless CLI).
         full_stripped = command.strip()
         first_word, query = parse_slash_command(full_stripped)
         if first_word: