Implement --tree flag for ASCII execution tree visualization

- render_execution_tree(): ASCII art tree output for terminal
- Improved prompt preview handling for context dicts
- Outputs to stderr with box-drawing characters

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: rawwerks

src/rlm_cli/cli.py

@@ -10,7 +10,18 @@
 
 import typer
 
-from .config import DEFAULT_CONFIG, load_effective_config, render_effective_config_text
+from .config import (
+    DEFAULT_CONFIG,
+    coerce_value,
+    get_local_config_path,
+    get_nested_value,
+    get_user_config_path,
+    load_effective_config,
+    load_or_create_config,
+    render_effective_config_text,
+    set_nested_value,
+    write_config_file,
+)
 from .context import WalkOptions, build_context_from_sources
 from .errors import (
     CliError,
@@ -29,6 +40,7 @@
     capture_stdout,
     emit_json,
     emit_text,
+    render_execution_tree,
 )
 from .rlm_adapter import parse_json_args, parse_kv_args, run_completion
 
@@ -1118,6 +1130,12 @@ def _run_ask(
                 warnings.insert(0, "Stopped early (Ctrl+C) - returning best answer so far")
             _emit_text_output(result.response, output, warnings)
 
+            # Print tree to stderr if requested
+            if show_tree:
+                tree_str = render_execution_tree(result.raw)
+                if tree_str:
+                    _emit_execution_tree(tree_str)
+
             # Print summary to stderr if requested
             if show_summary:
                 summary = build_execution_summary(result.raw)
@@ -1491,6 +1509,15 @@ def _emit_text_output(result_text: str, output: str | None, warnings: list[str])
     emit_text(result_text, warnings=warnings)
 
 
+def _emit_execution_tree(tree_str: str) -> None:
+    """Emit execution tree to stderr."""
+    import sys
+
+    sys.stderr.write("\n=== RLM Execution Tree ===\n")
+    sys.stderr.write(tree_str)
+    sys.stderr.write("\n")
+
+
 def _emit_execution_summary(summary: dict[str, object]) -> None:
     """Emit execution summary to stderr in a human-readable format."""
     import sys

src/rlm_cli/output.py

@@ -116,13 +116,24 @@ def build_execution_tree(raw: object, depth: int = 0) -> dict[str, object] | Non
     if isinstance(prompt, str):
         prompt_preview = _truncate(prompt)
     elif isinstance(prompt, dict):
-        prompt_preview = _truncate(str(prompt))
+        # Try to extract meaningful preview from context dict
+        if "query" in prompt:
+            prompt_preview = _truncate(str(prompt["query"]))
+        elif "root" in prompt:
+            prompt_preview = f"[context: {prompt.get('root', 'unknown')}]"
+        else:
+            prompt_preview = _truncate(str(prompt), 60)
     elif isinstance(prompt, list) and prompt:
         # Message list - get last user message content
         for msg in reversed(prompt):
             if isinstance(msg, dict) and msg.get("role") == "user":
                 content = msg.get("content", "")
-                prompt_preview = _truncate(str(content))
+                if isinstance(content, str):
+                    prompt_preview = _truncate(content)
+                elif isinstance(content, dict) and "query" in content:
+                    prompt_preview = _truncate(str(content["query"]))
+                else:
+                    prompt_preview = _truncate(str(content))
                 break
 
     node: dict[str, object] = {
@@ -192,6 +203,78 @@ def _build_iteration_node(iteration: object, num: int, depth: int) -> dict[str,
     return node
 
 
+def render_execution_tree(raw: object) -> str | None:
+    """
+    Render execution tree as ASCII art for terminal display.
+
+    Returns a string like:
+    ┌─ [openai/gpt-4] 2.3s $0.05
+    │  Q: Analyze the codebase...
+    │  A: I'll start by...
+    │
+    └─┬─ [google/gemini] 1.2s $0.02
+      │  Q: What is X?
+      │  A: X is...
+      │
+      └── [openai/gpt-4] 0.5s
+          Q: Details?
+          A: The details...
+    """
+    tree = build_execution_tree(raw)
+    if tree is None:
+        return None
+
+    lines: list[str] = []
+
+    def format_node_header(node: dict[str, object]) -> str:
+        model = node.get("model", "unknown")
+        duration = node.get("duration", 0)
+        cost = node.get("cost")
+        header = f"[{model}] {duration}s"
+        if cost:
+            header += f" ${cost:.4f}"
+        return header
+
+    def render_node(node: dict[str, object], prefix: str, is_last: bool, is_root: bool) -> None:
+        # Determine box drawing characters
+        if is_root:
+            branch = "┌─ "
+            child_prefix = "│  "
+        elif is_last:
+            branch = "└── "
+            child_prefix = "    "
+        else:
+            branch = "├── "
+            child_prefix = "│   "
+
+        # Node header
+        header = format_node_header(node)
+        lines.append(f"{prefix}{branch}{header}")
+
+        # Content prefix for Q/A lines
+        content_prefix = prefix + child_prefix
+
+        # Show prompt/response previews
+        prompt = node.get("prompt_preview", "")
+        response = node.get("response_preview", "")
+        if prompt:
+            lines.append(f"{content_prefix}Q: {prompt}")
+        if response:
+            lines.append(f"{content_prefix}A: {response}")
+
+        # Process children
+        children = node.get("children", []) or []
+        if children:
+            lines.append(content_prefix.rstrip())  # blank line before children
+            for i, child in enumerate(children):
+                if isinstance(child, dict):
+                    is_last_child = i == len(children) - 1
+                    render_node(child, content_prefix, is_last_child, False)
+
+    render_node(tree, "", True, True)
+    return "\n".join(lines)
+
+
 def build_execution_summary(raw: object) -> dict[str, object] | None:
     """
     Build summary statistics from execution tree.