soothe-cli 0.5.28__tar.gz → 0.5.30__tar.gz

{soothe_cli-0.5.28 → soothe_cli-0.5.30}/.gitignore

@@ -218,3 +218,4 @@ __MACOSX
 .qoder
 .soothe
 deploy/config.yml
+.backups/

{soothe_cli-0.5.28 → soothe_cli-0.5.30}/PKG-INFO

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

@@ -91,7 +91,7 @@ def run(
         detail = client.get_goal(goal_id)
         goal = detail.get("goal") or {}
         status = goal.get("status", "unknown")
-        if status in ("completed", "failed", "suspended"):
+        if status in ("completed", "failed", "cancelled", "suspended"):
             typer.echo(f"Goal {goal_id[:8]}: {status}")
             if status == "failed":
                 sys.exit(1)
@@ -133,27 +133,121 @@ def status() -> None:
 
 
 @app.command("list")
-def list_goals(
+def list_jobs(
     status_filter: str = typer.Option("", "--status", "-s", help="Filter by status."),
 ) -> None:
-    """List goals from the live daemon autopilot DAG."""
+    """List jobs (root goals) from the daemon autopilot.
+
+    Jobs are user-submitted tasks. Subgoals created during autonomous
+    execution are not shown here; use 'goal <id>' to inspect subgoals.
+    """
     client = _require_daemon_http()
-    payload = client.list_goals()
-    goals = payload.get("goals") or []
-    if not goals:
-        typer.echo("No goals found.")
+    payload = client.list_jobs()
+    jobs = payload.get("jobs") or []
+    if not jobs:
+        typer.echo("No jobs found.")
         return
 
-    for g in goals:
-        if status_filter and g.get("status", "") != status_filter:
+    for j in jobs:
+        if status_filter and j.get("status", "") != status_filter:
             continue
-        sid = g.get("id", "?")[:8]
-        sdesc = preview_first(g.get("description", ""), 60)
-        sstat = g.get("status", "pending")
-        spri = g.get("priority", 50)
+        sid = j.get("id", "?")[:8]
+        sdesc = preview_first(j.get("description", ""), 60)
+        sstat = j.get("status", "pending")
+        spri = j.get("priority", 50)
         typer.echo(f"  [{sid}] {sstat:10s} pri={spri:3d}  {sdesc}")
 
 
+def _render_dag_tree(dag: dict, root_id: str) -> None:
+    """Render DAG as ASCII tree for job visualization."""
+    nodes = {n["id"]: n for n in dag.get("nodes", [])}
+    edges = dag.get("edges", [])
+
+    # Build children map from edges
+    children: dict[str, list[str]] = {}
+    for edge in edges:
+        src = edge.get("source")
+        tgt = edge.get("target")
+        if src and tgt:
+            if src not in children:
+                children[src] = []
+            children[src].append(tgt)
+
+    def render_node(goal_id: str, indent: str = "", is_last: bool = True) -> None:
+        node = nodes.get(goal_id)
+        if not node:
+            return
+
+        # Prefix for this level
+        if indent:
+            prefix = indent + ("└─ " if is_last else "├─ ")
+        else:
+            prefix = ""
+
+        status = node.get("status", "pending")
+        desc = preview_first(node.get("description", ""), 50)
+        typer.echo(f'{prefix}{goal_id[:8]} ({status}) "{desc}"')
+
+        # Render children
+        child_ids = children.get(goal_id, [])
+        for i, child_id in enumerate(child_ids):
+            child_indent = indent + ("    " if is_last else "│   ")
+            render_node(child_id, child_indent, i == len(child_ids) - 1)
+
+    render_node(root_id)
+
+
+@app.command("job")
+def show_job(
+    job_id: str = typer.Argument(..., help="Job ID to show details and DAG."),
+) -> None:
+    """Show job status and DAG tree visualization.
+
+    A job is a root goal submitted by the user. This command shows
+    the job's details and the complete goal DAG under it.
+    """
+    client = _require_daemon_http()
+    try:
+        payload = client.get_job(job_id)
+    except RuntimeError as exc:
+        typer.echo(str(exc), err=True)
+        raise typer.Exit(1)
+
+    job = payload.get("job")
+    dag = payload.get("dag")
+
+    if not job:
+        typer.echo(f"Job '{job_id}' not found.", err=True)
+        raise typer.Exit(1)
+
+    # Job header
+    typer.echo(f"Job ID:          {job.get('id')}")
+    typer.echo(f"Status:          {job.get('status', 'pending')}")
+    typer.echo(f"Priority:        {job.get('priority', 50)}")
+    if job.get("workspace"):
+        typer.echo(f"Workspace:       {job['workspace']}")
+    created = job.get("created_at", "")
+    if created:
+        # Truncate timestamp for readability
+        created_short = created[:19] if len(created) > 19 else created
+        typer.echo(f"Created:         {created_short}")
+
+    # DAG stats from response
+    active = payload.get("active_goals", 0)
+    completed = payload.get("completed_goals", 0)
+    total = payload.get("total_goals", 0)
+    typer.echo(f"Active goals:    {active}")
+    typer.echo(f"Completed goals: {completed}")
+    typer.echo(f"Total goals:     {total}")
+
+    # DAG tree
+    typer.echo("\nDAG:")
+    if dag:
+        _render_dag_tree(dag, job_id)
+    else:
+        typer.echo("  (no subgoals)")
+
+
 @app.command("goal")
 def show_goal(
     goal_id: str = typer.Argument(..., help="Goal ID to show details for."),
@@ -216,6 +310,26 @@ def reject_goal(
     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."),
+) -> None:
+    """Resume a suspended or blocked goal.
+
+    Reactivates a paused goal back to pending status so the scheduler
+    can pick it up for execution. Use 'jobs' to list goals and their status.
+    """
+    client = _require_daemon_http()
+    try:
+        result = client.resume(goal_id)
+    except RuntimeError as exc:
+        typer.echo(str(exc), err=True)
+        raise typer.Exit(1) from exc
+    typer.echo(
+        f"Goal resumed: {result.get('goal_id', goal_id)} → {result.get('new_status', 'pending')}"
+    )
+
+
 @app.command("wake")
 def wake() -> None:
     """Exit dreaming mode — resume active execution."""

soothe_cli-0.5.30/src/soothe_cli/runtime/parse/_utils.py

@@ -0,0 +1,14 @@
+"""Re-export shim for ``soothe_sdk.display._text_utils`` (RFC-413).
+
+These utilities live in the SDK so the daemon-resident ``CardBinder`` can
+reuse them. This module preserves the original CLI import path.
+"""
+
+from __future__ import annotations
+
+from soothe_sdk.display._text_utils import (
+    normalize_tool_name,
+    text_looks_like_error,
+)
+
+__all__ = ["normalize_tool_name", "text_looks_like_error"]

soothe_cli-0.5.30/src/soothe_cli/runtime/parse/message_processing.py

@@ -0,0 +1,51 @@
+"""Re-export shim for ``soothe_sdk.display.message_processing`` (RFC-413).
+
+These helpers live in the SDK so the daemon-resident ``CardBinder`` can
+reuse them. This module preserves the original CLI import path used
+across the runtime, TUI, and tests.
+"""
+
+from __future__ import annotations
+
+# Underscore-prefixed names below are re-exported intentionally — they are
+# imported by other CLI modules (tool_call_resolution, widgets/messages, etc.)
+# and CLI tests. Keep them in __all__ to keep `ruff` from stripping them.
+from soothe_sdk.display.message_processing import (
+    _normalize_tool_name_for_arg_map,
+    _pending_or_overlay_id_matches_lookup,
+    _resolve_pending_lookup_tool_name,
+    accumulate_tool_call_chunks,
+    coerce_tool_call_args_to_dict,
+    coerce_tool_call_entry_to_dict,
+    extract_tool_args_dict,
+    extract_tool_brief,
+    finalize_pending_tool_call,
+    ingest_tool_call_stream_state,
+    normalize_tool_calls_list,
+    richest_pending_args_for_lookup,
+    seed_pending_tool_calls_from_message,
+    tool_calls_have_any_arg_dict,
+    tool_ids_touched_by_stream_message,
+    tool_lookup_step_id,
+    try_parse_pending_tool_call_args,
+)
+
+__all__ = [
+    "_normalize_tool_name_for_arg_map",
+    "_pending_or_overlay_id_matches_lookup",
+    "_resolve_pending_lookup_tool_name",
+    "accumulate_tool_call_chunks",
+    "coerce_tool_call_args_to_dict",
+    "coerce_tool_call_entry_to_dict",
+    "extract_tool_args_dict",
+    "extract_tool_brief",
+    "finalize_pending_tool_call",
+    "ingest_tool_call_stream_state",
+    "normalize_tool_calls_list",
+    "richest_pending_args_for_lookup",
+    "seed_pending_tool_calls_from_message",
+    "tool_calls_have_any_arg_dict",
+    "tool_ids_touched_by_stream_message",
+    "tool_lookup_step_id",
+    "try_parse_pending_tool_call_args",
+]

soothe_cli-0.5.30/src/soothe_cli/runtime/parse/tool_message_format.py

@@ -0,0 +1,17 @@
+"""Re-export shim for ``soothe_sdk.display.tool_message_format`` (RFC-413)."""
+
+from __future__ import annotations
+
+from soothe_sdk.display.tool_message_format import (
+    format_content_block_for_tool_display,
+    format_tool_message_content,
+    run_python_envelope_indicates_failure,
+    try_parse_run_python_result_envelope,
+)
+
+__all__ = [
+    "format_content_block_for_tool_display",
+    "format_tool_message_content",
+    "run_python_envelope_indicates_failure",
+    "try_parse_run_python_result_envelope",
+]

soothe_cli-0.5.30/src/soothe_cli/runtime/parse/tool_result.py

@@ -0,0 +1,15 @@
+"""Re-export shim for ``soothe_sdk.display.tool_result`` (RFC-413)."""
+
+from __future__ import annotations
+
+from soothe_sdk.display.tool_result import (
+    ToolResultPayload,
+    extract_tool_result_payload,
+    infer_tool_output_suggests_error,
+)
+
+__all__ = [
+    "ToolResultPayload",
+    "extract_tool_result_payload",
+    "infer_tool_output_suggests_error",
+]

soothe_cli-0.5.30/src/soothe_cli/runtime/state/transcript.py

@@ -0,0 +1,24 @@
+"""Transcript message models for TUI display.
+
+These types live in ``soothe_sdk.display.transcript_types`` so they can be
+shared with the daemon-resident ``CardBinder`` (RFC-413). This module
+re-exports them to preserve the CLI's existing import paths.
+
+DOM virtualization lives in ``soothe_cli.tui.widgets.message_store``.
+"""
+
+from __future__ import annotations
+
+from soothe_sdk.display.transcript_types import (
+    UPDATABLE_FIELDS,
+    MessageData,
+    MessageType,
+    ToolStatus,
+)
+
+__all__ = [
+    "UPDATABLE_FIELDS",
+    "MessageData",
+    "MessageType",
+    "ToolStatus",
+]

{soothe_cli-0.5.28 → soothe_cli-0.5.30}/src/soothe_cli/runtime/transport/session.py

@@ -32,7 +32,13 @@ _POST_IDLE_DRAIN_DEADLINE_S = 2.5
 class TuiDaemonSession:
     """Own the daemon websocket session used by the TUI."""
 
-    def __init__(self, cfg: Any, *, workspace: str | None = None) -> None:
+    def __init__(
+        self,
+        cfg: Any,
+        *,
+        workspace: str | None = None,
+        post_idle_drain_deadline: float = _POST_IDLE_DRAIN_DEADLINE_S,
+    ) -> None:
         self._cfg = cfg
         self._workspace = workspace
         ws_url = websocket_url_from_config(cfg)
@@ -43,6 +49,7 @@ class TuiDaemonSession:
         self._rpc_lock = asyncio.Lock()
         self._rpc_connected = False
         self._streaming = False
+        self._post_idle_drain_deadline = post_idle_drain_deadline
         self.turn_event_stats = TurnEventStats()
 
     @property
@@ -178,7 +185,9 @@ class TuiDaemonSession:
     ) -> Any:
         """Yield stream chunks that arrive just after ``idle`` (headless client parity)."""
         loop = asyncio.get_running_loop()
-        deadline = loop.time() + _POST_IDLE_DRAIN_DEADLINE_S
+        deadline = loop.time() + getattr(
+            self, "_post_idle_drain_deadline", _POST_IDLE_DRAIN_DEADLINE_S
+        )
         exp = expected_loop_id
         while loop.time() < deadline:
             try:
@@ -381,6 +390,57 @@ class TuiDaemonSession:
         await connect_websocket_with_retries(self._rpc_client)
         self._rpc_connected = True
 
+    async def fetch_loop_cards(self, loop_id: str) -> SimpleNamespace:
+        """Fetch the daemon's bound display-card snapshot for a loop.
+
+        RFC-413: returns a populated ledger (eagerly backfilled if the loop
+        has no ``cards.jsonl`` yet) so resume can render through the same
+        binder that produced the original cards.
+
+        Args:
+            loop_id: AgentLoop id.
+
+        Returns:
+            ``SimpleNamespace`` with ``cards: list[dict]``, ``seq: int``,
+            ``success: bool``. On error, ``cards=[]`` and ``success=False`` so
+            the caller can fall back to the legacy resume path.
+        """
+        lid = str(loop_id or "").strip()
+        if not lid:
+            return SimpleNamespace(cards=[], seq=0, success=False)
+
+        async with self._rpc_lock:
+            await self._ensure_rpc_connected()
+            try:
+                resp = await self._rpc_client.request_response(
+                    {"type": "loop_cards_fetch", "loop_id": lid},
+                    response_type="loop_cards_fetch_response",
+                    timeout=30.0,
+                )
+            except Exception:
+                logger.warning(
+                    "loop_cards_fetch failed for loop %s",
+                    lid[:16],
+                    exc_info=True,
+                )
+                return SimpleNamespace(cards=[], seq=0, success=False)
+
+        raw_cards = resp.get("cards")
+        cards = list(raw_cards) if isinstance(raw_cards, list) else []
+        seq = int(resp.get("seq") or 0)
+        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
+        )
+        return SimpleNamespace(
+            cards=cards,
+            seq=seq,
+            context_tokens=context_tokens,
+            success=True,
+        )
+
     async def aget_loop_state(self, loop_id: str) -> Any:
         """Load agent-loop state channels from the daemon (``loop_state_get`` RPC).
 

soothe_cli-0.5.30/src/soothe_cli/runtime/wire/display_text.py

@@ -0,0 +1,15 @@
+"""Re-export shim for ``soothe_sdk.display.text_extract`` (RFC-413)."""
+
+from __future__ import annotations
+
+from soothe_sdk.display.text_extract import (
+    extract_ai_text_for_display,
+    extract_user_text_for_display,
+    normalize_stream_message,
+)
+
+__all__ = [
+    "extract_ai_text_for_display",
+    "extract_user_text_for_display",
+    "normalize_stream_message",
+]

{soothe_cli-0.5.28 → soothe_cli-0.5.30}/src/soothe_cli/runtime/wire/message_text.py

@@ -25,7 +25,7 @@ def extract_text_from_message_content(content: Any) -> str:
                 parts.append(block)
             elif isinstance(block, dict) and "text" in block:
                 parts.append(str(block["text"]))
-        return "".join(parts)
+        return "\n".join(parts)
     return ""
 
 
@@ -41,7 +41,7 @@ def extract_plain_text_from_stream_message(msg: Any) -> str:
                 if text:
                     texts.append(str(text))
         if texts:
-            return "".join(texts)
+            return "\n".join(texts)
     if hasattr(msg, "content"):
         return extract_text_from_message_content(getattr(msg, "content", None))
     if isinstance(msg, dict):
@@ -54,7 +54,7 @@ def extract_plain_text_from_stream_message(msg: Any) -> str:
                     text = block.get("text", "")
                     if text:
                         texts.append(str(text))
-            return "".join(texts)
+            return "\n".join(texts)
         content = body.get("content", "")
         if isinstance(content, str):
             return content

{soothe_cli-0.5.28 → soothe_cli-0.5.30}/src/soothe_cli/tui/app/_app.py

@@ -224,6 +224,9 @@ class SootheApp(
 
         self._agent_running = False
 
+        self._bg_event_worker: Worker[None] | None = None
+        """Background daemon event consumer worker (cancelled on active turn start)."""
+
         self._server_startup_error: str | None = None
         """Set when daemon bootstrap fails; persists for the session lifetime."""
 

{soothe_cli-0.5.28 → soothe_cli-0.5.30}/src/soothe_cli/tui/app/_execution.py

@@ -246,7 +246,12 @@ class _ExecutionMixin:
         # 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.
-        await self._run_agent_task(payload_text)
+        #
+        # Use ``_send_to_agent`` (not a direct ``await _run_agent_task``) so the
+        # resumed turn runs in a Textual worker. Awaiting the task inline blocks
+        # the message handler — and therefore the event loop — until the loop
+        # next pauses, which freezes scrolling and chat-input focus.
+        await self._send_to_agent(payload_text)
 
     async def _handle_shell_command(self, command: str) -> None:
         """Handle a shell command (! prefix).
@@ -335,10 +340,13 @@ class _ExecutionMixin:
         self._shell_process = None
         self._shell_running = False
         self._shell_worker = None
-        if was_interrupted:
-            await self._mount_message(AppMessage("Command interrupted"))
+
+        # Restore input focus first so the user can type immediately.
         if self._chat_input:
             self._chat_input.set_cursor_active(active=True)
+
+        if was_interrupted:
+            await self._mount_message(AppMessage("Command interrupted"))
         try:
             await self._maybe_drain_deferred()
         except Exception:
@@ -485,10 +493,10 @@ class _ExecutionMixin:
         elif cmd == "/help":
             await self._mount_message(UserMessage(command))
             help_body = (
-                "Commands: /quit, /clear, /editor, /autopilot, /mcp, "
+                "Commands: /quit, /clear, /editor, /autopilot <task>, /autopilot-dashboard, /mcp, "
                 "/model [--model-params JSON] [--default], /notifications, "
                 "/reload, /skill:<name>, /theme, "
-                "/tokens, /loops, "
+                "/tokens, /resume, "
                 "/research, /explore, /plan, /«subagent» (when configured), "
                 "/update, /auto-update, /changelog, /docs, /feedback, /help\n\n"
                 "Interactive Features:\n"
@@ -571,7 +579,7 @@ class _ExecutionMixin:
                     await self._mount_message(AppMessage(f"Started new loop: {new_loop_id}"))
         elif cmd == "/editor":
             await self.action_open_editor()
-        elif cmd == "/loops":
+        elif cmd == "/resume":
             await self._show_loop_selector()
         elif cmd == "/update":
             await self._handle_update_command()
@@ -628,7 +636,19 @@ class _ExecutionMixin:
             args = command.strip()[len("/skill-creator") :].strip()
             rewritten = f"/skill:skill-creator {args}" if args else "/skill:skill-creator"
             await self._handle_skill_command(rewritten)
-        elif cmd == "/autopilot":
+        elif cmd == "/autopilot" or cmd.startswith("/autopilot "):
+            # Submit autopilot job via HTTP REST (like CLI `soothe autopilot run`)
+            args = command.strip()[len("/autopilot") :].strip()
+            if not args:
+                await self._mount_message(UserMessage(command))
+                await self._mount_message(
+                    AppMessage(
+                        "Usage: /autopilot <task description>\nExample: /autopilot refactor the auth module"
+                    )
+                )
+                return
+            await self._submit_autopilot_job(args)
+        elif cmd == "/autopilot-dashboard":
             await self._show_autopilot_dashboard()
         elif cmd == "/mcp":
             await self._show_mcp_viewer()
@@ -813,6 +833,12 @@ class _ExecutionMixin:
                     return
             self._agent_running = True
 
+            # Cancel background event consumer so it doesn't compete for
+            # WebSocket reads with the active turn's iter_turn_chunks().
+            if self._bg_event_worker is not None:
+                self._bg_event_worker.cancel()
+                self._bg_event_worker = None
+
             if self._chat_input:
                 self._chat_input.set_cursor_active(active=False)
 
@@ -950,12 +976,14 @@ class _ExecutionMixin:
         self._agent_running = False
         self._agent_worker = None
 
-        # Remove spinner if present
-        await self._set_spinner(None)
-
+        # Restore input focus FIRST so the user can start typing immediately
+        # while remaining cleanup (spinner, tokens, deferred) runs.
         if self._chat_input:
             self._chat_input.set_cursor_active(active=True)
 
+        # Remove spinner if present
+        await self._set_spinner(None)
+
         # Ensure token display is restored (in case of early cancellation).
         # Pass the cached approximate flag so an interrupted "+" isn't clobbered.
         self._show_tokens(approximate=self._tokens_approximate)