daveloop 1.4.0__py3-none-any.whl → 1.5.1__py3-none-any.whl

daveloop.py

@@ -14,6 +14,8 @@ import itertools
 import json
 from datetime import datetime
 from pathlib import Path
+from collections import deque
+from concurrent.futures import ThreadPoolExecutor, as_completed
 
 # Configuration
 MAX_ITERATIONS = 20
@@ -29,6 +31,12 @@ SIGNAL_RESOLVED = "[DAVELOOP:RESOLVED]"
 SIGNAL_BLOCKED = "[DAVELOOP:BLOCKED]"
 SIGNAL_CLARIFY = "[DAVELOOP:CLARIFY]"
 
+# Allowed tools for Claude Code CLI
+# Default: no Task tool (prevents recursive sub-agent spawning)
+ALLOWED_TOOLS_DEFAULT = "Bash,Read,Write,Edit,Glob,Grep"
+# Swarm mode: Task tool enabled for controlled sub-agent spawning
+ALLOWED_TOOLS_SWARM = "Bash,Read,Write,Edit,Glob,Grep,Task"
+
 # ============================================================================
 # ANSI Color Codes
 # ============================================================================
@@ -268,6 +276,508 @@ class TaskQueue:
         print()
 
 
+# ============================================================================
+# Swarm Budget
+# ============================================================================
+class SwarmBudget:
+    """Tracks and enforces sub-agent spawn budget for swarm mode."""
+
+    def __init__(self, max_spawns: int = 5, max_depth: int = 1):
+        self.max_spawns = max_spawns
+        self.max_depth = max_depth
+        self.spawn_count = 0
+        self.active_agents = 0
+        self.completed_agents = 0
+
+    def can_spawn(self) -> bool:
+        """Check if spawning another sub-agent is within budget."""
+        return self.spawn_count < self.max_spawns
+
+    def record_spawn(self, description: str):
+        """Record a sub-agent spawn."""
+        self.spawn_count += 1
+        self.active_agents += 1
+        print(f"  {C.BRIGHT_CYAN}[Swarm]{C.RESET} Sub-agent {self.spawn_count}/{self.max_spawns}: {description}")
+
+    def record_completion(self):
+        """Record a sub-agent completion."""
+        self.active_agents -= 1
+        self.completed_agents += 1
+
+    def budget_exhausted_message(self) -> str:
+        """Return message when budget is exhausted."""
+        return (
+            f"Sub-agent budget exhausted ({self.spawn_count}/{self.max_spawns}). "
+            f"Complete remaining work directly without spawning more sub-agents."
+        )
+
+    def summary(self) -> dict:
+        """Return budget tracking summary."""
+        return {
+            "total_spawned": self.spawn_count,
+            "completed": self.completed_agents,
+            "budget": self.max_spawns,
+        }
+
+
+# ============================================================================
+# Turbo Dashboard (Rich-based split-pane UI)
+# ============================================================================
+class TurboDashboard:
+    """Rich-based split-pane terminal dashboard for parallel DaveLoop instances.
+
+    Shows one panel per instance with: instance ID, current task name,
+    and a scrolling window of the last ~20 lines of output.
+    """
+
+    PANEL_COLORS = ["cyan", "green", "yellow", "magenta", "blue", "red"]
+
+    def __init__(self, instance_count: int):
+        from rich.live import Live
+        from rich.layout import Layout
+        from rich.panel import Panel
+        from rich.text import Text
+        from rich.console import Console
+
+        self._Live = Live
+        self._Layout = Layout
+        self._Panel = Panel
+        self._Text = Text
+        self._console = Console()
+
+        self.instance_count = instance_count
+        self._lock = threading.Lock()
+
+        # Per-instance state
+        self.task_names = ["Waiting..."] * instance_count
+        self.statuses = ["pending"] * instance_count  # pending, running, done, failed
+        self.output_buffers = [deque(maxlen=20) for _ in range(instance_count)]
+        self.iterations = [0] * instance_count
+        self.max_iterations = [0] * instance_count
+        self.start_times = [None] * instance_count
+
+        self._live = None
+
+    def _build_layout(self):
+        """Build the Rich Layout with panels for each instance."""
+        layout = self._Layout()
+
+        # Create rows of 2 panels each
+        rows = []
+        for i in range(0, self.instance_count, 2):
+            row_name = f"row_{i // 2}"
+            row = self._Layout(name=row_name)
+            left = self._Layout(name=f"inst_{i}")
+
+            if i + 1 < self.instance_count:
+                right = self._Layout(name=f"inst_{i + 1}")
+                row.split_row(left, right)
+            else:
+                row.split_row(left)
+
+            rows.append(row)
+
+        if rows:
+            layout.split_column(*rows)
+
+        return layout
+
+    def _render_panel(self, idx: int):
+        """Render a single instance panel."""
+        color = self.PANEL_COLORS[idx % len(self.PANEL_COLORS)]
+        status = self.statuses[idx]
+
+        # Status indicator
+        if status == "running":
+            status_icon = "[bold bright_green]\u25cf RUNNING[/]"
+        elif status == "done":
+            status_icon = "[bold bright_green]\u2713 RESOLVED[/]"
+        elif status == "failed":
+            status_icon = "[bold bright_red]\u2717 FAILED[/]"
+        else:
+            status_icon = "[dim]\u25cb PENDING[/]"
+
+        # Iteration info
+        iter_info = ""
+        if self.max_iterations[idx] > 0:
+            iter_info = f" | Iter {self.iterations[idx]}/{self.max_iterations[idx]}"
+
+        # Elapsed time
+        elapsed = ""
+        if self.start_times[idx]:
+            secs = int(time.time() - self.start_times[idx])
+            mins, secs = divmod(secs, 60)
+            elapsed = f" | {mins}m{secs:02d}s"
+
+        # Build subtitle
+        subtitle = f"{status_icon}{iter_info}{elapsed}"
+
+        # Build output text
+        lines = list(self.output_buffers[idx])
+        if not lines:
+            lines = ["[dim]Waiting for output...[/]"]
+
+        output_text = "\n".join(lines)
+
+        task_name = self.task_names[idx]
+        if len(task_name) > 50:
+            task_name = task_name[:47] + "..."
+
+        panel = self._Panel(
+            output_text,
+            title=f"[bold {color}] Instance {idx + 1} [/] {task_name}",
+            subtitle=subtitle,
+            border_style=color if status == "running" else "dim" if status == "pending" else "green" if status == "done" else "red",
+            padding=(0, 1),
+        )
+        return panel
+
+    def _refresh(self):
+        """Rebuild and update the live display."""
+        layout = self._build_layout()
+        for i in range(self.instance_count):
+            try:
+                layout[f"inst_{i}"].update(self._render_panel(i))
+            except KeyError:
+                pass
+        return layout
+
+    def start(self):
+        """Start the live dashboard."""
+        self._live = self._Live(
+            self._refresh(),
+            console=self._console,
+            refresh_per_second=4,
+            screen=True,
+        )
+        self._live.start()
+
+    def stop(self):
+        """Stop the live dashboard."""
+        if self._live:
+            self._live.stop()
+
+    def update_task(self, idx: int, task_name: str, max_iterations: int):
+        """Set the task name and max iterations for an instance."""
+        with self._lock:
+            self.task_names[idx] = task_name
+            self.max_iterations[idx] = max_iterations
+            self.statuses[idx] = "running"
+            self.start_times[idx] = time.time()
+            if self._live:
+                self._live.update(self._refresh())
+
+    def update_iteration(self, idx: int, iteration: int):
+        """Update the current iteration number for an instance."""
+        with self._lock:
+            self.iterations[idx] = iteration
+            if self._live:
+                self._live.update(self._refresh())
+
+    def append_output(self, idx: int, line: str):
+        """Append a line to an instance's output buffer."""
+        with self._lock:
+            # Strip ANSI codes for cleaner display in Rich panels
+            clean = _strip_ansi(line)
+            if clean.strip():
+                self.output_buffers[idx].append(clean)
+                if self._live:
+                    self._live.update(self._refresh())
+
+    def mark_done(self, idx: int, outcome: str = "done"):
+        """Mark an instance as completed."""
+        with self._lock:
+            self.statuses[idx] = outcome
+            if self._live:
+                self._live.update(self._refresh())
+
+
+def _strip_ansi(text: str) -> str:
+    """Remove ANSI escape sequences from a string."""
+    import re
+    return re.sub(r'\x1b\[[0-9;]*[a-zA-Z]', '', text)
+
+
+def run_claude_code_turbo(prompt: str, working_dir: str, instance_idx: int,
+                          dashboard: TurboDashboard, timeout: int = DEFAULT_TIMEOUT,
+                          swarm_mode: bool = False, swarm_budget_max: int = 5,
+                          swarm_depth_max: int = 1) -> str:
+    """Execute Claude Code CLI for turbo mode, streaming output to a dashboard panel.
+
+    Similar to run_claude_code but routes output to a TurboDashboard panel
+    instead of printing directly to stdout.
+    """
+    claude_cmd = find_claude_cli()
+    if not claude_cmd:
+        return "[DAVELOOP:ERROR] Claude CLI not found"
+
+    cmd = [claude_cmd]
+    allowed = ALLOWED_TOOLS_SWARM if swarm_mode else ALLOWED_TOOLS_DEFAULT
+    cmd.extend(["-p", "--verbose", "--output-format", "stream-json", "--allowedTools", allowed])
+
+    try:
+        process = subprocess.Popen(
+            cmd,
+            stdin=subprocess.PIPE,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.STDOUT,
+            text=True,
+            encoding='utf-8',
+            errors='replace',
+            cwd=working_dir,
+            bufsize=1
+        )
+
+        process.stdin.write(prompt)
+        process.stdin.close()
+
+        full_text = []
+
+        for line in process.stdout:
+            line = line.strip()
+            if not line:
+                continue
+
+            try:
+                data = json.loads(line)
+                msg_type = data.get("type", "")
+
+                if msg_type == "assistant":
+                    content = data.get("message", {}).get("content", [])
+                    for block in content:
+                        if block.get("type") == "text":
+                            text = block.get("text", "")
+                            for text_line in text.split('\n'):
+                                if text_line.strip():
+                                    dashboard.append_output(instance_idx, text_line)
+                            full_text.append(text)
+                        elif block.get("type") == "tool_use":
+                            tool_name = block.get("name", "unknown")
+                            tool_input = block.get("input", {})
+                            tool_desc = _format_tool_short(tool_name, tool_input)
+                            dashboard.append_output(instance_idx, f"\u25b6 {tool_desc}")
+
+                elif msg_type == "content_block_delta":
+                    delta = data.get("delta", {})
+                    if delta.get("type") == "text_delta":
+                        text = delta.get("text", "")
+                        full_text.append(text)
+                        # Only push meaningful chunks to dashboard
+                        for text_line in text.split('\n'):
+                            if text_line.strip():
+                                dashboard.append_output(instance_idx, text_line)
+
+                elif msg_type == "tool_use":
+                    tool_name = data.get("name", "unknown")
+                    tool_input = data.get("input", {})
+                    tool_desc = _format_tool_short(tool_name, tool_input)
+                    dashboard.append_output(instance_idx, f"\u25b6 {tool_desc}")
+
+                elif msg_type == "tool_result":
+                    dashboard.append_output(instance_idx, "\u2514\u2500 \u2713 done")
+
+                elif msg_type == "result":
+                    text = data.get("result", "")
+                    if text:
+                        full_text.append(text)
+
+                elif msg_type == "error":
+                    error_msg = data.get("error", {}).get("message", "Unknown error")
+                    dashboard.append_output(instance_idx, f"\u2717 ERROR: {error_msg}")
+
+            except json.JSONDecodeError:
+                dashboard.append_output(instance_idx, line)
+                full_text.append(line)
+
+        process.wait(timeout=timeout)
+        return '\n'.join(full_text)
+
+    except subprocess.TimeoutExpired:
+        return f"[DAVELOOP:TIMEOUT] Claude Code timed out after {timeout // 60} minutes"
+    except FileNotFoundError:
+        return "[DAVELOOP:ERROR] Claude Code CLI not found"
+    except Exception as e:
+        return f"[DAVELOOP:ERROR] {str(e)}"
+
+
+def _format_tool_short(tool_name: str, tool_input: dict) -> str:
+    """Format a tool call for compact dashboard display."""
+    if tool_name == "Bash":
+        cmd = tool_input.get("command", "")
+        return f"Bash({cmd[:40]}{'...' if len(cmd) > 40 else ''})"
+    elif tool_name in ("Read", "Write", "Edit"):
+        fp = tool_input.get("file_path", "")
+        fname = fp.split("\\")[-1].split("/")[-1]
+        return f"{tool_name}({fname})"
+    elif tool_name == "Grep":
+        pat = tool_input.get("pattern", "")
+        return f"Grep({pat[:25]}{'...' if len(pat) > 25 else ''})"
+    elif tool_name == "Glob":
+        pat = tool_input.get("pattern", "")
+        return f"Glob({pat})"
+    elif tool_name == "Task":
+        desc = tool_input.get("description", "")
+        return f"Task({desc[:30]}{'...' if len(desc) > 30 else ''})"
+    return tool_name
+
+
+def run_turbo_task(task_desc: str, task_idx: int, system_prompt: str,
+                   working_dir: str, max_iterations: int, timeout: int,
+                   dashboard: TurboDashboard, swarm_mode: bool = False,
+                   swarm_budget_max: int = 5, swarm_depth_max: int = 1) -> dict:
+    """Run a single DaveLoop task inside the turbo dashboard.
+
+    Returns a dict with outcome, iterations, and output.
+    """
+    dashboard.update_task(task_idx, task_desc[:50], max_iterations)
+
+    context = f"""
+## Bug Report
+
+{task_desc}
+
+## Instructions
+
+Analyze this bug. Gather whatever logs/information you need to understand it.
+Then fix it. Use the reasoning protocol before each action.
+"""
+    full_output = []
+
+    for iteration in range(1, max_iterations + 1):
+        dashboard.update_iteration(task_idx, iteration)
+        dashboard.append_output(task_idx, f"--- Iteration {iteration}/{max_iterations} ---")
+
+        if iteration == 1:
+            full_prompt = f"{system_prompt}\n\n---\n\n{context}"
+        else:
+            full_prompt = context
+
+        output = run_claude_code_turbo(
+            full_prompt, working_dir,
+            instance_idx=task_idx,
+            dashboard=dashboard,
+            timeout=timeout,
+            swarm_mode=swarm_mode,
+            swarm_budget_max=swarm_budget_max,
+            swarm_depth_max=swarm_depth_max,
+        )
+
+        full_output.append(output)
+
+        signal, should_exit = check_exit_condition(output)
+
+        if should_exit:
+            if signal == "RESOLVED":
+                dashboard.append_output(task_idx, "\u2713 BUG RESOLVED!")
+                dashboard.mark_done(task_idx, "done")
+                return {"outcome": "RESOLVED", "iterations": iteration, "output": '\n'.join(full_output)}
+            elif signal == "BLOCKED":
+                dashboard.append_output(task_idx, "\u2717 BLOCKED - needs human help")
+                dashboard.mark_done(task_idx, "failed")
+                return {"outcome": "BLOCKED", "iterations": iteration, "output": '\n'.join(full_output)}
+            elif signal == "CLARIFY":
+                dashboard.append_output(task_idx, "\u2717 NEEDS CLARIFICATION")
+                dashboard.mark_done(task_idx, "failed")
+                return {"outcome": "CLARIFY", "iterations": iteration, "output": '\n'.join(full_output)}
+            else:
+                dashboard.append_output(task_idx, f"\u2717 Error: {signal}")
+                dashboard.mark_done(task_idx, "failed")
+                return {"outcome": signal, "iterations": iteration, "output": '\n'.join(full_output)}
+
+        # Prepare next iteration context
+        context = f"""
+## Iteration {iteration + 1}
+
+The bug is NOT yet resolved. You have full context from previous iterations.
+
+Continue debugging. Analyze what happened, determine next steps, and proceed.
+Use the reasoning protocol before each action.
+"""
+
+    # Max iterations reached
+    dashboard.append_output(task_idx, f"\u2717 Max iterations ({max_iterations}) reached")
+    dashboard.mark_done(task_idx, "failed")
+    return {"outcome": "MAX_ITERATIONS", "iterations": max_iterations, "output": '\n'.join(full_output)}
+
+
+# ============================================================================
+# Token Tracker
+# ============================================================================
+class TokenTracker:
+    """Tracks token usage across API turns in a DaveLoop session."""
+
+    def __init__(self):
+        self.total_input = 0
+        self.total_output = 0
+        self.turn_count = 0
+        self.peak_input = 0
+        self.peak_output = 0
+        self.peak_total = 0
+        self.per_tool = {}  # tool_name -> {"input": int, "output": int, "count": int}
+        self._current_tool = None  # Track which tool is active for per-tool attribution
+        self._turn_input = 0  # Accumulate within a turn for per-tool attribution
+        self._turn_output = 0
+
+    def set_current_tool(self, tool_name: str):
+        """Set the currently active tool for per-tool token attribution."""
+        self._current_tool = tool_name
+
+    def record_usage(self, input_tokens: int, output_tokens: int):
+        """Record token usage from an API turn."""
+        self.total_input += input_tokens
+        self.total_output += output_tokens
+        self.turn_count += 1
+
+        turn_total = input_tokens + output_tokens
+        if turn_total > self.peak_total:
+            self.peak_total = turn_total
+            self.peak_input = input_tokens
+            self.peak_output = output_tokens
+
+        # Attribute to current tool if one is active
+        if self._current_tool:
+            if self._current_tool not in self.per_tool:
+                self.per_tool[self._current_tool] = {"input": 0, "output": 0, "count": 0}
+            self.per_tool[self._current_tool]["input"] += input_tokens
+            self.per_tool[self._current_tool]["output"] += output_tokens
+            self.per_tool[self._current_tool]["count"] += 1
+
+    @property
+    def total_tokens(self) -> int:
+        return self.total_input + self.total_output
+
+    def summary(self) -> dict:
+        """Return a dict with all token stats."""
+        return {
+            "input_tokens": self.total_input,
+            "output_tokens": self.total_output,
+            "total_tokens": self.total_tokens,
+            "turn_count": self.turn_count,
+            "peak_turn": {
+                "input": self.peak_input,
+                "output": self.peak_output,
+                "total": self.peak_total,
+            },
+            "per_tool": dict(self.per_tool),
+        }
+
+    def summary_line(self) -> str:
+        """Return a one-line summary string for display."""
+        return (
+            f"Tokens: {self.total_input:,} in / {self.total_output:,} out / "
+            f"{self.total_tokens:,} total ({self.turn_count} turns)"
+        )
+
+    def verbose_turn_line(self, input_tokens: int, output_tokens: int) -> str:
+        """Return a per-turn detail line for --show-tokens mode."""
+        total = input_tokens + output_tokens
+        tool_info = f" [{self._current_tool}]" if self._current_tool else ""
+        return (
+            f"  Turn {self.turn_count}: {input_tokens:,} in / {output_tokens:,} out / "
+            f"{total:,} total{tool_info}"
+        )
+
+
 # ============================================================================
 # Session Memory
 # ============================================================================
