soothe-cli 0.6.8__tar.gz → 0.6.9__tar.gz

{soothe_cli-0.6.8 → soothe_cli-0.6.9}/PKG-INFO

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

@@ -10,6 +10,7 @@ import asyncio
 import os
 import sys
 import time
+from collections import Counter
 from pathlib import Path
 
 import typer
@@ -124,12 +125,40 @@ def submit(
 
 @app.command("status")
 def status() -> None:
-    """Show overall autopilot state from the daemon."""
+    """Show overall autopilot state and goal DAG summary."""
     client = _require_daemon_http()
     data = client.status()
-    typer.echo(f"Autopilot state: {data.get('state', data.get('status', 'unknown'))}")
-    if "active_goals" in data:
-        typer.echo(f"Active goals: {len(data['active_goals'])}")
+    state = data.get("state", data.get("status", "unknown"))
+    running = data.get("running", False)
+    dreaming = data.get("dreaming", False)
+    typer.echo(f"Autopilot state: {state}")
+    typer.echo(f"Scheduling loop: {'running' if running else 'stopped'}")
+    if dreaming:
+        typer.echo("Dreaming: yes")
+    loop_pool = data.get("loop_pool")
+    if isinstance(loop_pool, dict) and loop_pool:
+        typer.echo(f"Worker pool: {loop_pool}")
+
+    jobs = client.list_jobs().get("jobs") or []
+    goals = client.list_goals().get("goals") or []
+    typer.echo(f"\nJobs (root goals): {len(jobs)}")
+    if goals:
+        counts = Counter(str(g.get("status", "pending")) for g in goals)
+        typer.echo(f"Goals in DAG: {len(goals)}")
+        for stat, count in sorted(counts.items()):
+            typer.echo(f"  {stat}: {count}")
+    elif not jobs:
+        typer.echo("Goals in DAG: 0")
+
+    if jobs:
+        typer.echo("\nJobs:")
+        for j in jobs:
+            jid = str(j.get("id", "?"))
+            sid = jid[:8]
+            sstat = j.get("status", "pending")
+            sdesc = preview_first(j.get("description", ""), 50)
+            typer.echo(f"  [{sid}] {sstat:10s}  {sdesc}")
+        typer.echo("\nFull DAG for a job: soothe autopilot job <job_id>")
 
 
 @app.command("list")
@@ -139,8 +168,20 @@ def list_jobs(
     """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.
+    execution are not shown here; use ``goals`` or ``goal <id>`` for details.
     """
+    _list_jobs_impl(status_filter)
+
+
+@app.command("jobs")
+def list_jobs_alias(
+    status_filter: str = typer.Option("", "--status", "-s", help="Filter by status."),
+) -> None:
+    """Alias for ``list`` — list root autopilot jobs."""
+    _list_jobs_impl(status_filter)
+
+
+def _list_jobs_impl(status_filter: str) -> None:
     client = _require_daemon_http()
     payload = client.list_jobs()
     jobs = payload.get("jobs") or []
@@ -158,6 +199,29 @@ def list_jobs(
         typer.echo(f"  [{sid}] {sstat:10s} pri={spri:3d}  {sdesc}")
 
 
+@app.command("goals")
+def list_goals(
+    status_filter: str = typer.Option("", "--status", "-s", help="Filter by status."),
+) -> None:
+    """List all goals in the daemon autopilot DAG (including subgoals)."""
+    client = _require_daemon_http()
+    payload = client.list_goals()
+    goals = payload.get("goals") or []
+    if not goals:
+        typer.echo("No goals found.")
+        return
+
+    for g in goals:
+        if status_filter and g.get("status", "") != status_filter:
+            continue
+        gid = str(g.get("id", "?"))[:8]
+        parent = g.get("parent_id")
+        parent_s = f" parent={str(parent)[:8]}" if parent else ""
+        desc = preview_first(g.get("description", ""), 50)
+        stat = g.get("status", "pending")
+        typer.echo(f"  [{gid}] {stat:10s}{parent_s}  {desc}")
+
+
 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", [])}
@@ -199,9 +263,9 @@ def _render_dag_tree(dag: dict, root_id: str) -> None:
 
 @app.command("job")
 def show_job(
-    job_id: str = typer.Argument(..., help="Job ID to show details and DAG."),
+    job_id: str = typer.Argument(..., help="Job ID to show details and goal DAG."),
 ) -> None:
-    """Show job status and DAG tree visualization.
+    """Show job status and goal 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.
@@ -211,7 +275,7 @@ def show_job(
         payload = client.get_job(job_id)
     except RuntimeError as exc:
         typer.echo(str(exc), err=True)
-        raise typer.Exit(1)
+        raise typer.Exit(1) from exc
 
     job = payload.get("job")
     dag = payload.get("dag")
@@ -228,11 +292,9 @@ def show_job(
         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)
@@ -240,10 +302,9 @@ def show_job(
     typer.echo(f"Completed goals: {completed}")
     typer.echo(f"Total goals:     {total}")
 
-    # DAG tree
-    typer.echo("\nDAG:")
+    typer.echo("\nGoal DAG:")
     if dag:
-        _render_dag_tree(dag, job_id)
+        _render_dag_tree(dag, str(job.get("id") or job_id))
     else:
         typer.echo("  (no subgoals)")
 

{soothe_cli-0.6.8 → soothe_cli-0.6.9}/src/soothe_cli/runtime/transport/session.py

@@ -45,6 +45,7 @@ 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
@@ -57,6 +58,11 @@ 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)
@@ -77,6 +83,8 @@ 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:

{soothe_cli-0.6.8 → soothe_cli-0.6.9}/src/soothe_cli/tui/app/_app.py

@@ -177,6 +177,7 @@ class SootheApp(
         # Active StrangeLoop id; LangGraph stores it as configurable.thread_id.
         # Named `_lc_loop_id` to avoid colliding with Textual's App._thread_id.
         self._lc_loop_id = resume_loop_id
+        self._loop_autopilot_mode: str = "solo"
 
         self._initial_prompt = initial_prompt
 

{soothe_cli-0.6.8 → soothe_cli-0.6.9}/src/soothe_cli/tui/app/_execution.py

@@ -570,6 +570,7 @@ class _ExecutionMixin:
                     )
                     self._session_state.loop_id = new_loop_id
                     self._lc_loop_id = new_loop_id
+                    self._apply_loop_autopilot_mode(status_event.get("autopilot_mode"))
                     try:
                         banner = self.query_one("#welcome-banner", WelcomeBanner)
                         banner.update_loop_id(new_loop_id)
@@ -650,6 +651,8 @@ class _ExecutionMixin:
             await self._submit_autopilot_job(args)
         elif cmd == "/autopilot-dashboard":
             await self._show_autopilot_dashboard()
+        elif cmd == "/autopilot-toggle":
+            await self._toggle_autopilot_mode()
         elif cmd == "/mcp":
             await self._show_mcp_viewer()
         elif cmd == "/theme":

{soothe_cli-0.6.8 → soothe_cli-0.6.9}/src/soothe_cli/tui/app/_model.py

@@ -265,12 +265,26 @@ class _ModelMixin:
             return None
         return resp.get("servers")
 
+    def _apply_loop_autopilot_mode(self, mode: str | None) -> None:
+        """Sync local Solo/Autopilot mode from daemon bootstrap or toggle events."""
+        if mode not in ("solo", "autopilot"):
+            return
+        self._loop_autopilot_mode = mode
+        if self._status_bar is not None:
+            label = "Autopilot" if mode == "autopilot" else "Solo"
+            self._status_bar.set_session_tip(f"Mode: {label}")
+
     async def _show_autopilot_dashboard(self) -> None:
         """Show autopilot dashboard as a screen overlay."""
         from soothe_cli.tui.widgets.autopilot_screen import AutopilotScreen
 
         is_narrow = self.size.width < 100
-        screen = AutopilotScreen(is_narrow=is_narrow)
+        mode = (
+            self._loop_autopilot_mode
+            if self._loop_autopilot_mode in ("solo", "autopilot")
+            else "solo"
+        )
+        screen = AutopilotScreen(is_narrow=is_narrow, mode=mode)
 
         def handle_result(result: None) -> None:  # noqa: ARG001
             if self._chat_input:
@@ -278,6 +292,48 @@ class _ModelMixin:
 
         self.push_screen(screen, handle_result)
 
+    async def _toggle_autopilot_mode(self) -> None:
+        """Toggle autopilot mode (solo ↔ autopilot) via daemon RPC.
+
+        Sends command_request to daemon and updates local dashboard mode.
+        """
+        from soothe_cli.tui.widgets.messages import ErrorMessage, UserMessage
+
+        await self._mount_message(UserMessage("/autopilot-toggle"))
+
+        lid = self._loop_id
+        if not lid:
+            await self._mount_message(ErrorMessage("No active loop for autopilot toggle"))
+            return
+
+        if not self._client:
+            await self._mount_message(ErrorMessage("Not connected to daemon"))
+            return
+
+        try:
+            from soothe_cli.tui.commands.command_router import handle_rpc_command
+            from soothe_cli.tui.commands.slash_commands import COMMANDS
+
+            entry = COMMANDS.get("/autopilot-toggle")
+            if not entry:
+                await self._mount_message(ErrorMessage("Command /autopilot-toggle not found"))
+                return
+
+            await handle_rpc_command(
+                entry,
+                "autopilot-toggle",
+                None,
+                self._console,
+                self._client,
+                loop_id=lid,
+            )
+            new_mode = "solo" if self._loop_autopilot_mode == "autopilot" else "autopilot"
+            self._apply_loop_autopilot_mode(new_mode)
+
+        except Exception as exc:
+            logger.exception("Autopilot toggle failed")
+            await self._mount_message(ErrorMessage(f"Failed to toggle autopilot: {exc}"))
+
     async def _submit_autopilot_job(self, task: str) -> None:
         """Submit an autopilot job via HTTP REST (like CLI `soothe autopilot run`).
 

{soothe_cli-0.6.8 → soothe_cli-0.6.9}/src/soothe_cli/tui/app/_startup.py

@@ -478,6 +478,13 @@ class _StartupMixin:
             if self._session_state is not None:
                 self._session_state.loop_id = status_loop_id
 
+        autopilot_mode = event.status_event.get("autopilot_mode")
+        if autopilot_mode not in ("solo", "autopilot") and event.session is not None:
+            autopilot_mode = getattr(event.session, "autopilot_mode", None)
+        self._apply_loop_autopilot_mode(
+            str(autopilot_mode) if autopilot_mode in ("solo", "autopilot") else None
+        )
+
         try:
             banner = self.query_one("#welcome-banner", WelcomeBanner)
             banner.set_connected(self._mcp_tool_count)

{soothe_cli-0.6.8 → soothe_cli-0.6.9}/src/soothe_cli/tui/commands/slash_commands.py

@@ -272,6 +272,13 @@ COMMANDS: dict[str, dict[str, Any]] = {
         "requires_loop": True,
         "handler": show_autopilot_dashboard,
     },
+    "/autopilot-toggle": {
+        "location": "daemon",
+        "type": "rpc",
+        "daemon_command": "autopilot_toggle",
+        "description": "Toggle autopilot mode (solo ↔ autopilot)",
+        "requires_loop": True,
+    },
     # Daemon routing commands (3)
     "/plan": {"location": "daemon", "type": "routing", "description": "Trigger plan mode"},
     "/tacitus": {

{soothe_cli-0.6.8 → soothe_cli-0.6.9}/src/soothe_cli/tui/input.py

@@ -16,9 +16,6 @@ from soothe_cli.tui.path_utils import path_exists, path_is_dir, path_is_file
 from soothe_cli.tui.preview_limits import (
     CHAT_INPUT_PASTE_ABBREVIATE_CHAR_COUNT,
     CHAT_INPUT_PASTE_ABBREVIATE_LINE_COUNT,
-    CHAT_INPUT_PASTE_PREVIEW_HEAD_LINES,
-    CHAT_INPUT_PASTE_PREVIEW_LINE_MAX_CHARS,
-    CHAT_INPUT_PASTE_PREVIEW_TAIL_LINES,
 )
 
 logger = logging.getLogger(__name__)
@@ -806,16 +803,44 @@ def should_abbreviate_pasted_input(text: str) -> bool:
     return len(text) > CHAT_INPUT_PASTE_ABBREVIATE_CHAR_COUNT
 
 
-def _truncate_paste_preview_line(line: str) -> str:
-    """Truncate a single preview line for the chat input."""
-    if len(line) <= CHAT_INPUT_PASTE_PREVIEW_LINE_MAX_CHARS:
-        return line
-    budget = CHAT_INPUT_PASTE_PREVIEW_LINE_MAX_CHARS - 1
-    return f"{line[:budget]}…"
+def compose_paste_into_input(
+    existing_text: str,
+    pasted_text: str,
+    *,
+    replace_start: int | None = None,
+    replace_end: int | None = None,
+) -> str:
+    """Return input text after applying a paste at the given replacement range.
+
+    Args:
+        existing_text: Current input text before paste.
+        pasted_text: Raw pasted payload.
+        replace_start: Inclusive replacement start offset. Defaults to the end.
+        replace_end: Exclusive replacement end offset. Defaults to start.
+
+    Returns:
+        Full input text after replacing ``[replace_start:replace_end]`` with
+        ``pasted_text``.
+    """
+    text_len = len(existing_text)
+    if replace_start is None:
+        start = text_len
+    else:
+        start = max(0, min(replace_start, text_len))
+
+    if replace_end is None:
+        end = start
+    else:
+        end = max(0, min(replace_end, text_len))
+
+    if end < start:
+        start, end = end, start
+
+    return f"{existing_text[:start]}{pasted_text}{existing_text[end:]}"
 
 
 def abbreviate_pasted_input_display(text: str) -> str:
-    """Build a short multi-line preview for a large pasted payload.
+    """Build a compact one-line preview for a large pasted payload.
 
     The full ``text`` is retained separately for submission; this string is
     only for on-screen display in the input widget.
@@ -824,25 +849,11 @@ def abbreviate_pasted_input_display(text: str) -> str:
         text: Full pasted content.
 
     Returns:
-        Abbreviated display text with a header and head/tail line previews.
+        Abbreviated display text containing only a summary header.
     """
     lines = text.splitlines()
     if not lines and text:
         lines = [text]
     n_lines = len(lines) if lines else 1
     n_chars = len(text)
-    header = f"[pasted {n_lines} lines, {n_chars} characters]"
-
-    head_n = min(CHAT_INPUT_PASTE_PREVIEW_HEAD_LINES, n_lines)
-    tail_n = min(CHAT_INPUT_PASTE_PREVIEW_TAIL_LINES, max(0, n_lines - head_n))
-    omitted = n_lines - head_n - tail_n
-
-    parts: list[str] = [header]
-    parts.extend(_truncate_paste_preview_line(line) for line in lines[:head_n])
-    if omitted > 0:
-        parts.append(f"… ({omitted} more lines) …")
-    if tail_n > 0:
-        tail_start = n_lines - tail_n
-        if tail_start > head_n:
-            parts.extend(_truncate_paste_preview_line(line) for line in lines[tail_start:])
-    return "\n".join(parts)
+    return f"[pasted {n_lines} lines, {n_chars} characters]"

{soothe_cli-0.6.8 → soothe_cli-0.6.9}/src/soothe_cli/tui/preview_limits.py

@@ -15,10 +15,10 @@ from typing import Final
 STEP_CARD_SHOW_TOOL_ROW_DETAILS: Final[bool] = False
 
 # Latest per-tool invocation lines shown per scope (task branch vs main-agent branch).
-STEP_CARD_TOOL_ACTIVITY_PREVIEW_COUNT: Final[int] = 5
+STEP_CARD_TOOL_ACTIVITY_PREVIEW_COUNT: Final[int] = 3
 
 # When estimated body lines exceed this count, the card auto-collapses (strict `>`).
-STEP_TASK_CARD_COLLAPSE_LINE_THRESHOLD: Final[int] = 5
+STEP_TASK_CARD_COLLAPSE_LINE_THRESHOLD: Final[int] = 3
 
 # --- Skill invocation cards (`SkillMessage` collapsed SKILL.md body) ---
 SKILL_CARD_PREVIEW_LINES: Final[int] = 4

{soothe_cli-0.6.8 → soothe_cli-0.6.9}/src/soothe_cli/tui/textual_adapter.py

@@ -1482,6 +1482,26 @@ def _log_turn_event_stats(
     )
 
 
+def _should_show_clarification_prompt(
+    *, event_data: dict[str, Any], fallback_mode: str | None
+) -> bool:
+    """Return True when TUI should show the interactive clarification card.
+
+    In auto mode, clarifications are resolved/deferred by policy and should not
+    render "Awaiting your answer" UI prompts in the TUI message stream.
+    """
+    mode = event_data.get("mode")
+    if isinstance(mode, str) and mode.strip():
+        normalized = mode.strip().lower()
+    elif isinstance(fallback_mode, str) and fallback_mode.strip():
+        normalized = fallback_mode.strip().lower()
+    else:
+        normalized = "auto"
+    if normalized not in {"auto", "manual"}:
+        normalized = "auto"
+    return normalized == "manual"
+
+
 async def execute_task_textual(
     user_input: str,
     assistant_id: str | None,
@@ -2511,7 +2531,10 @@ async def execute_task_textual(
                                     questions_list = [
                                         str(q) for q in raw_questions if str(q).strip()
                                     ]
-                                    if questions_list:
+                                    if questions_list and _should_show_clarification_prompt(
+                                        event_data=data,
+                                        fallback_mode=clarification_mode,
+                                    ):
                                         # The ask_user step card was put into "running" by
                                         # ``step_started`` just before await_clarification.
                                         # Surface the pending questions on it so the user