borisxdave 0.2.0__py3-none-any.whl → 0.3.0__py3-none-any.whl

boris.py

@@ -202,15 +202,23 @@ def parse_args() -> argparse.Namespace:
         description="Boris - Autonomous Project Orchestrator. Breaks tasks into milestones and executes via Claude CLI.",
     )
     parser.add_argument("task", nargs="?", help="The task description string")
+    parser.add_argument(
+        "-f", "--file", help="Read task description from a file"
+    )
     parser.add_argument(
         "-d", "--dir", default=os.getcwd(), help="Working directory for the project (default: current dir)"
     )
     parser.add_argument(
         "-r", "--resume", action="store_true", help="Resume from last saved state"
     )
-    parser.add_argument(
+    plan_group = parser.add_mutually_exclusive_group()
+    plan_group.add_argument(
         "--plan-only", action="store_true", help="Generate plan but don't execute"
     )
+    plan_group.add_argument(
+        "--exec-only", metavar="PLAN_FILE",
+        help="Skip planning and execute an existing plan file directly"
+    )
     parser.add_argument("--remote", help="Git remote URL to set up")
     parser.add_argument(
         "--no-git", action="store_true", help="Disable git management"
@@ -224,6 +232,18 @@ def parse_args() -> argparse.Namespace:
     parser.add_argument(
         "--skip-ui", action="store_true", help="Skip UI testing phase after structural milestones"
     )
+    parser.add_argument(
+        "--incremental", action="store_true",
+        help="Execute one milestone at a time, then pause. Use with -r to continue to the next milestone."
+    )
+    parser.add_argument(
+        "--turbo", action="store_true",
+        help="Enable parallel DaveLoop execution for independent milestones"
+    )
+    parser.add_argument(
+        "--stop-at", metavar="MILESTONE_ID", dest="stop_at",
+        help="Stop execution after completing this milestone ID (e.g. M4). Implies --incremental."
+    )
 
     return parser.parse_args()
 
@@ -400,9 +420,110 @@ def _run_ui_milestones(st, plan, project_dir, args, logger):
     logger.info("UI testing complete: %d/%d", ui_completed, ui_total)
 
 
+def get_ready_milestones(plan: state_module.Plan) -> list[state_module.Milestone]:
+    """Return all pending milestones whose dependencies are all completed or skipped."""
+    done_statuses = {"completed", "skipped"}
+    done_ids = {m.id for m in plan.milestones if m.status in done_statuses}
+    ready = []
+    for m in plan.milestones:
+        if m.status != "pending":
+            continue
+        if all(dep in done_ids for dep in m.depends_on):
+            ready.append(m)
+    return ready
+
+
+def _process_milestone_verdict(verdict_result, result, milestone, plan, st, project_dir, args, logger, prompt):
+    """Process a single milestone's verdict (corrections, retries). Used by both sequential and turbo modes."""
+    if verdict_result.verdict == Verdict.RESOLVED:
+        milestone.status = "completed"
+        milestone.completed_at = datetime.now().isoformat()
+        state_module.save(st)
+        print(f"[Boris] Milestone {milestone.id} COMPLETE", flush=True)
+        logger.info("Milestone %s completed", milestone.id)
+
+    elif verdict_result.verdict == Verdict.OFF_PLAN:
+        correction_count = 0
+        resolved = False
+
+        while correction_count < MAX_CORRECTIONS:
+            correction_count += 1
+            print(
+                f"  [Boris] Off-plan detected. Correction attempt {correction_count}/{MAX_CORRECTIONS}...",
+                flush=True,
+            )
+            logger.info(
+                "Off-plan correction attempt %d for milestone %s",
+                correction_count,
+                milestone.id,
+            )
+
+            correction_prompt = prompts.craft_correction(
+                result.output, milestone, plan, verdict_result.reason
+            )
+            result = engine.run(correction_prompt, project_dir, args.max_iter, milestone=milestone)
+            verdict_result = engine.check(result, milestone)
+
+            if verdict_result.verdict == Verdict.RESOLVED:
+                milestone.status = "completed"
+                milestone.completed_at = datetime.now().isoformat()
+                state_module.save(st)
+                print(f"[Boris] Milestone {milestone.id} COMPLETE (after correction)", flush=True)
+                logger.info("Milestone %s completed after correction", milestone.id)
+                resolved = True
+                break
+
+        if not resolved:
+            print(f"  [Boris] Milestone {milestone.id} could not be corrected. Skipping.", flush=True)
+            logger.warning("Milestone %s skipped after failed corrections", milestone.id)
+            milestone.status = "skipped"
+            state_module.save(st)
+
+    elif verdict_result.verdict == Verdict.FAILED:
+        retry_count = 0
+        resolved = False
+
+        while retry_count < MAX_RETRIES:
+            retry_count += 1
+            milestone.retry_count = retry_count
+            print(
+                f"  [Boris] Failed. Retry {retry_count}/{MAX_RETRIES}...",
+                flush=True,
+            )
+            logger.info(
+                "Retry %d for milestone %s", retry_count, milestone.id
+            )
+
+            result = engine.run(prompt, project_dir, args.max_iter, milestone=milestone)
+            verdict_result = engine.check(result, milestone)
+
+            if verdict_result.verdict == Verdict.RESOLVED:
+                milestone.status = "completed"
+                milestone.completed_at = datetime.now().isoformat()
+                state_module.save(st)
+                print(f"[Boris] Milestone {milestone.id} COMPLETE (after retry)", flush=True)
+                logger.info("Milestone %s completed after retry", milestone.id)
+                resolved = True
+                break
+
+        if not resolved:
+            print(
+                f"  [Boris] Milestone {milestone.id} failed after {MAX_RETRIES} retries. Skipping.",
+                flush=True,
+            )
+            logger.warning("Milestone %s skipped after failed retries", milestone.id)
+            milestone.status = "skipped"
+            state_module.save(st)
+
+
 def main():
     """Main Boris orchestration loop."""
     args = parse_args()
+
+    # --stop-at implies incremental mode
+    if args.stop_at:
+        args.incremental = True
+
     logger = setup_logging()
 
     # Create required dirs
@@ -427,21 +548,66 @@ def main():
         else:
             print(f"[Boris] Resuming from milestone {start_index + 1}...", flush=True)
             logger.info("Resuming from milestone %d", start_index + 1)
+    elif args.exec_only:
+        # Exec-only mode - load an existing plan file and execute it
+        plan_file = os.path.abspath(args.exec_only)
+        print_banner()
+        print(f"[Boris] Exec-only mode: loading plan from {plan_file}", flush=True)
+        logger.info("Exec-only mode: loading plan from %s", plan_file)
+
+        try:
+            plan = prompts.load_plan_from_file(plan_file)
+        except (FileNotFoundError, RuntimeError) as e:
+            print(f"[Boris] Error loading plan file: {e}", flush=True)
+            logger.error("Failed to load plan file: %s", e)
+            sys.exit(1)
+
+        print(f"[Boris] Plan loaded with {len(plan.milestones)} milestones", flush=True)
+        logger.info("Plan loaded with %d milestones", len(plan.milestones))
+
+        print_plan_summary(plan)
+
+        # Create initial state from the loaded plan
+        st = state_module.State(
+            plan=plan,
+            current_milestone_index=0,
+            project_dir=project_dir,
+            git_remote=args.remote,
+            no_git=args.no_git,
+            turbo=args.turbo,
+        )
+        state_module.save(st)
+        start_index = 0
     else:
-        # New task mode
-        if not args.task:
-            print("[Boris] Error: task is required (unless using --resume)", flush=True)
+        # New task mode - resolve task from args or file
+        task = args.task
+        if args.file:
+            try:
+                with open(args.file, "r", encoding="utf-8") as f:
+                    task = f.read().strip()
+                print(f"[Boris] Read task from file: {args.file} ({len(task)} chars)", flush=True)
+            except FileNotFoundError:
+                print(f"[Boris] Error: File not found: {args.file}", flush=True)
+                sys.exit(1)
+            except Exception as e:
+                print(f"[Boris] Error reading file: {e}", flush=True)
+                sys.exit(1)
+
+        if not task:
+            print("[Boris] Error: task is required (pass as argument or use -f FILE)", flush=True)
             sys.exit(1)
 
+        args.task = task
+
         print_banner()
-        logger.info("Starting Boris for task: %s", args.task)
+        logger.info("Starting Boris for task: %s", args.task[:200])
 
         # Create plan (retry once on timeout)
         print("[Boris] Creating plan...", flush=True)
         plan = None
         for attempt in range(2):
             try:
-                plan = prompts.create_plan(args.task, project_dir)
+                plan = prompts.create_plan(args.task, project_dir, turbo=args.turbo)
                 break
             except RuntimeError as e:
                 if attempt == 0 and "timed out" in str(e).lower():
@@ -470,6 +636,7 @@ def main():
             project_dir=project_dir,
             git_remote=args.remote,
             no_git=args.no_git,
+            turbo=args.turbo,
         )
         state_module.save(st)
         start_index = 0
@@ -491,156 +658,304 @@ def main():
             print(f"[Boris] Setting up remote: {args.remote}", flush=True)
             git_manager.setup_remote(project_dir, args.remote)
 
+    # Determine turbo mode (from state on resume, from args on new run)
+    turbo = getattr(st, "turbo", False) or getattr(args, "turbo", False)
+
     # Phase 1: Structural milestones (skip if resuming into UI phase)
     try:
         if st.phase != "ui_testing":
-            for i in range(start_index, len(plan.milestones)):
-                milestone = plan.milestones[i]
-
-                if milestone.status == "completed":
-                    logger.info("Skipping already completed milestone %s", milestone.id)
-                    continue
-
-                if milestone.status == "skipped":
-                    logger.info("Skipping previously skipped milestone %s", milestone.id)
-                    continue
-
+            if turbo:
+                # === TURBO MODE: Parallel DaveLoop execution ===
                 print(flush=True)
-                print(f"=== Milestone {milestone.id}: {milestone.title} ===", flush=True)
-                logger.info("Starting milestone %s: %s", milestone.id, milestone.title)
-
-                # Mark in progress
-                milestone.status = "in_progress"
-                st.current_milestone_index = i
-                state_module.save(st)
+                print("[Boris] TURBO MODE: Parallel DaveLoop execution enabled", flush=True)
+                logger.info("TURBO MODE enabled")
+
+                batch_num = 0
+                while True:
+                    ready = get_ready_milestones(plan)
+                    if not ready:
+                        # Check if there are still pending milestones (deadlock detection)
+                        pending = [m for m in plan.milestones if m.status == "pending"]
+                        if pending:
+                            pending_ids = [m.id for m in pending]
+                            print(f"[Boris] TURBO: No milestones ready but {len(pending)} still pending: {pending_ids}", flush=True)
+                            print("[Boris] TURBO: Possible dependency deadlock. Skipping remaining.", flush=True)
+                            logger.warning("Turbo deadlock: pending=%s", pending_ids)
+                            for m in pending:
+                                m.status = "skipped"
+                            state_module.save(st)
+                        break
 
-                # Craft prompt and execute
-                print(f"[Boris] Crafting prompt for {milestone.id}...", flush=True)
-                prompt = prompts.craft_prompt(milestone, plan, project_dir)
-                print(f"[Boris] Prompt ready ({len(prompt)} chars). Spawning DaveLoop...", flush=True)
-                result = engine.run(prompt, project_dir, args.max_iter, milestone=milestone)
-
-                # Check verdict
-                print(f"[Boris] DaveLoop finished. Checking verdict for {milestone.id}...", flush=True)
-                verdict_result = engine.check(result, milestone)
-                logger.info(
-                    "Milestone %s verdict: %s - %s",
-                    milestone.id,
-                    verdict_result.verdict.value,
-                    verdict_result.reason,
-                )
+                    batch_num += 1
+                    batch_ids = [m.id for m in ready]
+                    print(flush=True)
+                    print(f"[Boris] TURBO: Launching batch {batch_num} of {len(ready)} parallel DaveLoops: {batch_ids}", flush=True)
+                    logger.info("TURBO batch %d: %s", batch_num, batch_ids)
 
-                if verdict_result.verdict == Verdict.RESOLVED:
-                    milestone.status = "completed"
-                    milestone.completed_at = datetime.now().isoformat()
+                    # Mark all in batch as in_progress
+                    for m in ready:
+                        m.status = "in_progress"
                     state_module.save(st)
 
-                    if not st.no_git:
-                        print(f"[Boris] Committing milestone {milestone.id} to git...", flush=True)
-                        if git_manager.commit_milestone(project_dir, milestone):
-                            logger.info("Git commit succeeded for milestone %s", milestone.id)
-                        else:
-                            logger.warning("Git commit FAILED for milestone %s", milestone.id)
-                            print(f"  [Boris] WARNING: Git commit failed for {milestone.id}", flush=True)
-
-                    print(f"[Boris] Milestone {milestone.id} COMPLETE", flush=True)
-                    logger.info("Milestone %s completed", milestone.id)
-
-                elif verdict_result.verdict == Verdict.OFF_PLAN:
-                    # Attempt correction
-                    correction_count = 0
-                    resolved = False
-
-                    while correction_count < MAX_CORRECTIONS:
-                        correction_count += 1
-                        print(
-                            f"  [Boris] Off-plan detected. Correction attempt {correction_count}/{MAX_CORRECTIONS}...",
-                            flush=True,
-                        )
+                    # Craft prompts for all milestones in batch
+                    tasks = []
+                    prompt_map = {}  # milestone.id -> prompt, for retries
+                    for m in ready:
+                        print(f"[Boris] TURBO: Crafting prompt for {m.id}...", flush=True)
+                        # Compute sibling milestones (all others in this batch)
+                        siblings = [sib for sib in ready if sib.id != m.id]
+                        prompt = prompts.craft_prompt(m, plan, project_dir,
+                                                      turbo=True, sibling_milestones=siblings)
+                        print(f"[Boris] TURBO: Prompt ready for {m.id} ({len(prompt)} chars)", flush=True)
+                        tasks.append((prompt, m))
+                        prompt_map[m.id] = prompt
+
+                    # Run all DaveLoops in parallel
+                    parallel_results = engine.run_parallel(tasks, project_dir, args.max_iter)
+
+                    # 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(
-                            "Off-plan correction attempt %d for milestone %s",
-                            correction_count,
+                            "TURBO milestone %s verdict: %s - %s",
                             milestone.id,
+                            verdict_result.verdict.value,
+                            verdict_result.reason,
                         )
 
