daveloop 1.1.0__py3-none-any.whl → 1.2.0__py3-none-any.whl

{daveloop-1.1.0.dist-info → daveloop-1.2.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: daveloop
-Version: 1.1.0
+Version: 1.2.0
 Summary: Self-healing debug agent powered by Claude Code CLI
 Home-page: https://github.com/davebruzil/DaveLoop
 Author: Dave Bruzil

daveloop-1.2.0.dist-info/RECORD

@@ -0,0 +1,7 @@
+daveloop.py,sha256=7URdVP8E72feFkOkoRy1lloGqArUuoyUc3Vzcm00rww,34370
+daveloop_swebench.py,sha256=iD9AU3XRiMQpt7TknFNlvnmPCNp64V-JaTfqTFgsGBM,15996
+daveloop-1.2.0.dist-info/METADATA,sha256=PDmw8YwkHmb4anVrpVK-DSeRDfwLJGI9mY1LD3b5etQ,10285
+daveloop-1.2.0.dist-info/WHEEL,sha256=hPN0AlP2dZM_3ZJZWP4WooepkmU9wzjGgCLCeFjkHLA,92
+daveloop-1.2.0.dist-info/entry_points.txt,sha256=QcFAZgFrDfPtIikNQb7eW9DxOpBK7T-qWrKqbGAS9Ww,86
+daveloop-1.2.0.dist-info/top_level.txt,sha256=36DiYt70m4DIK8t7IhV_y6hAzUIyeb5-qDUf3-gbDdg,27
+daveloop-1.2.0.dist-info/RECORD,,

daveloop.py

@@ -79,70 +79,81 @@ if sys.platform == "win32":
 # ============================================================================
 # ASCII Art Banner
 # ============================================================================
-BANNER = f"""
-{C.BRIGHT_BLUE}{C.BOLD}
-   ██████╗  █████╗ ██╗   ██╗███████╗██╗      ██████╗  ██████╗ ██████╗
-   ██╔══██╗██╔══██╗██║   ██║██╔════╝██║     ██╔═══██╗██╔═══██╗██╔══██╗
-   ██║  ██║███████║██║   ██║█████╗  ██║     ██║   ██║██║   ██║██████╔╝
-   ██║  ██║██╔══██║╚██╗ ██╔╝██╔══╝  ██║     ██║   ██║██║   ██║██╔═══╝
-   ██████╔╝██║  ██║ ╚████╔╝ ███████╗███████╗╚██████╔╝╚██████╔╝██║
-   ╚═════╝ ╚═╝  ╚═╝  ╚═══╝  ╚══════╝╚══════╝ ╚═════╝  ╚═════╝ ╚═╝
-{C.RESET}
-{C.BRIGHT_WHITE}{C.BOLD}                  Self-Healing Debug Agent{C.RESET}
-{C.WHITE}            Powered by Claude Code - Autonomous Mode{C.RESET}
-"""
+BANNER = f"""{C.BRIGHT_BLUE}  ❄ · ✦ · ❄ · ✦ · ❄ · ✦ · ❄ · ✦ · ❄ · ✦ · ❄ · ✦ · ❄ · ✦ · ❄ · ✦ · ❄{C.RESET}
+
+{C.BRIGHT_BLUE}{C.BOLD}  ██████╗  █████╗ ██╗   ██╗███████╗██╗      ██████╗  ██████╗ ██████╗
+  ██╔══██╗██╔══██╗██║   ██║██╔════╝██║     ██╔═══██╗██╔═══██╗██╔══██╗
+  ██║  ██║███████║██║   ██║█████╗  ██║     ██║   ██║██║   ██║██████╔╝
+  ██║  ██║██╔══██║╚██╗ ██╔╝██╔══╝  ██║     ██║   ██║██║   ██║██╔═══╝
+  ██████╔╝██║  ██║ ╚████╔╝ ███████╗███████╗╚██████╔╝╚██████╔╝██║
+  ╚═════╝ ╚═╝  ╚═╝  ╚═══╝  ╚══════╝╚══════╝ ╚═════╝  ╚═════╝ ╚═╝{C.RESET}
+
+{C.BRIGHT_BLUE}  ❄ · ✦ · ❄ · ✦ · ❄ · ✦ · ❄ · ✦ · ❄ · ✦ · ❄ · ✦ · ❄ · ✦ · ❄ · ✦ · ❄{C.RESET}
+
+{C.BRIGHT_WHITE}{C.BOLD}                    Self-Healing Debug Agent{C.RESET}
+{C.DIM}                Powered by Claude Code · Autonomous{C.RESET}"""
 
 # ============================================================================
 # UI Components
 # ============================================================================
 def print_header_box(title: str, color: str = C.BRIGHT_BLUE):
     """Print a header."""
-    print(f"\n{color}{C.BOLD}{title}{C.RESET}")
-    print(f"{color}{'─'*len(title)}{C.RESET}\n")
+    print(f"{color}{C.BOLD}┌─ {title} {'─' * (66 - len(title))}┐{C.RESET}")
 
 def print_section(title: str, color: str = C.BRIGHT_BLUE):
     """Print a section divider."""
-    print(f"\n{color}{C.BOLD}{title}{C.RESET}")
-    print(f"{color}{'─'*len(title)}{C.RESET}\n")
+    print(f"\n{color}{C.BOLD}◆ {title}{C.RESET}")
+    print(f"{color}{'─' * 70}{C.RESET}")
 
 def print_status(label: str, value: str, color: str = C.WHITE):
     """Print a status line."""
-    print(f"  {C.WHITE}{label}:{C.RESET} {color}{value}{C.RESET}")
+    print(f"  {C.BRIGHT_BLUE}│{C.RESET} {C.DIM}{label}:{C.RESET} {color}{value}{C.RESET}")
 
 def print_iteration_header(iteration: int, max_iter: int):
     """Print the iteration header with visual progress."""
     progress = iteration / max_iter
-    bar_width = 30
+    bar_width = 25
     filled = int(bar_width * progress)
-    bar = f"{C.BLUE}{'█' * filled}{C.DIM}{'░' * (bar_width - filled)}{C.RESET}"
-
-    iteration_text = f"ITERATION {iteration}/{max_iter}"
-    percentage_text = f"{int(progress*100)}%"
+    empty = bar_width - filled
+    bar = '█' * filled + '░' * empty
 
-    print(f"\n{C.BOLD}{C.WHITE}{iteration_text}{C.RESET}  {bar}  {C.BRIGHT_BLUE}{percentage_text}{C.RESET}\n")
+    print(f"""
+{C.BRIGHT_BLUE}  ──────────────────────────────────────────────────────────────────────{C.RESET}
+{C.BRIGHT_WHITE}{C.BOLD}                         ITERATION {iteration}/{max_iter}{C.RESET}
+{C.BRIGHT_BLUE}                      [{bar}] {int(progress*100)}%{C.RESET}
+{C.BRIGHT_BLUE}  ──────────────────────────────────────────────────────────────────────{C.RESET}
+""")
 
-def print_success_box(message: str):
+def print_success_box(message: str = ""):
     """Print an epic success message."""
-    print(f"\n{C.BRIGHT_GREEN}{C.BOLD}")
-    print("    ███████╗ ██╗   ██╗  ██████╗  ██████╗ ███████╗ ███████╗ ███████╗")
-    print("    ██╔════╝ ██║   ██║ ██╔════╝ ██╔════╝ ██╔════╝ ██╔════╝ ██╔════╝")
-    print("    ███████╗ ██║   ██║ ██║      ██║      █████╗   ███████╗ ███████╗")
-    print("    ╚════██║ ██║   ██║ ██║      ██║      ██╔══╝   ╚════██║ ╚════██║")
-    print("    ███████║ ╚██████╔╝ ╚██████╗ ╚██████╗ ███████╗ ███████║ ███████║")
-    print("    ╚══════╝  ╚═════╝   ╚═════╝  ╚═════╝ ╚══════╝ ╚══════╝ ╚══════╝")
-    print()
-    print(f"         {C.BRIGHT_YELLOW}★ ★ ★{C.RESET}{C.BRIGHT_GREEN}{C.BOLD}  {C.BRIGHT_WHITE}BUG SUCCESSFULLY RESOLVED{C.RESET}{C.BRIGHT_GREEN}{C.BOLD}  {C.BRIGHT_YELLOW}★ ★ ★{C.RESET}")
-    print()
-    print(f"                      {C.WHITE}{message}{C.RESET}")
-    print(f"{C.RESET}\n")
+    print(f"""
+{C.BRIGHT_GREEN}{C.BOLD}  ███████╗██╗   ██╗ ██████╗ ██████╗███████╗███████╗███████╗
+  ██╔════╝██║   ██║██╔════╝██╔════╝██╔════╝██╔════╝██╔════╝
+  ███████╗██║   ██║██║     ██║     █████╗  ███████╗███████╗
+  ╚════██║██║   ██║██║     ██║     ██╔══╝  ╚════██║╚════██║
+  ███████║╚██████╔╝╚██████╗╚██████╗███████╗███████║███████║
+  ╚══════╝ ╚═════╝  ╚═════╝ ╚═════╝╚══════╝╚══════╝╚══════╝{C.RESET}
+
+{C.BRIGHT_WHITE}{C.BOLD}                  ✓ BUG SUCCESSFULLY RESOLVED{C.RESET}
+""")
 
 def print_error_box(message: str):
     """Print an error message."""
-    print(f"\n{C.BRIGHT_RED}{C.BOLD}✗ ERROR: {C.WHITE}{message}{C.RESET}\n")
+    print(f"""
+{C.BRIGHT_RED}╭{'─' * 70}╮
+│{C.RESET} {C.BOLD}{C.BRIGHT_RED}✗ ERROR{C.RESET}                                                              {C.BRIGHT_RED}│
+│{C.RESET} {C.WHITE}{message[:66]}{C.RESET} {C.BRIGHT_RED}│
+╰{'─' * 70}╯{C.RESET}
+""")
 
 def print_warning_box(message: str):
     """Print a warning message."""
-    print(f"\n{C.BRIGHT_YELLOW}{C.BOLD}⚠ WARNING: {C.WHITE}{message}{C.RESET}\n")
+    print(f"""
+{C.BRIGHT_YELLOW}╭{'─' * 70}╮
+│{C.RESET} {C.BOLD}{C.BRIGHT_YELLOW}⚠ WARNING{C.RESET}                                                            {C.BRIGHT_YELLOW}│
+│{C.RESET} {C.WHITE}{message[:66]}{C.RESET} {C.BRIGHT_YELLOW}│
+╰{'─' * 70}╯{C.RESET}
+""")
 
 # ============================================================================
 # Spinner Animation
@@ -360,19 +371,8 @@ def run_claude_code(prompt: str, working_dir: str = None, continue_session: bool
             process.stdin.write(prompt)
             process.stdin.close()
 
-            # Heartbeat thread to show we're alive
+            # Track start time
             start_time = time.time()
-            heartbeat_active = True
-
-            def heartbeat():
-                while heartbeat_active:
-                    elapsed = int(time.time() - start_time)
-                    print(f"\r  {C.BLUE}[{elapsed}s elapsed...]{C.RESET}    ", end='')
-                    sys.stdout.flush()
-                    time.sleep(3)
-
-            heartbeat_thread = threading.Thread(target=heartbeat, daemon=True)
-            heartbeat_thread.start()
 
             # Read and display JSON stream output
             import json
@@ -380,8 +380,6 @@ def run_claude_code(prompt: str, working_dir: str = None, continue_session: bool
             full_text = []
 
             for line in process.stdout:
-                # Clear heartbeat line
-                print(f"\r{' '*40}\r", end='')
 
                 line = line.strip()
                 if not line:
@@ -391,6 +389,7 @@ def run_claude_code(prompt: str, working_dir: str = None, continue_session: bool
                     data = json.loads(line)
                     msg_type = data.get("type", "")
 
+
                     # Handle different message types
                     if msg_type == "assistant":
                         # Assistant text message
@@ -402,6 +401,43 @@ def run_claude_code(prompt: str, working_dir: str = None, continue_session: bool
                                     formatted = format_output_line(line_text)
                                     print(formatted)
                                 full_text.append(text)
+                            elif block.get("type") == "tool_use":
+                                # Tool being called - show what Claude is doing
+                                tool_name = block.get("name", "unknown")
+                                tool_input = block.get("input", {})
+
+                                # Format tool call based on type
+                                if tool_name == "Bash":
+                                    cmd = tool_input.get("command", "")
+                                    cmd_display = cmd[:50] + "..." if len(cmd) > 50 else cmd
+                                    tool_display = f"{C.BRIGHT_BLUE}Bash{C.RESET}({C.WHITE}{cmd_display}{C.RESET})"
+                                elif tool_name == "Read":
+                                    file_path = tool_input.get("file_path", "")
+                                    filename = file_path.split("\\")[-1].split("/")[-1]
+                                    tool_display = f"{C.BRIGHT_BLUE}Read{C.RESET}({C.WHITE}{filename}{C.RESET})"
+                                elif tool_name == "Write":
+                                    file_path = tool_input.get("file_path", "")
+                                    filename = file_path.split("\\")[-1].split("/")[-1]
+                                    tool_display = f"{C.BRIGHT_BLUE}Write{C.RESET}({C.WHITE}{filename}{C.RESET})"
+                                elif tool_name == "Edit":
+                                    file_path = tool_input.get("file_path", "")
+                                    filename = file_path.split("\\")[-1].split("/")[-1]
+                                    tool_display = f"{C.BRIGHT_BLUE}Edit{C.RESET}({C.WHITE}{filename}{C.RESET})"
+                                elif tool_name == "Grep":
+                                    pattern = tool_input.get("pattern", "")
+                                    pattern_display = pattern[:25] + "..." if len(pattern) > 25 else pattern
+                                    tool_display = f"{C.BRIGHT_BLUE}Grep{C.RESET}({C.WHITE}{pattern_display}{C.RESET})"
+                                elif tool_name == "Glob":
+                                    pattern = tool_input.get("pattern", "")
+                                    tool_display = f"{C.BRIGHT_BLUE}Glob{C.RESET}({C.WHITE}{pattern}{C.RESET})"
+                                elif tool_name == "Task":
+                                    desc = tool_input.get("description", "")
+                                    tool_display = f"{C.BRIGHT_BLUE}Task{C.RESET}({C.WHITE}{desc}{C.RESET})"
+                                else:
+                                    tool_display = f"{C.BRIGHT_BLUE}{tool_name}{C.RESET}"
+
+                                print(f"  {C.BRIGHT_BLUE}▶{C.RESET} {tool_display}")
+                                sys.stdout.flush()
 
                     elif msg_type == "content_block_delta":
                         # Streaming text delta
@@ -412,13 +448,53 @@ def run_claude_code(prompt: str, working_dir: str = None, continue_session: bool
                             full_text.append(text)
 
                     elif msg_type == "tool_use":
-                        # Tool being used
+                        # Tool being used - show what Claude is doing
                         tool_name = data.get("name", "unknown")
-                        print(f"\n  {C.BLUE}🔧 Using tool: {tool_name}{C.RESET}")
+                        tool_input = data.get("input", {})
+
+                        # Format tool call based on type
+                        if tool_name == "Bash":
+                            cmd = tool_input.get("command", "")
+                            cmd_display = cmd[:50] + "..." if len(cmd) > 50 else cmd
+                            tool_display = f"{C.BRIGHT_BLUE}Bash{C.RESET}({C.WHITE}{cmd_display}{C.RESET})"
+                        elif tool_name == "Read":
+                            file_path = tool_input.get("file_path", "")
+                            filename = file_path.split("\\")[-1].split("/")[-1]
+                            tool_display = f"{C.BRIGHT_BLUE}Read{C.RESET}({C.WHITE}{filename}{C.RESET})"
+                        elif tool_name == "Write":
+                            file_path = tool_input.get("file_path", "")
+                            filename = file_path.split("\\")[-1].split("/")[-1]
+                            tool_display = f"{C.BRIGHT_BLUE}Write{C.RESET}({C.WHITE}{filename}{C.RESET})"
+                        elif tool_name == "Edit":
+                            file_path = tool_input.get("file_path", "")
+                            filename = file_path.split("\\")[-1].split("/")[-1]
+                            tool_display = f"{C.BRIGHT_BLUE}Edit{C.RESET}({C.WHITE}{filename}{C.RESET})"
+                        elif tool_name == "Grep":
+                            pattern = tool_input.get("pattern", "")
+                            pattern_display = pattern[:25] + "..." if len(pattern) > 25 else pattern
+                            tool_display = f"{C.BRIGHT_BLUE}Grep{C.RESET}({C.WHITE}{pattern_display}{C.RESET})"
+                        elif tool_name == "Glob":
+                            pattern = tool_input.get("pattern", "")
+                            tool_display = f"{C.BRIGHT_BLUE}Glob{C.RESET}({C.WHITE}{pattern}{C.RESET})"
+                        elif tool_name == "Task":
+                            desc = tool_input.get("description", "")
+                            tool_display = f"{C.BRIGHT_BLUE}Task{C.RESET}({C.WHITE}{desc}{C.RESET})"
+                        else:
+                            tool_display = f"{C.BRIGHT_BLUE}{tool_name}{C.RESET}"
+
+                        print(f"  {C.BRIGHT_BLUE}▶{C.RESET} {tool_display}")
+                        sys.stdout.flush()
 
                     elif msg_type == "tool_result":
-                        # Tool result
-                        print(f"  {C.BLUE}✓ Tool completed{C.RESET}\n")
+                        # Tool completed
+                        print(f"  {C.BRIGHT_BLUE}└─{C.RESET} {C.GREEN}✓{C.RESET}")
+
+                    elif msg_type == "user":
+                        # Tool results come back as user messages
+                        content = data.get("message", {}).get("content", [])
+                        for block in content:
+                            if block.get("type") == "tool_result":
+                                print(f"  {C.BRIGHT_BLUE}└─{C.RESET} {C.GREEN}✓{C.RESET}")
 
                     elif msg_type == "result":
                         # Final result
@@ -442,9 +518,6 @@ def run_claude_code(prompt: str, working_dir: str = None, continue_session: bool
 
                 output_lines.append(line)
 
-            heartbeat_active = False
-            print(f"\r{' '*40}\r", end='')  # Clear final heartbeat
-
             process.wait(timeout=timeout)
             return '\n'.join(full_text)
         else:
@@ -476,36 +549,40 @@ def format_output_line(line: str) -> str:
     """Format a single line of Claude's output with colors."""
     # Reasoning markers
     if "=== DAVELOOP REASONING ===" in line:
-        return f"\n{C.BRIGHT_BLUE}{'─'*50}\n  🧠 REASONING\n{'─'*50}{C.RESET}"
+        return f"""
+{C.BRIGHT_BLUE}  ┌─ 🧠 REASONING ─────────────────────────────────────────────────────┐{C.RESET}"""
     if "===========================" in line:
-        return f"{C.BRIGHT_BLUE}{'─'*50}{C.RESET}\n"
+        return f"{C.BRIGHT_BLUE}  └─────────────────────────────────────────────────────────────────────┘{C.RESET}"
 
     # Reasoning labels
     if line.startswith("KNOWN:"):
-        return f"  {C.BLUE}KNOWN:{C.RESET}{C.WHITE}{line[6:]}{C.RESET}"
+        return f"  {C.BRIGHT_BLUE}│{C.RESET} {C.BRIGHT_BLUE}KNOWN:{C.RESET} {C.WHITE}{line[6:]}{C.RESET}"
     if line.startswith("UNKNOWN:"):
-        return f"  {C.BLUE}UNKNOWN:{C.RESET}{C.WHITE}{line[8:]}{C.RESET}"
+        return f"  {C.BRIGHT_BLUE}│{C.RESET} {C.BRIGHT_BLUE}UNKNOWN:{C.RESET} {C.WHITE}{line[8:]}{C.RESET}"
     if line.startswith("HYPOTHESIS:"):
-        return f"  {C.BLUE}HYPOTHESIS:{C.RESET}{C.WHITE}{line[11:]}{C.RESET}"
+        return f"  {C.BRIGHT_BLUE}│{C.RESET} {C.BRIGHT_BLUE}HYPOTHESIS:{C.RESET} {C.WHITE}{line[11:]}{C.RESET}"
     if line.startswith("NEXT ACTION:"):
-        return f"  {C.BLUE}NEXT ACTION:{C.RESET}{C.WHITE}{line[12:]}{C.RESET}"
+        return f"  {C.BRIGHT_BLUE}│{C.RESET} {C.BRIGHT_BLUE}NEXT:{C.RESET} {C.WHITE}{line[12:]}{C.RESET}"
     if line.startswith("WHY:"):
-        return f"  {C.BLUE}WHY:{C.RESET}{C.WHITE}{line[4:]}{C.RESET}"
+        return f"  {C.BRIGHT_BLUE}│{C.RESET} {C.BRIGHT_BLUE}WHY:{C.RESET} {C.WHITE}{line[4:]}{C.RESET}"
 
-    # Exit signals - just dim them out in the stream, don't make them prominent
-    # The actual success/error boxes will be shown after iteration completes
+    # Exit signals - hide them, the success/error box will show
     if "[DAVELOOP:RESOLVED]" in line:
-        return f"  {C.DIM}→ [Exit signal detected: RESOLVED]{C.RESET}"
+        return ""
     if "[DAVELOOP:BLOCKED]" in line:
-        return f"  {C.DIM}→ [Exit signal detected: BLOCKED]{C.RESET}"
+        return ""
     if "[DAVELOOP:CLARIFY]" in line:
-        return f"  {C.DIM}→ [Exit signal detected: CLARIFY]{C.RESET}"
+        return ""
 
-    # Code blocks
+    # Code blocks - hide the markers
     if line.strip().startswith("```"):
-        return f"{C.BLUE}{'─'*40}{C.RESET}"
+        return ""
+
+    # Empty lines - minimal spacing
+    if not line.strip():
+        return ""
 
-    # Default - white text
+    # Default - white text with subtle indent
     return f"  {C.WHITE}{line}{C.RESET}"
 
 
@@ -573,20 +650,18 @@ def main():
 
     # Session info
     print_header_box(f"SESSION: {session_id}", C.BRIGHT_BLUE)
-    print_status("Working Directory", working_dir, C.WHITE)
-    print_status("Max Iterations", str(args.max_iterations), C.WHITE)
-    print_status("Timeout", f"{args.timeout // 60} min ({args.timeout}s) per iteration", C.WHITE)
-    print_status("Context Mode", "PERSISTENT (--continue)", C.WHITE)
-    print_status("System Prompt", f"{len(system_prompt)} chars loaded", C.WHITE)
-    print()
+    print_status("Directory", working_dir, C.WHITE)
+    print_status("Iterations", str(args.max_iterations), C.WHITE)
+    print_status("Timeout", f"{args.timeout // 60}m per iteration", C.WHITE)
+    print_status("Mode", "Autonomous", C.WHITE)
+    print(f"{C.BRIGHT_BLUE}└{'─' * 70}┘{C.RESET}")
 
     print_section("BUG REPORT", C.BRIGHT_RED)
     # Wrap bug input nicely
-    for line in bug_input.split('\n')[:10]:
-        print(f"  {C.RED}{line[:80]}{C.RESET}")
-    if len(bug_input.split('\n')) > 10:
-        print(f"  {C.RED}... ({len(bug_input.split(chr(10))) - 10} more lines){C.RESET}")
-    print()
+    for line in bug_input.split('\n')[:8]:
+        print(f"  {C.BRIGHT_RED}{line[:70]}{C.RESET}")
+    if len(bug_input.split('\n')) > 8:
+        print(f"  {C.RED}... +{len(bug_input.split(chr(10))) - 8} more lines{C.RESET}")
 
     sys.stdout.flush()
 
@@ -605,7 +680,6 @@ Then fix it. Use the reasoning protocol before each action.
     iteration_history = []
 
     for iteration in range(1, args.max_iterations + 1):
-        print_iteration_header(iteration, args.max_iterations)
 
         if iteration == 1:
             full_prompt = f"{system_prompt}\n\n---\n\n{context}"
@@ -618,13 +692,13 @@ Then fix it. Use the reasoning protocol before each action.
             print(f"  {C.DIM}[DEBUG] Prompt: {len(full_prompt)} chars, continue={continue_session}{C.RESET}")
 
         # Show "Claude is working" indicator
-        print(f"\n  {C.BRIGHT_BLUE}▶ Claude is working...{C.RESET}\n")
+        print(f"\n  {C.BRIGHT_BLUE}◆ Agent active...{C.RESET}\n")
         sys.stdout.flush()
 
         # Run Claude with real-time streaming output
         output = run_claude_code(full_prompt, working_dir, continue_session=continue_session, stream=True, timeout=args.timeout)
 
-        print(f"\n  {C.BLUE}✓ Iteration complete{C.RESET}\n")
+        print(f"\n{C.BRIGHT_BLUE}  {'─' * 70}{C.RESET}")
 
         # Save log
         save_log(iteration, output, session_id)
@@ -635,10 +709,9 @@ Then fix it. Use the reasoning protocol before each action.
 
         if should_exit:
             if signal == "RESOLVED":
-                print_success_box(f"Bug fixed in {iteration} iteration(s)!")
-                print_status("Session", session_id, C.WHITE)
-                print_status("Logs", str(LOG_DIR), C.WHITE)
-                print()
+                print_success_box("")
+                print(f"  {C.DIM}Session: {session_id}{C.RESET}")
+                print(f"  {C.DIM}Logs: {LOG_DIR}{C.RESET}\n")
                 return 0
             elif signal == "CLARIFY":
                 print_warning_box("Claude needs clarification")

daveloop-1.1.0.dist-info/RECORD

@@ -1,7 +0,0 @@
-daveloop.py,sha256=qSdddbGuqeAbwpKRrloy9BHfReRp5KqemJoTkO4OgeQ,28496
-daveloop_swebench.py,sha256=iD9AU3XRiMQpt7TknFNlvnmPCNp64V-JaTfqTFgsGBM,15996
-daveloop-1.1.0.dist-info/METADATA,sha256=AQ6vfEzvM2yGDxvuHROHjki3QS_w_CpCFJ1KE6D482M,10285
-daveloop-1.1.0.dist-info/WHEEL,sha256=hPN0AlP2dZM_3ZJZWP4WooepkmU9wzjGgCLCeFjkHLA,92
-daveloop-1.1.0.dist-info/entry_points.txt,sha256=QcFAZgFrDfPtIikNQb7eW9DxOpBK7T-qWrKqbGAS9Ww,86
-daveloop-1.1.0.dist-info/top_level.txt,sha256=36DiYt70m4DIK8t7IhV_y6hAzUIyeb5-qDUf3-gbDdg,27
-daveloop-1.1.0.dist-info/RECORD,,