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

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

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

@@ -74,39 +74,41 @@ async def _fetch_ready_state(ws_url: str, timeout: float = 5.0) -> dict[str, Any
     return None
 
 
-def _render_connection_table(config: Any, ws_url: str) -> Table:
-    """Render connection settings table."""
-    table = Table(title="Connection Settings")
-    table.add_column("Setting", style="cyan")
-    table.add_column("Value", style="green")
-
-    table.add_row("WebSocket URL", ws_url)
-    table.add_row("Daemon Host", config.daemon_host)
-    table.add_row("Daemon Port", str(config.daemon_port))
-    table.add_row("Soothe Home", str(config.soothe_home))
-
-    return table
-
-
-def _render_daemon_table(
+def _render_unified_status_table(
+    config: Any,
     ws_url: str,
-    running: bool,
-    port_live: bool,
-    active_threads: int,
-    daemon_pid: int | None,
+    running: bool | None = None,
+    port_live: bool | None = None,
+    active_threads: int | None = None,
+    daemon_pid: int | None = None,
     ready_state: dict[str, Any] | None = None,
+    daemon_live: bool = True,
 ) -> Table:
-    """Render daemon status table."""
-    table = Table(title="Daemon Status")
+    """Render unified status table without duplicated info.
+
+    Sections:
+    - Connection: WebSocket URL, Soothe Home
+    - Daemon: Running, Threads, PID (only when daemon is live)
+    """
+    table = Table(title="Soothe Status")
+    table.add_column("Section", style="dim", width=12)
     table.add_column("Setting", style="cyan")
     table.add_column("Value", style="green")
 
-    table.add_row("WebSocket URL", ws_url)
-    table.add_row("Running", "[green]Yes[/green]" if running else "[red]No[/red]")
-    table.add_row("Port Live", "[green]Yes[/green]" if port_live else "[red]No[/red]")
-    table.add_row("Active Threads", str(active_threads))
+    # Connection section
+    table.add_row("Connection", "WebSocket URL", ws_url)
+    table.add_row("", "Soothe Home", str(config.soothe_home))
+
+    # Daemon section
+    if not daemon_live:
+        table.add_row("Daemon", "Status", "[red]Not running[/red]")
+        return table
+
+    table.add_row("Daemon", "Status", "[green]Running[/green]")
     if daemon_pid:
-        table.add_row("Daemon PID", str(daemon_pid))
+        table.add_row("", "PID", str(daemon_pid))
+    if active_threads is not None:
+        table.add_row("", "Active Threads", str(active_threads))
 
     if ready_state:
         state = ready_state.get("state", "unknown")
@@ -118,9 +120,9 @@ def _render_daemon_table(
             "warming": "blue",
             "stopped": "dim",
         }.get(state, "white")
-        table.add_row("Readiness", f"[{state_color}]{state}[/{state_color}]")
+        table.add_row("", "Readiness", f"[{state_color}]{state}[/{state_color}]")
         if ready_state.get("message"):
-            table.add_row("Message", ready_state["message"])
+            table.add_row("", "Message", ready_state["message"])
 
     return table
 
@@ -163,15 +165,9 @@ def daemon_status(
                 )
             )
         else:
-            console.print(
-                Panel(
-                    f"WebSocket URL: {ws_url}\n"
-                    "Status: [red]Not running[/red]\n"
-                    "Hint: Start with 'soothed start'",
-                    title="Daemon Status",
-                    border_style="red",
-                )
-            )
+            table = _render_unified_status_table(config, ws_url, daemon_live=False)
+            console.print(table)
+            console.print("\n[dim]Hint: Start with 'soothed start'[/dim]")
         sys.exit(1)
 
     # Fetch detailed status
@@ -218,14 +214,14 @@ def daemon_status(
         console.print_json(json.dumps(output))
         return
 
-    # Render daemon status table
+    # Render unified daemon status table
     running = status.get("running", True)
     port_live = status.get("port_live", True)
     active_threads = status.get("active_threads", 0)
     daemon_pid = status.get("daemon_pid")
 
-    table = _render_daemon_table(
-        ws_url, running, port_live, active_threads, daemon_pid, ready_state
+    table = _render_unified_status_table(
+        config, ws_url, running, port_live, active_threads, daemon_pid, ready_state
     )
     console.print(table)
 
@@ -261,7 +257,12 @@ def connection_status(
         )
         return
 
-    table = _render_connection_table(config, ws_url)
+    # Simple connection table
+    table = Table(title="Connection Settings")
+    table.add_column("Setting", style="cyan")
+    table.add_column("Value", style="green")
+    table.add_row("WebSocket URL", ws_url)
+    table.add_row("Soothe Home", str(config.soothe_home))
     console.print(table)
 
 
@@ -313,20 +314,11 @@ def status_main(
         console.print_json(json.dumps(output))
         return
 
-    # Render combined status with tables
+    # Render unified status table
     if not live:
-        console.print(
-            Panel(
-                f"WebSocket URL: {ws_url}\n"
-                f"Daemon Host: {config.daemon_host}\n"
-                f"Daemon Port: {config.daemon_port}\n"
-                f"Soothe Home: {config.soothe_home}\n\n"
-                "Daemon Status: [red]Not running[/red]\n"
-                "Hint: Start with 'soothed start'",
-                title="Soothe Status",
-                border_style="red",
-            )
-        )
+        table = _render_unified_status_table(config, ws_url, daemon_live=False)
+        console.print(table)
+        console.print("\n[dim]Hint: Start with 'soothed start'[/dim]")
         sys.exit(1)
 
     # Fetch detailed daemon status
@@ -335,29 +327,22 @@ def status_main(
     if "error" in status:
         console.print(
             Panel(
-                f"WebSocket URL: {ws_url}\n"
-                f"Daemon Host: {config.daemon_host}\n"
-                f"Daemon Port: {config.daemon_port}\n"
-                f"Soothe Home: {config.soothe_home}\n\n"
-                f"Daemon Status: [red]Error[/red]\n"
-                f"Error: {status['error']}",
-                title="Soothe Status",
+                f"WebSocket URL: {ws_url}\nError: [red]{status['error']}[/red]",
+                title="Daemon Status",
                 border_style="red",
             )
         )
         sys.exit(1)
 
-    # Render both tables
-    connection_table = _render_connection_table(config, ws_url)
-    console.print(connection_table)
-
     running = status.get("running", True)
     port_live = status.get("port_live", True)
     active_threads = status.get("active_threads", 0)
     daemon_pid = status.get("daemon_pid")
 
-    daemon_table = _render_daemon_table(ws_url, running, port_live, active_threads, daemon_pid)
-    console.print(daemon_table)
+    table = _render_unified_status_table(
+        config, ws_url, running, port_live, active_threads, daemon_pid
+    )
+    console.print(table)
 
 
 __all__ = [

{soothe_cli-0.6.8 → soothe_cli-0.6.10}/src/soothe_cli/runtime/parse/tool_call_resolution.py

@@ -39,6 +39,18 @@ def tool_args_meaningful(raw: Any) -> bool:
     return True
 
 
+def is_execute_step_namespace(ns_key: tuple[str, ...]) -> bool:
+    """True for CoreAgent execute root namespace (``execute:{run_id}``), not nested ``tools:`` subgraphs."""
+    if len(ns_key) != 1:
+        return False
+    return str(ns_key[0] or "").startswith("execute:")
+
+
+def is_step_card_tool_scope(*, ns_key: tuple[str, ...]) -> bool:
+    """True when tool activity belongs on the step card as main execute-graph tools."""
+    return ns_key == () or is_execute_step_namespace(ns_key)
+
+
 def is_main_step_level_tool_call_id(tool_call_id: str) -> bool:
     """True for unified main-graph step tools (``{step}:s:{tool}:{n}``), not ``task`` rows."""
     from soothe_sdk.ux.task_namespace import is_step_level_task_tool_id, parse_unified_tool_call_id
@@ -52,9 +64,23 @@ def is_main_step_level_tool_call_id(tool_call_id: str) -> bool:
     return not is_step_level_task_tool_id(tcid)
 
 
+def is_task_level_subgraph_tool_call_id(tool_call_id: str) -> bool:
+    """True for unified subgraph tools (``{step}:t{n}:{tool}:{seq}``), not nested ``task`` rows."""
+    from soothe_sdk.ux.task_namespace import (
+        is_inner_subgraph_task_tool_id,
+        parse_unified_tool_call_id,
+    )
+
+    tcid = str(tool_call_id or "").strip()
+    if not tcid or is_inner_subgraph_task_tool_id(tcid):
+        return False
+    _, type_code, _, _ = parse_unified_tool_call_id(tcid)
+    return type_code == "t"
+
+
 def should_ingest_tool_for_step_stats(
     *,
-    is_main_agent: bool,
+    is_step_card_scope: bool,
     tool_name: str,
     tool_call_id: str,
     args_meaningful: bool,
@@ -70,7 +96,10 @@ def should_ingest_tool_for_step_stats(
         return False
     if args_meaningful:
         return True
-    return is_main_agent and is_main_step_level_tool_call_id(tcid)
+    if is_step_card_scope and is_main_step_level_tool_call_id(tcid):
+        return True
+    # Subgraph explore tools often arrive with ``{"_subgraph_tool": true}`` before real args.
+    return not is_step_card_scope and is_task_level_subgraph_tool_call_id(tcid)
 
 
 def _args_from_toolish_block(block: dict[str, Any]) -> dict[str, Any]:
@@ -465,7 +494,10 @@ def build_streaming_args_overlay(
 __all__ = [
     "ResolvedToolInvocation",
     "build_streaming_args_overlay",
+    "is_execute_step_namespace",
     "is_main_step_level_tool_call_id",
+    "is_step_card_tool_scope",
+    "is_task_level_subgraph_tool_call_id",
     "is_toolish_display_block",
     "materialize_ai_blocks_with_resolved_tools",
     "merge_tool_display_args",

{soothe_cli-0.6.8 → soothe_cli-0.6.10}/src/soothe_cli/runtime/state/step_router.py

@@ -17,7 +17,7 @@ from typing import Any, TypeAlias
 from soothe_sdk.ux.task_namespace import (
     TaskScope,
     is_inner_subgraph_task_tool_id,
-    normalize_step_task_tool_call_id,
+    normalize_main_task_delegation_id,
     parse_unified_tool_call_id,
     prune_bound_pending_namespaces,
     register_task_spawn_for_step,
@@ -62,6 +62,21 @@ def _subgraph_pending_key(ns_key: tuple[str, ...], lookup_id: str) -> tuple[tupl
     return (ns_key, str(lookup_id).strip())
 
 
+def _is_task_metadata_subgraph_tool(item: PendingSubgraphTool) -> bool:
+    """True when a buffered subgraph item is task metadata, not a user-facing tool row."""
+    if (item.tool_name or "").strip() == "task":
+        return True
+    for candidate in (item.lookup_id, item.display_key):
+        cid = str(candidate or "").strip()
+        if cid and is_inner_subgraph_task_tool_id(cid):
+            return True
+    args = item.args if isinstance(item.args, dict) else {}
+    subagent_type = str(args.get("subagent_type") or "").strip()
+    prompt = str(args.get("description") or args.get("prompt") or "").strip()
+    # Some providers emit opaque names (e.g. "tool-<id>") for task chunks.
+    return bool(subagent_type and prompt)
+
+
 @dataclass
 class StepTaskRouter:
     """High-performance per-turn router for steps, tools, and task namespaces.
@@ -123,7 +138,15 @@ class StepTaskRouter:
         if existing is None:
             self._pending_subgraph_tools[key] = item
             return
-        args = item.args if len(item.args) >= len(existing.args) else existing.args
+        # Prefer meaningful args over placeholder metadata like {"_subgraph_tool": true}.
+        from soothe_cli.runtime.parse.message_processing import extract_tool_args_dict
+
+        item_meaningful = extract_tool_args_dict(item.args or {})
+        existing_meaningful = extract_tool_args_dict(existing.args or {})
+        if len(item_meaningful) >= len(existing_meaningful):
+            args = item.args
+        else:
+            args = existing.args
         raw = item.raw_args if len(item.raw_args) >= len(existing.raw_args) else existing.raw_args
         self._pending_subgraph_tools[key] = PendingSubgraphTool(
             ns_key=item.ns_key,
@@ -219,14 +242,12 @@ class StepTaskRouter:
         if not tcid or is_inner_subgraph_task_tool_id(tcid):
             return False
         parsed_sid, type_code, _, _ = parse_unified_tool_call_id(tcid)
-        if type_code == "t":
-            return False
-        sid = parsed_sid if (parsed_sid and type_code == "s") else ""
+        sid = parsed_sid if (parsed_sid and type_code in ("s", "t")) else ""
         if not sid:
             sid = str(step_id).strip()
         if not sid:
             return False
-        normalized_tcid = normalize_step_task_tool_call_id(sid, tcid)
+        normalized_tcid = normalize_main_task_delegation_id(sid, tcid, tool_name="task")
         spawn_key = (sid, normalized_tcid)
         if spawn_key in self._spawn_recorded:
             return False
@@ -375,7 +396,7 @@ class StepTaskRouter:
         tool_to_step: dict[str, ParentWidget],
     ) -> bool:
         """Register one subgraph tool row on an already-resolved parent step card."""
-        if (item.tool_name or "").strip() == "task":
+        if _is_task_metadata_subgraph_tool(item):
             # Inner explore ``task`` chunks are not user-facing tool stats; ingesting
             # them used to rewrite the main ``{step}:s:task:…`` delegation row args.
             return True
@@ -399,13 +420,31 @@ class StepTaskRouter:
         if has_row(row_id):
             update = getattr(parent, "update_tool_args", None)
             if callable(update):
-                update(row_id, item.args)
+                resolved_args = dict(item.args or {})
+                # Placeholder args like {"_subgraph_tool": true} are not meaningful.
+                # Parse raw_args when resolved_args lacks real invocation kwargs.
+                from soothe_cli.runtime.parse.message_processing import extract_tool_args_dict
+
+                meaningful_args = extract_tool_args_dict(resolved_args)
+                if item.raw_args and not meaningful_args:
+                    parsed = extract_tool_args_dict({"_raw": item.raw_args})
+                    if parsed:
+                        resolved_args = parsed
+                update(row_id, resolved_args)
         else:
             parent_task_id = str(scope[0]).strip()
+            resolved_args = dict(item.args or {})
+            from soothe_cli.runtime.parse.message_processing import extract_tool_args_dict
+
+            meaningful_args = extract_tool_args_dict(resolved_args)
+            if item.raw_args and not meaningful_args:
+                parsed = extract_tool_args_dict({"_raw": item.raw_args})
+                if parsed:
+                    resolved_args = parsed
             ingest(
                 row_id,
                 item.tool_name,
-                dict(item.args or {}),
+                resolved_args,
                 raw_args=item.raw_args,
                 parent_tool_call_id=parent_task_id or None,
             )

{soothe_cli-0.6.8 → soothe_cli-0.6.10}/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.10}/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.10}/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.10}/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.10}/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)