borisxdave 0.3.4__py3-none-any.whl → 0.3.6__py3-none-any.whl

boris.py

@@ -14,6 +14,8 @@ if hasattr(sys.stdout, "reconfigure"):
         pass
 os.environ["PYTHONUNBUFFERED"] = "1"
 
+import threading
+import time as _time
 import engine
 import git_manager
 import prompts
@@ -811,30 +813,39 @@ def _print_swarm_dashboard(project_dir: str, batch_num: int, batch_milestones: l
         return
 
     active = sum(1 for s in statuses.values() if s.get("state") in ("starting", "working"))
+    done = sum(1 for s in statuses.values() if s.get("state") == "done")
     total_actions = sum(s.get("actions", 0) for s in statuses.values())
 
+    elapsed = ""
+    started_times = [s.get("started_at", 0) for s in statuses.values() if s.get("started_at")]
+    if started_times:
+        elapsed_sec = int(_time.time() - min(started_times))
+        elapsed = f" | Elapsed: {elapsed_sec // 60}m {elapsed_sec % 60}s"
+
     print(flush=True)
-    print("=== BORIS SWARM STATUS ===", flush=True)
-    print(f"Batch {batch_num} | Workers: {active} active / {len(statuses)} total | Actions: {total_actions}", flush=True)
-    print(flush=True)
+    print("╔══════════════════════════════════════════════════════════════════╗", flush=True)
+    print(f"║  BORIS SWARM DASHBOARD  │  Batch {batch_num}  │  {active} active / {done} done / {len(statuses)} total{elapsed}", flush=True)
+    print("╠══════════════════════════════════════════════════════════════════╣", flush=True)
 
     for m in batch_milestones:
         status = statuses.get(m.id, {})
-        state = status.get("state", "unknown")
+        state = status.get("state", "waiting")
         actions = status.get("actions", 0)
         reasoning = status.get("reasoning_blocks", 0)
         interrupts = status.get("interrupts", 0)
         last = status.get("last_action", "")
 
         # Progress indicator based on reasoning blocks (rough proxy)
-        bar_len = min(reasoning, 10)
-        bar = "#" * bar_len + "-" * (10 - bar_len)
+        bar_len = min(reasoning, 20)
+        bar = "█" * bar_len + "░" * (20 - bar_len)
 
+        state_icons = {"starting": "⏳", "working": "⚙️", "done": "✅", "failed": "❌"}
+        icon = state_icons.get(state, "⏸️")
         state_str = state.upper()
-        interrupt_str = f" | {interrupts} interrupts" if interrupts > 0 else ""
-        print(f"[{m.id}] {m.title[:30]:<30} [{bar}] {state_str} | {actions} actions{interrupt_str}", flush=True)
+        interrupt_str = f" │ ⚠ {interrupts} interrupts" if interrupts > 0 else ""
+        print(f"║  {icon} [{m.id}] {m.title[:28]:<28} [{bar}] {state_str:>8} │ {actions:>3} actions{interrupt_str}", flush=True)
         if last:
-            print(f"      Last: {last}", flush=True)
+            print(f"║       └─ {last[:60]}", flush=True)
 
     # Show file locks if file_lock.py is available
     try:
@@ -843,14 +854,29 @@ def _print_swarm_dashboard(project_dir: str, batch_num: int, batch_milestones: l
         locks = flm.get_locked_files()
         if locks:
             lock_strs = [f"{os.path.basename(f)} ({owner})" for f, owner in locks.items()]
-            print(f"\nFile locks: {', '.join(lock_strs)}", flush=True)
+            print(f"║  🔒 Locks: {', '.join(lock_strs)}", flush=True)
     except ImportError:
         pass
 
-    print("===========================", flush=True)
+    print("╚══════════════════════════════════════════════════════════════════╝", flush=True)
     print(flush=True)
 
 
+def _start_live_dashboard(project_dir: str, batch_num: int, batch_milestones: list, interval: float = 10.0):
+    """Start a background thread that prints the swarm dashboard periodically."""
+    stop_event = threading.Event()
+
+    def _loop():
+        while not stop_event.is_set():
+            stop_event.wait(interval)
+            if not stop_event.is_set():
+                _print_swarm_dashboard(project_dir, batch_num, batch_milestones)
+
+    t = threading.Thread(target=_loop, daemon=True)
+    t.start()
+    return stop_event
+
+
 def _apply_preset(args):
     """Apply a swarm preset to args if specified. Preset implies --swarm."""
     if not args.preset:
@@ -1141,32 +1167,50 @@ def main():
                         tasks.append((prompt, m))
                         prompt_map[m.id] = prompt
 
-                    # Run all DaveLoops in parallel
+                    # Run all DaveLoops in parallel with live dashboard
                     isolation = getattr(args, 'isolation', 'none') if getattr(args, 'swarm', False) else 'none'
+                    _print_swarm_dashboard(project_dir, batch_num, ready)
+                    dashboard_stop = _start_live_dashboard(project_dir, batch_num, ready, interval=15.0)
                     parallel_results = engine.run_parallel(tasks, project_dir, args.max_iter, isolation=isolation)
+                    dashboard_stop.set()
 
-                    # Print swarm dashboard after parallel run completes (B7)
+                    # Print final swarm dashboard after parallel run completes (B7)
                     _print_swarm_dashboard(project_dir, batch_num, ready)
                     engine.clear_worker_statuses(project_dir)
 
                     # Process verdicts sequentially (corrections/retries run sequentially)
                     batch_summary = {}
                     for milestone, result in parallel_results:
-                        print(f"[Boris] TURBO: Checking verdict for {milestone.id}...", flush=True)
-                        verdict_result = engine.check(result, milestone)
-                        logger.info(
-                            "TURBO milestone %s verdict: %s - %s",
-                            milestone.id,
-                            verdict_result.verdict.value,
-                            verdict_result.reason,
-                        )
-
-                        _process_milestone_verdict(
-                            verdict_result, result, milestone, plan, st,
-                            project_dir, args, logger, prompt_map[milestone.id]
-                        )
+                        try:
+                            print(f"[Boris] TURBO: Checking verdict for {milestone.id}...", flush=True)
+                            verdict_result = engine.check(result, milestone)
+                            logger.info(
+                                "TURBO milestone %s verdict: %s - %s",
+                                milestone.id,
+                                verdict_result.verdict.value,
+                                verdict_result.reason,
+                            )
+
+                            _process_milestone_verdict(
+                                verdict_result, result, milestone, plan, st,
+                                project_dir, args, logger, prompt_map[milestone.id]
+                            )
+                        except Exception as e:
+                            print(f"[Boris] TURBO: Error processing verdict for {milestone.id}: {e}", flush=True)
+                            logger.error("Verdict processing error for %s: %s", milestone.id, e)
+                            milestone.status = "skipped"
+                            state_module.save(st)
                         batch_summary[milestone.id] = milestone.status.upper()
 
+                    # Safety net: any milestone still in_progress after batch must be marked skipped
+                    for m in ready:
+                        if m.status == "in_progress":
+                            print(f"[Boris] TURBO: {m.id} still in_progress after batch - marking skipped", flush=True)
+                            logger.warning("Milestone %s stuck in_progress after batch, marking skipped", m.id)
+                            m.status = "skipped"
+                            batch_summary[m.id] = "SKIPPED"
+                    state_module.save(st)
+
                     # Convergence phase: reconcile type conflicts from parallel workers
                     if not getattr(args, 'no_converge', False):
                         completed_in_batch = [m for m, r in parallel_results if m.status == "completed"]

{borisxdave-0.3.4.dist-info → borisxdave-0.3.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: borisxdave
-Version: 0.3.4
+Version: 0.3.6
 Summary: Boris - Autonomous Project Orchestrator
 Requires-Python: >=3.8
 Dynamic: requires-python

{borisxdave-0.3.4.dist-info → borisxdave-0.3.6.dist-info}/RECORD

@@ -1,14 +1,14 @@
-boris.py,sha256=x758NOe-Gl-57nYlfgMyEyPNfqf0RdfSSjeNVZFak9I,63834
+boris.py,sha256=bBQtt-_sPC7dYX99knZR7GmDZVojqPUlQM87M3xcom4,66784
 boris_prompt_data.py,sha256=ZBvWMrQOBrl07cNFzgeGumJ54cYg0Be9RSSnK6a3YQY,7940
 config.py,sha256=KfFKyCGasdm1yBvIRFv-ykzA_oRo-zu1Euu9YC7V1Cg,324
-engine.py,sha256=Pdu0i4XrNxiU246EV8MjXvYp9CBvuJWGLA18QMIYvFM,37468
+engine.py,sha256=QGwPdbaekYkT2XuANO26eWMO7bDuJn-5olayooR-hkI,38577
 file_lock.py,sha256=1YriAAayVy8YFe7JFuGIloiJWWvN2FSY0Ry1sB043Sc,4823
 git_manager.py,sha256=BuuTT4naPb5-jLhOik1xHM2ztzuKvJ_bnecZmlYgwFs,8493
 planner.py,sha256=UrU--kBvzvyD1gOVxIn-kdbJiu8tt4rcowsln66WkGw,5670
 prompts.py,sha256=-eSwZ-oTBR12Wx4Md57sVF816T9vHEFlMsvT4zMkwOg,35187
 state.py,sha256=2DCPlcM7SBlCkwWvcnIabltcduv74W46FZ7DxKurWkw,5752
-borisxdave-0.3.4.dist-info/METADATA,sha256=2xBFOjfdS4w_Tlb5MrdRqFs6rJ4YBWCBvnXhitrWC9I,175
-borisxdave-0.3.4.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-borisxdave-0.3.4.dist-info/entry_points.txt,sha256=a6FLWgxiQjGMJIRSV5sDxaaaaQchunm04ZuzX8N7-6I,61
-borisxdave-0.3.4.dist-info/top_level.txt,sha256=C3fTm1vt0QEQyJtvSZiFiOvmR4d0hWmmr6hujJqFrQE,82
-borisxdave-0.3.4.dist-info/RECORD,,
+borisxdave-0.3.6.dist-info/METADATA,sha256=NmCdAb7IuHdrY71AXiQ1_AhNYNPdXClzYRvJBhOVqJU,175
+borisxdave-0.3.6.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+borisxdave-0.3.6.dist-info/entry_points.txt,sha256=a6FLWgxiQjGMJIRSV5sDxaaaaQchunm04ZuzX8N7-6I,61
+borisxdave-0.3.6.dist-info/top_level.txt,sha256=C3fTm1vt0QEQyJtvSZiFiOvmR4d0hWmmr6hujJqFrQE,82
+borisxdave-0.3.6.dist-info/RECORD,,

engine.py

@@ -609,19 +609,27 @@ def run_parallel(tasks: list, project_dir: str, max_iterations: int = None,
         with concurrent.futures.ThreadPoolExecutor(max_workers=len(tasks)) as executor:
             futures = {executor.submit(_run_one_worktree, t): t for t in tasks}
             for future in concurrent.futures.as_completed(futures):
-                milestone, result = future.result()
-                # Merge worktree back if it was used
-                wt_info = worktree_map.get(milestone.id)
-                if wt_info and result.resolved:
-                    wt_path, branch = wt_info
-                    merge_ok = _merge_worktree(project_dir, wt_path, branch, milestone.id)
-                    if not merge_ok:
-                        print(f"  [Boris] WARNING: Merge conflict for {milestone.id} worktree", flush=True)
-                        logger.warning("Worktree merge conflict for %s", milestone.id)
-                elif wt_info:
-                    # Failed milestone - just clean up worktree
-                    _cleanup_worktree(project_dir, wt_info[0], wt_info[1])
-                results.append((milestone, result))
+                try:
+                    milestone, result = future.result()
+                    # Merge worktree back if it was used
+                    wt_info = worktree_map.get(milestone.id)
+                    if wt_info and result.resolved:
+                        wt_path, branch = wt_info
+                        merge_ok = _merge_worktree(project_dir, wt_path, branch, milestone.id)
+                        if not merge_ok:
+                            print(f"  [Boris] WARNING: Merge conflict for {milestone.id} worktree", flush=True)
+                            logger.warning("Worktree merge conflict for %s", milestone.id)
+                    elif wt_info:
+                        # Failed milestone - just clean up worktree
+                        _cleanup_worktree(project_dir, wt_info[0], wt_info[1])
+                    results.append((milestone, result))
+                except Exception as e:
+                    # Worker crashed - return a failed result
+                    _, crashed_milestone = futures[future]
+                    print(f"  [Boris] Worker for {crashed_milestone.id} crashed: {e}", flush=True)
+                    logger.error("Worker crashed for %s: %s", crashed_milestone.id, e)
+                    failed_result = ExecutionResult(output=f"Worker crashed: {e}", resolved=False, exit_code=1)
+                    results.append((crashed_milestone, failed_result))
 
     else:
         # No isolation or single task - original behavior
@@ -633,7 +641,14 @@ def run_parallel(tasks: list, project_dir: str, max_iterations: int = None,
         with concurrent.futures.ThreadPoolExecutor(max_workers=len(tasks)) as executor:
             futures = {executor.submit(_run_one, t): t for t in tasks}
             for future in concurrent.futures.as_completed(futures):
-                results.append(future.result())
+                try:
+                    results.append(future.result())
+                except Exception as e:
+                    _, crashed_milestone = futures[future]
+                    print(f"  [Boris] Worker for {crashed_milestone.id} crashed: {e}", flush=True)
+                    logger.error("Worker crashed for %s: %s", crashed_milestone.id, e)
+                    failed_result = ExecutionResult(output=f"Worker crashed: {e}", resolved=False, exit_code=1)
+                    results.append((crashed_milestone, failed_result))
 
     return results