@@ -294,16 +804,21 @@ def save_history(working_dir: str, history_data: dict):
     history_file.write_text(json.dumps(history_data, indent=2), encoding="utf-8")
 
 
-def summarize_session(bug: str, outcome: str, iterations: int) -> dict:
+def summarize_session(bug: str, outcome: str, iterations: int, token_tracker: "TokenTracker" = None) -> dict:
     """Return a dict summarizing a session."""
     now = datetime.now()
-    return {
+    entry = {
         "session_id": now.strftime("%Y%m%d_%H%M%S"),
         "bug": bug,
         "outcome": outcome,
         "iterations": iterations,
         "timestamp": now.isoformat()
     }
+    if token_tracker and token_tracker.turn_count > 0:
+        entry["tokens_in"] = token_tracker.total_input
+        entry["tokens_out"] = token_tracker.total_output
+        entry["tokens_total"] = token_tracker.total_tokens
+    return entry
 
 
 def format_history_context(sessions: list) -> str:
@@ -329,10 +844,12 @@ def print_history_box(sessions: list):
         outcome = s.get("outcome", "UNKNOWN")
         bug = s.get("bug", "unknown")[:55]
         iters = s.get("iterations", "?")
+        tokens_total = s.get("tokens_total")
+        token_str = f" · {tokens_total:,} tok" if tokens_total else ""
         if outcome == "RESOLVED":
-            print(f"  {C.BRIGHT_GREEN}✓{C.RESET} {C.WHITE}{bug}{C.RESET} {C.DIM}({iters} iter){C.RESET}")
+            print(f"  {C.BRIGHT_GREEN}✓{C.RESET} {C.WHITE}{bug}{C.RESET} {C.DIM}({iters} iter{token_str}){C.RESET}")
         else:
-            print(f"  {C.BRIGHT_RED}✗{C.RESET} {C.WHITE}{bug}{C.RESET} {C.DIM}({iters} iter){C.RESET}")
+            print(f"  {C.BRIGHT_RED}✗{C.RESET} {C.WHITE}{bug}{C.RESET} {C.DIM}({iters} iter{token_str}){C.RESET}")
     print()
 
 
@@ -426,7 +943,7 @@ class InputMonitor:
     Call resume_reading() after the main thread is done with input().
     """
 
-    VALID_COMMANDS = ("wait", "pause", "add", "done")
+    VALID_COMMANDS = ("wait", "pause", "add", "done", "stop")
 
     def __init__(self):
         self._command = None
@@ -554,12 +1071,17 @@ def find_claude_cli():
     return None
 
 
-def run_claude_code(prompt: str, working_dir: str = None, continue_session: bool = False, stream: bool = True, timeout: int = DEFAULT_TIMEOUT, input_monitor=None) -> str:
+def run_claude_code(prompt: str, working_dir: str = None, continue_session: bool = False, stream: bool = True, timeout: int = DEFAULT_TIMEOUT, input_monitor=None, swarm_mode: bool = False, swarm_budget_max: int = 5, swarm_depth_max: int = 1, token_tracker: "TokenTracker" = None, show_tokens: bool = False) -> str:
     """Execute Claude Code CLI with the given prompt.
 
     If stream=True, output is printed in real-time and also returned.
     timeout is in seconds (default 600 = 10 minutes).
     input_monitor: optional InputMonitor to check for user commands during execution.
+    swarm_mode: if True, enables Task tool for sub-agent spawning.
+    swarm_budget_max: max sub-agents per session in swarm mode.
+    swarm_depth_max: max sub-agent depth in swarm mode.
+    token_tracker: optional TokenTracker to accumulate token usage from the stream.
+    show_tokens: if True, print per-turn token usage during execution.
     """
     claude_cmd = find_claude_cli()
     if not claude_cmd:
@@ -578,7 +1100,8 @@ def run_claude_code(prompt: str, working_dir: str = None, continue_session: bool
     if continue_session:
         cmd.append("--continue")
 
-    cmd.extend(["-p", "--verbose", "--output-format", "stream-json", "--allowedTools", "Bash,Read,Write,Edit,Glob,Grep,Task"])
+    allowed = ALLOWED_TOOLS_SWARM if swarm_mode else ALLOWED_TOOLS_DEFAULT
+    cmd.extend(["-p", "--verbose", "--output-format", "stream-json", "--allowedTools", allowed])
 
     try:
         if stream:
@@ -602,6 +1125,9 @@ def run_claude_code(prompt: str, working_dir: str = None, continue_session: bool
             # Track start time
             start_time = time.time()
 
+            # Swarm budget tracking (only active in swarm mode)
+            swarm_budget = SwarmBudget(max_spawns=swarm_budget_max, max_depth=swarm_depth_max) if swarm_mode else None
+
             # Read and display JSON stream output
             output_lines = []
             full_text = []
@@ -617,6 +1143,19 @@ def run_claude_code(prompt: str, working_dir: str = None, continue_session: bool
                     msg_type = data.get("type", "")
 
 
+                    # Extract token usage from any message that has it
+                    if token_tracker:
+                        usage = (data.get("message", {}).get("usage")
+                                 or data.get("usage")
+                                 or None)
+                        if usage and isinstance(usage, dict):
+                            inp = usage.get("input_tokens", 0)
+                            outp = usage.get("output_tokens", 0)
+                            if inp or outp:
+                                token_tracker.record_usage(inp, outp)
+                                if show_tokens:
+                                    print(f"  {C.DIM}{token_tracker.verbose_turn_line(inp, outp)}{C.RESET}")
+
                     # Handle different message types
                     if msg_type == "assistant":
                         # Assistant text message
@@ -631,6 +1170,8 @@ def run_claude_code(prompt: str, working_dir: str = None, continue_session: bool
                             elif block.get("type") == "tool_use":
                                 # Tool being called - show what Claude is doing
                                 tool_name = block.get("name", "unknown")
+                                if token_tracker:
+                                    token_tracker.set_current_tool(tool_name)
                                 tool_input = block.get("input", {})
 
                                 # Format tool call based on type
@@ -660,6 +1201,18 @@ def run_claude_code(prompt: str, working_dir: str = None, continue_session: bool
                                 elif tool_name == "Task":
                                     desc = tool_input.get("description", "")
                                     tool_display = f"{C.BRIGHT_BLUE}Task{C.RESET}({C.WHITE}{desc}{C.RESET})"
+                                    # Swarm budget enforcement
+                                    if swarm_budget:
+                                        if not swarm_budget.can_spawn():
+                                            print(f"  {C.BRIGHT_YELLOW}[Swarm] Budget exhausted. Terminating to restart without Task tool.{C.RESET}")
+                                            process.terminate()
+                                            try:
+                                                process.wait(timeout=10)
+                                            except Exception:
+                                                process.kill()
+                                            return '\n'.join(full_text) + "\n[DAVELOOP:SWARM_BUDGET_EXHAUSTED]"
+                                        else:
+                                            swarm_budget.record_spawn(desc)
                                 else:
                                     tool_display = f"{C.BRIGHT_BLUE}{tool_name}{C.RESET}"
 
@@ -677,6 +1230,8 @@ def run_claude_code(prompt: str, working_dir: str = None, continue_session: bool
                     elif msg_type == "tool_use":
                         # Tool being used - show what Claude is doing
                         tool_name = data.get("name", "unknown")
+                        if token_tracker:
+                            token_tracker.set_current_tool(tool_name)
                         tool_input = data.get("input", {})
 
                         # Format tool call based on type
@@ -706,6 +1261,18 @@ def run_claude_code(prompt: str, working_dir: str = None, continue_session: bool
                         elif tool_name == "Task":
                             desc = tool_input.get("description", "")
                             tool_display = f"{C.BRIGHT_BLUE}Task{C.RESET}({C.WHITE}{desc}{C.RESET})"
+                            # Swarm budget enforcement
+                            if swarm_budget:
+                                if not swarm_budget.can_spawn():
+                                    print(f"  {C.BRIGHT_YELLOW}[Swarm] Budget exhausted. Terminating to restart without Task tool.{C.RESET}")
+                                    process.terminate()
+                                    try:
+                                        process.wait(timeout=10)
+                                    except Exception:
+                                        process.kill()
+                                    return '\n'.join(full_text) + "\n[DAVELOOP:SWARM_BUDGET_EXHAUSTED]"
+                                else:
+                                    swarm_budget.record_spawn(desc)
                         else:
                             tool_display = f"{C.BRIGHT_BLUE}{tool_name}{C.RESET}"
 
@@ -859,6 +1426,18 @@ def main():
     parser.add_argument("-v", "--verbose", action="store_true", help="Verbose output")
     parser.add_argument("--maestro", action="store_true", help="Enable Maestro mobile testing mode")
     parser.add_argument("--web", action="store_true", help="Enable Playwright web UI testing mode")
+    parser.add_argument("--swarm", action="store_true",
+                        help="Enable swarm mode: DaveLoop can spawn sub-agents via Task tool")
+    parser.add_argument("--swarm-budget", type=int, default=5,
+                        help="Max sub-agents per DaveLoop worker in swarm mode (default: 5)")
+    parser.add_argument("--swarm-depth", type=int, default=1, choices=[1, 2],
+                        help="Max sub-agent depth in swarm mode (default: 1, no recursive spawning)")
+    parser.add_argument("--show-tokens", action="store_true",
+                        help="Show verbose per-turn token usage during execution")
+    parser.add_argument("--turbo", action="store_true",
+                        help="Run all tasks in parallel with a Rich split-pane dashboard")
+    parser.add_argument("--turbo-workers", type=int, default=None,
+                        help="Max parallel workers in turbo mode (default: number of tasks)")
 
     args = parser.parse_args()
 
@@ -908,6 +1487,14 @@ def main():
     print_status("Tasks", str(len(bug_descriptions)), C.WHITE)
     mode_name = "Maestro Mobile Testing" if args.maestro else "Playwright Web Testing" if args.web else "Autonomous"
     print_status("Mode", mode_name, C.WHITE)
+    if args.swarm:
+        print_status("Swarm", f"ENABLED (budget: {args.swarm_budget}, depth: {args.swarm_depth})", C.BRIGHT_CYAN)
+        print_status("Tools", ALLOWED_TOOLS_SWARM, C.WHITE)
+    else:
+        print_status("Tools", ALLOWED_TOOLS_DEFAULT, C.WHITE)
+    if args.turbo:
+        workers = args.turbo_workers or len(bug_descriptions)
+        print_status("Turbo", f"ENABLED ({workers} parallel workers)", C.BRIGHT_MAGENTA)
     print(f"{C.BRIGHT_BLUE}└{'─' * 70}┘{C.RESET}")
 
     # Build task queue
@@ -917,18 +1504,103 @@ def main():
 
     # Print controls hint
     print(f"\n{C.BRIGHT_BLUE}{C.BOLD}┌─ CONTROLS {'─' * 58}┐{C.RESET}")
-    print(f"{C.BRIGHT_BLUE}│{C.RESET} Type while running:  {C.BRIGHT_WHITE}wait{C.RESET} {C.DIM}·{C.RESET} {C.BRIGHT_WHITE}pause{C.RESET} {C.DIM}·{C.RESET} {C.BRIGHT_WHITE}add{C.RESET} {C.DIM}·{C.RESET} {C.BRIGHT_WHITE}done{C.RESET}                     {C.BRIGHT_BLUE}│{C.RESET}")
+    print(f"{C.BRIGHT_BLUE}│{C.RESET} Type while running:  {C.BRIGHT_WHITE}wait{C.RESET} {C.DIM}·{C.RESET} {C.BRIGHT_WHITE}pause{C.RESET} {C.DIM}·{C.RESET} {C.BRIGHT_WHITE}add{C.RESET} {C.DIM}·{C.RESET} {C.BRIGHT_WHITE}done{C.RESET} {C.DIM}·{C.RESET} {C.BRIGHT_WHITE}stop{C.RESET}                {C.BRIGHT_BLUE}│{C.RESET}")
     print(f"{C.BRIGHT_BLUE}└{'─' * 70}┘{C.RESET}")
 
-    # Start input monitor
-    input_monitor = InputMonitor()
-    input_monitor.start()
-
     # Build history context for initial prompt
     history_context = ""
     if history_data["sessions"]:
         history_context = "\n\n" + format_history_context(history_data["sessions"])
 
+    # ========================================================================
+    # TURBO MODE: parallel execution with Rich dashboard
+    # ========================================================================
+    if args.turbo and len(bug_descriptions) >= 1:
+        num_workers = args.turbo_workers or len(bug_descriptions)
+        num_workers = min(num_workers, len(bug_descriptions))
+
+        print(f"\n  {C.BRIGHT_MAGENTA}{C.BOLD}◆ Launching Turbo Mode with {num_workers} parallel workers...{C.RESET}\n")
+        time.sleep(1)  # Brief pause so user sees the message before dashboard takes over
+
+        dashboard = TurboDashboard(len(bug_descriptions))
+        system_prompt_full = system_prompt + history_context
+
+        # Launch all tasks in parallel
+        results = [None] * len(bug_descriptions)
+
+        dashboard.start()
+        try:
+            with ThreadPoolExecutor(max_workers=num_workers) as executor:
+                futures = {}
+                for idx, desc in enumerate(bug_descriptions):
+                    future = executor.submit(
+                        run_turbo_task,
+                        task_desc=desc,
+                        task_idx=idx,
+                        system_prompt=system_prompt_full,
+                        working_dir=working_dir,
+                        max_iterations=args.max_iterations,
+                        timeout=args.timeout,
+                        dashboard=dashboard,
+                        swarm_mode=args.swarm,
+                        swarm_budget_max=args.swarm_budget,
+                        swarm_depth_max=args.swarm_depth,
+                    )
+                    futures[future] = idx
+
+                for future in as_completed(futures):
+                    idx = futures[future]
+                    try:
+                        results[idx] = future.result()
+                    except Exception as e:
+                        results[idx] = {"outcome": "ERROR", "iterations": 0, "output": str(e)}
+                        dashboard.append_output(idx, f"\u2717 Exception: {e}")
+                        dashboard.mark_done(idx, "failed")
+        finally:
+            # Keep dashboard visible for a moment so user can see final state
+            time.sleep(2)
+            dashboard.stop()
+
+        # Print final summary
+        print(f"\n{BANNER}\n")
+        print(f"\n{C.BRIGHT_BLUE}{C.BOLD}◆ TURBO MODE COMPLETE{C.RESET}")
+        print(f"{C.BRIGHT_BLUE}{'─' * 70}{C.RESET}")
+        for idx, desc in enumerate(bug_descriptions):
+            r = results[idx]
+            outcome = r["outcome"] if r else "ERROR"
+            iters = r["iterations"] if r else 0
+            desc_short = desc[:55]
+            if outcome == "RESOLVED":
+                print(f"  {C.BRIGHT_GREEN}✓{C.RESET} {C.WHITE}{desc_short}{C.RESET} {C.DIM}({iters} iter){C.RESET}")
+            else:
+                print(f"  {C.BRIGHT_RED}✗{C.RESET} {C.RED}{desc_short}{C.RESET} {C.DIM}({outcome}, {iters} iter){C.RESET}")
+
+            # Save to history
+            session_entry = summarize_session(desc, outcome, iters)
+            history_data["sessions"].append(session_entry)
+
+            # Save log
+            save_log(idx + 1, r.get("output", "") if r else "", session_id)
+
+        save_history(working_dir, history_data)
+
+        print(f"\n  {C.DIM}Session: {session_id}{C.RESET}")
+        print(f"  {C.DIM}Logs: {LOG_DIR}{C.RESET}\n")
+
+        all_resolved = all(r and r["outcome"] == "RESOLVED" for r in results)
+        return 0 if all_resolved else 1
+
+    # ========================================================================
+    # SEQUENTIAL MODE (original behavior)
+    # ========================================================================
+
+    # Start input monitor
+    input_monitor = InputMonitor()
+    input_monitor.start()
+
+    # Session-wide token tracking (aggregates across all tasks)
+    session_token_tracker = TokenTracker()
+
     # === OUTER LOOP: iterate over tasks ===
     while True:
         task = task_queue.next()
@@ -1004,6 +1676,7 @@ Then fix it. Use the reasoning protocol before each action.
 """
 
         iteration_history = []
+        task_token_tracker = TokenTracker()
 
         # === INNER LOOP: iterations for current task ===
         for iteration in range(1, args.max_iterations + 1):
@@ -1027,11 +1700,20 @@ Then fix it. Use the reasoning protocol before each action.
                 full_prompt, working_dir,
                 continue_session=continue_session,
                 stream=True, timeout=args.timeout,
-                input_monitor=input_monitor
+                input_monitor=input_monitor,
+                swarm_mode=args.swarm,
+                swarm_budget_max=args.swarm_budget,
+                swarm_depth_max=args.swarm_depth,
+                token_tracker=task_token_tracker,
+                show_tokens=args.show_tokens
             )
 
             print(f"\n{C.BRIGHT_BLUE}  {'─' * 70}{C.RESET}")
 
