- Checks run in a repository of their own holding only the commit (and
the commit the run started from, as refs/wishforge/base), so code that
asks Git which commit it is gets the true answer; the verifier's
repository and configuration stay out of reach
- A frontend test gets two minutes before it fails, instead of one that
never settles holding the whole suite until the check is killed
- When frontend or Go tests fail, the same tests run at the commit the
run started from; only failures that were not there before fail the
change
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
In Kubernetes mode the per-run network policy allowed only DNS, the API,
Temporal and Git, so dependency installs could not reach a registry and image
builds had no builder.
- WF_RUN_INSTALL_PROXY_URL points both sandboxes at an operator's egress proxy
(pods labelled egress-proxy); the per-run policy admits it and installation
commands get HTTP(S)_PROXY, also inside bubblewrap, while checks still have
no network.
- WF_VERIFIER_DOCKER_HOST with a TLS client certificate points the verifier at
a remote builder daemon (pods labelled image-builder); a separate policy
lets only the verifier pod reach it, and release deletes that policy too.
Builds pass DOCKER_HOST, DOCKER_TLS_VERIFY and DOCKER_CERT_PATH, and refuse
a Docker context and a remote builder together.
- The control namespace's baseline admits sandbox traffic to both components.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Verification ran git inside the tree under test, kept no command output and
treated every infrastructure fault as a test failure; repairs went through an
executor lease the coordinator should not hold; and a project without delivery
could never succeed. This reworks the worker execution path and the control-plane
contracts it depends on.
- Verification exports the exact commit to a directory without .git, installs
dependencies (network allowed) and runs the protected commands under
bubblewrap in kata mode or directly in host mode; evidence records exit code,
duration, digest, a redacted output tail and the isolation used. Production
rejects host evidence. A failed installation waits as infrastructure.
- Waiting reasons are an enum with a redacted detail; dispatcher, GitHub and
model-proxy states map onto it, and the console explains each one with a way out.
- Repairs are requested by the coordinator through /internal/runs/:id/repair;
the control plane derives the failure summary from the verifier's evidence and
enforces the repair budget. Continuing after the budget is spent grants one more
round; a new requirement revision starts a fresh budget.
- Execution identities may only move a run within their own stages and only to
running or waiting; success comes from integration evidence (no delivery
configured) or deployment acceptance. The unused preview stage is gone.
- Integration fast-forwards when the target has not moved, merges and re-verifies
otherwise, retries when a push finds the target moved, and turns merge conflicts
into a repair round that merges the current target for the agent to resolve.
- Successful runs that needed a repair leave a project lesson; active lessons are
injected into later prompts, and admins can list, add, disable and delete them.
- Executor progress (messages, commands, file changes, plan updates) is stored as
normalized events; previously agent messages were recorded as the literal word
"output". Provider failures keep the work as a checkpoint and wait as
provider_error instead of failing the run.
- Workers declare WF_SANDBOX_MODE=host|kata (host refused in production),
heartbeat with retries until the lease could have expired, and retry safe
control-plane reads with backoff.
- tests/local-loop.test.ts runs the loop end to end with real Git, the in-process
control plane behind its internal routes and a scripted agent.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>