hyperloop 0.5.0__tar.gz → 0.6.1__tar.gz

{hyperloop-0.5.0 → hyperloop-0.6.1}/CHANGELOG.md

@@ -2,6 +2,12 @@
 
 <!-- version list -->
 
+## v0.6.1 (2026-04-15)
+
+
+## v0.6.0 (2026-04-15)
+
+
 ## v0.5.0 (2026-04-15)
 
 ### Features

{hyperloop-0.5.0 → hyperloop-0.6.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hyperloop
-Version: 0.5.0
+Version: 0.6.1
 Summary: Orchestrator that walks tasks through composable process pipelines using AI agents
 Requires-Python: >=3.12
 Requires-Dist: pyyaml>=6.0.3

{hyperloop-0.5.0 → hyperloop-0.6.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "hyperloop"
-version = "0.5.0"
+version = "0.6.1"
 description = "Orchestrator that walks tasks through composable process pipelines using AI agents"
 readme = "README.md"
 requires-python = ">=3.12"

{hyperloop-0.5.0 → hyperloop-0.6.1}/src/hyperloop/adapters/git_state.py

@@ -213,6 +213,12 @@ class GitStateStore:
             return None
         return file_path.read_text()
 
+    def set_task_pr(self, task_id: str, pr_url: str) -> None:
+        """Set the PR URL on a task file."""
+        fm, body = self._read_task_file(task_id)
+        fm["pr"] = pr_url
+        self._write_task_file(task_id, fm, body)
+
     def commit(self, message: str) -> None:
         """Stage all changes and create a git commit."""
         self._git("add", "-A")

{hyperloop-0.5.0 → hyperloop-0.6.1}/src/hyperloop/cli.py

@@ -228,6 +228,7 @@ def run(
         serial_runner=serial_runner,
         poll_interval=cfg.poll_interval,
         on_cycle=_on_cycle,
+        max_rebase_attempts=cfg.max_rebase_attempts,
     )
 
     # 6. Recover and run

{hyperloop-0.5.0 → hyperloop-0.6.1}/src/hyperloop/loop.py

@@ -79,6 +79,7 @@ class Orchestrator:
         poll_interval: float = 30.0,
         on_cycle: Callable[[dict[str, object]], None] | None = None,
         serial_runner: SerialRunner | None = None,
+        max_rebase_attempts: int = 3,
     ) -> None:
         self._state = state
         self._runtime = runtime
@@ -91,9 +92,12 @@ class Orchestrator:
         self._poll_interval = poll_interval
         self._on_cycle = on_cycle
         self._serial_runner = serial_runner
+        self._max_rebase_attempts = max_rebase_attempts
 
         # Active worker tracking: task_id -> (handle, pipeline_position)
         self._workers: dict[str, tuple[WorkerHandle, PipelinePosition]] = {}
+        # Consecutive rebase failure count per task
+        self._rebase_attempts: dict[str, int] = {}
 
     def run_loop(self, max_cycles: int = 1000) -> str:
         """Run the orchestrator loop until halt or max_cycles. Returns halt reason."""
@@ -181,6 +185,9 @@ class Orchestrator:
             pipe_action, new_pos = executor.next_action(position, result)
 
             if isinstance(pipe_action, PipelineComplete):
+                # Mark PR ready if reviews passed and pipeline is done
+                if self._pr_manager is not None and task.pr is not None:
+                    self._pr_manager.mark_ready(task.pr)
                 self._state.transition_task(task_id, TaskStatus.COMPLETE, phase=None)
                 self._state.clear_findings(task_id)
 
@@ -211,6 +218,14 @@ class Orchestrator:
                         round=new_round,
                     )
                 else:
