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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: soothe-cli
-Version: 0.6.9
+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.9 → 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.9 → 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.9 → 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.9 → soothe_cli-0.6.10}/src/soothe_cli/tui/textual_adapter.py

@@ -50,7 +50,7 @@ from soothe_sdk.ux.stream_tool_wire import STREAM_TOOL_CALL_UPDATE, TOOL_CALL_UP
 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,
     row_key_for_subgraph_tool,
 )
@@ -62,6 +62,8 @@ from soothe_cli.runtime.parse.message_processing import (
 )
 from soothe_cli.runtime.parse.tool_call_resolution import (
     build_streaming_args_overlay,
+    is_execute_step_namespace,
+    is_step_card_tool_scope,
     materialize_ai_blocks_with_resolved_tools,
     merge_tool_display_args,
     resolve_stream_tool_name,
@@ -521,7 +523,7 @@ def _ingest_main_task_tool_on_step_card(
             adapter._tool_display_by_call_id,
         )
         return
-    norm_tcid = normalize_step_task_tool_call_id(sid, tcid)
+    norm_tcid = normalize_main_task_delegation_id(sid, tcid, tool_name="task")
     step_w = _resolve_step_widget_for_tool(
         adapter,
         router,
@@ -597,10 +599,18 @@ def _fallback_ingest_subgraph_tool_on_step_card(
     if step_w is None:
         return False
     row_id = lookup if type_code == "t" else (display or lookup)
+    resolved_args = dict(args or {})
+    # Placeholder args like {"_subgraph_tool": true} are not meaningful.
+    # Parse raw_args when resolved_args lacks real invocation kwargs.
+    meaningful_args = extract_tool_args_dict(resolved_args)
+    if raw_args and not meaningful_args:
+        parsed = extract_tool_args_dict({"_raw": raw_args})
+        if parsed:
+            resolved_args = parsed
     if step_w.has_tool_call_row(row_id):
-        step_w.update_tool_args(row_id, args)
+        step_w.update_tool_args(row_id, resolved_args)
     else:
-        step_w.add_tool_call(row_id, tool_name, args, raw_args=raw_args)
+        step_w.add_tool_call(row_id, tool_name, resolved_args, raw_args=raw_args)
     adapter._tool_to_step[row_id] = step_w
     adapter._tool_display_by_call_id[row_id] = step_w
     return True
@@ -858,7 +868,7 @@ async def apply_tool_call_wire_update(
     if str(data.get("type", "")) != STREAM_TOOL_CALL_UPDATE:
         return False
 
-    if ns_key:
+    if ns_key and not is_execute_step_namespace(ns_key):
         router.on_subgraph_namespace(ns_key)
 
     tcid = str(data.get("tool_call_id", "")).strip()
@@ -866,62 +876,79 @@ async def apply_tool_call_wire_update(
         return True
 
     name = str(data.get("name") or "").strip() or "tool"
-    raw_args = data.get("args")
-    if not isinstance(raw_args, dict):
-        raw_args = {}
-    is_main = ns_key == ()
-    if not raw_args and not should_ingest_tool_for_step_stats(
-        is_main_agent=is_main,
+    raw_args_field = data.get("args")
+    raw_args_stream = ""
+    if isinstance(raw_args_field, str):
+        raw_args_stream = raw_args_field
+    elif raw_args_field is not None:
+        try:
+            raw_args_stream = json.dumps(raw_args_field, separators=(",", ":"), default=str)
+        except (TypeError, ValueError):
+            raw_args_stream = str(raw_args_field)
+    display_args = extract_tool_args_dict(raw_args_field)
+    is_step_scope = is_step_card_tool_scope(ns_key=ns_key)
+    if not display_args and not should_ingest_tool_for_step_stats(
+        is_step_card_scope=is_step_scope,
         tool_name=name,
         tool_call_id=tcid,
         args_meaningful=False,
     ):
         return True
 
-    if ui_coalesce is not None and ui_coalesce.note_wire_apply(tcid, raw_args):
+    if ui_coalesce is not None and ui_coalesce.note_wire_apply(
+        tcid, display_args or raw_args_field
+    ):
         return True
 
     overlay = streaming_overlay if streaming_overlay is not None else {}
     ts = router.resolve_task_scope(ns_key) if ns_key else None
     merge_id, row_key = (
-        (tcid, tcid) if is_main else canonical_subgraph_tool_ids(ns_key, tcid, task_scope=ts)
+        (tcid, tcid) if is_step_scope else canonical_subgraph_tool_ids(ns_key, tcid, task_scope=ts)
     )
 
+    overlay_payload = dict(display_args or {})
     for key in {tcid, merge_id, row_key}:
         if not key:
             continue
-        overlay[key] = dict(raw_args)
+        if overlay_payload:
+            overlay[key] = dict(overlay_payload)
         pending_tool_calls_lc[key] = {
             "name": name,
-            "args_str": json.dumps(raw_args, separators=(",", ":")),
+            "args_str": raw_args_stream
+            if raw_args_stream
+            else json.dumps(overlay_payload, separators=(",", ":")),
             "is_complete_json": True,
             "emitted": False,
-            "is_main": is_main,
+            "is_main": is_step_scope,
         }
 
-    if ns_key:
+    if ns_key and not is_execute_step_namespace(ns_key):
         alias_subgraph_pending_and_overlay(pending_tool_calls_lc, overlay, router, ns_key)
 
     display_args = merge_tool_display_args(
         merge_id or tcid,
-        block_args=raw_args,
+        block_args=display_args,
         streaming_overlay=overlay,
         pending_tool_calls_lc=pending_tool_calls_lc,
         tool_name=name,
     )
 
-    if file_op_tracker is not None and name in FILE_CHANGE_TOOLS and tool_args_meaningful(raw_args):
+    if (
+        file_op_tracker is not None
+        and name in FILE_CHANGE_TOOLS
+        and tool_args_meaningful(display_args)
+    ):
         file_tcid = str(merge_id or tcid)
-        track_file_operation(file_op_tracker, name, raw_args, file_tcid)
+        track_file_operation(file_op_tracker, name, display_args, file_tcid)
         await mount_file_change_preview(
             adapter,
             tool_name=name,
-            args=raw_args,
+            args=display_args,
             tool_call_id=file_tcid,
             assistant_id=adapter._file_preview_assistant_id,
         )
 
-    if is_main and name == "task":
+    if is_step_scope and name == "task":
         if is_inner_subgraph_task_tool_id(tcid):
             return True
         parsed_sid, _, _, _ = parse_unified_tool_call_id(tcid)
@@ -935,7 +962,7 @@ async def apply_tool_call_wire_update(
         )
         return True
 
-    if is_main:
+    if is_step_scope:
         parsed_sid, _, _, _ = parse_unified_tool_call_id(tcid)
         bound_step_id = parsed_sid or router.step_id_for_tool(tcid)
         step_w = _resolve_step_widget_for_tool(
@@ -945,10 +972,13 @@ async def apply_tool_call_wire_update(
             ns_key=ns_key,
         )
         if step_w is not None and name != "task":
+            update_payload = dict(display_args or {})
+            if not update_payload and raw_args_stream:
+                update_payload = {"_raw": raw_args_stream}
             if step_w.has_tool_call_row(tcid):
-                step_w.update_tool_args(tcid, display_args)
+                step_w.update_tool_args(tcid, update_payload)
             else:
-                step_w.add_tool_call(tcid, name, display_args)
+                step_w.add_tool_call(tcid, name, update_payload, raw_args=raw_args_stream)
             adapter._tool_to_step[tcid] = step_w
         return True
 
@@ -960,6 +990,7 @@ async def apply_tool_call_wire_update(
             display_key=display_key,
             tool_name=name,
             args=display_args,
+            raw_args=raw_args_stream,
             step_cards=adapter._current_step_messages,
             tool_to_step=adapter._tool_to_step,
             tool_display_by_call_id=adapter._tool_display_by_call_id,
@@ -972,6 +1003,7 @@ async def apply_tool_call_wire_update(
                 display_key=display_key,
                 tool_name=name,
                 args=display_args,
+                raw_args=raw_args_stream,
                 ns_key=ns_key,
             )
     return True
@@ -1736,6 +1768,7 @@ async def execute_task_textual(
                     # namespaces. Assistant *text* from subgraphs is suppressed (avoid duplicate
                     # prose with main). Tool stats attach to step cards on the main graph only.
                     is_main_agent = ns_key == ()
+                    is_step_scope = is_step_card_tool_scope(ns_key=ns_key)
                     suppress_subgraph_assistant_text = not is_main_agent
                     suppress_main_agent_assistant_text = False
 
@@ -1765,7 +1798,7 @@ async def execute_task_textual(
                             message, metadata = data
                             message = _normalize_lc_stream_message(message)
 
-                        if ns_key:
+                        if ns_key and not is_execute_step_namespace(ns_key):
                             router.on_subgraph_namespace(ns_key)
 
                         # Filter out summarization model output, but keep UI feedback.
@@ -2285,7 +2318,7 @@ async def execute_task_textual(
                                     parsed_args = extract_tool_args_dict(parsed_args)
 
                                 merge_lookup_id = lookup_id
-                                if lookup_id and not is_main_agent:
+                                if lookup_id and not is_step_scope:
                                     ts_merge = router.resolve_task_scope(ns_key)
                                     merge_lookup_id, _rk = canonical_subgraph_tool_ids(
                                         ns_key, str(lookup_id), task_scope=ts_merge
@@ -2327,7 +2360,7 @@ async def execute_task_textual(
 
                                 args_meaningful = tool_args_meaningful(parsed_args)
                                 ingest_for_stats = should_ingest_tool_for_step_stats(
-                                    is_main_agent=is_main_agent,
+                                    is_step_card_scope=is_step_scope,
                                     tool_name=str(buffer_name or ""),
                                     tool_call_id=str(lookup_id or ""),
                                     args_meaningful=args_meaningful,
@@ -2339,7 +2372,7 @@ async def execute_task_textual(
                                 if lookup_id and buffer_name and ingest_for_stats:
                                     if buffer_name in FILE_CHANGE_TOOLS and args_meaningful:
                                         file_tcid = str(lookup_id)
-                                        if not is_main_agent:
+                                        if not is_step_scope:
                                             ts_file = router.resolve_task_scope(ns_key)
                                             file_tcid, _fk = canonical_subgraph_tool_ids(
                                                 ns_key, file_tcid, task_scope=ts_file
@@ -2359,7 +2392,7 @@ async def execute_task_textual(
                                             assistant_id=assistant_id,
                                         )
 
-                                    if is_main_agent and buffer_name == "task":
+                                    if is_step_scope and buffer_name == "task":
                                         if not is_inner_subgraph_task_tool_id(str(lookup_id)):
                                             parsed_step_id, _, _, _ = parse_unified_tool_call_id(
                                                 str(lookup_id)
@@ -2374,7 +2407,7 @@ async def execute_task_textual(
                                                 parsed_args,
                                                 bound_step_id=bound_step_id,
                                             )
-                                    elif is_main_agent and buffer_name != "task":
+                                    elif is_step_scope and buffer_name != "task":
                                         parsed_sid, _, _, _ = parse_unified_tool_call_id(
                                             str(lookup_id)
                                         )
@@ -2410,7 +2443,7 @@ async def execute_task_textual(
                                                 parsed_args,
                                                 raw_args=raw_args_stream,
                                             )
-                                    elif not is_main_agent:
+                                    elif not is_step_scope:
                                         ts_disp = router.resolve_task_scope(ns_key)
                                         _merge_disp, display_key = canonical_subgraph_tool_ids(
                                             ns_key, str(lookup_id), task_scope=ts_disp

{soothe_cli-0.6.9 → soothe_cli-0.6.10}/src/soothe_cli/tui/tool_display.py

@@ -10,13 +10,16 @@ from soothe_sdk.tools.metadata import get_tool_meta
 from soothe_sdk.utils import get_tool_display_name
 from soothe_sdk.utils.formatting import convert_and_abbreviate_path
 
-from soothe_cli.runtime.parse.message_processing import _normalize_tool_name_for_arg_map
+from soothe_cli.runtime.parse.message_processing import (
+    _normalize_tool_name_for_arg_map,
+    extract_tool_args_dict,
+)
 from soothe_cli.runtime.presentation.duration_format import format_duration_ms
 
 _ARG_PREVIEW_MAX_CHARS = 80
 _EDIT_STRING_PREVIEW_MAX_CHARS = 30
 _EDIT_STRING_ARG_KEYS = frozenset({"old_string", "new_string"})
-_SKIP_ARG_KEYS = frozenset({"_raw"})
+_SKIP_ARG_KEYS = frozenset({"_raw", "_subgraph_tool", "value"})
 
 
 def compact_arg_text(text: str) -> str:
@@ -72,7 +75,18 @@ def _ordered_arg_keys(tool_name: str, clean: dict[str, Any]) -> list[str]:
 
 def _args_preview(tool_name: str, args: dict[str, Any]) -> str:
     """Comma-separated arg summary: primary value bare, extras as ``key=value``."""
-    clean = {k: v for k, v in (args or {}).items() if k not in _SKIP_ARG_KEYS}
+    normalized = extract_tool_args_dict(args or {})
+    if not normalized and isinstance(args, dict):
+        raw_value = args.get("value")
+        if isinstance(raw_value, str) and raw_value.strip():
+            try:
+                loaded = json.loads(raw_value)
+            except (TypeError, ValueError):
+                loaded = None
+            if isinstance(loaded, dict):
+                normalized = loaded
+    source_args = normalized if normalized else (args or {})
+    clean = {k: v for k, v in source_args.items() if k not in _SKIP_ARG_KEYS}
     if not clean:
         return ""
     segments: list[str] = []