+            # Print token usage summary for this iteration
+            if task_token_tracker.turn_count > 0:
+                print(f"  {C.BRIGHT_CYAN}⊛ {task_token_tracker.summary_line()}{C.RESET}")
+
             # Save log
             save_log(iteration, output, session_id)
             iteration_history.append(output)
@@ -1085,22 +1767,34 @@ Continue the current debugging task. Use the reasoning protocol before each acti
                 elif user_cmd == "done":
                     # Clean exit
                     input_monitor.stop()
-                    session_entry = summarize_session(bug_input, "DONE_BY_USER", iteration)
+                    session_entry = summarize_session(bug_input, "DONE_BY_USER", iteration, task_token_tracker)
                     history_data["sessions"].append(session_entry)
                     save_history(working_dir, history_data)
                     print(f"\n  {C.GREEN}✓{C.RESET} Session saved. Exiting by user request.")
                     return 0
 
+                elif user_cmd == "stop":
+                    # Boris-commanded stop - terminate this iteration immediately
+                    print(f"\n  {C.BRIGHT_RED}{C.BOLD}  ■ STOPPED BY BORIS{C.RESET}")
+                    print(f"{C.BRIGHT_RED}  {'─' * 70}{C.RESET}")
+                    input_monitor.stop()
+                    session_entry = summarize_session(bug_input, "STOPPED_BY_BORIS", iteration, task_token_tracker)
+                    history_data["sessions"].append(session_entry)
+                    save_history(working_dir, history_data)
+                    return 1
+
             # Check exit condition
             signal, should_exit = check_exit_condition(output)
 
             if should_exit:
                 if signal == "RESOLVED":
                     print_success_box("")