+                    # Advancing forward on PASS — create draft PR if needed
+                    if self._pr_manager is not None and task.pr is None:
+                        branch = task.branch or f"worker/{task_id}"
+                        pr_url = self._pr_manager.create_draft(
+                            task_id, branch, task.title, task.spec_ref
+                        )
+                        self._state.set_task_pr(task_id, pr_url)
+
                     self._state.transition_task(
                         task_id,
                         TaskStatus.IN_PROGRESS,
@@ -389,19 +404,62 @@ class Orchestrator:
                 self._merge_local(task.id, branch)
 
     def _merge_via_pr(self, task_id: str, pr_url: str, spec_ref: str, branch: str) -> None:
-        """Merge via GitHub PR: rebase, then squash-merge."""
+        """Merge via GitHub PR: mark ready, rebase, then squash-merge."""
         assert self._pr_manager is not None
 
+        # Mark the draft PR as ready before merging
+        self._pr_manager.mark_ready(pr_url)
+
         if not self._pr_manager.rebase_branch(branch, "main"):
             logger.warning("Rebase conflict for task %s, marking NEEDS_REBASE", task_id)
+            self._rebase_attempts[task_id] = self._rebase_attempts.get(task_id, 0) + 1
+            if self._rebase_attempts[task_id] >= self._max_rebase_attempts:
+                logger.warning(
+                    "Task %s exceeded max_rebase_attempts (%d), looping back",
+                    task_id,
+                    self._max_rebase_attempts,
+                )
+                self._rebase_attempts.pop(task_id, None)
+                task = self._state.get_task(task_id)
+                self._state.store_findings(
+                    task_id, f"Rebase conflict after {self._max_rebase_attempts} attempts"
+                )
+                self._state.transition_task(
+                    task_id,
+                    TaskStatus.IN_PROGRESS,
+                    phase=Phase("implementer"),
+                    round=task.round + 1,
+                )
+                return
             self._state.transition_task(task_id, TaskStatus.NEEDS_REBASE, phase=Phase("merge-pr"))
             return
 
         if not self._pr_manager.merge(pr_url, task_id, spec_ref):
             logger.warning("Merge conflict for task %s, marking NEEDS_REBASE", task_id)
+            self._rebase_attempts[task_id] = self._rebase_attempts.get(task_id, 0) + 1
+            if self._rebase_attempts[task_id] >= self._max_rebase_attempts:
+                logger.warning(
+                    "Task %s exceeded max_rebase_attempts (%d), looping back",
+                    task_id,
+                    self._max_rebase_attempts,
+                )
+                self._rebase_attempts.pop(task_id, None)
+                task = self._state.get_task(task_id)
+                self._state.store_findings(
+                    task_id, f"Merge conflict after {self._max_rebase_attempts} attempts"
+                )
+                self._state.transition_task(
+                    task_id,
+                    TaskStatus.IN_PROGRESS,
+                    phase=Phase("implementer"),
+                    round=task.round + 1,
+                )
+                return
             self._state.transition_task(task_id, TaskStatus.NEEDS_REBASE, phase=Phase("merge-pr"))
             return
 
+        # Merge succeeded — reset counter
+        self._rebase_attempts.pop(task_id, None)
         self._state.transition_task(task_id, TaskStatus.COMPLETE, phase=None)
         self._state.clear_findings(task_id)
         logger.info("Merged PR for task %s", task_id)
@@ -420,12 +478,32 @@ class Orchestrator:
                 check=True,
                 capture_output=True,
             )
+            self._rebase_attempts.pop(task_id, None)
             self._state.transition_task(task_id, TaskStatus.COMPLETE, phase=None)
             self._state.clear_findings(task_id)
             logger.info("Local merge of %s into base branch", task_id)
         except subprocess.CalledProcessError:
             logger.warning("Local merge conflict for task %s, marking NEEDS_REBASE", task_id)
             subprocess.run([*git_cmd, "merge", "--abort"], capture_output=True, check=False)
