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

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

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: daveloop
-Version: 1.2.0
+Version: 1.4.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.4.0.dist-info/RECORD

@@ -0,0 +1,7 @@
+daveloop.py,sha256=vO_mKj_kSciLmupY_GAw3qkRp4Axo6rsrTJx-lhFIZc,53540
+daveloop_swebench.py,sha256=iD9AU3XRiMQpt7TknFNlvnmPCNp64V-JaTfqTFgsGBM,15996
+daveloop-1.4.0.dist-info/METADATA,sha256=KFXheqH4I1_XexxlhPXlXnMRNzeYEVDnDKCGydjFqEg,10463
+daveloop-1.4.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+daveloop-1.4.0.dist-info/entry_points.txt,sha256=QcFAZgFrDfPtIikNQb7eW9DxOpBK7T-qWrKqbGAS9Ww,86
+daveloop-1.4.0.dist-info/top_level.txt,sha256=36DiYt70m4DIK8t7IhV_y6hAzUIyeb5-qDUf3-gbDdg,27
+daveloop-1.4.0.dist-info/RECORD,,

{daveloop-1.2.0.dist-info → daveloop-1.4.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.46.3)
+Generator: setuptools (80.10.2)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

daveloop.py

@@ -11,6 +11,7 @@ import argparse
 import threading
 import time
 import itertools
+import json
 from datetime import datetime
 from pathlib import Path
 
@@ -19,6 +20,8 @@ MAX_ITERATIONS = 20
 DEFAULT_TIMEOUT = 600  # 10 minutes in seconds
 SCRIPT_DIR = Path(__file__).parent
 PROMPT_FILE = SCRIPT_DIR / "daveloop_prompt.md"
+MAESTRO_PROMPT_FILE = SCRIPT_DIR / "daveloop_maestro_prompt.md"
+WEB_PROMPT_FILE = SCRIPT_DIR / "daveloop_web_prompt.md"
 LOG_DIR = SCRIPT_DIR / "logs"
 
 # Exit signals from Claude Code
@@ -195,6 +198,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 +415,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
 # ============================================================================
@@ -286,6 +495,24 @@ def load_prompt() -> str:
         return "You are debugging. Fix the bug. Output [DAVELOOP:RESOLVED] when done."
 
 
+def load_maestro_prompt() -> str:
+    """Load the Maestro mobile testing prompt."""
+    if MAESTRO_PROMPT_FILE.exists():
+        return MAESTRO_PROMPT_FILE.read_text(encoding="utf-8")
+    else:
+        print_warning_box(f"Maestro prompt file not found: {MAESTRO_PROMPT_FILE}")
+        return None
+
+
+def load_web_prompt() -> str:
+    """Load the Web UI testing prompt."""
+    if WEB_PROMPT_FILE.exists():
+        return WEB_PROMPT_FILE.read_text(encoding="utf-8")
+    else:
+        print_warning_box(f"Web prompt file not found: {WEB_PROMPT_FILE}")
+        return None
+
+
 def find_claude_cli():
     """Find Claude CLI executable path."""
     import platform
@@ -327,11 +554,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 +603,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 +724,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 +742,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,13 +850,15 @@ 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)
     parser.add_argument("-t", "--timeout", type=int, default=DEFAULT_TIMEOUT,
                         help="Timeout per iteration in seconds (default: 600)")
     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")
 
     args = parser.parse_args()
 
@@ -630,46 +866,136 @@ 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
 
     # Setup
     session_id = datetime.now().strftime("%Y%m%d_%H%M%S")
     system_prompt = load_prompt()
+    if args.maestro:
+        maestro_prompt = load_maestro_prompt()
+        if maestro_prompt:
+            system_prompt = system_prompt + "\n\n---\n\n" + maestro_prompt
+    elif args.web:
+        web_prompt = load_web_prompt()
+        if web_prompt:
+            system_prompt = system_prompt + "\n\n---\n\n" + web_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("Mode", "Autonomous", C.WHITE)
+    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)
     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)
