radar

Radar

Two agents. Two green branches. One broken merge. Radar catches it before you merge.

You run coding agents in parallel, each in its own worktree (cmux, Orca, Claude Code, Codex, or plain git worktree). Each branch passes its own tests. Merged together, they break. Radar combines the branches in private Git state, checks the combination, runs selected tests when authorized, and provides repair leads.

It is a local CLI. It needs no API key, sends no telemetry, and never touches your branches.

Try it in one minute

Two agents edit separate branches. Each branch passes its tests. Combined, they fail. Paste this into a shell after installing Radar (it needs Git and Python 3 and works in a new temporary directory):

cd "$(mktemp -d)" && git init -q -b main shop && cd shop
git config user.name demo && git config user.email [email protected]
printf 'def price():\n    return 1\n' > backend.py
printf 'export const QUANTITY = 1;\n' > frontend.ts
cat > test_checkout.py <<'PY'
import re, unittest
from pathlib import Path
from backend import price

class Checkout(unittest.TestCase):
    def test_budget(self):
        quantity = int(re.search(r"QUANTITY = (\d+)", Path("frontend.ts").read_text())[1])
        self.assertLessEqual(price() * quantity, 2)
PY
git add . && git commit -qm baseline
git worktree add -q -b agent-backend ../backend
git worktree add -q -b agent-frontend ../frontend
printf 'def price():\n    return 2\n' > ../backend/backend.py
git -C ../backend commit -qam 'Raise price'
printf 'export const QUANTITY = 2;\n' > ../frontend/frontend.ts
git -C ../frontend commit -qam 'Raise quantity'

radar gate          # PASS (static): the branches merge cleanly; no test ran
radar gate --run    # FAIL: the combined tree breaks the budget test

$ radar gate --run
Radar gate: FAIL — 1 of 1 test command failed on the combined tree
2 branches onto main @ e4d5f9ed44f0

  agent-backend   2b02738cceb2  1 file changed
  agent-frontend  93f3399937e6  1 file changed

  ✓ Merge           branches merge without conflicts
  · Contracts       none declared, so no contract was checked (radar discover proposes candidates)
  ✗ Tests           1 of 1 test command failed on the combined tree
  ? Test selection  incomplete — 1 changed file has no related test
  policy supported-integration requires textual_merge, no_breaking_contracts, integration_execution, test_selection

Problems
  ✗ integration_execution_failed
    Combined verification command python3 -m unittest discover -s . -p test_checkout.py (in .) returned failed (exit 1).
    failed cases: test_checkout.Checkout.test_budget
    look at (import-based lead): agent-backend (backend.py)
    reproduce: d=$(mktemp -d) && git worktree add --detach "$d" e4d5f9ed44f0 && cd "$d" && git merge --no-ff --no-edit --no-verify 2b02738cceb2 && git merge --no-ff --no-edit --no-verify 93f3399937e6 && python3 -m unittest discover -s . -p test_checkout.py
    fix: Reproduce the supplied command on the combined changes, reconcile producer/consumer assumptions, and repair the failing invariant.

Tests (balanced): ran 1 of 1 selected command
  ✗ python3 -m unittest discover -s . -p test_checkout.py  (in .; 1 recognized test)
  Test files: 1 inventoried, 1 selected (relationships are not behavioral coverage)
  ? Uncovered changes (no established test relationship): frontend.ts
    Resolve with supported tests, review --suite full, or explicitly select a limited --policy.

Next: repair on the branches above, commit, then rerun: radar gate --run
Details: add --json. Radar never touches your branches; the combination is built in private Git state.

look at is an import-based repair lead, not proof of blame. Extra diagnostic reruns are off by default. Use radar gate --run --attribution-runs 8 to look for a smaller branch combination that reproduces the failure; observed lines describe those bounded reruns and remain repair leads. The reproduce line rebuilds the same commits in a throwaway worktree under a new temporary directory (remove it later with git worktree remove). It skips commit hooks like Radar does, but checkout and merge hooks, your Git configuration and your environment still apply, so it can differ from Radar's sanitized run.

Install

Linux (amd64, arm64) and macOS (Apple Silicon, Intel):

curl -fsSL https://raw.githubusercontent.com/Jake-Network/radar/v0.2.0/scripts/install-release.sh | bash -s -- --version v0.2.0

This installs a checksum-verified binary to ~/.local/bin (--dir changes it). Binaries need no Go or C compiler; Git is required, and radar gate --run uses your repository's own test runners. Then:

radar doctor

Windows binaries are not published yet: Windows Git defaults such as core.autocrlf are not handled yet. On other systems, build from source with Go 1.23+ and a native C compiler (for Tree-sitter):

git clone --branch v0.2.0 --depth 1 https://github.com/Jake-Network/radar.git
cd radar
go build -trimpath -o radar ./cmd/radar

Use the GitHub binary installer or tag checkout for 0.2.0. The version's earlier source commit was cached by the Go module proxy before the hook release; go install [email protected] can therefore install that earlier implementation.

Release details and runtime limits: RELEASING.

The 0.2.0 release adds continuous saved-change previews and installable native coding-agent Stop hooks. See the changelog for the release scope.

First run in your repository

radar doctor          # base, agent branches, uncommitted worktrees, test runners, next step
radar setup claude    # optional: connect Claude Code (or codex, both); add --dry-run first
radar gate            # combine every agent branch and check it; runs no code
radar gate --run      # also run the related tests on the combined tree

Radar needs no configuration. radar gate picks the base (origin/HEAD's branch, main, master or trunk) and every worktree branch with commits beyond it. Name branches to choose them: radar gate agent-a agent-b --base develop. Gate checks committed changes; uncommitted work in a worktree is listed and left out, so commit first. radar watch --include-dirty can instead preview saved staged, unstaged and nonignored untracked changes in private snapshots; those results do not verify the committed branches.

In a terminal, bare radar opens a menu that shows the same information and runs the same commands (tests only after you confirm). radar watch rechecks while agents commit; see watch.

Reading the result

Marks: ✓ passed, ✗ failed, ? not verified, ! needs attention, · not checked or skipped. Color only decorates them; NO_COLOR and pipes give plain text. --json output is never styled. Every report ends with one Next: step.

Common NOT VERIFIED causes and fixes:

• **A test