Six stages. One sequence. Nothing ships unproven.

Replaces the human standing watch over every change — the scope-enforcer who can never blink.

Captures the after-state so 'looks done' has to face the record — but cannot reach back and undo.

Refuses to let the run call itself finished on its own say-so.

Holds an unproven subagent result at the seam instead of waving it through.

Removes the role you played as the agent's memory — re-introducing the requirement it forgot.

Re-anchors the run to its requirements so nothing starts unmoored.

Pins each task to a stated requirement so later you can prove which one it served.

Does the build inside the gate — its output is held to the same proving as everything else.

Takes over hand-checking whether code truly runs vs. merely compiles green.

Absorbs the tool-selector role so the choice is recorded, not improvised in your head.

Keeps the evidence record where an auditor can read it, not trapped in a vanished session.

Makes every step observable so the path from requirement to result is reconstructable.

Proves the change behaves through a real path, not just in isolation.

Searches for the counterexample you would not have thought to write by hand.

Holds generative behaviour to stated criteria instead of a vibe check.

Finds the defect class before it reaches a path you own in production.

Encodes the rule once so the gate, not a reviewer's memory, enforces it.

Exercises the running surface for exposure the static view cannot see.

Stops a leaked credential at the gate rather than in an incident review later.

Discharges the conditions you would otherwise reason about by hand and hope you got right.

Ties the artifact back to how it was built so the chain is inspectable.

Lets a change land behind a flag so exposure is a decision, not an accident.

Coordinates multi-step work that outlives a single run — sits outside the gate engine by design.