+            self._rebase_attempts[task_id] = self._rebase_attempts.get(task_id, 0) + 1
+            if self._rebase_attempts[task_id] >= self._max_rebase_attempts:
+                logger.warning(
+                    "Task %s exceeded max_rebase_attempts (%d), looping back",
+                    task_id,
+                    self._max_rebase_attempts,
+                )
+                self._rebase_attempts.pop(task_id, None)
+                task = self._state.get_task(task_id)
+                self._state.store_findings(
+                    task_id, f"Merge conflict after {self._max_rebase_attempts} attempts"
+                )
+                self._state.transition_task(
+                    task_id,
+                    TaskStatus.IN_PROGRESS,
+                    phase=Phase("implementer"),
+                    round=task.round + 1,
+                )
+                return
             self._state.transition_task(task_id, TaskStatus.NEEDS_REBASE, phase=Phase("merge-pr"))
 
     # -----------------------------------------------------------------------
@@ -469,10 +547,10 @@ class Orchestrator:
         prompt = self._composer.compose(
             role="pm",
             task_id="intake",
-            spec_ref="specs/",
+            spec_ref="",
             findings="",
         )
-        prompt += f"\n## Specs to Process\n{spec_list}\n"
+        prompt += f"\n\n## Specs to Process\n\n{spec_list}\n"
 
         success = self._serial_runner.run("pm", prompt)
         if success:
@@ -496,7 +574,7 @@ class Orchestrator:
         prompt = self._composer.compose(
             role="process-improver",
             task_id="process-improvement",
-            spec_ref="specs/prompts",
+            spec_ref="",
             findings=findings_text,
         )
 

{hyperloop-0.5.0 → hyperloop-0.6.1}/src/hyperloop/ports/state.py

@@ -60,6 +60,10 @@ class StateStore(Protocol):
         """Read a file from trunk. Returns None if the file does not exist."""
         ...
 
+    def set_task_pr(self, task_id: str, pr_url: str) -> None:
+        """Set the PR URL on a task."""
+        ...
+
     def commit(self, message: str) -> None:
         """Persist all pending state changes."""
         ...

{hyperloop-0.5.0 → hyperloop-0.6.1}/tests/test_loop.py