-                        correction_prompt = prompts.craft_correction(
-                            result.output, milestone, plan, verdict_result.reason
+                        _process_milestone_verdict(
+                            verdict_result, result, milestone, plan, st,
+                            project_dir, args, logger, prompt_map[milestone.id]
                         )
-                        result = engine.run(correction_prompt, project_dir, args.max_iter, milestone=milestone)
-                        verdict_result = engine.check(result, milestone)
+                        batch_summary[milestone.id] = milestone.status.upper()
 
-                        if verdict_result.verdict == Verdict.RESOLVED:
-                            milestone.status = "completed"
-                            milestone.completed_at = datetime.now().isoformat()
-                            state_module.save(st)
-
-                            if not st.no_git:
-                                print(f"[Boris] Committing corrected milestone {milestone.id} to git...", flush=True)
+                    # Git commits sequentially after entire batch
+                    if not st.no_git:
+                        for milestone, result in parallel_results:
+                            if milestone.status == "completed":
+                                print(f"[Boris] TURBO: Committing {milestone.id} to git...", flush=True)
                                 if git_manager.commit_milestone(project_dir, milestone):
-                                    logger.info("Git commit succeeded for milestone %s (after correction)", milestone.id)
+                                    logger.info("Git commit succeeded for milestone %s", milestone.id)
                                 else:
-                                    logger.warning("Git commit FAILED for milestone %s (after correction)", milestone.id)
+                                    logger.warning("Git commit FAILED for milestone %s", milestone.id)
                                     print(f"  [Boris] WARNING: Git commit failed for {milestone.id}", flush=True)
 
-                            print(f"[Boris] Milestone {milestone.id} COMPLETE (after correction)", flush=True)
-                            logger.info("Milestone %s completed after correction", milestone.id)
-                            resolved = True
-                            break
-
-                    if not resolved:
-                        print(f"  [Boris] Milestone {milestone.id} could not be corrected. Skipping.", flush=True)
-                        logger.warning("Milestone %s skipped after failed corrections", milestone.id)
-                        milestone.status = "skipped"
-                        state_module.save(st)
+                    # Save state after whole batch
+                    state_module.save(st)
 
-                elif verdict_result.verdict == Verdict.FAILED:
-                    # Retry logic
-                    retry_count = 0
-                    resolved = False
-
-                    while retry_count < MAX_RETRIES:
-                        retry_count += 1
-                        milestone.retry_count = retry_count
-                        print(
-                            f"  [Boris] Failed. Retry {retry_count}/{MAX_RETRIES}...",
-                            flush=True,
-                        )
-                        logger.info(
-                            "Retry %d for milestone %s", retry_count, milestone.id
-                        )
+                    # Print batch summary
+                    summary_parts = [f"{mid}={status}" for mid, status in batch_summary.items()]
+                    print(f"[Boris] TURBO: Batch {batch_num} complete. Results: {', '.join(summary_parts)}", flush=True)
+                    logger.info("TURBO batch %d complete: %s", batch_num, batch_summary)
+
+                    # Incremental / --stop-at: pause after batch in turbo
+                    should_pause = False
+                    if args.stop_at:
+                        # Pause only if the --stop-at milestone was in this batch
+                        batch_completed_ids = {mid for mid, status in batch_summary.items()
+                                               if status in ("COMPLETED", "SKIPPED")}
+                        if args.stop_at in batch_completed_ids:
+                            should_pause = True
+                    elif args.incremental:
+                        should_pause = True
+
+                    if should_pause:
+                        remaining = sum(1 for m in plan.milestones if m.status == "pending")
+                        if remaining > 0:
+                            print(flush=True)
+                            if args.stop_at:
+                                print(f"[Boris] --stop-at {args.stop_at}: pausing after batch {batch_num}.", flush=True)
+                            else:
+                                print(f"[Boris] Incremental mode: pausing after batch {batch_num}.", flush=True)
+                            print(f"[Boris] {remaining} milestone(s) remaining.", flush=True)
+                            resume_flags = f"-r --turbo -d \"{project_dir}\""
+                            if args.stop_at:
+                                resume_flags += f" --stop-at {args.stop_at}"
+                            elif args.incremental:
+                                resume_flags += " --incremental"
+                            print(f"[Boris] Resume with: boris {resume_flags}", flush=True)
+                            logger.info("Pausing after batch %d. %d remaining.", batch_num, remaining)
+                            state_module.save(st)
+                            sys.exit(0)
+            else:
+                # === SEQUENTIAL MODE (original behavior) ===
+                for i in range(start_index, len(plan.milestones)):
+                    milestone = plan.milestones[i]
+
+                    if milestone.status == "completed":
+                        logger.info("Skipping already completed milestone %s", milestone.id)
+                        continue
+
+                    if milestone.status == "skipped":
+                        logger.info("Skipping previously skipped milestone %s", milestone.id)
+                        continue
+
+                    print(flush=True)
+                    print(f"=== Milestone {milestone.id}: {milestone.title} ===", flush=True)
+                    logger.info("Starting milestone %s: %s", milestone.id, milestone.title)
+
+                    # Mark in progress
+                    milestone.status = "in_progress"
+                    st.current_milestone_index = i
+                    state_module.save(st)
 
-                        result = engine.run(prompt, project_dir, args.max_iter, milestone=milestone)
-                        verdict_result = engine.check(result, milestone)
+                    # Craft prompt and execute
+                    print(f"[Boris] Crafting prompt for {milestone.id}...", flush=True)
+                    prompt = prompts.craft_prompt(milestone, plan, project_dir)
+                    print(f"[Boris] Prompt ready ({len(prompt)} chars). Spawning DaveLoop...", flush=True)
+                    result = engine.run(prompt, project_dir, args.max_iter, milestone=milestone)
+
+                    # Check verdict
+                    print(f"[Boris] DaveLoop finished. Checking verdict for {milestone.id}...", flush=True)
+                    verdict_result = engine.check(result, milestone)
+                    logger.info(
+                        "Milestone %s verdict: %s - %s",
+                        milestone.id,
+                        verdict_result.verdict.value,
+                        verdict_result.reason,
+                    )
+
+                    if verdict_result.verdict == Verdict.RESOLVED:
+                        milestone.status = "completed"
+                        milestone.completed_at = datetime.now().isoformat()
+                        state_module.save(st)
 
-                        if verdict_result.verdict == Verdict.RESOLVED:
-                            milestone.status = "completed"
-                            milestone.completed_at = datetime.now().isoformat()
+                        if not st.no_git:
+                            print(f"[Boris] Committing milestone {milestone.id} to git...", flush=True)
+                            if git_manager.commit_milestone(project_dir, milestone):
+                                logger.info("Git commit succeeded for milestone %s", milestone.id)
+                            else:
+                                logger.warning("Git commit FAILED for milestone %s", milestone.id)
+                                print(f"  [Boris] WARNING: Git commit failed for {milestone.id}", flush=True)
+
+                        print(f"[Boris] Milestone {milestone.id} COMPLETE", flush=True)
+                        logger.info("Milestone %s completed", milestone.id)
+
+                    elif verdict_result.verdict == Verdict.OFF_PLAN:
+                        # Attempt correction
+                        correction_count = 0
+                        resolved = False
+
+                        while correction_count < MAX_CORRECTIONS:
+                            correction_count += 1
+                            print(
+                                f"  [Boris] Off-plan detected. Correction attempt {correction_count}/{MAX_CORRECTIONS}...",
+                                flush=True,
+                            )
+                            logger.info(
+                                "Off-plan correction attempt %d for milestone %s",
+                                correction_count,
+                                milestone.id,
+                            )
+
+                            correction_prompt = prompts.craft_correction(
+                                result.output, milestone, plan, verdict_result.reason
+                            )
+                            result = engine.run(correction_prompt, project_dir, args.max_iter, milestone=milestone)
+                            verdict_result = engine.check(result, milestone)
+
+                            if verdict_result.verdict == Verdict.RESOLVED:
+                                milestone.status = "completed"
+                                milestone.completed_at = datetime.now().isoformat()
+                                state_module.save(st)
+
+                                if not st.no_git:
+                                    print(f"[Boris] Committing corrected milestone {milestone.id} to git...", flush=True)
+                                    if git_manager.commit_milestone(project_dir, milestone):
+                                        logger.info("Git commit succeeded for milestone %s (after correction)", milestone.id)
+                                    else:
+                                        logger.warning("Git commit FAILED for milestone %s (after correction)", milestone.id)
+                                        print(f"  [Boris] WARNING: Git commit failed for {milestone.id}", flush=True)
+
+                                print(f"[Boris] Milestone {milestone.id} COMPLETE (after correction)", flush=True)
+                                logger.info("Milestone %s completed after correction", milestone.id)
+                                resolved = True
+                                break
+
+                        if not resolved:
+                            print(f"  [Boris] Milestone {milestone.id} could not be corrected. Skipping.", flush=True)
+                            logger.warning("Milestone %s skipped after failed corrections", milestone.id)
+                            milestone.status = "skipped"
                             state_module.save(st)
 
-                            if not st.no_git:
-                                print(f"[Boris] Committing retried milestone {milestone.id} to git...", flush=True)
-                                if git_manager.commit_milestone(project_dir, milestone):
-                                    logger.info("Git commit succeeded for milestone %s (after retry)", milestone.id)
-                                else:
-                                    logger.warning("Git commit FAILED for milestone %s (after retry)", milestone.id)
-                                    print(f"  [Boris] WARNING: Git commit failed for {milestone.id}", flush=True)
-
-                            print(f"[Boris] Milestone {milestone.id} COMPLETE (after retry)", flush=True)
-                            logger.info("Milestone %s completed after retry", milestone.id)
-                            resolved = True
-                            break
+                    elif verdict_result.verdict == Verdict.FAILED:
+                        # Retry logic
+                        retry_count = 0
+                        resolved = False
+
+                        while retry_count < MAX_RETRIES:
+                            retry_count += 1
+                            milestone.retry_count = retry_count
+                            print(
+                                f"  [Boris] Failed. Retry {retry_count}/{MAX_RETRIES}...",
+                                flush=True,
+                            )
+                            logger.info(
+                                "Retry %d for milestone %s", retry_count, milestone.id
+                            )
+
+                            result = engine.run(prompt, project_dir, args.max_iter, milestone=milestone)
+                            verdict_result = engine.check(result, milestone)
+
+                            if verdict_result.verdict == Verdict.RESOLVED:
+                                milestone.status = "completed"
+                                milestone.completed_at = datetime.now().isoformat()
+                                state_module.save(st)
+
+                                if not st.no_git:
+                                    print(f"[Boris] Committing retried milestone {milestone.id} to git...", flush=True)
+                                    if git_manager.commit_milestone(project_dir, milestone):
+                                        logger.info("Git commit succeeded for milestone %s (after retry)", milestone.id)
+                                    else:
+                                        logger.warning("Git commit FAILED for milestone %s (after retry)", milestone.id)
+                                        print(f"  [Boris] WARNING: Git commit failed for {milestone.id}", flush=True)
+
+                                print(f"[Boris] Milestone {milestone.id} COMPLETE (after retry)", flush=True)
+                                logger.info("Milestone %s completed after retry", milestone.id)
+                                resolved = True
+                                break
+
+                        if not resolved:
+                            print(
+                                f"  [Boris] Milestone {milestone.id} failed after {MAX_RETRIES} retries. Skipping.",
+                                flush=True,
+                            )
+                            logger.warning("Milestone %s skipped after failed retries", milestone.id)
+                            milestone.status = "skipped"
+                            state_module.save(st)
 
-                    if not resolved:
-                        print(
-                            f"  [Boris] Milestone {milestone.id} failed after {MAX_RETRIES} retries. Skipping.",
-                            flush=True,
-                        )
-                        logger.warning("Milestone %s skipped after failed retries", milestone.id)
-                        milestone.status = "skipped"
-                        state_module.save(st)
+                    # Save state after each milestone outcome
+                    state_module.save(st)
 
-                # Save state after each milestone outcome
-                state_module.save(st)
+                    # Incremental mode: pause after each milestone
+                    # --stop-at: only pause when the target milestone completes
+                    should_pause = False
+                    if args.stop_at and milestone.status in ("completed", "skipped"):
+                        if milestone.id == args.stop_at:
+                            should_pause = True
+                    elif args.incremental and milestone.status in ("completed", "skipped"):
+                        should_pause = True
+
+                    if should_pause:
+                        remaining = sum(1 for m in plan.milestones if m.status == "pending")
+                        if remaining > 0:
+                            print(flush=True)
+                            if args.stop_at:
+                                print(f"[Boris] --stop-at {args.stop_at}: pausing after {milestone.id}.", flush=True)
+                            else:
+                                print(f"[Boris] Incremental mode: pausing after {milestone.id}.", flush=True)
+                            print(f"[Boris] {remaining} milestone(s) remaining.", flush=True)
+                            resume_flags = f"-r -d \"{project_dir}\""
+                            if args.stop_at:
+                                resume_flags += f" --stop-at {args.stop_at}"
+                            elif args.incremental:
+                                resume_flags += " --incremental"
+                            print(f"[Boris] Resume with: boris {resume_flags}", flush=True)
+                            logger.info("Pausing after %s. %d remaining.", milestone.id, remaining)
+                            state_module.save(st)
+                            sys.exit(0)
 
         # Phase 2: UI Testing & Polish
         _run_ui_phase(st, plan, project_dir, args, logger)

{borisxdave-0.2.0.dist-info → borisxdave-0.3.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: borisxdave
-Version: 0.2.0
+Version: 0.3.0
 Summary: Boris - Autonomous Project Orchestrator
 Requires-Python: >=3.8
 

borisxdave-0.3.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+boris.py,sha256=xStvDOxKqbvQiNsQORr4qcD5wEiruNIcm7v_fFPjwZ8,44667
+config.py,sha256=KfFKyCGasdm1yBvIRFv-ykzA_oRo-zu1Euu9YC7V1Cg,324
+engine.py,sha256=LuVUwtlE1j8K3MOIH_pozB6Vy04_kPJs7Q0l9g-ePa8,27875
+git_manager.py,sha256=BuuTT4naPb5-jLhOik1xHM2ztzuKvJ_bnecZmlYgwFs,8493
+planner.py,sha256=UrU--kBvzvyD1gOVxIn-kdbJiu8tt4rcowsln66WkGw,5670
+prompts.py,sha256=oBVDZ0dG50FcSBa4F9GTkCPxmMB653BsK3RShoGcWUM,34182
+state.py,sha256=8MeUiDwL9ecgD9N6RhNUQf_P-qE7HeG3WlgL_SbRQic,3160
+borisxdave-0.3.0.dist-info/METADATA,sha256=qP3P-mpjm-BaQuJBXasveJ4L_wGNH9S-pIhNLAdNVd4,133
+borisxdave-0.3.0.dist-info/WHEEL,sha256=hPN0AlP2dZM_3ZJZWP4WooepkmU9wzjGgCLCeFjkHLA,92
+borisxdave-0.3.0.dist-info/entry_points.txt,sha256=a6FLWgxiQjGMJIRSV5sDxaaaaQchunm04ZuzX8N7-6I,61
+borisxdave-0.3.0.dist-info/top_level.txt,sha256=zNzzkbLJWzWpTjJTQsnbdOBypcA4XpioE1dEgWZVBx4,54
+borisxdave-0.3.0.dist-info/RECORD,,

{borisxdave-0.2.0.dist-info → borisxdave-0.3.0.dist-info}/entry_points.txt

@@ -1,2 +1,3 @@
 [console_scripts]
 boris = boris:main
+borisxdave = boris:main

engine.py

@@ -1,4 +1,5 @@
 """Boris engine - execution and monitoring (merged from executor + monitor)."""
+import concurrent.futures
 import enum
 import logging
 import os
@@ -413,6 +414,32 @@ def _setup_log(project_dir: str) -> str:
     return os.path.join(_LOGS_DIR, f"boris_exec_{timestamp}.log")
 
 
+def run_parallel(tasks: list, project_dir: str, max_iterations: int = None) -> list:
+    """Run multiple DaveLoop instances in parallel using ThreadPoolExecutor.
+
+    Args:
+        tasks: List of (prompt, milestone) tuples.
+        project_dir: Working directory for the project.
+        max_iterations: Max DaveLoop iterations per milestone.
+
+    Returns:
+        List of (milestone, ExecutionResult) tuples, one per input task.
+    """
+    results = []
+
+    def _run_one(prompt_milestone):
+        prompt, milestone = prompt_milestone
+        result = run(prompt, project_dir, max_iterations, milestone=milestone)
+        return (milestone, result)
+
+    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())
+
+    return results
+
+
 # --- Monitoring (from monitor.py) ---
 
 

planner.py

@@ -43,7 +43,7 @@ def create_plan(task: str, project_dir: str) -> Plan:
 
     try:
         result = subprocess.run(
-            [config.CLAUDE_CMD, "-p"],
+            [config.CLAUDE_CMD, "-p", "--output-format", "text"],
             input=prompt,
             capture_output=True,
             text=True,
@@ -63,6 +63,14 @@ def create_plan(task: str, project_dir: str) -> Plan:
         response = re.sub(r"\n?```\s*$", "", response)
         response = response.strip()
 
+        # Try to extract JSON array from response if it contains extra text
+        if not response.startswith("["):
+            match = re.search(r"\[.*\]", response, re.DOTALL)
+            if match:
+                response = match.group(0)
+            else:
+                logger.error("Claude response (no JSON found): %s", response[:500])
+
         milestones_data = json.loads(response)
 
         milestones = [

prompts.py

@@ -87,14 +87,45 @@ def _list_project_files(project_dir: str, max_files: int = 500) -> str:
 # --- Planning (from planner.py) ---
 
 
-def create_plan(task: str, project_dir: str) -> Plan:
-    """Break a task into milestones using Claude CLI."""
+def create_plan(task: str, project_dir: str, turbo: bool = False) -> Plan:
+    """Break a task into milestones using Claude CLI.
+
+    Args:
+        task: The task description.
+        project_dir: Path to the project directory.
+        turbo: When True, emphasize minimal dependencies and maximum parallelism.
+    """
     file_listing = _list_project_files(project_dir)
 
+    if turbo:
+        dependency_instructions = (
+            "CRITICAL DEPENDENCY RULES (turbo/parallel mode):\n"
+            "- Only add a dependency if the milestone TRULY requires output from another milestone to function.\n"
+            "- Two milestones that share a common dependency should NOT depend on each other unless one genuinely needs the other's output.\n"
+            "- Maximize parallelism in the dependency graph. Independent features, pages, or modules that share the same foundation should run in parallel.\n"
+            "- Do NOT chain milestones linearly unless there is a real data/code dependency between them.\n\n"
+            "Example of WRONG dependencies (overly sequential):\n"
+            '  M1: Project Setup (depends_on: [])\n'
+            '  M2: Auth Backend (depends_on: ["M1"])\n'
+            '  M3: Login Page (depends_on: ["M2"])\n'
+            '  M4: Dashboard Page (depends_on: ["M3"])  <-- WRONG: only needs M2, not M3\n'
+            '  M5: Profile Page (depends_on: ["M4"])    <-- WRONG: only needs M2, not M4\n\n'
+            "Example of CORRECT dependencies (maximizes parallelism):\n"
+            '  M1: Project Setup (depends_on: [])\n'
+            '  M2: Auth Backend (depends_on: ["M1"])\n'
+            '  M3: Login Page (depends_on: ["M2"])\n'
+            '  M4: Dashboard Page (depends_on: ["M2"])  <-- parallel with M3\n'
+            '  M5: Profile Page (depends_on: ["M2"])    <-- parallel with M3, M4\n\n'
+        )
+    else:
+        dependency_instructions = (
+            "Order by dependency: foundation first, then features that depend on it.\n"
+        )
+
     prompt = (
         "You are a technical project planner. Break this task into ordered milestones.\n"
         "Each milestone must be a concrete, buildable unit that DaveLoop can execute independently.\n"
-        "Order by dependency: foundation first, then features that depend on it.\n\n"
+        f"{dependency_instructions}\n"
         f"Task: {task}\n"
         f"Project directory: {project_dir}\n"
         f"Existing files:\n{file_listing}\n\n"
@@ -279,14 +310,116 @@ def _save_plan_markdown(plan: Plan, task: str) -> str:
     return filepath
 
 
+def load_plan_from_file(filepath: str) -> Plan:
+    """Parse a saved plan markdown file back into a Plan object.
+
+    Reads the markdown format produced by _save_plan_markdown and reconstructs
+    the Plan with its Milestone objects.
+    """
+    if not os.path.exists(filepath):
+        raise FileNotFoundError(f"Plan file not found: {filepath}")
+
+    with open(filepath, "r", encoding="utf-8") as f:
+        content = f.read()
+
+    # Extract task from **Task:** line
+    task_match = re.search(r"\*\*Task:\*\*\s*(.+)", content)
+    task = task_match.group(1).strip() if task_match else "Unknown task"
+
+    # Extract created_at from **Created:** line
+    created_match = re.search(r"\*\*Created:\*\*\s*(.+)", content)
+    created_at = created_match.group(1).strip() if created_match else datetime.now().isoformat()
+
+    # Split into milestone sections by ## M<N>: headers
+    milestone_sections = re.split(r"(?=^## M\d+:)", content, flags=re.MULTILINE)
+
+    milestones = []
+    for section in milestone_sections:
+        # Only process sections that start with a milestone header
+        header_match = re.match(r"^## (M\d+):\s*(.+)", section)
+        if not header_match:
+            continue
+
+        m_id = header_match.group(1)
+        m_title = header_match.group(2).strip()
+
+        # Extract description: text between the header and the first **bold** field or ---
+        # Skip the header line, then collect lines until we hit a **field:** or ---
+        lines = section.split("\n")
+        desc_lines = []
+        in_desc = False
+        for line in lines[1:]:  # skip header line
+            stripped = line.strip()
+            if not stripped:
+                if in_desc:
+                    desc_lines.append("")
+                continue
+            if stripped.startswith("**") or stripped == "---":
+                break
+            desc_lines.append(stripped)
+            in_desc = True
+        description = "\n".join(desc_lines).strip()
+
+        # Extract depends_on
+        depends_match = re.search(r"\*\*Depends on:\*\*\s*(.+)", section)
+        depends_on = []
+        if depends_match:
+            deps_str = depends_match.group(1).strip()
+            depends_on = [d.strip() for d in deps_str.split(",") if d.strip()]
+
+        # Extract acceptance criteria (bulleted list after **Acceptance Criteria:**)
+        criteria = []
+        criteria_match = re.search(r"\*\*Acceptance Criteria:\*\*\s*\n((?:\s*- .+\n?)+)", section)
+        if criteria_match:
+            for line in criteria_match.group(1).strip().split("\n"):
+                line = line.strip()
+                if line.startswith("- "):
+                    criteria.append(line[2:].strip())
+
+        # Extract files to create
+        files_create_match = re.search(r"\*\*Files to create:\*\*\s*(.+)", section)
+        files_to_create = []
+        if files_create_match:
+            files_to_create = [f.strip() for f in files_create_match.group(1).split(",") if f.strip()]
+
+        # Extract files to modify
+        files_modify_match = re.search(r"\*\*Files to modify:\*\*\s*(.+)", section)
+        files_to_modify = []
+        if files_modify_match:
+            files_to_modify = [f.strip() for f in files_modify_match.group(1).split(",") if f.strip()]
+
+        milestones.append(Milestone(
+            id=m_id,
+            title=m_title,
+            description=description,
+            depends_on=depends_on,
+            acceptance_criteria=criteria,
+            files_to_create=files_to_create,
+            files_to_modify=files_to_modify,
+        ))
+
+    if not milestones:
+        raise RuntimeError(f"No milestones found in plan file: {filepath}")
+
+    return Plan(task=task, milestones=milestones, created_at=created_at)
+
+
 # --- Prompt Crafting (from crafter.py) ---
 
 
-def craft_prompt(milestone: Milestone, plan: Plan, project_dir: str) -> str:
+def craft_prompt(milestone: Milestone, plan: Plan, project_dir: str,
+                  turbo: bool = False, sibling_milestones: list[Milestone] | None = None) -> str:
     """Build a detailed prompt for DaveLoop to execute a milestone.
 
     This is the most critical function in Boris. DaveLoop needs everything
     in ONE prompt - context, spec, integration points, acceptance criteria.
+
+    Args:
+        milestone: The milestone to build a prompt for.
+        plan: The full plan for context.
+        project_dir: Path to the project directory.
+        turbo: When True, adds parallel execution warnings.
+        sibling_milestones: Other milestones running concurrently in the same turbo batch.
     """
     sections = []
 
@@ -305,6 +438,37 @@ def craft_prompt(milestone: Milestone, plan: Plan, project_dir: str) -> str:
         sections.append("**Do NOT create or modify any other files.**")
         sections.append("")
 
+    # Turbo mode: parallel execution warning
+    if turbo and sibling_milestones:
+        sections.append("## PARALLEL EXECUTION WARNING")
+        sections.append("")
+        sections.append("**You are running in PARALLEL with other DaveLoops.** Other milestones")
+        sections.append("are being built AT THE SAME TIME by sibling DaveLoop processes.")
+        sections.append("Modifying files outside your scope WILL cause conflicts or silent overwrites.")
+        sections.append("")
+        sections.append("**Sibling milestones running concurrently:**")
+        for sib in sibling_milestones:
+            sib_files = (sib.files_to_create or []) + (sib.files_to_modify or [])
+            sib_files_str = ", ".join(sib_files) if sib_files else "(no specific files)"
+            sections.append(f"- **{sib.id}: {sib.title}** - Files: {sib_files_str}")
+        sections.append("")
+        # Collect all sibling files into a flat list for the explicit prohibition
+        all_sibling_files = []
+        for sib in sibling_milestones:
+            all_sibling_files.extend(sib.files_to_create or [])
+            all_sibling_files.extend(sib.files_to_modify or [])
+        if all_sibling_files:
+            unique_sibling_files = sorted(set(all_sibling_files))
+            sections.append("**DO NOT touch these files (owned by sibling milestones):**")
+            for sf in unique_sibling_files:
+                sections.append(f"- {sf}")
+            sections.append("")
+        sections.append("**Rules:**")
+        sections.append("1. ONLY modify files listed in YOUR files_to_create/files_to_modify scope above.")
+        sections.append("2. Do NOT modify shared config files (package.json, routing tables, etc.) unless they are explicitly in YOUR scope.")
+        sections.append("3. If you need a shared file changed, add a TODO comment instead of editing it.")
+        sections.append("")
+
     # What to build
     sections.append(f"## What to Build")
     sections.append(milestone.description)

state.py

@@ -63,6 +63,7 @@ class State:
     updated_at: str = field(default_factory=lambda: datetime.now().isoformat())
     phase: str = "structural"  # structural | ui_testing
     ui_plan: Optional[UIPlan] = None
+    turbo: bool = False
 
 
 def save(state: State) -> None:
@@ -98,6 +99,7 @@ def load(project_dir: str) -> Optional[State]:
             no_git=data.get("no_git", False),
             started_at=data.get("started_at", ""),
             updated_at=data.get("updated_at", ""),
+            turbo=data.get("turbo", False),
         )
     except (json.JSONDecodeError, KeyError, TypeError):
         return None

borisxdave-0.2.0.dist-info/RECORD

@@ -1,12 +0,0 @@
-boris.py,sha256=0AvcqWPhvfoR1U8zUGhcnCJImpcy8cITcD4zzJpx9Jk,28715
-config.py,sha256=KfFKyCGasdm1yBvIRFv-ykzA_oRo-zu1Euu9YC7V1Cg,324
-engine.py,sha256=PGRtbnsvr6egikqo0ENpA8WnXKdQ1kW2XWUFgJ-AXzk,26889
-git_manager.py,sha256=BuuTT4naPb5-jLhOik1xHM2ztzuKvJ_bnecZmlYgwFs,8493
-planner.py,sha256=HHrw2lpcZhRBzmCapk8Uw8ivUpB7fSz2V6_FaJLHlU4,5297
-prompts.py,sha256=6QHAftDjDqk_e2WCq5NkTH5Jd41PgFk68fkg4nMsy-Q,26228
-state.py,sha256=erggbuwJu-Ks6Y7hLQpFwIEN4LjqzBPpy8kTLZtk0ZM,3092
-borisxdave-0.2.0.dist-info/METADATA,sha256=adf_nOv8TymIA4ez-Hb7EEzzDXaFkAmVMJ512pY21Po,133
-borisxdave-0.2.0.dist-info/WHEEL,sha256=hPN0AlP2dZM_3ZJZWP4WooepkmU9wzjGgCLCeFjkHLA,92
-borisxdave-0.2.0.dist-info/entry_points.txt,sha256=fuO7JxKFLOm6xp6m3JHRA1UO_QW1dYU-F0IooA1NqQs,37
-borisxdave-0.2.0.dist-info/top_level.txt,sha256=zNzzkbLJWzWpTjJTQsnbdOBypcA4XpioE1dEgWZVBx4,54
-borisxdave-0.2.0.dist-info/RECORD,,