+                    if task_token_tracker.turn_count > 0:
+                        print(f"  {C.BRIGHT_CYAN}⊛ {task_token_tracker.summary_line()}{C.RESET}")
                     print(f"  {C.DIM}Session: {session_id}{C.RESET}")
                     print(f"  {C.DIM}Logs: {LOG_DIR}{C.RESET}\n")
                     task_queue.mark_done()
-                    session_entry = summarize_session(bug_input, "RESOLVED", iteration)
+                    session_entry = summarize_session(bug_input, "RESOLVED", iteration, task_token_tracker)
                     history_data["sessions"].append(session_entry)
                     save_history(working_dir, history_data)
                     break  # Move to next task
@@ -1126,14 +1820,14 @@ Continue debugging with this information. Use the reasoning protocol before each
                     print_status("Logs", str(LOG_DIR), C.WHITE)
                     print()
                     task_queue.mark_failed()
-                    session_entry = summarize_session(bug_input, "BLOCKED", iteration)
+                    session_entry = summarize_session(bug_input, "BLOCKED", iteration, task_token_tracker)
                     history_data["sessions"].append(session_entry)
                     save_history(working_dir, history_data)
                     break  # Move to next task
                 else:
                     print_error_box(f"Error occurred: {signal}")
                     task_queue.mark_failed()