@@ -81,6 +81,7 @@ def _make_orchestrator(
     composer: PromptComposer | None = None,
     poll_interval: float = 0,
     on_cycle: Callable[[dict[str, object]], None] | None = None,
+    max_rebase_attempts: int = 3,
 ) -> Orchestrator:
     return Orchestrator(
         state=state,
@@ -92,6 +93,7 @@ def _make_orchestrator(
         composer=composer,
         poll_interval=poll_interval,
         on_cycle=on_cycle,
+        max_rebase_attempts=max_rebase_attempts,
     )
 
 
@@ -1035,3 +1037,235 @@ class TestPromptComposition:
 
         task = state.get_task("task-001")
         assert task.status == TaskStatus.IN_PROGRESS
+
+
+class TestPRLifecycle:
+    """PR lifecycle: draft created at first review step, marked ready on completion."""
+
+    MERGE_PROCESS = Process(
+        name="merge-process",
+        intake=(),
+        pipeline=(
+            LoopStep(
+                steps=(
+                    RoleStep(role="implementer", on_pass=None, on_fail=None),
+                    RoleStep(role="verifier", on_pass=None, on_fail=None),
+                ),
+            ),
+            ActionStep(action="merge-pr"),
+        ),
+    )
+
+    def test_draft_pr_created_when_task_advances_to_verifier(self) -> None:
+        """A draft PR is created when a task advances from implementer to verifier."""
+        state = InMemoryStateStore()
+        runtime = InMemoryRuntime()
+        pr_mgr = FakePRManager(repo="org/repo")
+
+        state.add_task(_task(id="task-001", branch="worker/task-001"))
+
+        orch = _make_orchestrator(state, runtime, process=self.MERGE_PROCESS, pr_manager=pr_mgr)
+
+        # Cycle 1: spawn implementer
+        orch.run_cycle()
+        assert state.get_task("task-001").phase == Phase("implementer")
+        assert state.get_task("task-001").pr is None
+
+        # Implementer passes
+        runtime.set_poll_status("task-001", "done")
+        runtime.set_result("task-001", PASS_RESULT)
+
+        # Cycle 2: reap implementer, advance to verifier -> draft PR created
+        orch.run_cycle()
+        task = state.get_task("task-001")
+        assert task.phase == Phase("verifier")
+        assert task.pr is not None
+        assert "github.com" in task.pr
+
+        # The PR should be a draft
+        assert pr_mgr.is_draft(task.pr)
+
+    def test_mark_ready_called_when_task_completes_pipeline(self) -> None:
+        """mark_ready is called when a task reaches the merge step."""
+        state = InMemoryStateStore()
+        runtime = InMemoryRuntime()
+        pr_mgr = FakePRManager(repo="org/repo")
+
+        state.add_task(
+            _task(
+                id="task-001",
+                status=TaskStatus.IN_PROGRESS,
+                phase=Phase("merge-pr"),
+                branch="worker/task-001",
+            )
+        )
+        # Create and set PR on the task
+        pr_url = pr_mgr.create_draft(
+            "task-001", "worker/task-001", "Task task-001", "specs/task-001.md"
+        )
+        state.set_task_pr("task-001", pr_url)
+
+        orch = _make_orchestrator(state, runtime, process=self.MERGE_PROCESS, pr_manager=pr_mgr)
+        orch.run_cycle()
+
+        # mark_ready should have been called before merge
+        assert pr_url in pr_mgr.marked_ready
+        # And the task should be complete (merged)
+        assert state.get_task("task-001").status == TaskStatus.COMPLETE
+
+    def test_no_pr_created_when_pr_manager_is_none(self) -> None:
+        """No PR is created when pr_manager is not set."""
+        state = InMemoryStateStore()
+        runtime = InMemoryRuntime()
+
+        state.add_task(_task(id="task-001", branch="worker/task-001"))
+
+        orch = _make_orchestrator(state, runtime, process=self.MERGE_PROCESS, pr_manager=None)
+
+        # Cycle 1: spawn implementer
+        orch.run_cycle()
+
+        # Implementer passes
+        runtime.set_poll_status("task-001", "done")
+        runtime.set_result("task-001", PASS_RESULT)
+
+        # Cycle 2: advance to verifier — no PR should be created
+        orch.run_cycle()
+        task = state.get_task("task-001")
+        assert task.phase == Phase("verifier")
+        assert task.pr is None
+
+    def test_draft_pr_not_recreated_on_loop_back(self) -> None:
+        """When a task loops back (verifier fails), the existing PR is reused."""
+        state = InMemoryStateStore()
+        runtime = InMemoryRuntime()
+        pr_mgr = FakePRManager(repo="org/repo")
+
+        state.add_task(_task(id="task-001", branch="worker/task-001"))
+
+        orch = _make_orchestrator(state, runtime, process=self.MERGE_PROCESS, pr_manager=pr_mgr)
+
+        # Cycle 1: spawn implementer
+        orch.run_cycle()
+
+        # Implementer passes -> advance to verifier, create draft
+        runtime.set_poll_status("task-001", "done")
+        runtime.set_result("task-001", PASS_RESULT)
+        orch.run_cycle()
+
+        first_pr = state.get_task("task-001").pr
+        assert first_pr is not None
+
+        # Verifier fails -> loops back to implementer
+        runtime.set_poll_status("task-001", "done")
+        runtime.set_result("task-001", FAIL_RESULT)
+        orch.run_cycle()
+
+        # Implementer passes again -> advance to verifier again
+        runtime.set_poll_status("task-001", "done")
+        runtime.set_result("task-001", PASS_RESULT)
+        orch.run_cycle()
+
+        # PR should be the same (not recreated)
+        assert state.get_task("task-001").pr == first_pr
+
+
+class TestMaxRebaseAttempts:
+    """max_rebase_attempts: after N consecutive rebase failures, task loops back."""
+
+    MERGE_PROCESS = Process(
+        name="merge-process",
+        intake=(),
+        pipeline=(
+            LoopStep(
+                steps=(
+                    RoleStep(role="implementer", on_pass=None, on_fail=None),
+                    RoleStep(role="verifier", on_pass=None, on_fail=None),
+                ),
+            ),
+            ActionStep(action="merge-pr"),
+        ),
+    )
+
+    def test_rebase_failure_exceeds_max_attempts_loops_task_back(self) -> None:
+        """After max_rebase_attempts consecutive rebase failures, task loops back."""
+        state = InMemoryStateStore()
+        runtime = InMemoryRuntime()
+        pr_mgr = FakePRManager(repo="org/repo")
+
+        pr_url = pr_mgr.create_draft("task-001", "worker/task-001", "Widget", "specs/task-001.md")
+        pr_mgr.set_rebase_fails("worker/task-001")
+
+        state.add_task(
+            _task(
+                id="task-001",
+                status=TaskStatus.IN_PROGRESS,
+                phase=Phase("merge-pr"),
+                branch="worker/task-001",
+            )
+        )
+        state.set_task_pr("task-001", pr_url)
+
+        orch = _make_orchestrator(
+            state,
+            runtime,
+            process=self.MERGE_PROCESS,
+            pr_manager=pr_mgr,
+            max_rebase_attempts=3,
+        )
+
+        # First two failures: task stays in NEEDS_REBASE / rebase-resolver cycle
+        for _ in range(2):
+            orch.run_cycle()
+            task = state.get_task("task-001")
+            # Should be NEEDS_REBASE or spawning rebase-resolver
+            assert task.status in (TaskStatus.NEEDS_REBASE, TaskStatus.IN_PROGRESS)
+
+            # If rebase-resolver was spawned, let it complete and return to merge-pr
+            if task.phase == Phase("rebase-resolver"):
+                runtime.set_poll_status("task-001", "done")
+                runtime.set_result("task-001", PASS_RESULT)
+                orch.run_cycle()
+                # Manually transition back to merge-pr for next attempt
+                state.transition_task("task-001", TaskStatus.IN_PROGRESS, phase=Phase("merge-pr"))
+
+        # Third failure: should exceed max_rebase_attempts -> loop back
+        orch.run_cycle()
+        task = state.get_task("task-001")
+        assert task.status == TaskStatus.IN_PROGRESS
+        assert task.round == 1  # round incremented
+        assert task.phase == Phase("implementer")  # looped back to start
+
+    def test_successful_merge_resets_rebase_counter(self) -> None:
+        """A successful merge resets the rebase attempt counter for a task."""
+        state = InMemoryStateStore()
+        runtime = InMemoryRuntime()
+        pr_mgr = FakePRManager(repo="org/repo")
+
+        pr_url = pr_mgr.create_draft("task-001", "worker/task-001", "Widget", "specs/task-001.md")
+
+        state.add_task(
+            _task(
+                id="task-001",
+                status=TaskStatus.IN_PROGRESS,
+                phase=Phase("merge-pr"),
+                branch="worker/task-001",
+            )
+        )
+        state.set_task_pr("task-001", pr_url)
+
+        orch = _make_orchestrator(
+            state,
+            runtime,
+            process=self.MERGE_PROCESS,
+            pr_manager=pr_mgr,
+            max_rebase_attempts=3,
+        )
+
+        # Merge succeeds
+        orch.run_cycle()
+        task = state.get_task("task-001")
+        assert task.status == TaskStatus.COMPLETE
+
+        # The counter should be reset (no external way to verify directly,
+        # but the task completed successfully — that's the behavior we want)