hyperloop 0.1.1__tar.gz → 0.3.0__tar.gz

{hyperloop-0.1.1 → hyperloop-0.3.0}/CHANGELOG.md

@@ -2,6 +2,12 @@
 
 <!-- version list -->
 
+## v0.3.0 (2026-04-15)
+
+
+## v0.2.0 (2026-04-15)
+
+
 ## v0.1.1 (2026-04-15)
 
 

{hyperloop-0.1.1 → hyperloop-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hyperloop
-Version: 0.1.1
+Version: 0.3.0
 Summary: Orchestrator that walks tasks through composable process pipelines using AI agents
 Requires-Python: >=3.12
 Requires-Dist: pyyaml>=6.0.3
@@ -15,14 +15,14 @@ Description-Content-Type: text/markdown
 
 # hyperloop
 
-Walks tasks through composable process pipelines using AI agents. You write specs, it creates tasks, implements them, verifies the work, and merges PRs.
+Walks tasks through composable process pipelines using AI agents. You write specs, it creates tasks, implements them, verifies the work, and merges the results.
 
 ## Prerequisites
 
 - Python 3.12+
 - [Claude Code CLI](https://docs.anthropic.com/en/docs/claude-code) (`claude` on PATH)
-- `gh` CLI (authenticated, for PR management)
 - `git`
+- `gh` CLI (optional, for GitHub PR operations)
 
 ## Install
 
@@ -67,23 +67,23 @@ Implement JWT-based authentication for the API.
 - JWTs expire after 24 hours
 ```
 
-3. Run:
+3. Run against the local repo:
 
 ```bash
-# From source:
-uv run hyperloop run --repo owner/repo --branch main
+# From inside the repo
+uv run hyperloop run
 
-# Or if installed:
-hyperloop run --repo owner/repo --branch main
-```
+# Or point to a repo elsewhere
+uv run hyperloop run --path ~/code/my-project
 
-4. See what it would do without executing:
+# With GitHub PR support (draft PRs, lgtm gates, squash-merge)
+uv run hyperloop run --repo owner/repo
 
-```bash
-hyperloop run --repo owner/repo --dry-run
+# Dry run (show config, don't execute)
+uv run hyperloop run --dry-run
 ```
 
-The orchestrator reads your specs, has the PM create tasks in `specs/tasks/`, then walks each task through the default pipeline: implement, verify, merge.
+When `--repo` is not set, completed work is merged locally into the base branch via `git merge`. When `--repo` is set, the orchestrator creates draft PRs, polls for `lgtm` labels on gates, and squash-merges via GitHub.
 
 ## Configuration
 
@@ -101,13 +101,14 @@ merge:
   strategy: squash
 ```
 
-Then just run from the repo directory:
+Then run from the repo directory (or use `--path`):
 
 ```bash
 hyperloop run
+hyperloop run --path ~/code/my-project
 ```
 
-The repo is inferred from your git remote. All settings have sensible defaults.
+All settings have sensible defaults. `--repo` is only needed for GitHub PR operations.
 
 ## Customizing Agent Behavior
 

{hyperloop-0.1.1 → hyperloop-0.3.0}/README.md

@@ -1,13 +1,13 @@
 # hyperloop
 
-Walks tasks through composable process pipelines using AI agents. You write specs, it creates tasks, implements them, verifies the work, and merges PRs.
+Walks tasks through composable process pipelines using AI agents. You write specs, it creates tasks, implements them, verifies the work, and merges the results.
 
 ## Prerequisites
 
 - Python 3.12+
 - [Claude Code CLI](https://docs.anthropic.com/en/docs/claude-code) (`claude` on PATH)
-- `gh` CLI (authenticated, for PR management)
 - `git`
+- `gh` CLI (optional, for GitHub PR operations)
 
 ## Install
 
@@ -52,23 +52,23 @@ Implement JWT-based authentication for the API.
 - JWTs expire after 24 hours
 ```
 
-3. Run:
+3. Run against the local repo:
 
 ```bash
-# From source:
-uv run hyperloop run --repo owner/repo --branch main
+# From inside the repo
+uv run hyperloop run
 
-# Or if installed:
-hyperloop run --repo owner/repo --branch main
-```
+# Or point to a repo elsewhere
+uv run hyperloop run --path ~/code/my-project
 
-4. See what it would do without executing:
+# With GitHub PR support (draft PRs, lgtm gates, squash-merge)
+uv run hyperloop run --repo owner/repo
 
-```bash
-hyperloop run --repo owner/repo --dry-run
+# Dry run (show config, don't execute)
+uv run hyperloop run --dry-run
 ```
 
-The orchestrator reads your specs, has the PM create tasks in `specs/tasks/`, then walks each task through the default pipeline: implement, verify, merge.
+When `--repo` is not set, completed work is merged locally into the base branch via `git merge`. When `--repo` is set, the orchestrator creates draft PRs, polls for `lgtm` labels on gates, and squash-merges via GitHub.
 
 ## Configuration
 
@@ -86,13 +86,14 @@ merge:
   strategy: squash
 ```
 
-Then just run from the repo directory:
+Then run from the repo directory (or use `--path`):
 
 ```bash
 hyperloop run
+hyperloop run --path ~/code/my-project
 ```
 
-The repo is inferred from your git remote. All settings have sensible defaults.
+All settings have sensible defaults. `--repo` is only needed for GitHub PR operations.
 
 ## Customizing Agent Behavior
 

{hyperloop-0.1.1 → hyperloop-0.3.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "hyperloop"
-version = "0.1.1"
+version = "0.3.0"
 description = "Orchestrator that walks tasks through composable process pipelines using AI agents"
 readme = "README.md"
 requires-python = ">=3.12"
@@ -58,6 +58,9 @@ reportMissingTypeStubs = false
 
 [tool.pytest.ini_options]
 testpaths = ["tests"]
+markers = [
+    "slow: end-to-end integration tests (real git repos, subprocesses)",
+]
 
 [tool.semantic_release]
 commit_parser = "conventional"

{hyperloop-0.1.1 → hyperloop-0.3.0}/src/hyperloop/adapters/local.py

@@ -56,8 +56,10 @@ class LocalRuntime:
         # Ensure the parent directory exists
         os.makedirs(self._worktree_base, exist_ok=True)
 
-        # Create the git worktree on a new branch
-        subprocess.run(
+        # Create the git worktree — reuse existing branch if it survived
+        # a previous pipeline step, otherwise create a new one.
+        env = _clean_git_env()
+        result = subprocess.run(
             [
                 "git",
                 "-C",
@@ -65,14 +67,29 @@ class LocalRuntime:
                 "worktree",
                 "add",
                 worktree_path,
-                "-b",
                 branch,
-                "HEAD",
             ],
-            check=True,
             capture_output=True,
-            env=_clean_git_env(),
+            env=env,
         )
+        if result.returncode != 0:
+            # Branch doesn't exist yet — create it
+            subprocess.run(
+                [
+                    "git",
+                    "-C",
+                    self._repo_path,
+                    "worktree",
+                    "add",
+                    worktree_path,
+                    "-b",
+                    branch,
+                    "HEAD",
+                ],
+                check=True,
+                capture_output=True,
+                env=env,
+            )
 
         # Write the prompt file
         prompt_path = os.path.join(worktree_path, "prompt.md")
@@ -120,7 +137,10 @@ class LocalRuntime:
         return "failed"
 
     def reap(self, handle: WorkerHandle) -> WorkerResult:
-        """Read the result file, clean up worktree and branch, return WorkerResult."""
+        """Read the result file, clean up worktree, return WorkerResult.
+
+        Preserves the branch so later pipeline steps (e.g. merge-pr) can use it.
+        """
         task_id = handle.task_id
         worktree_path = self._worktrees.get(task_id)
 
@@ -152,6 +172,7 @@ class LocalRuntime:
 
         branch = self._get_worktree_branch(worktree_path)
         self._cleanup_worktree(task_id, worktree_path, branch)
+        self._delete_branch(branch)
 
     def find_orphan(self, task_id: str, branch: str) -> WorkerHandle | None:
         """Check if a worktree exists for the given branch. Return a handle if so."""
@@ -229,7 +250,7 @@ class LocalRuntime:
             return None
 
     def _cleanup_worktree(self, task_id: str, worktree_path: str, branch: str | None) -> None:
-        """Remove the worktree directory and delete the branch."""
+        """Remove the worktree directory. Preserves the branch for later pipeline steps."""
         # Remove from internal tracking
         self._processes.pop(task_id, None)
         self._worktrees.pop(task_id, None)
@@ -264,10 +285,11 @@ class LocalRuntime:
                 env=env,
             )
 
-        # Delete the branch
+    def _delete_branch(self, branch: str | None) -> None:
+        """Delete a branch from the repo (best-effort, used by cancel)."""
         if branch:
             subprocess.run(
                 ["git", "-C", self._repo_path, "branch", "-D", branch],
                 capture_output=True,
-                env=env,
+                env=_clean_git_env(),
             )

{hyperloop-0.1.1 → hyperloop-0.3.0}/src/hyperloop/cli.py

@@ -7,6 +7,7 @@ the orchestrator, and runs the loop with rich status output.
 from __future__ import annotations
 
 import sys
+from importlib.metadata import version as pkg_version
 from pathlib import Path
 
 import typer
@@ -23,8 +24,23 @@ app = typer.Typer(
 console = Console()
 
 
+def _version_callback(value: bool) -> None:
+    if value:
+        console.print(f"hyperloop {pkg_version('hyperloop')}")
+        raise typer.Exit()
+
+
 @app.callback()
-def main() -> None:
+def main(
+    version: bool = typer.Option(
+        False,
+        "--version",
+        "-V",
+        help="Show version and exit.",
+        callback=_version_callback,
+        is_eager=True,
+    ),
+) -> None:
     """AI agent orchestrator for composable process pipelines."""
 
 
@@ -52,6 +68,10 @@ def _config_table(cfg: Config) -> Table:
 
 @app.command()
 def run(
+    path: Path = typer.Option(
+        Path.cwd(),
+        help="Path to the target repo. Default: current directory.",
+    ),
     repo: str | None = typer.Option(
         None,
         help="GitHub repo (owner/repo). Inferred from git remote if not set.",
@@ -64,7 +84,7 @@ def run(
         None,
         "--config",
         "-c",
-        help="Config file path. Default: .hyperloop.yaml",
+        help="Config file path. Default: .hyperloop.yaml in the target repo.",
     ),
     max_workers: int | None = typer.Option(
         None,
@@ -78,7 +98,8 @@ def run(
 ) -> None:
     """Run the orchestrator loop."""
     # 1. Load config (file + CLI overrides)
-    config_path = config_file or Path(".hyperloop.yaml")
+    repo_path = path.resolve()
+    config_path = config_file or (repo_path / ".hyperloop.yaml")
     try:
         cfg = load_config(
             config_path,
@@ -99,7 +120,9 @@ def run(
             style="blue",
         )
     )
-    console.print(_config_table(cfg))
+    table = _config_table(cfg)
+    table.add_row("path", str(repo_path))
+    console.print(table)
     console.print()
 
     # 3. Dry run — show config and exit
@@ -107,13 +130,15 @@ def run(
         console.print("[bold yellow]Dry run[/bold yellow] -- exiting without executing.")
         return
 
-    # 4. Validate repo is set (required for actual run)
+    # 4. Validate repo path exists and is a git repo
+    if not (repo_path / ".git").exists():
+        console.print(f"[bold red]Error:[/bold red] {repo_path} is not a git repository.")
+        raise typer.Exit(code=1)
+
     if cfg.repo is None:
         console.print(
-            "[bold red]Error:[/bold red] No repo specified. "
-            "Use --repo owner/repo or set target.repo in .hyperloop.yaml"
+            "[dim]No --repo set. PR operations (draft, merge, gate) will be skipped.[/dim]"
         )
-        raise typer.Exit(code=1)
 
     # 5. Construct runtime and state store, run loop
     from hyperloop.adapters.git_state import GitStateStore
@@ -136,7 +161,6 @@ def run(
         ),
     )
 
-    repo_path = Path.cwd()
     state = GitStateStore(repo_path, specs_dir=cfg.specs_dir)
     runtime = LocalRuntime(repo_path=str(repo_path))
 

{hyperloop-0.1.1 → hyperloop-0.3.0}/src/hyperloop/loop.py

@@ -71,6 +71,7 @@ class Orchestrator:
         max_rounds: int = 50,
         pr_manager: PRPort | None = None,
         composer: PromptComposer | None = None,
+        repo_path: str | None = None,
     ) -> None:
         self._state = state
         self._runtime = runtime
@@ -79,6 +80,7 @@ class Orchestrator:
         self._max_rounds = max_rounds
         self._pr_manager = pr_manager
         self._composer = composer
+        self._repo_path = repo_path
 
         # Active worker tracking: task_id -> (handle, pipeline_position)
         self._workers: dict[str, tuple[WorkerHandle, PipelinePosition]] = {}
@@ -340,45 +342,65 @@ class Orchestrator:
                 self._state.clear_findings(task.id)
 
     def _merge_ready_prs(self) -> None:
-        """Merge PRs for tasks at the merge-pr action step.
+        """Merge branches for tasks at the merge-pr action step.
 
-        Rebases branch first; on conflict transitions to NEEDS_REBASE.
+        With a PRManager: rebase + squash-merge the PR.
+        Without a PRManager: local git merge of worker branch into base branch.
+        On conflict, transitions to NEEDS_REBASE.
         """
-        if self._pr_manager is None:
-            logger.debug("merge: no PRManager — skipping merge")
-            return
-
         all_tasks = self._state.get_world().tasks
         for task in all_tasks.values():
             if task.status != TaskStatus.IN_PROGRESS:
                 continue
             if task.phase != Phase("merge-pr"):
                 continue
-            if task.pr is None:
-                continue
 
             branch = task.branch or f"worker/{task.id}"
 
-            # Step 1: Rebase onto base branch
-            if not self._pr_manager.rebase_branch(branch, "main"):
-                logger.warning("Rebase conflict for task %s, marking NEEDS_REBASE", task.id)
-                self._state.transition_task(
-                    task.id, TaskStatus.NEEDS_REBASE, phase=Phase("merge-pr")
-                )
-                continue
+            if self._pr_manager is not None and task.pr is not None:
+                self._merge_via_pr(task.id, task.pr, task.spec_ref, branch)
+            else:
+                self._merge_local(task.id, branch)
 
-            # Step 2: Squash-merge the PR
-            if not self._pr_manager.merge(task.pr, task.id, task.spec_ref):
-                logger.warning("Merge conflict for task %s, marking NEEDS_REBASE", task.id)
-                self._state.transition_task(
-                    task.id, TaskStatus.NEEDS_REBASE, phase=Phase("merge-pr")
-                )
-                continue
+    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."""
+        assert self._pr_manager is not None
+
+        if not self._pr_manager.rebase_branch(branch, "main"):
+            logger.warning("Rebase conflict for task %s, marking NEEDS_REBASE", task_id)
+            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._state.transition_task(task_id, TaskStatus.NEEDS_REBASE, phase=Phase("merge-pr"))
+            return
+
+        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)
+
+    def _merge_local(self, task_id: str, branch: str) -> None:
+        """Merge worker branch into base branch locally (no PR)."""
+        import subprocess
 
-            # Merge succeeded — mark task complete
-            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)
+        git_cmd = ["git"]
+        if self._repo_path is not None:
+            git_cmd = ["git", "-C", self._repo_path]
+
+        try:
+            subprocess.run(
+                [*git_cmd, "merge", branch, "--no-edit", "-m", f"merge: {task_id}"],
+                check=True,
+                capture_output=True,
+            )
+            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._state.transition_task(task_id, TaskStatus.NEEDS_REBASE, phase=Phase("merge-pr"))
 
     # -----------------------------------------------------------------------
     # World building

hyperloop-0.3.0/tests/test_e2e.py

@@ -0,0 +1,591 @@
+"""End-to-end integration tests for the hyperloop orchestrator.
+
+Wires real GitStateStore + LocalRuntime + Orchestrator against a real git repo
+with a deterministic fake "agent" shell script. No mocks.
+"""
+
+from __future__ import annotations
+
+import os
+import subprocess
+from textwrap import dedent
+from typing import TYPE_CHECKING
+
+import pytest
+
+from hyperloop.adapters.git_state import GitStateStore
+from hyperloop.adapters.local import LocalRuntime
+from hyperloop.domain.model import (
+    ActionStep,
+    GateStep,
+    LoopStep,
+    Process,
+    RoleStep,
+    TaskStatus,
+)
+from hyperloop.loop import Orchestrator
+from tests.fakes.pr import FakePRManager
+
+if TYPE_CHECKING:
+    from pathlib import Path
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+
+def _clean_git_env() -> dict[str, str]:
+    """Strip GIT_* env vars so tests work inside pre-commit hooks."""
+    env = os.environ.copy()
+    for key in list(env):
+        if key.startswith("GIT_"):
+            del env[key]
+    return env
+
+
+def _git(repo: Path, *args: str) -> str:
+    """Run a git command in `repo` and return stdout."""
+    result = subprocess.run(
+        ["git", "-C", str(repo), *args],
+        check=True,
+        capture_output=True,
+        text=True,
+        env=_clean_git_env(),
+    )
+    return result.stdout.strip()
+
+
+def _init_repo(path: Path) -> None:
+    """Create a git repo with user config and an initial commit."""
+    env = _clean_git_env()
+    subprocess.run(["git", "init", str(path)], check=True, capture_output=True, env=env)
+    subprocess.run(
+        ["git", "-C", str(path), "config", "user.email", "test@test.com"],
+        check=True,
+        capture_output=True,
+        env=env,
+    )
+    subprocess.run(
+        ["git", "-C", str(path), "config", "user.name", "Test"],
+        check=True,
+        capture_output=True,
+        env=env,
+    )
+    subprocess.run(
+        ["git", "-C", str(path), "commit", "--allow-empty", "-m", "init"],
+        check=True,
+        capture_output=True,
+        env=env,
+    )
+
+
+def _write_task_file(repo: Path, task_id: str, content: str) -> None:
+    """Write a task file into the repo's specs/tasks directory."""
+    tasks_dir = repo / "specs" / "tasks"
+    tasks_dir.mkdir(parents=True, exist_ok=True)
+    (tasks_dir / f"{task_id}.md").write_text(content)
+
+
+def _write_spec_file(repo: Path, name: str, content: str) -> None:
+    """Write a spec file into the repo's specs directory."""
+    specs_dir = repo / "specs"
+    specs_dir.mkdir(parents=True, exist_ok=True)
+    (specs_dir / name).write_text(content)
+
+
+def _commit_all(repo: Path, message: str) -> None:
+    """Stage and commit all changes in the repo."""
+    _git(repo, "add", "-A")
+    _git(repo, "commit", "-m", message)
+
+
+def _make_agent_script(tmp_path: Path, name: str, body: str) -> str:
+    """Create an executable shell script and return its absolute path."""
+    script_path = tmp_path / name
+    script_path.write_text(body)
+    script_path.chmod(0o755)
+    return str(script_path)
+
+
+# Pipeline used by basic e2e tests: LoopStep(implementer, verifier).
+# No merge-pr step — keeps tests focused on the orchestrator loop logic.
+E2E_PIPELINE = Process(
+    name="e2e",
+    intake=(),
+    pipeline=(
+        LoopStep(
+            steps=(
+                RoleStep(role="implementer", on_pass=None, on_fail=None),
+                RoleStep(role="verifier", on_pass=None, on_fail=None),
+            ),
+        ),
+    ),
+)
+
+
+TASK_CONTENT = dedent("""\
+    ---
+    id: {task_id}
+    title: Implement example feature
+    spec_ref: specs/example.md
+    status: not-started
+    phase: null
+    deps: []
+    round: 0
+    branch: null
+    pr: null
+    ---
+
+    ## Spec
+    Build the example feature.
+
+    ## Findings
+    """)
+
+
+# Pipeline with merge-pr step: LoopStep(implementer, verifier), then merge-pr.
+E2E_MERGE_PIPELINE = Process(
+    name="e2e-merge",
+    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"),
+    ),
+)
+
+# Pipeline with gate: LoopStep(implementer) -> gate(human-pr-approval) -> merge-pr.
+E2E_GATE_PIPELINE = Process(
+    name="e2e-gate",
+    intake=(),
+    pipeline=(
+        LoopStep(
+            steps=(
+                RoleStep(role="implementer", on_pass=None, on_fail=None),
+                RoleStep(role="verifier", on_pass=None, on_fail=None),
+            ),
+        ),
+        GateStep(gate="human-pr-approval"),
+        ActionStep(action="merge-pr"),
+    ),
+)
+
+
+# Minimal shell script that writes a passing .worker-result.json.
+# Avoids git operations to keep execution time minimal (~10ms vs ~600ms).
+PASS_AGENT_BODY = """\
+#!/bin/bash
+set -e
+cat > /dev/null
+cat > .worker-result.json <<'RESULT'
+{"verdict": "pass", "findings": 0, "detail": "implemented"}
+RESULT
+"""
+
+# Agent script that creates a file, commits it, and reports pass.
+# Used by merge tests to verify code lands on the base branch.
+COMMIT_AGENT_BODY = """\
+#!/bin/bash
+set -e
+cat > /dev/null
+
+# Strip GIT_* env vars (may interfere when running inside pre-commit)
+for var in $(env | grep '^GIT_' | cut -d= -f1); do
+    unset "$var"
+done
+
+# Only create the file if it doesn't already exist (idempotent across roles)
+if [ ! -f feature.txt ]; then
+    echo "hello from agent" > feature.txt
+    git add feature.txt
+    git commit -m "feat: add feature.txt"
+fi
+
+cat > .worker-result.json <<'RESULT'
+{"verdict": "pass", "findings": 0, "detail": "implemented"}
+RESULT
+"""
+
+
+# ---------------------------------------------------------------------------
+# Tests
+# ---------------------------------------------------------------------------
+
+# Each orchestrator cycle takes ~10ms (reads task files, polls subprocesses,
+# calls decide). Worker subprocesses take ~50-200ms. max_cycles must be high
+# enough to cover the wall-clock time of subprocess execution. 500 cycles
+# gives a ~5s budget which is more than sufficient.
+MAX_CYCLES = 500
+
+
+@pytest.mark.slow
+class TestSingleTaskCompletesE2E:
+    """One task, deterministic agent always passes.
+
+    Task goes from not-started -> implementer -> verifier -> complete.
+    """
+
+    def test_single_task_completes_e2e(self, tmp_path: Path) -> None:
+        repo = tmp_path / "repo"
+        repo.mkdir()
+        _init_repo(repo)
+
+        # Seed the repo with a spec and a task
+        _write_spec_file(repo, "example.md", "# Example\nBuild a widget.\n")
+        _write_task_file(repo, "task-001", TASK_CONTENT.format(task_id="task-001"))
+        _commit_all(repo, "chore: seed spec and task")
+
+        # Create the agent script
+        agent_script = _make_agent_script(tmp_path, "pass-agent.sh", PASS_AGENT_BODY)
+
+        # Wire up real adapters
+        state = GitStateStore(repo_path=repo)
+        runtime = LocalRuntime(
+            repo_path=str(repo),
+            worktree_base=str(tmp_path / "worktrees"),
+            command=f"bash {agent_script}",
+        )
+        orch = Orchestrator(
+            state=state,
+            runtime=runtime,
+            process=E2E_PIPELINE,
+            max_workers=2,
+            max_rounds=10,
+        )
+
+        reason = orch.run_loop(max_cycles=MAX_CYCLES)
+
+        assert "all tasks complete" in reason.lower()
+
+        task = state.get_task("task-001")
+        assert task.status == TaskStatus.COMPLETE
+
+        # Verify the orchestrator committed state changes to trunk
+        log = _git(repo, "log", "--oneline")
+        assert "orchestrator" in log.lower()
+
+
+@pytest.mark.slow
+class TestFailedVerificationRetriesE2E:
+    """Verifier agent script returns fail on the first call, then pass on the second.
+
+    Uses a counter file in tmp_path to track invocations.
+    """
+
+    def test_failed_verification_retries_e2e(self, tmp_path: Path) -> None:
+        repo = tmp_path / "repo"
+        repo.mkdir()
+        _init_repo(repo)
+
+        _write_spec_file(repo, "example.md", "# Example\nBuild a widget.\n")
+        _write_task_file(repo, "task-001", TASK_CONTENT.format(task_id="task-001"))
+        _commit_all(repo, "chore: seed spec and task")
+
+        counter_file = tmp_path / "verifier-counter"
+
+        # Agent script that fails on the first invocation (counter file absent),
+        # then passes on all subsequent invocations.
+        retry_agent_body = f"""\
+#!/bin/bash
+set -e
+cat > /dev/null
+
+COUNTER_FILE="{counter_file}"
+
+if [ ! -f "$COUNTER_FILE" ]; then
+    echo "1" > "$COUNTER_FILE"
+    cat > .worker-result.json <<'RESULT'
+{{"verdict": "fail", "findings": 1, "detail": "tests failed on first run"}}
+RESULT
+else
+    cat > .worker-result.json <<'RESULT'
+{{"verdict": "pass", "findings": 0, "detail": "all good"}}
+RESULT
+fi
+"""
+
+        agent_script = _make_agent_script(tmp_path, "retry-agent.sh", retry_agent_body)
+
+        state = GitStateStore(repo_path=repo)
+        runtime = LocalRuntime(
+            repo_path=str(repo),
+            worktree_base=str(tmp_path / "worktrees"),
+            command=f"bash {agent_script}",
+        )
+        orch = Orchestrator(
+            state=state,
+            runtime=runtime,
+            process=E2E_PIPELINE,
+            max_workers=2,
+            max_rounds=10,
+        )
+
+        reason = orch.run_loop(max_cycles=MAX_CYCLES)
+
+        assert "all tasks complete" in reason.lower()
+
+        task = state.get_task("task-001")
+        assert task.status == TaskStatus.COMPLETE
+
+        # Verify the fail path ran at least once
+        assert counter_file.exists()
+
+
+@pytest.mark.slow
+class TestTwoTasksRunInParallelE2E:
+    """Two independent tasks, both complete. Verify both worker branches are created."""
+
+    def test_two_tasks_run_in_parallel_e2e(self, tmp_path: Path) -> None:
+        repo = tmp_path / "repo"
+        repo.mkdir()
+        _init_repo(repo)
+
+        _write_spec_file(repo, "example.md", "# Example\nBuild widgets.\n")
+        _write_task_file(repo, "task-001", TASK_CONTENT.format(task_id="task-001"))
+        _write_task_file(repo, "task-002", TASK_CONTENT.format(task_id="task-002"))
+        _commit_all(repo, "chore: seed spec and tasks")
+
+        agent_script = _make_agent_script(tmp_path, "pass-agent.sh", PASS_AGENT_BODY)
+
+        state = GitStateStore(repo_path=repo)
+        runtime = LocalRuntime(
+            repo_path=str(repo),
+            worktree_base=str(tmp_path / "worktrees"),
+            command=f"bash {agent_script}",
+        )
+        orch = Orchestrator(
+            state=state,
+            runtime=runtime,
+            process=E2E_PIPELINE,
+            max_workers=4,
+            max_rounds=10,
+        )
+
+        reason = orch.run_loop(max_cycles=MAX_CYCLES)
+
+        assert "all tasks complete" in reason.lower()
+
+        task1 = state.get_task("task-001")
+        task2 = state.get_task("task-002")
+        assert task1.status == TaskStatus.COMPLETE
+        assert task2.status == TaskStatus.COMPLETE
+
+        # Verify orchestrator committed state changes
+        log = _git(repo, "log", "--oneline")
+        assert "orchestrator" in log.lower()
+
+
+@pytest.mark.slow
+class TestLocalMergeLandsCodeOnBaseBranch:
+    """Full pipeline with merge-pr step, no PRManager (local merge mode).
+
+    Verifies that code committed by the agent on the worker branch is merged
+    into the base branch when the pipeline completes.
+    """
+
+    def test_local_merge_lands_code_on_base_branch(self, tmp_path: Path) -> None:
+        repo = tmp_path / "repo"
+        repo.mkdir()
+        _init_repo(repo)
+
+        _write_spec_file(repo, "example.md", "# Example\nBuild a widget.\n")
+        _write_task_file(repo, "task-001", TASK_CONTENT.format(task_id="task-001"))
+        _commit_all(repo, "chore: seed spec and task")
+
+        agent_script = _make_agent_script(tmp_path, "commit-agent.sh", COMMIT_AGENT_BODY)
+
+        state = GitStateStore(repo_path=repo)
+        runtime = LocalRuntime(
+            repo_path=str(repo),
+            worktree_base=str(tmp_path / "worktrees"),
+            command=f"bash {agent_script}",
+        )
+        orch = Orchestrator(
+            state=state,
+            runtime=runtime,
+            process=E2E_MERGE_PIPELINE,
+            max_workers=2,
+            max_rounds=10,
+            repo_path=str(repo),
+        )
+
+        reason = orch.run_loop(max_cycles=MAX_CYCLES)
+
+        assert "all tasks complete" in reason.lower()
+
+        task = state.get_task("task-001")
+        assert task.status == TaskStatus.COMPLETE
+
+        # Verify the agent's file exists on the base branch
+        assert (repo / "feature.txt").exists()
+        assert (repo / "feature.txt").read_text().strip() == "hello from agent"
+
+
+@pytest.mark.slow
+class TestPRFlowWithFakePRManager:
+    """Full pipeline with FakePRManager wired into the Orchestrator.
+
+    Proves the PR path works end-to-end: implementer -> verifier -> merge-pr
+    with real GitStateStore + LocalRuntime + FakePRManager.
+    """
+
+    def test_pr_flow_with_fake_pr_manager(self, tmp_path: Path) -> None:
+        repo = tmp_path / "repo"
+        repo.mkdir()
+        _init_repo(repo)
+
+        _write_spec_file(repo, "example.md", "# Example\nBuild a widget.\n")
+        # Task needs a pr field set so _merge_via_pr is used instead of _merge_local
+        task_with_pr = dedent("""\
+            ---
+            id: task-001
+            title: Implement example feature
+            spec_ref: specs/example.md
+            status: not-started
+            phase: null
+            deps: []
+            round: 0
+            branch: null
+            pr: https://github.com/test/repo/pull/1
+            ---
+
+            ## Spec
+            Build the example feature.
+
+            ## Findings
+            """)
+        _write_task_file(repo, "task-001", task_with_pr)
+        _commit_all(repo, "chore: seed spec and task")
+
+        agent_script = _make_agent_script(tmp_path, "pass-agent.sh", PASS_AGENT_BODY)
+
+        pr_manager = FakePRManager(repo="test/repo")
+        # Pre-create the PR in the fake so it exists when merge is called
+        pr_url = pr_manager.create_draft(
+            task_id="task-001",
+            branch="worker/task-001",
+            title="Implement example feature",
+            spec_ref="specs/example.md",
+        )
+
+        state = GitStateStore(repo_path=repo)
+        runtime = LocalRuntime(
+            repo_path=str(repo),
+            worktree_base=str(tmp_path / "worktrees"),
+            command=f"bash {agent_script}",
+        )
+        orch = Orchestrator(
+            state=state,
+            runtime=runtime,
+            process=E2E_MERGE_PIPELINE,
+            max_workers=2,
+            max_rounds=10,
+            pr_manager=pr_manager,
+        )
+
+        reason = orch.run_loop(max_cycles=MAX_CYCLES)
+
+        assert "all tasks complete" in reason.lower()
+
+        task = state.get_task("task-001")
+        assert task.status == TaskStatus.COMPLETE
+
+        # Verify FakePRManager received the merge call
+        assert len(pr_manager.merged) == 1
+        assert pr_manager.rebased == [("worker/task-001", "main")]
+
+        # Verify the PR was actually merged in the fake
+        assert pr_manager._prs[pr_url].merged
+
+
+@pytest.mark.slow
+class TestGateBlocksUntilLgtm:
+    """Pipeline with gate: implementer -> verifier -> gate(human-pr-approval) -> merge-pr.
+
+    Task reaches the gate and stalls. Test adds the lgtm signal to FakePRManager.
+    Next cycle clears the gate. Task proceeds to merge and completes.
+    """
+
+    def test_gate_blocks_until_lgtm(self, tmp_path: Path) -> None:
+        repo = tmp_path / "repo"
+        repo.mkdir()
+        _init_repo(repo)
+
+        _write_spec_file(repo, "example.md", "# Example\nBuild a widget.\n")
+        task_with_pr = dedent("""\
+            ---
+            id: task-001
+            title: Implement example feature
+            spec_ref: specs/example.md
+            status: not-started
+            phase: null
+            deps: []
+            round: 0
+            branch: null
+            pr: https://github.com/test/repo/pull/1
+            ---
+
+            ## Spec
+            Build the example feature.
+
+            ## Findings
+            """)
+        _write_task_file(repo, "task-001", task_with_pr)
+        _commit_all(repo, "chore: seed spec and task")
+
+        agent_script = _make_agent_script(tmp_path, "pass-agent.sh", PASS_AGENT_BODY)
+
+        pr_manager = FakePRManager(repo="test/repo")
+        pr_url = pr_manager.create_draft(
+            task_id="task-001",
+            branch="worker/task-001",
+            title="Implement example feature",
+            spec_ref="specs/example.md",
+        )
+
+        state = GitStateStore(repo_path=repo)
+        runtime = LocalRuntime(
+            repo_path=str(repo),
+            worktree_base=str(tmp_path / "worktrees"),
+            command=f"bash {agent_script}",
+        )
+        orch = Orchestrator(
+            state=state,
+            runtime=runtime,
+            process=E2E_GATE_PIPELINE,
+            max_workers=2,
+            max_rounds=10,
+            pr_manager=pr_manager,
+        )
+
+        # Run enough cycles for implementer + verifier to complete, reaching the gate
+        for _ in range(MAX_CYCLES):
+            result = orch.run_cycle()
+            if result is not None:
+                break
+            task = state.get_task("task-001")
+            if task.phase is not None and str(task.phase) == "human-pr-approval":
+                break
+
+        # Task should be at the gate
+        task = state.get_task("task-001")
+        assert task.status == TaskStatus.IN_PROGRESS
+        assert str(task.phase) == "human-pr-approval"
+
+        # Simulate human approval: add lgtm label
+        pr_manager.add_label(pr_url, "lgtm")
+
+        # Run more cycles — gate should clear, merge should succeed
+        reason = orch.run_loop(max_cycles=MAX_CYCLES)
+
+        assert "all tasks complete" in reason.lower()
+
+        task = state.get_task("task-001")
+        assert task.status == TaskStatus.COMPLETE
+
+        # Verify the PR was merged
+        assert len(pr_manager.merged) == 1

{hyperloop-0.1.1 → hyperloop-0.3.0}/tests/test_local_runtime.py

@@ -229,7 +229,7 @@ class TestReap:
         worktree_path = tmp_path / "worktrees" / "workers" / "task-022"
         assert not worktree_path.exists()
 
-    def test_cleans_up_branch_after_reap(self, tmp_path: Path) -> None:
+    def test_preserves_branch_after_reap(self, tmp_path: Path) -> None:
         _init_repo(tmp_path)
         rt = LocalRuntime(repo_path=str(tmp_path), command=PASS_COMMAND)
 
@@ -243,7 +243,7 @@ class TestReap:
 
         rt.reap(handle)
 
-        # Branch should be deleted
+        # Branch should be preserved for later pipeline steps (e.g. merge-pr)
         result = subprocess.run(
             ["git", "-C", str(tmp_path), "branch", "--list", "worker/task-023"],
             check=True,
@@ -251,7 +251,7 @@ class TestReap:
             text=True,
             env=_clean_git_env(),
         )
-        assert result.stdout.strip() == ""
+        assert "worker/task-023" in result.stdout.strip()
 
     def test_returns_error_result_when_no_result_file(self, tmp_path: Path) -> None:
         _init_repo(tmp_path)

{hyperloop-0.1.1 → hyperloop-0.3.0}/uv.lock

@@ -61,7 +61,7 @@ wheels = [
 
 [[package]]
 name = "hyperloop"
-version = "0.1.0"
+version = "0.1.1"
 source = { editable = "." }
 dependencies = [
     { name = "pyyaml" },