+
+    # 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}")
+
+    # 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()
+
+        if args.maestro:
+            print_section("MAESTRO TASK", C.BRIGHT_CYAN)
+            section_color = C.BRIGHT_CYAN
+        elif args.web:
+            print_section("WEB UI TASK", C.BRIGHT_MAGENTA)
+            section_color = C.BRIGHT_MAGENTA
+        else:
+            print_section("BUG REPORT", C.BRIGHT_RED)
+            section_color = C.BRIGHT_RED
+        for line in bug_input.split('\n')[:8]:
+            print(f"  {section_color}{line[:70]}{C.RESET}")
+        if len(bug_input.split('\n')) > 8:
+            print(f"  {section_color}... +{len(bug_input.split(chr(10))) - 8} more lines{C.RESET}")
+        sys.stdout.flush()
+
+        # Initial context for this task
+        if args.maestro:
+            context = f"""
+## Maestro Mobile Testing Task
+
+{bug_input}
+{history_context}
+
+## Instructions
+
+1. First, detect connected devices/emulators (run `adb devices` and/or `xcrun simctl list devices available`)
+2. If no device is found, auto-launch an emulator/simulator
+3. Ensure the target app is installed on the device
+4. Proceed with the Maestro testing task described above
+5. Before declaring success, verify by running the flow(s) 3 consecutive times - all must pass
+
+Use the reasoning protocol before each action.
+"""
+        elif args.web:
+            context = f"""
+## Web UI Testing Task
 
-    sys.stdout.flush()
+{bug_input}
+{history_context}
 
-    # Initial context
-    context = f"""
+## Instructions
+
+1. First, explore the project to detect the framework and find the dev server command
+2. Install Playwright if not already installed (`npm install -D @playwright/test && npx playwright install chromium`)
+3. Start the dev server if not already running
+4. Read the source code to understand the UI components, especially any gesture/drag/interactive elements
+5. Write Playwright tests in an `e2e/` directory that test the app like a real human would - use actual mouse movements, drags, clicks, hovers, keyboard input
+6. Test gestures and buttons SEPARATELY - a working button does not prove the gesture works
+7. Before declaring success, verify by running the tests 3 consecutive times - all must pass
+
+Use the reasoning protocol before each action.
+"""
+        else:
+            context = f"""
 ## Bug Report
 
 {bug_input}
+{history_context}
 
 ## Instructions
 
@@ -677,66 +1003,165 @@ 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)
+            # 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}")
+            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)
 
-        # Save log
-        save_log(iteration, output, session_id)
-        iteration_history.append(output)
+{human_input}
 
-        # Check exit condition
-        signal, should_exit = check_exit_condition(output)
+Continue debugging with this corrected context. Use the reasoning protocol before each action.
+"""
+                    continue
 
-        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"""
+                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
+                    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
+            if args.maestro:
+                context = f"""
+## Iteration {iteration + 1}
+
+The Maestro flow(s) are NOT yet passing reliably. You have full context from previous iterations.
+
+Continue working on the flows. Check device status, inspect the UI hierarchy, fix selectors or timing issues, and re-run.
+Remember: all flows must pass 3 consecutive times before resolving.
+Use the reasoning protocol before each action.
+"""
+            elif args.web:
+                context = f"""
+## Iteration {iteration + 1}
+
+The Playwright tests are NOT yet passing reliably. You have full context from previous iterations.
 
-        # Prepare context for next iteration
-        context = f"""
+Continue working on the tests. Check selectors, timing, server status, and re-run.
+Make sure you are testing like a real human - use actual mouse gestures, not just button clicks.
+Remember: all tests must pass 3 consecutive times before resolving.
+Use the reasoning protocol before each action.
+"""
+            else:
+                context = f"""
 ## Iteration {iteration + 1}
 
 The bug is NOT yet resolved. You have full context from previous iterations.
@@ -744,23 +1169,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.dist-info/RECORD

@@ -1,7 +0,0 @@
-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,,