daveloop 1.2.0__tar.gz → 1.3.0__tar.gz

{daveloop-1.2.0 → daveloop-1.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: daveloop
-Version: 1.2.0
+Version: 1.3.0
 Summary: Self-healing debug agent powered by Claude Code CLI
 Home-page: https://github.com/davebruzil/DaveLoop
 Author: Dave Bruzil
@@ -19,6 +19,14 @@ Classifier: Topic :: Software Development :: Debuggers
 Classifier: Topic :: Software Development :: Quality Assurance
 Requires-Python: >=3.7
 Description-Content-Type: text/markdown
+Dynamic: author
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: requires-python
+Dynamic: summary
 
  # DaveLoop
                                                                                                                                           

{daveloop-1.2.0 → daveloop-1.3.0}/daveloop.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: daveloop
-Version: 1.2.0
+Version: 1.3.0
 Summary: Self-healing debug agent powered by Claude Code CLI
 Home-page: https://github.com/davebruzil/DaveLoop
 Author: Dave Bruzil
@@ -19,6 +19,14 @@ Classifier: Topic :: Software Development :: Debuggers
 Classifier: Topic :: Software Development :: Quality Assurance
 Requires-Python: >=3.7
 Description-Content-Type: text/markdown
+Dynamic: author
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: requires-python
+Dynamic: summary
 
  # DaveLoop
                                                                                                                                           

{daveloop-1.2.0 → daveloop-1.3.0}/daveloop.py

@@ -11,6 +11,7 @@ import argparse
 import threading
 import time
 import itertools
+import json
 from datetime import datetime
 from pathlib import Path
 
@@ -195,6 +196,144 @@ class Spinner:
             sys.stdout.write(f"\r  {C.GREEN}✓{C.RESET} {self.message} complete {C.DIM}({elapsed:.1f}s){C.RESET}                    \n")
         sys.stdout.flush()
 
+# ============================================================================
+# Task Queue
+# ============================================================================
+class TaskQueue:
+    """Manages multiple bug tasks in sequence."""
+
+    def __init__(self):
+        self.tasks = []  # list of {"description": str, "status": "pending"|"active"|"done"|"failed"}
+
+    def add(self, description: str):
+        """Add a new task with pending status."""
+        self.tasks.append({"description": description, "status": "pending"})
+
+    def next(self):
+        """Find first pending task, set it to active, return it. None if no pending tasks."""
+        for task in self.tasks:
+            if task["status"] == "pending":
+                task["status"] = "active"
+                return task
+        return None
+
+    def current(self):
+        """Return the task with status active, or None."""
+        for task in self.tasks:
+            if task["status"] == "active":
+                return task
+        return None
+
+    def mark_done(self):
+        """Set current active task to done."""
+        task = self.current()
+        if task:
+            task["status"] = "done"
+
+    def mark_failed(self):
+        """Set current active task to failed."""
+        task = self.current()
+        if task:
+            task["status"] = "failed"
+
+    def remaining(self) -> int:
+        """Count of pending tasks."""
+        return sum(1 for t in self.tasks if t["status"] == "pending")
+
+    def all(self):
+        """Return all tasks."""
+        return self.tasks
+
+    def summary_display(self):
+        """Print a nice box showing all tasks with status icons."""
+        active_count = sum(1 for t in self.tasks if t["status"] == "active")
+        done_count = sum(1 for t in self.tasks if t["status"] == "done")
+        total = len(self.tasks)
+        active_idx = next((i for i, t in enumerate(self.tasks) if t["status"] == "active"), 0)
+
+        print(f"\n{C.BRIGHT_BLUE}{C.BOLD}◆ TASK QUEUE ({active_idx + 1}/{total} active){C.RESET}")
+        print(f"{C.BRIGHT_BLUE}{'─' * 70}{C.RESET}")
+        for task in self.tasks:
+            desc = task["description"][:50]
+            if task["status"] == "done":
+                print(f"  {C.BRIGHT_GREEN}✓{C.RESET} {C.WHITE}{desc}{C.RESET}")
+            elif task["status"] == "active":
+                print(f"  {C.BRIGHT_CYAN}▶{C.RESET} {C.BRIGHT_WHITE}{desc}{C.RESET}  {C.DIM}(active){C.RESET}")
+            elif task["status"] == "pending":
+                print(f"  {C.DIM}○{C.RESET} {C.DIM}{desc}{C.RESET}    {C.DIM}(pending){C.RESET}")
+            elif task["status"] == "failed":
+                print(f"  {C.BRIGHT_RED}✗{C.RESET} {C.RED}{desc}{C.RESET}")
+        print()
+
+
+# ============================================================================
+# Session Memory
+# ============================================================================
+def load_history(working_dir: str) -> dict:
+    """Read .daveloop_history.json from working_dir. Return default if missing or corrupted."""
+    history_file = Path(working_dir) / ".daveloop_history.json"
+    if not history_file.exists():
+        return {"sessions": []}
+    try:
+        data = json.loads(history_file.read_text(encoding="utf-8"))
+        if not isinstance(data, dict) or "sessions" not in data:
+            print_warning_box("Corrupted history file - resetting")
+            return {"sessions": []}
+        return data
+    except (json.JSONDecodeError, ValueError):
+        print_warning_box("Corrupted history JSON - resetting")
+        return {"sessions": []}
+
+
+def save_history(working_dir: str, history_data: dict):
+    """Write to .daveloop_history.json. Keep only last 20 sessions."""
+    history_file = Path(working_dir) / ".daveloop_history.json"
+    history_data["sessions"] = history_data["sessions"][-20:]
+    history_file.write_text(json.dumps(history_data, indent=2), encoding="utf-8")
+
+
+def summarize_session(bug: str, outcome: str, iterations: int) -> dict:
+    """Return a dict summarizing a session."""
+    now = datetime.now()
+    return {
+        "session_id": now.strftime("%Y%m%d_%H%M%S"),
+        "bug": bug,
+        "outcome": outcome,
+        "iterations": iterations,
+        "timestamp": now.isoformat()
+    }
+
+
+def format_history_context(sessions: list) -> str:
+    """Return markdown string summarizing recent sessions for Claude context."""
+    if not sessions:
+        return ""
+    lines = ["## Previous DaveLoop Sessions"]
+    for s in sessions[-10:]:  # Show last 10
+        outcome = s.get("outcome", "UNKNOWN")
+        bug = s.get("bug", "unknown")[:60]
+        iters = s.get("iterations", "?")
+        lines.append(f"- [{outcome}] \"{bug}\" ({iters} iterations)")
+    return "\n".join(lines)
+
+
+def print_history_box(sessions: list):
+    """Print a nice UI box showing loaded history."""
+    if not sessions:
+        return
+    print(f"\n{C.BRIGHT_BLUE}{C.BOLD}◆ SESSION HISTORY{C.RESET}")
+    print(f"{C.BRIGHT_BLUE}{'─' * 70}{C.RESET}")
+    for s in sessions[-10:]:
+        outcome = s.get("outcome", "UNKNOWN")
+        bug = s.get("bug", "unknown")[:55]
+        iters = s.get("iterations", "?")
+        if outcome == "RESOLVED":
+            print(f"  {C.BRIGHT_GREEN}✓{C.RESET} {C.WHITE}{bug}{C.RESET} {C.DIM}({iters} iter){C.RESET}")
+        else:
+            print(f"  {C.BRIGHT_RED}✗{C.RESET} {C.WHITE}{bug}{C.RESET} {C.DIM}({iters} iter){C.RESET}")
+    print()
+
+
 # ============================================================================
 # Output Formatter
 # ============================================================================
@@ -274,6 +413,74 @@ def format_claude_output(output: str) -> str:
 
     return '\n'.join(formatted)
 
+# ============================================================================
+# Input Monitor
+# ============================================================================
+class InputMonitor:
+    """Daemon thread that reads stdin for commands while Claude is running.
+
+    After detecting a command, stops reading stdin so that input() calls
+    in the main thread can safely read without a race condition.
+    Call resume_reading() after the main thread is done with input().
+    """
+
+    VALID_COMMANDS = ("wait", "pause", "add", "done")
+
+    def __init__(self):
+        self._command = None
+        self._lock = threading.Lock()
+        self._thread = threading.Thread(target=self._read_loop, daemon=True)
+        self._running = False
+        self._read_gate = threading.Event()
+        self._read_gate.set()  # Start with reading enabled
+
+    def start(self):
+        """Start monitoring stdin."""
+        self._running = True
+        self._thread.start()
+
+    def stop(self):
+        """Stop monitoring stdin."""
+        self._running = False
+        self._read_gate.set()  # Unblock the thread so it can exit
+
+    def resume_reading(self):
+        """Resume reading stdin after an interrupt has been handled."""
+        self._read_gate.set()
+
+    def _read_loop(self):
+        """Read lines from stdin, looking for valid commands."""
+        while self._running:
+            # Wait until reading is enabled (blocks after a command is detected)
+            self._read_gate.wait()
+            if not self._running:
+                break
+            try:
+                line = sys.stdin.readline()
+                if not line:
+                    break
+                cmd = line.strip().lower()
+                if cmd in self.VALID_COMMANDS:
+                    with self._lock:
+                        self._command = cmd
+                    # Stop reading so input() in the main thread has no competition
+                    self._read_gate.clear()
+            except (EOFError, OSError):
+                break
+
+    def has_command(self) -> bool:
+        """Check if a command has been received."""
+        with self._lock:
+            return self._command is not None
+
+    def get_command(self) -> str:
+        """Get and clear the current command."""
+        with self._lock:
+            cmd = self._command
+            self._command = None
+            return cmd
+
+
 # ============================================================================
 # Core Functions
 # ============================================================================
@@ -327,11 +534,12 @@ 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) -> 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) -> 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.
     """
     claude_cmd = find_claude_cli()
     if not claude_cmd:
@@ -375,7 +583,6 @@ def run_claude_code(prompt: str, working_dir: str = None, continue_session: bool
             start_time = time.time()
 
             # Read and display JSON stream output
-            import json
             output_lines = []
             full_text = []
 
@@ -497,12 +704,9 @@ def run_claude_code(prompt: str, working_dir: str = None, continue_session: bool
                                 print(f"  {C.BRIGHT_BLUE}└─{C.RESET} {C.GREEN}✓{C.RESET}")
 
                     elif msg_type == "result":
-                        # Final result
+                        # Final result - skip printing as it duplicates streamed content
                         text = data.get("result", "")
                         if text:
-                            for line_text in text.split('\n'):
-                                formatted = format_output_line(line_text)
-                                print(formatted)
                             full_text.append(text)
 
                     elif msg_type == "error":
@@ -518,6 +722,16 @@ def run_claude_code(prompt: str, working_dir: str = None, continue_session: bool
 
                 output_lines.append(line)
 
+                # Check for user commands from InputMonitor
+                if input_monitor and input_monitor.has_command():
+                    user_cmd = input_monitor.get_command()
+                    try:
+                        process.terminate()
+                        process.wait(timeout=5)
+                    except Exception:
+                        pass
+                    return f"[DAVELOOP:INTERRUPTED:{user_cmd}]"
+
             process.wait(timeout=timeout)
             return '\n'.join(full_text)
         else:
@@ -616,7 +830,7 @@ def main():
         description="DaveLoop - Self-Healing Debug Agent",
         formatter_class=argparse.RawDescriptionHelpFormatter
     )
-    parser.add_argument("bug", nargs="?", help="Bug description or error message")
+    parser.add_argument("bug", nargs="*", help="Bug description(s) or error message(s)")
     parser.add_argument("-f", "--file", help="Read bug description from file")
     parser.add_argument("-d", "--dir", help="Working directory for Claude Code")
     parser.add_argument("-m", "--max-iterations", type=int, default=MAX_ITERATIONS)
@@ -630,16 +844,19 @@ def main():
     os.system('cls' if os.name == 'nt' else 'clear')
     print(BANNER)
 
-    # Get bug description
+    # Collect bug descriptions
+    bug_descriptions = []
     if args.file:
-        bug_input = Path(args.file).read_text(encoding="utf-8")
+        bug_descriptions.append(Path(args.file).read_text(encoding="utf-8"))
     elif args.bug:
-        bug_input = args.bug
+        bug_descriptions.extend(args.bug)
     else:
         print(f"  {C.CYAN}Describe the bug (Ctrl+D or Ctrl+Z to finish):{C.RESET}")
-        bug_input = sys.stdin.read().strip()
+        stdin_input = sys.stdin.read().strip()
+        if stdin_input:
+            bug_descriptions.append(stdin_input)
 
-    if not bug_input:
+    if not bug_descriptions:
         print_error_box("No bug description provided")
         return 1
 
@@ -648,28 +865,61 @@ def main():
     system_prompt = load_prompt()
     working_dir = args.dir or os.getcwd()
 
+    # Load session history
+    history_data = load_history(working_dir)
+    if history_data["sessions"]:
+        print_history_box(history_data["sessions"])
+
     # Session info
     print_header_box(f"SESSION: {session_id}", C.BRIGHT_BLUE)
     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("Tasks", str(len(bug_descriptions)), 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')[: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}")
+    # Build task queue
+    task_queue = TaskQueue()
+    for desc in bug_descriptions:
+        task_queue.add(desc)
 
-    sys.stdout.flush()
+    # 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}└{'─' * 70}┘{C.RESET}")
 
-    # Initial context
-    context = f"""
+    # 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"])
+
+    # === OUTER LOOP: iterate over tasks ===
+    while True:
+        task = task_queue.next()
+        if task is None:
+            break
+
+        bug_input = task["description"]
+        task_queue.summary_display()
+
+        print_section("BUG REPORT", C.BRIGHT_RED)
+        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()
+
+        # Initial context for this task
+        context = f"""
 ## Bug Report
 
 {bug_input}
+{history_context}
 
 ## Instructions
 
@@ -677,66 +927,143 @@ Analyze this bug. Gather whatever logs/information you need to understand it.
 Then fix it. Use the reasoning protocol before each action.
 """
 
