Every ported function carries a provenance comment, // PORT: shared/mechanics/Sprites.pas:1234, so any TypeScript behavior can be diffed against the Pascal it came from. Deliberate divergences get a DESIGN OVERRIDE marker pointing at the graph node that ratified them.

The float trick: Pascal computes in 32-bit Single, JavaScript in f64. Instead of wrapping every operation in Math.fround forever, fidelity became a test gate. Every physics step goes through one scalar seam (packages/sim/src/scalar.ts):

/**
 * Round to f32 when STRICT_F32 is on; identity in production f64 mode.
 * Wrap the result of each arithmetic step in ported physics to get Pascal
 * `Single` semantics under the golden master: `a = f(a + f(b * c))`.
 */
export const f: (x: number) => number =
  STRICT_F32 ? Math.fround : (x: number): number => x;

The whole suite runs twice, plain f64 and STRICT_F32=1, and the graph's adversarial reviewers kept the porting honest:

⬢ 55 · RNG is not Pascal-bit-compatible, caps golden-master scope⬢ 73 · M8 'sandboxed ScriptHost' is not sandboxed

The pacifist-bot bug and the black-map bug shared a shape: perfectly typed, perfectly tested, completely broken. The bots-can't-see-each-other fix is still in packages/client/src/app/game.ts:857, comment and all:

// promoting `s.alpha = 255` to both modes is the one-line fix). Combat
s.alpha = 255;

The ported perception code skips invisible sprites exactly as the Pascal does, and nothing in the new spawn path ever set alpha. Every bot was, by its own rules, invisible to every other bot. The review node that predicted this class of failure, before it happened:

⬢ 68 · Seven milestones green by typecheck+unit-test, zero ground-truth validation

Since then, every feature ends with a headless-browser check. Types and tests are one category of truth; pixels are another.

The faithful-first rule bends, but it has to say so in the code. The jets are the canonical example, the override and its regression round both live in the graph and in the test names (packages/sim/src/step.control.test.ts):

// DESIGN OVERRIDE (decision node 94): rocket boots favor UP. While the jet
// is held, up-force runs 1.8× and lateral drift is damped to half.

// DESIGN OVERRIDE regressions (node 100): "boots still wrong" round.

Same pattern for the air-fuel trickle: coasting regenerates exactly the burn rate, so a 50% thrust duty cycle hovers forever but climbing still spends the tank. Skyreach v2 added the ceiling slab after telemetry caught mean altitude running away to −361.

⬢ 94 · rocket boots favor UP⬢ 100 · the 'boots still wrong' regression round

The entire contract that made sixteen brains possible is small enough to quote (packages/client/src/ai/engine.ts):

export interface BotBrain {
  tick(botIndex: number, ctx: BotEngineContext): void;
}

Three rules guard it: brains read the world but never mutate it (same rule as the telemetry observers, or determinism dies), randomness comes from world.rng and never Math.random, and the seam lives at the client layer because ammo, reload state, and spawn points live there. The ported Pascal AI became classic with a regression test pinning play mode byte-identical, so the baseline can never silently drift while the arms race rages above it.

Kestrel's edge was archaeology, not aim. Every earlier brain compensated for the soldier's gravity; bullets fall 2.25× harder. The discovery is one constant now (kestrel.ts:88):

DROP_G: 0.135, // px/tick² — TRUE bullet gravity (GRAV 0.06 × 2.25)

And wolf's whole pack doctrine is a deterministic function, which is exactly what made it beatable. From the prey selection (wolf.ts):

// Two tiers: inside PREY_RADIUS of the centroid, lowest health wins
// (kill-securing); a wounded enemy beyond it doesn't drag the pack
// across the map past healthy guns — outside the radius only the
// nearest-to-centroid counts, as a fallback when nobody is in reach.

Plover read that function and fed it a decoy. Hydra rotated its wounded out of it. Determinism cuts both ways: a published mind is an attackable mind.

The sport self-runs on two small pieces of code. The commissioner (arena-live/commissioner.mjs) forces fresh blood into title fights on a timer:

// THE COMMISSIONER — automated "fresh blood" title defenses.
//   challenger = the card whose coach+engine appears LEAST in the
//   recent crucible ledger; then:
//   pnpm arena fight fights/<challenger> fights/<champion> --matches 3

And the Big Board rewards showing up: every result is weighted by exponential age decay (build.mjs, decayWeight(), halving every few hours), an idle champion bleeds score until defending is cheaper than hiding. The online 1v1 lobby rides the same machinery:

⬢ 450 · True multiplayer: two visitors matched into one live 1v1

The learned line is a chain of honest negative results, each one logged before the next attempt. The graph reads like a lab notebook:

⬢ 473 · train a v2 model brain (features v2 + hit-filtered aim)⬢ 485 · NEGATIVE RESULT (clean): PRODIGY worse than DISCIPLE by −9.83 kills/match, p=3e-64⬢ 484 · exposure bias: live aim error 26.6° with history vs 7.9° without → 50% history dropout⬢ 481 · parity bug: tap cadence phase-locks to tick parity, shot rows ALWAYS sample⬢ 489 · PRODIGY v2 verdict: aim improved, hit% 5.4 vs 17.4, trigger discipline lost⬢ 504 · BUTTSTEIN: replay schema v2, exact threats + spray heat, blended aim labels

The buttstein trainer (tools/train-buttstein.mjs) ships the cures as flags, blended aim labels where landed shots carry 5× gradient, and the exposure-bias fix:

const HIT_WEIGHT   = Number(flag('hit-weight', 5));    // landed rows: 5× gradient
const HIST_DROPOUT = Number(flag('hist-dropout', 0.5)); // forget history half the time

All of it pure JavaScript, a hand-rolled MLP over Float64Arrays, no ML framework, trained on the same machine that plays the matches.

Half the engineering lives in tools/, instruments the project built to study itself.

The screenshot rig (tools/screenshot.mjs), every historical image on this page came through it. Its own header explains the problem it solves:

// Why CDP and not `chrome --screenshot --virtual-time-budget`: the game
// boots asynchronously (PixiJS init, async asset fetches, RAF loop) and
// virtual time expires before the first real frame, producing a black
// capture. Driving Chrome over the DevTools protocol lets us wait REAL
// seconds while the match actually plays, then grab the canvas mid-action.

It spawns a throwaway-profile Chrome, holds keys down (that's why the first-light player is mid-jump), dispatches wheel events for close-ups, and shot the historical builds from git worktrees serving four eras on four ports.

The analyst (analyze-match.mjs) turns a telemetry dump into a gameplay report, it's what caught the bots fighting like infantry (jet use 2–4%) and proved the Skyreach fix (47–56%).

The smoke driver (online-smoke.mjs) speaks the real binary protocol as two fake players to prove the whole online 3v3 loop, pairing, snapshots, kill feed, with no browser at all.

The disk rescuer (offload-replays.mjs) moves replay blobs to object storage, verified before deleting, manifests, events, and telemetry stay forever, because the site re-simulates replays from seeds anyway.

The autopilot (autopilot.mjs, evolve.mjs, autopilot-gate.mjs) runs the whole lab unattended: pick a teacher, train, gauntlet the result against the veterans, and only ship weights that win, rejected candidates leave a ledger entry instead of a regression.

And the graph itself: a hook blocks file edits unless a decision node was logged in the last fifteen minutes. The work cannot happen without the record of why.