-                    session_entry = summarize_session(bug_input, "ERROR", iteration)
+                    session_entry = summarize_session(bug_input, "ERROR", iteration, task_token_tracker)
                     history_data["sessions"].append(session_entry)
                     save_history(working_dir, history_data)
                     break  # Move to next task
@@ -1173,15 +1867,33 @@ Use the reasoning protocol before each action.
             # Max iterations reached for this task (for-else)
             print_warning_box(f"Max iterations ({args.max_iterations}) reached for current task")
             task_queue.mark_failed()
-            session_entry = summarize_session(bug_input, "MAX_ITERATIONS", args.max_iterations)
+            session_entry = summarize_session(bug_input, "MAX_ITERATIONS", args.max_iterations, task_token_tracker)
             history_data["sessions"].append(session_entry)
             save_history(working_dir, history_data)
 
+        # Aggregate task tokens into session-level tracker
+        if task_token_tracker.turn_count > 0:
+            session_token_tracker.total_input += task_token_tracker.total_input
+            session_token_tracker.total_output += task_token_tracker.total_output
+            session_token_tracker.turn_count += task_token_tracker.turn_count
+            if task_token_tracker.peak_total > session_token_tracker.peak_total:
+                session_token_tracker.peak_total = task_token_tracker.peak_total
+                session_token_tracker.peak_input = task_token_tracker.peak_input
+                session_token_tracker.peak_output = task_token_tracker.peak_output
+            for tool, stats in task_token_tracker.per_tool.items():
+                if tool not in session_token_tracker.per_tool:
+                    session_token_tracker.per_tool[tool] = {"input": 0, "output": 0, "count": 0}
+                session_token_tracker.per_tool[tool]["input"] += stats["input"]
+                session_token_tracker.per_tool[tool]["output"] += stats["output"]
+                session_token_tracker.per_tool[tool]["count"] += stats["count"]
+
         # Save iteration summary for this task
         LOG_DIR.mkdir(exist_ok=True)
         summary = f"# DaveLoop Session {session_id}\n\n"
         summary += f"Bug: {bug_input[:200]}...\n\n"
         summary += f"Iterations: {len(iteration_history)}\n\n"