-    iteration_history = []
+        iteration_history = []
 
-    for iteration in range(1, args.max_iterations + 1):
+        # === INNER LOOP: iterations for current task ===
+        for iteration in range(1, args.max_iterations + 1):
 
-        if iteration == 1:
-            full_prompt = f"{system_prompt}\n\n---\n\n{context}"
-            continue_session = False
-        else:
-            full_prompt = context
-            continue_session = True
+            if iteration == 1:
+                full_prompt = f"{system_prompt}\n\n---\n\n{context}"
+                continue_session = False
+            else:
+                full_prompt = context
+                continue_session = True
 
-        if args.verbose:
-            print(f"  {C.DIM}[DEBUG] Prompt: {len(full_prompt)} chars, continue={continue_session}{C.RESET}")
+            if args.verbose:
+                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}◆ Agent active...{C.RESET}\n")
-        sys.stdout.flush()
+            # Show "Claude is working" indicator
+            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.BRIGHT_BLUE}  {'─' * 70}{C.RESET}")
-
-        # Save log
-        save_log(iteration, output, session_id)
-        iteration_history.append(output)
-
-        # Check exit condition
-        signal, should_exit = check_exit_condition(output)
-
-        if should_exit:
-            if signal == "RESOLVED":
-                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")
-                print(f"\n  {C.BLUE}Your response:{C.RESET}")
-                human_input = input(f"  {C.WHITE}> {C.RESET}")
-                context = f"""
+            # Run Claude with real-time streaming output
+            output = run_claude_code(
+                full_prompt, working_dir,
+                continue_session=continue_session,
+                stream=True, timeout=args.timeout,
+                input_monitor=input_monitor
+            )
+
+            print(f"\n{C.BRIGHT_BLUE}  {'─' * 70}{C.RESET}")
+
+            # Save log
+            save_log(iteration, output, session_id)
+            iteration_history.append(output)
+
+            # Check for user interrupt commands
+            if "[DAVELOOP:INTERRUPTED:" in output:
+                # Extract the command name
+                cmd_start = output.index("[DAVELOOP:INTERRUPTED:") + len("[DAVELOOP:INTERRUPTED:")
+                cmd_end = output.index("]", cmd_start)
+                user_cmd = output[cmd_start:cmd_end]
+
+                if user_cmd in ("wait", "pause"):
+                    # Pause and get user correction
+                    print(f"\n{C.BRIGHT_YELLOW}{C.BOLD}  \u23f8 PAUSED - DaveLoop is waiting for your input{C.RESET}")
+                    print(f"{C.BRIGHT_YELLOW}  {'─' * 70}{C.RESET}")
+                    print(f"  {C.WHITE}  Type your correction or additional context:{C.RESET}")
+                    try:
+                        human_input = input(f"  {C.WHITE}> {C.RESET}")
+                    except EOFError:
+                        human_input = ""
+                    input_monitor.resume_reading()
+                    context = f"""
+## Human Correction (pause/wait command)
+
+{human_input}
+
+Continue debugging with this corrected context. Use the reasoning protocol before each action.
+"""
+                    continue
+
+                elif user_cmd == "add":
+                    # Prompt for new task, then resume current
+                    print(f"\n  {C.BRIGHT_CYAN}Enter new task description:{C.RESET}")
+                    try:
+                        new_desc = input(f"  {C.WHITE}> {C.RESET}")
+                    except EOFError:
+                        new_desc = ""
+                    input_monitor.resume_reading()
+                    if new_desc.strip():
+                        task_queue.add(new_desc.strip())
+                        print(f"  {C.GREEN}✓{C.RESET} Task added to queue")
+                        task_queue.summary_display()
+                    # Resume current task with --continue
+                    context = f"""
+## Continuing after user added a new task to the queue
+
+Continue the current debugging task. Use the reasoning protocol before each action.
+"""
+                    continue
+
+                elif user_cmd == "done":
+                    # Clean exit
+                    input_monitor.stop()
+                    session_entry = summarize_session(bug_input, "DONE_BY_USER", iteration)
+                    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
+
+            # Check exit condition
+            signal, should_exit = check_exit_condition(output)
+
+            if should_exit:
+                if signal == "RESOLVED":
+                    print_success_box("")
+                    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)
+                    history_data["sessions"].append(session_entry)
+                    save_history(working_dir, history_data)
+                    break  # Move to next task
+                elif signal == "CLARIFY":
+                    print_warning_box("Claude needs clarification")
+                    print(f"\n  {C.BLUE}Your response:{C.RESET}")
+                    try:
+                        human_input = input(f"  {C.WHITE}> {C.RESET}")
+                    except EOFError:
+                        human_input = ""
+                    input_monitor.resume_reading()
+                    context = f"""
 ## Human Clarification
 
 {human_input}
 
 Continue debugging with this information. Use the reasoning protocol before each action.
 """
-                continue
-            elif signal == "BLOCKED":
-                print_error_box(f"Claude is blocked - needs human help")
-                print_status("Session", session_id, C.WHITE)
-                print_status("Logs", str(LOG_DIR), C.WHITE)
-                print()
-                return 1
-            else:
-                print_error_box(f"Error occurred: {signal}")
-                return 1
-
-        # Prepare context for next iteration
-        context = f"""
+                    continue
+                elif signal == "BLOCKED":
+                    print_error_box("Claude is blocked - needs human help")
+                    print_status("Session", session_id, C.WHITE)
+                    print_status("Logs", str(LOG_DIR), C.WHITE)
+                    print()
+                    task_queue.mark_failed()
+                    session_entry = summarize_session(bug_input, "BLOCKED", iteration)
+                    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)
+                    history_data["sessions"].append(session_entry)
+                    save_history(working_dir, history_data)
+                    break  # Move to next task
+
+            # Prepare context for next iteration
+            context = f"""
 ## Iteration {iteration + 1}
 
 The bug is NOT yet resolved. You have full context from previous iterations.
@@ -744,23 +1071,46 @@ 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
-    print_warning_box(f"Max iterations ({args.max_iterations}) reached")
-    print_status("Session", session_id, C.WHITE)
-    print_status("Logs", str(LOG_DIR), C.WHITE)
+        else:
+            # 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)
+            history_data["sessions"].append(session_entry)
+            save_history(working_dir, history_data)
+
+        # 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"
+        summary += "## Iteration History\n\n"
+        for i, hist in enumerate(iteration_history, 1):
+            summary += f"### Iteration {i}\n```\n{hist[:500]}...\n```\n\n"
+        (LOG_DIR / f"{session_id}_summary.md").write_text(summary, encoding="utf-8")
+
+    # === All tasks done - print final summary ===
+    input_monitor.stop()
+
+    print(f"\n{C.BRIGHT_BLUE}{C.BOLD}◆ ALL TASKS COMPLETE{C.RESET}")
+    print(f"{C.BRIGHT_BLUE}{'─' * 70}{C.RESET}")
+    for task in task_queue.all():
+        desc = task["description"][:55]
+        status = task["status"]
+        if status == "done":
+            print(f"  {C.BRIGHT_GREEN}✓{C.RESET} {C.WHITE}{desc}{C.RESET}")
+        elif status == "failed":
+            print(f"  {C.BRIGHT_RED}✗{C.RESET} {C.RED}{desc}{C.RESET}")
+        else:
+            print(f"  {C.DIM}○ {desc}{C.RESET}")
     print()
 
-    # Save summary
-    summary = f"# DaveLoop Session {session_id}\n\n"
-    summary += f"Bug: {bug_input[:200]}...\n\n"
-    summary += f"Iterations: {args.max_iterations}\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"
-    (LOG_DIR / f"{session_id}_summary.md").write_text(summary, encoding="utf-8")
+    print(f"  {C.DIM}Session: {session_id}{C.RESET}")
+    print(f"  {C.DIM}Logs: {LOG_DIR}{C.RESET}\n")
 
-    return 1
+    # Return 0 if all tasks done, 1 if any failed
+    all_done = all(t["status"] == "done" for t in task_queue.all())
+    return 0 if all_done else 1
 
 
 if __name__ == "__main__":

{daveloop-1.2.0 → daveloop-1.3.0}/setup.py

@@ -13,7 +13,7 @@ long_description = readme_file.read_text(encoding="utf-8") if readme_file.exists
 
 setup(
     name="daveloop",
-    version="1.2.0",
+    version="1.3.0",
     description="Self-healing debug agent powered by Claude Code CLI",
     long_description=long_description,
     long_description_content_type="text/markdown",