feat: opt-in Go port of PR-AF on the AgentField Go SDK

[AbirAbbas]

Summary

Complete 1:1 port of PR-AF from Python to Go using the AgentField Go SDK, mirroring the SWE-AF port (Agent-Field/SWE-AF#94). The Go node is an opt-in sibling: it registers as pr-af-go (:8007) so both stacks run against one control plane simultaneously. The Python implementation stays the default and is byte-untouched — every diff lives under go/, plus docker-compose.go.yml, one root-README section, and a new Go CI job.

Callers opt in by targeting the -go reasoner path, e.g. POST /api/v1/execute/async/pr-af-go.review; NODE_ID/PORT env overrides remain available.

Install story

• Default (unchanged): af install <repo> installs the Python node from the root manifest.
• Opt-in Go: af install <repo> --path go installs the Go node from go/agentfield-package.yaml (name: pr-af-go, language: go) — the control plane compiles bin/pr-af at install time. Requires the --path selector + Go-package support from feat: af install --path selector + Go SDK harness fixes agentfield#750. Verified end-to-end against an af binary built from that branch: manifest resolution from the go/ subtree, install-time compile, registration as pr-af-go, clean uninstall.
• Docker/compose: docker build -f go/Dockerfile ., or docker compose -f docker-compose.go.yml up -d as an add-on to the running Python stack (joins its network/volume as external references). Works independently of #750.

The committed go.mod pins the SDK by real pseudo-version (sdk/go v0.0.0-20260710152001-45311737c298, the #750 head) with no replace directive — it resolves from the module proxy, which is what makes the af install --path go build work without vendoring. Bump to the merged-main SHA once #750 lands.

Parity contract honored

• Registration surface: all 17 reasoners under their exact Python names — review (untagged, with input schema) + 16 tagged ["review","pr"]. Asserted by a functional test against a live control plane.
• No app.call: like Python, the 16 internal reasoners run in-process (goroutines + errgroup/semaphore reproducing asyncio.gather order-preservation and the streaming reviewer→layer queue); only review is externally driven.
• Result JSON: snake_case model_dump() key sets reproduced per reasoner (pydantic non-zero defaults seeded via UnmarshalJSON); the hax HITL payload stays the one camelCase surface, with severity re-normalized at that boundary.
• Both divergent severity maps ported exactly (canonical schemas map vs scoring's private map that maps medium→important, low→suggestion).
• Prompts byte-verbatim: 25 builders, 51 golden fixtures, and — unlike the SWE-AF port — the Python fixture generator is committed (go/scripts/gen_golden.py) so goldens are reproducible from the repo.
• Deliberate quirks preserved: the code-level model default stays minimax/minimax-m2.5 while deploy artifacts default to openrouter/moonshotai/kimi-k2.5 (env wins); the $ cost ceiling stays inert (only the wall-clock cap is live); Python round() banker's-rounding reproduced in scoring and the summary Markdown is byte-exact vs _format_summary (golden generated from the running Python).
• HITL: SDK-native Agent.Pause (webhook-resumed) + direct hax REST client; the review gate never raises — every failure path returns a reject decision with the exact Python instruction strings.

Test plan

• go build ./... && go vet ./... && go test ./... — whole module green (16 packages with tests; orchestrator + evidence also -race-clean); gofmt -l empty.
• Python suite untouched and green: zero Python-source diffs vs main, ruff check clean, pytest 69/69.
• Both Docker images build (root Python image and go/Dockerfile).
• Functional suite (go test -tags functional ./test/functional/) against a real dockerized control plane: health, exact 17-name registration parity + tags, fail-fast error shape. 3/3 PASS, stack torn down cleanly.
• Zero-GitHub-writes e2e (go/test/e2e/run.sh): full review of a fixture repo through a mock opencode shim against a real control plane — succeeded with 4 findings, all phases fired (anatomy → meta ×3 → review dimensions → evidence → adversary → compound/obligations → synthesis → output). The four .ai() gate calls (intake/coverage/merge-gate/polish) hit OpenRouter for real — cheap, but the harness needs OPENROUTER_API_KEY (documented in the script header; skips cleanly without it).
• af install <repo> --path go verified with a #750-built af (see Install story).

Known accepted differences (documented in code)

• A few nondeterministic Python behaviors were made deterministic where Python's own output is unstable across processes (set-iteration tie-breaks in cluster primary_language and compound-cluster grouping); JSON whole-value floats render 0 instead of 0.0 (numerically identical; the Markdown path uses Python-parity formatting).
• Shared harness output file race (present in BOTH implementations): parallel harness calls that share a Cwd share one <cwd>/.agentfield_output.json (both SDKs use the same deterministic path), so concurrent same-repo harness calls can race on write/cleanup. The port reproduces Python's behavior bug-for-bug per the parity contract; a proper fix (per-call isolation via ProjectDir/unique cwd) is a follow-up that should land in Python and Go together.

Docs

go/README.md covers build/run/compose/install; the root README gains one "Go implementation (opt-in)" section positioning Python as the default.

---

🤖 Generated with Claude Code

[AbirAbbas]

Addressed all four review findings (commits b35c96d and 4b5f828):

High — harness schemas stricter than Python: fixed in 4b5f828. Confirmed root cause: the invopop-reflected schemas (all fields required, pointers non-nullable, additionalProperties:false) predate the pinned SDK's strict JSON-Schema validation, so Python-valid output (omitted defaulted fields, "suggestion": null, extra keys) was rejected and retried. The 13 harness destination types now use embedded schemas generated from the real pydantic models by a committed generator (go/scripts/gen_schemas.py), with drift tests cross-checking every fixture against the Go structs' json tags, and a two-way behavioral proof test: the old invopop schema rejects — and the new pydantic schema accepts — the same Python-valid document. One deliberate deviation from raw model_json_schema(): the Severity enum is stripped to plain string, because pydantic's BeforeValidator coerces synonyms (high→important) rather than rejecting them — emitting the enum would have been stricter than Python's actual runtime and would re-create the swallowed-review incident severity.py documents. Side effect: the SDK's OUTPUT REQUIREMENTS prompt suffix now embeds the pydantic schema, structurally matching Python's. Remaining honest gap (inherent, unchanged by this fix): pydantic's type coercion ("0.7"→0.7) is more lenient than JSON-Schema validation; applies equally to the old schemas.

Medium — make docker-build context: fixed in b35c96d. The target now builds with the repo root as context (docker build -f Dockerfile -t $(IMAGE) ..), matching the Dockerfile's COPY go/... and the compose file.

Medium-low — HITL executionId: fixed in b35c96d. agent.ExecutionContextFrom is indeed exported at the pinned ref — the port comment was wrong. hitlMetadata now emits the real execution id (empty only when the ctx carries no execution, matching Python's app.ctx is None fallback).

Low — malformed numeric env: fixed in b35c96d. Now fails loud like Python instead of silently defaulting: request-path vars (PR_AF_MAX_COST_USD/PR_AF_MAX_DURATION_SECONDS) → HTTP 400 with Python's ValueError message shape; boot-path vars (PR_AF_MAX_TURNS etc.) → BuildAgent error (Python raises at module import).

All gates re-run green after the fixes: go build/vet/test ./... (16 packages), gofmt clean, generator idempotent.