+        if task_token_tracker.turn_count > 0:
+            summary += f"Token Usage: {task_token_tracker.summary_line()}\n\n"
         summary += "## Iteration History\n\n"
         for i, hist in enumerate(iteration_history, 1):
             summary += f"### Iteration {i}\n```\n{hist[:500]}...\n```\n\n"
@@ -1203,6 +1915,16 @@ Use the reasoning protocol before each action.
             print(f"  {C.DIM}○ {desc}{C.RESET}")
     print()
 
+    # Print session-wide token usage
+    if session_token_tracker.turn_count > 0:
+        print(f"  {C.BRIGHT_CYAN}⊛ {session_token_tracker.summary_line()}{C.RESET}")
+        if session_token_tracker.per_tool:
+            print(f"  {C.DIM}  Per tool:{C.RESET}")
+            for tool, stats in sorted(session_token_tracker.per_tool.items(), key=lambda x: x[1]["input"] + x[1]["output"], reverse=True):
+                tool_total = stats["input"] + stats["output"]
+                print(f"  {C.DIM}    {tool}: {stats['input']:,} in / {stats['output']:,} out / {tool_total:,} total ({stats['count']} calls){C.RESET}")
+        print()
+
     print(f"  {C.DIM}Session: {session_id}{C.RESET}")
     print(f"  {C.DIM}Logs: {LOG_DIR}{C.RESET}\n")