Make installing the repo give you the Go node as swe-planner, with the bundled coding engine as an opt-in preview

[AbirAbbas]

Makes af install <this repo> give you the Go node, makes an OpenRouter key the only thing you need to get it working, and ships the Go node's bundled high-performance coding engine behind an opt-in flag.

Installing the repo gives you the Go node — as swe-planner

The Go node is the maintained SWE node — same reasoners, same interface, one static binary, and it ships the coding engine. But it lived in go/ under the name swe-planner-go, so getting it meant knowing to type //go, and anyone who had already installed the Python swe-planner stayed on it forever.

Two changes make the bare repo URL the whole story. The root manifest carries a redirect:

superseded_by: https://github.com/Agent-Field/SWE-AF//go

and the Go node drops its -go suffix — package name, node ids, and reasoner tags — to take the product's names. The suffix existed so the port could run beside the Python node during the migration; it is not something a user should ever have had to type. Since both manifests now declare swe-planner, af install https://github.com/Agent-Field/SWE-AF replaces an existing install in place: same node id, same triggers, node-scoped secrets untouched because the scope name never changes. swe-planner.build means the same thing before and after, whichever implementation is serving it.

The mechanism behind the redirect is a generic manifest key in AgentField (Agent-Field/agentfield#864) — including the part that lets a successor share its predecessor's name, which is what an in-place rename needs. This repo only supplies the data.

The Python package is untouched and still what python -m swe_af and docker-compose.yml run. Because the two now answer to the same ids, running both against one control plane needs an explicit NODE_ID on one of them — docker-compose.go.yml does exactly that, and is now the only place carrying -go ids. To install the Python node deliberately, clone the repo and install the checkout as a local path; local-path installs do not follow the redirect.

Getting started is one key now

Several things quietly made the OpenRouter-only path fail:

• .env.example shipped ANTHROPIC_API_KEY uncommented with a placeholder. Any non-empty value disables the OpenRouter auto-select, so the documented cp .env.example .env quick start forced the claude_code runtime with a bogus key. GH_TOKEN had the same problem — a placeholder made git/gh attempt (and fail) auth instead of degrading to the no-token path. Both are commented out now, with OpenRouter presented first.
• Explicit SWE_DEFAULT_RUNTIME=open_code silently swapped the model. It opted out of the auto-selected default and fell back to minimax. The runtime base and the auto default are now the same model, so opting in explicitly resolves identically.
• Fast mode had no OpenRouter detection at all — with only an OpenRouter key it resolved claude_code/haiku and could not run. It now uses the same detection as the main path, and honours the SWE_DEFAULT_MODEL → AI_MODEL → HARNESS_MODEL cascade it previously ignored.
• Compose relied entirely on env_file: .env for provider keys on the planner services, so exporting a key in your shell gave you a working swe-fast and a keyless swe-planner. The functional compose file also still baked SWE_DEFAULT_RUNTIME=claude_code.

With only OPENROUTER_API_KEY set, the planner and fast nodes — Go and Python — now auto-select open_code and resolve every role to openrouter/deepseek/deepseek-v4-flash. GH_TOKEN stays optional. The claude_code path is unchanged.

Coding engine (opt-in preview)

The Go node bundles a prebuilt engine that is inert unless SWE_PRO_ENGINE=1. With it set, builds route per-issue coding through it; unset it and you are back on the classic loop. Branch, push and PR creation stay with the standard pipeline.

If the flag is on but no runnable binary is found, the node logs a warning and comes up on the classic loop. That check is deliberately about runnability, not mere existence: a binary that lost its execute bit used to look available, get pro_execute registered, and route every issue to an engine that could never start — worse than not opting in.

The opt-in is now discoverable: it is declared in the Go node's manifest (so it appears in the af install prompt), in .env.example, and in both READMEs. go/docs/pro-engine.md previously had zero inbound links.

Validation

• gofmt, go build ./..., go vet ./..., go test -race -count=1 ./... — all clean
• pytest — 1143 passed, 1 skipped
• Verified against a live control plane: the engine registers as its own node, a code_task produced correct code, and the tests it wrote pass
• Verified through a real af install: the engine resolves next to the built node binary, the sidecar spawns; with the execute bit removed it degrades cleanly instead of crash-looping
• Verified the redirect end to end with a real af install against a local repo carrying it, with the Python node already installed: it warned, installed the successor as swe-planner with its source recorded as …//go, replaced the predecessor's files in place, and left both the node-scoped and global secrets intact. The installed binary, started with NODE_ID unset, registers as node_id: swe-planner, and the engine binary lands next to it at 0755
• An earlier run of the same flow (pre-rename) reached a live control plane and completed an implement_issue with only OPENROUTER_API_KEY set

Note for reviewers

The engine binary is vendored at go/bin/swe-pro, refreshed to the engine's current main (15 commits past the previous build, including the in-process search fallback that removes the hard dependency on ripgrep being installed on the host). It is a static linux/amd64 build, reproducible — building it twice gives byte-identical output.

The branch is laid out so that binary is added exactly once in history: the refresh amends the commit that introduces it rather than layering a second 20 MB blob, so the branch still carries one.

🤖 Generated with Claude Code