diff --git a/docs/prd/CLIENTSIDE_AI_SNAKE_MOUNTAINCAR_PRD.md b/docs/prd/CLIENTSIDE_AI_SNAKE_MOUNTAINCAR_PRD.md
new file mode 100644
index 0000000..3e18184
--- /dev/null
+++ b/docs/prd/CLIENTSIDE_AI_SNAKE_MOUNTAINCAR_PRD.md
@@ -0,0 +1,211 @@
+# Client-side AI for Snake & MountainCar (PRD & Plan) — M33
+
+> **Goal (user's steer):** do for the remaining WebSocket-AI games what M32 did for FruitCake — move the env
+> **dynamics** + **observation** + **net forward** (+ any serving "wrapper" like masking) into a MintPlayer.Polyglot
+> `.pg` where feasible, ship the trained **checkpoint** as a browser asset, run the AI **client-side**, and delete
+> the server serving path. Per-viewer server inference/streaming → **zero**.
+
+- **Status:** ✅ **IMPLEMENTED — both games client-side, 2026-07-05.** Snake + MountainCar AI now run entirely in
+  the browser (single-source `.pg` env+obs+net, C# facades, browser directors, server path + `EpisodeStreamer`
+  retired). Verified host + Playwright (Snake ate 40; MountainCar reaches the flag), 0 console errors, 0 `/api/*`
+  AI calls. Branch `snake-clientside-ai`. See PLAN.md M33 for commit refs.
+- **Author:** Pieterjan (with Claude Code)
+- **Precedent:** `FRUITCAKE_CLIENT_SIDE_AI_PRD.md` (M32, shipped) — the pattern this replicates.
+
+---
+
+## 1. Scope — exactly two games
+
+The only games whose AI "watch" mode holds an open WebSocket are **Snake** (`/api/snake/live`) and **MountainCar**
+(`/api/mountaincar/live`), both driven by the shared `EpisodeStreamer`. The other three are **request/response REST**
+batch solvers with no per-viewer socket, so they need nothing here:
+- **2048** — `POST /api/2048/solve` (expectimax, one response).
+- **RushHour** — `POST /api/rushhour/solve` (policy-guided A*, one response).
+- **Cube** — `POST /api/cube/solve*` (beam search, one response).
+
+So M33 = **Snake + MountainCar**, as **two independent PRs** (they share only `EpisodeStreamer` and the checkpoint
+parser). **Snake first** (clean, high-value, lowest new-code); MountainCar second (has a real complication — §5).
+
+---
+
+## 2. What we confirmed (3-agent investigation + Polyglot 0.2.0 probes, 2026-07-05)
+
+### Polyglot 0.3.0 (verified 2026-07-05 — supersedes the 0.2.0 notes below)
+**0.3.0 fixes all of #11** (verified by probe): **transcendentals added** (`cos`/`sin`/`tan`/`exp`/`log`/`pow`/`tanh`
+— emit `System.Math.Cos`/`Math.cos` etc.); **module imports now LINK** (TS emits `import {…} from "./nn"`, C# no
+longer inlines → a shared `nn.pg` is viable, no CS0101); **`i32()` TS wrap fixed** (`Math.trunc(x)`, no `|0`). #9
+stays fixed. **Consequence: MountainCar's transcendental fork DISSOLVES** — `cos`/`tanh` can now be written directly
+in a `.pg`; the C#↔TS sub-ULP drift is harmless (no server twin post-cutover, argmax-robust), so MountainCar gets the
+same uniform full-Polyglot treatment as Snake (no poly-approx). §5's Option A is now the clean default. The
+Environments `.csproj` is bumped 0.1.4 → **0.3.0** (FruitCake TS codegen verified content-identical, 22 tests green).
+
+### ⚠️ BLOCKER discovered (MintPlayer.Polyglot#14) — multi-`.pg` prelude collision
+Adding a **second** `.pg` (Snake) to the Environments project fails to compile: **every transpiled `.pg` emits its
+own copy of the prelude** (`Option`/`Some`/`None` records + `PolyglotProgram`), so two generated `.cs` in one
+assembly hit **CS0101 duplicate** (+ CS8863). FruitCake only worked as the *sole* `.pg`. This contradicts the
+package targets' own §4.5 comment ("linked build → each type defined once → no CS0101") — the *import* linking works,
+but the auto-emitted prelude isn't deduped. **`snake_solver.pg` is written, type-checks, and generates correct
+C#/TS individually**, but is **parked** (excluded via `PolyglotFile Remove` in the csproj) until the fix. Given the
+0.1.4→0.2.0→0.3.0 turnaround, waiting for a prelude-dedup fix is preferred over a per-game-project workaround. Once
+fixed: delete the `Remove`, then continue SN1–SN6 (facade, parity tests, parser reuse, director, retire server).
+
+### Polyglot 0.2.0 (historical)
+- **All three M32 codegen bugs are FIXED** (issue MintPlayer.Polyglot#9, closed): `i32()/f64()` casts now lower to
+  `(int)x` / `Math.trunc(x)|0` / `(double)n`; `var x: T? = null` emits a typed decl; 2+ nested-generic params parse.
+  ⇒ **new `.pg` files can use casts, nullable locals, and nested generics freely** (no M32 workarounds needed).
+- **Integer `/` and `%` codegen correctly** (`a/b` → `(a/b|0)` in TS; `a%b` → `(a%b|0)`) — Snake's grid index math
+  (`head/Size`, `head%Size`, non-negative) is clean.
+- **std.math has NO transcendentals.** Only `abs`, `floor`, `sqrt` (+ `min`/`max`) exist; **`cos`, `sin`, `exp`,
+  `pow`, `tanh` are absent** — consistent with "only `+ − × ÷ √` are byte-identical across .NET and JS." This is the
+  crux for MountainCar (§5).
+- **User `.pg`→`.pg` imports DO work** (`import { X } from "./nn"` and `from "nn"` both check + build) — but via
+  **inlining**: the importer's output gets a *full copy* of the imported symbols (no cross-module reference emitted).
+  In the MSBuild "glob every `**/*.pg` → compile all into one assembly" setup, a standalone library `.pg` would then
+  be defined **twice** (once from its own transpile, once inlined into the importer) → CS0101 duplicate type. A shared
+  `nn.pg` is therefore feasible only if the library file is **excluded from the C# transpile glob** (and not committed
+  as a standalone TS). ⇒ **For two games, duplicate the net-forward per game** — Snake copies `PgDuelingNet` verbatim
+  (~70 lines), MountainCar gets a small `PgMlpNet`; the tiny duplication is simpler than the build-config work a
+  shared module needs. (Revisit a shared `nn.pg` only if a third+ net-bearing game appears.)
+
+### Checkpoint parser generalization
+The `.ckpt` envelope (`CheckpointFormat`) is shared: `RLNC` magic + 7-bit-length kind string + int32 version, then
+length-prefixed int/float/bool blocks. Two payload shapes:
+- **`dueling-q`** (Snake) — identical to FruitCake. **`fruitcake-net.ts` parses it unchanged.**
+- **`mlp`** (MountainCar) — `Ints Sizes` + `byte HiddenActivation` + per-layer `(W, b)` floats.
+⇒ Lift the shared header/primitive readers out of `fruitcake-net.ts` into a **shared `ckpt.ts`** (`parseDuelingQNet`
++ a new `parseMlp`); each game's loader hands the parsed tensors to *its* generated net class.
+
+### EpisodeStreamer
+`src/RLDemo.Web/Services/EpisodeStreamer.cs` is used **only** by Snake + MountainCar → **deletable** once both
+migrate (delete in whichever PR lands second).
+
+---
+
+## 3. Snake — full Polyglot client-side port (the clean one)
+
+**Facts** (`Environments/Snake/SnakeEnv.cs`; net `snake.dqn.ckpt`):
+- **Observation = 177** (a 9×9×2 egocentric patch = 162, + 15 scalars). *(Note: the "8-ray obs" memory is stale —
+  it's the 177-wide patch.)* Pure integer/`+−×÷` math → **byte-identity is free**.
+- **Net = plain `DuelingQNet` 177 → [256,256] → 4**, checkpoint kind `dueling-q` v1 → **reuse `PgDuelingNet.forward`
+  and the existing parser verbatim.**
+- **No search** — one greedy, **masked** Q-step per tick. Much simpler than FruitCake.
+- **The "wrapper" that must move to the browser = the action mask** (`CurrentActionMask` + `ReachableFreeSpace`):
+  (a) forbid the 180° reversal onto the neck; (b) the **anti-self-trap shield** — a **BFS flood-fill** keeping only
+  moves whose reachable free space ≥ snake length (never all-false). The net was trained *with* this shield
+  (`safeMask:true`), so serving must reproduce it exactly.
+- **Collections to re-express** (the main porting effort): `SnakeEnv` uses `LinkedList<int>` (body), `HashSet<int>`
+  (occupancy), `Queue<int>` (BFS) — Polyglot's `std.collections` is `List<T>` only. Re-express as: body =
+  `List<i32>` used as a deque (add-front / remove-last); occupancy = `List<bool>` of size `Cells`; BFS = `List<i32>`
+  + head cursor, `seen` = `List<bool>`. All flat, all integer.
+- **Food RNG** → `Math.random` client-side (nondeterministic, fine for a watch view; no need to port Xoshiro).
+- **Rendering** is a CSS-grid of `<div>`s (not canvas). Director `toFrame()` → `{body, food, foodEaten, done,
+  length}`, so the existing `render()` is unchanged. **Discrete tick** — reuse a `setInterval`/timer (like human
+  mode), not a RAF physics loop.
+
+### Snake plan (SN0–SN6) — ✅ DONE 2026-07-05
+> **Shipped (branch `snake-clientside-ai`).** `snake_solver.pg` single-sources the dynamics + 177-dim observation +
+> action mask (incl. the flood-fill shield) + `PgSnakeNet`; C# `SnakeEnv` is now a facade over it (9 SnakeEnvTests
+> green). Net shipped at `ClientApp/public/snake-net.ckpt` (+ `snake-net.ts` parser); `SnakeDirector` runs the AI in
+> the browser; server path (controller/service/`snake-api.ts`/stale net/`SnakeApiTests`) deleted. Verified host +
+> Playwright: the AI plays (ate 40, length ~35), 0 console errors, weights from `/snake-net.ckpt`, **0 `/api/snake`
+> calls**. Flood-fill was rewritten BFS→relaxation to dodge a Polyglot evolving-any TS7022 (net-agnostic; MintPlayer.Polyglot#14 was the multi-.pg prelude fix in 0.3.1).
+- **SN0 — `snake_solver.pg` scaffold + env dynamics.** Port `SnakeEnv` step (move/grow/collision/food, tail-follow
+  ordering) into `PgSnakeEnv` over flat `List` collections; bump the Environments `.csproj` Polyglot ref to **0.2.0**.
+  Gate: builds; a C# facade delegates; parity test vs `SnakeEnv` step outcomes.
+- **SN1 — observation in the `.pg`.** `buildObservation() -> f64[177]` (9×9×2 patch + 15 scalars + the flood-fill
+  free-space features). Gate: reproduces `SnakeEnv.Observation()` exactly (integer math → exact, not tolerance).
+- **SN2 — action mask in the `.pg`.** `currentActionMask() -> [bool;4]` (reversal + flood-fill shield). Gate: matches
+  `SnakeEnv.CurrentActionMask()` on played boards.
+- **SN3 — net forward.** Copy `PgDuelingNet` into `snake_solver.pg` (verbatim from FruitCake). Gate: argmax-exact vs
+  SDK `DuelingQNet.Forward` (reuse the M32 parity-test pattern).
+- **SN4 — checkpoint delivery + shared parser.** Copy `models/snake.dqn.ckpt` → `ClientApp/public/snake-net.ckpt`
+  (LFS); refactor `fruitcake-net.ts` → shared `ckpt.ts` (`parseDuelingQNet` unchanged). Gate: browser parses it →
+  177/[256,256]/4.
+- **SN5 — client director + rewire watch mode.** `snake-director.ts`: masked greedy step over `PgSnakeEnv` +
+  `PgDuelingNet`, `toFrame()` for the existing renderer; rewrite `snake.ts` watch mode to drive it (drop
+  `snake-api.ts`). Reconcile human-play `snake-logic.ts` onto the single-source `PgSnakeEnv` (eliminate the twin).
+  Gate: host + Playwright — Snake AI plays in-browser, 0 console errors, 0 `/api/snake` calls.
+- **SN6 — retire server path.** Delete `SnakeController`, `SnakeModelService` (+ `Program.cs` regs), `snake-api.ts`,
+  stale `models/snake.dqn.ckpt`; update `SnakeApiTests`. Gate: build + tests green; Playwright watch still works.
+
+---
+
+## 4. Reusable M32 machinery (both games)
+
+Build-time C# transpile via `MintPlayer.Polyglot.MSBuild` (bump **0.1.4 → 0.2.0**); committed generated `.ts`
+(regenerate on Windows with `polyglot build … --target typescript`); the internal-core + public-facade pattern +
+`InternalsVisibleTo` for tests; **`.ckpt` committed directly to `ClientApp/public/` via LFS** (M32 did *not* use an
+MSBuild copy — the asset is committed); the async-load client **director**; and the **Polyglot-C# == SDK-C#
+equivalence tests** (+ C#↔TS byte-identity free for integer/`+−×÷√` code).
+
+---
+
+## 5. MountainCar — the transcendental fork (needs a decision)
+
+MountainCar is tiny (env ≈ 15 lines; net = `Mlp [2,64,64,3]`), but it has **two transcendentals on the client path**,
+and **neither can be written in a `.pg`** (std.math has no `cos`/`tanh`):
+1. **`cos(3·position)`** in the env dynamics (every step).
+2. **`tanh`** — the PPO actor's hidden activation (`Mlp`, `Activation.Tanh`). Serving = `argmax` over 3 logits.
+
+(The observation itself — `(pos+0.3)/0.9`, `vel/MaxSpeed` — is pure `+−×÷`, so the *net input* is byte-safe; the
+checkpoint is kind `mlp`, needing a new `parseMlp` + a `PgMlpNet` forward.)
+
+> **UPDATE (Polyglot 0.3.0):** `cos` and `tanh` are now in std.math, so both CAN be written in a `.pg`. They are not
+> byte-identical across C#/TS (~1 ULP), but that no longer matters (no server twin after cutover; argmax-robust). So
+> **Option A is now the clean default — no polynomial approximations needed.** The fork below is retained for record.
+
+So MountainCar **cannot** get FruitCake's "byte-identical single source" for free. Two viable approaches:
+
+- **Option A — uniform Polyglot, with byte-identical polynomial approximations of `cos` and `tanh`** (pure `+−×÷`).
+  *Pro:* true single-source + C#↔TS byte-identity, matching the uniform goal. *Con:* the approximations change the
+  numbers vs the trained float32 `Math.Cos`/`Math.Tanh`, so it needs a **validation gate** (argmax unchanged across a
+  position/velocity sweep vs the real net) — feasible if the approximations are accurate (~1e-6), but real work and a
+  small risk of needing a re-eval/retrain.
+- **Option B — pragmatic client-side port, no Polyglot for the transcendental parts (RECOMMENDED).** Reuse the
+  existing hand-written `mountaincar-logic.ts` dynamics (it already has `Math.cos`), hand-write the ~30-line
+  `Mlp`+`tanh` forward in TS (JS `Math.tanh` — a ULP off .NET, argmax-robust), add `parseMlp`, ship the ckpt, delete
+  the socket. *Pro:* achieves the actual goal (zero server cost, client-side AI) with minimal work and **no net
+  perturbation**. *Con:* keeps a ~15-line C#/TS env twin (but MountainCar dynamics are stable and never change, so
+  drift risk is negligible), and doesn't "single-source via Polyglot."
+
+**Recommendation:** **Option B.** For a 15-line env whose twin never changes, Polyglot single-sourcing buys almost
+nothing, while the transcendentals actively fight it. The cost win (removing the socket) is identical either way.
+Reserve Option A only if *uniform Polyglot single-source* is a hard requirement — in which case gate it behind an
+approximation-accuracy spike (**MC0**) before committing.
+
+### MountainCar plan (MC0–MC5) — ✅ DONE 2026-07-05 (uniform Polyglot, per the 0.3.0 update above)
+> **Shipped.** `mountaincar_solver.pg` single-sources the dynamics (`cos`) + normalised obs + `PgMlpNet` (Tanh MLP,
+> argmax); C# `MountainCarEnv` is a facade (6 tests green, incl. the Gymnasium golden). Net at
+> `ClientApp/public/mountaincar-net.ckpt` + `mountaincar-net.ts` (`parseMlp`); `MountainCarDirector` runs it;
+> server path + `EpisodeStreamer` deleted; `app.UseWebSockets()` removed (no server WS left). Verified in-browser.
+- **MC0 (only if Option A) — approximation spike.** Implement `cos`/`tanh` in pure `+−×÷`; verify argmax matches the
+  real net across a state sweep. Pass → proceed Polyglot (mirror Snake's SN plan). Fail → fall back to Option B.
+- **MC1 — `parseMlp` in the shared `ckpt.ts`** (Sizes + activation byte + per-layer W/b).
+- **MC2 — TS `Mlp` forward** (`mountaincar-net.ts`: linear + tanh per hidden layer, linear head, argmax). Gate:
+  matches SDK `Mlp.Forward`/`PolicyAgent.Act` argmax on a state sweep.
+- **MC3 — checkpoint delivery.** Copy `models/mountaincar.ppo.ckpt` → `ClientApp/public/mountaincar-net.ckpt` (LFS).
+- **MC4 — client director + rewire.** `mountaincar-director.ts`: obs → net → argmax → step (reuse `mountaincar-logic.ts`
+  dynamics) → render; rewrite `mountaincar.ts` watch mode (drop `mountaincar-api.ts`). Gate: Playwright — plays,
+  0 console errors, 0 `/api/mountaincar` calls.
+- **MC5 — retire server path + delete `EpisodeStreamer`.** Delete `MountainCarController`, `MountainCarModelService`
+  (+ regs), `mountaincar-api.ts`, `EpisodeStreamer.cs` (now unused), stale `models/mountaincar.ppo.ckpt`; update
+  `MountainCarApiTests`. Gate: build + tests green; Playwright watch works.
+
+---
+
+## 6. Risks
+
+| Risk | Game | Mitigation |
+|---|---|---|
+| Action-mask shield (flood-fill) must be reproduced exactly in the browser | Snake | Port `CurrentActionMask` + `ReachableFreeSpace` to the `.pg`; equivalence-test vs `SnakeEnv`. Integer math → exact. |
+| Collection re-expression (LinkedList/HashSet/Queue → List) introduces a bug | Snake | Parity test the ported step + obs + mask against `SnakeEnv` on many played boards. |
+| `cos`/`tanh` can't be in a `.pg` → no byte-identity | MountainCar | Option B (recommended) sidesteps it (hand-port, argmax-robust); Option A gates on an accuracy spike. |
+| Net perturbation from approximations | MountainCar (Opt A only) | MC0 spike validates argmax parity before committing. |
+| Deploy: LFS asset must reach the SPA build | both | Same as M32 (verified): `playground-docker.yml` `lfs:true` + Dockerfile `COPY ClientApp/` before `npm build`; Angular serves `public/**`. |
+
+---
+
+## 7. Non-goals
+- 2048 / RushHour / Cube (request/response, no socket).
+- Retraining Snake or MountainCar (ship the existing checkpoints; both play well today).
+- A shared `nn.pg` (user `.pg` imports unsupported — duplicate per game).
diff --git a/docs/prd/PLAN.md b/docs/prd/PLAN.md
index 082350d..6bf7b29 100644
--- a/docs/prd/PLAN.md
+++ b/docs/prd/PLAN.md
@@ -1103,6 +1103,29 @@ in parallel). **Supersedes PG4.** Also advances MintPlayer.Polyglot (FruitCake i
 > architecture):** the shipped browser net is the **G3** net; if its net+search play quality (G4 A/B vs the
 > ~50%-watermelon / ~2505 bar) is unsatisfying, retrain (M30/G4) and replace `ClientApp/public/fruitcake-net.ckpt`.
 > Still recommended: **split into separate PRs** (NetTransfer is independently mergeable; M30/M31/M32 are entangled).
+> **UPDATE: merged to master via PR #23 (single PR) 2026-07-05.** A/B ship-as-is (2493 / 49% watermelon, on par).
+
+## M33 — Client-side AI for Snake & MountainCar  *(planned — see `CLIENTSIDE_AI_SNAKE_MOUNTAINCAR_PRD.md`)* 🔜
+
+Extend M32 to the **only two remaining WebSocket-AI games** (2048/RushHour/Cube are request/response REST → out of
+scope). A 3-agent investigation + Polyglot **0.2.0** probes (2026-07-05) confirmed: 0.2.0 **fixed all three M32
+codegen bugs** (#9 closed — casts / null-typed-locals / nested-generics now work); std.math still has **no
+transcendentals** (only `abs`/`floor`/`sqrt`/`min`/`max`); **user `.pg`→`.pg` imports work but *inline* the imported
+symbols** (a standalone library `.pg` would double-define under the glob-all build) → **duplicate the net-forward per
+game** (simpler than the glob-exclusion a shared `nn.pg` needs); the `.ckpt` parser generalizes to one shared `ckpt.ts`
+(`dueling-q` + a new `mlp` branch);
+`EpisodeStreamer` is used only by these two → deletable when both migrate. **Two independent PRs, Snake first.**
+- **Snake — ✅ DONE (client-side, verified in-browser).** obs **177** (9×9×2 patch + 15 scalars; the "8-ray" memory is stale); net =
+  plain `DuelingQNet 177→[256,256]→4` → **reuses `PgDuelingNet` + the parser verbatim**; **no search** (one greedy
+  masked Q-step). Real work: port the **action mask** (reversal + anti-self-trap **flood-fill shield**, load-bearing —
+  net trained with it) and re-express `LinkedList`/`HashSet`/`Queue` as flat `List`s. Pure integer math → byte-identity
+  free. Plan SN0–SN6.
+- **MountainCar — ✅ DONE (client-side, verified; uniform Polyglot — 0.3.0 added cos/tanh).** Two transcendentals on the client path (`cos(3·pos)` in the env, **`tanh`**
+  in the PPO `Mlp` net) — **neither writable in a `.pg`**. **Recommended: Option B** — pragmatic client-side hand-port
+  (reuse `mountaincar-logic.ts` dynamics, ~30-line TS `Mlp`+`tanh` forward, new `parseMlp`, ship ckpt, delete socket);
+  no net perturbation, keeps a trivial ~15-line env twin. **Option A** (uniform Polyglot with byte-identical `cos`/`tanh`
+  polynomial approximations) only if uniform single-source is a hard requirement, gated on an argmax-parity spike (MC0).
+  Plan MC0–MC5. **Payoff:** the last two per-viewer AI sockets → zero server inference.
 
 ## Testing strategy (cross-cutting, from research)
 
diff --git a/src/MintPlayer.AI.ReinforcementLearning.Environments/MintPlayer.AI.ReinforcementLearning.Environments.csproj b/src/MintPlayer.AI.ReinforcementLearning.Environments/MintPlayer.AI.ReinforcementLearning.Environments.csproj
index f4c13d4..c81fcff 100644
--- a/src/MintPlayer.AI.ReinforcementLearning.Environments/MintPlayer.AI.ReinforcementLearning.Environments.csproj
+++ b/src/MintPlayer.AI.ReinforcementLearning.Environments/MintPlayer.AI.ReinforcementLearning.Environments.csproj
@@ -9,7 +9,7 @@
        build-only transpiler OUT of this published package's dependencies. The 0.1.3+ CLI is bundled for
        win-x64/linux-x64/linux-arm64 (covers Windows dev + Linux CI/deploy); macOS dev must set $(PolyglotTool). -->
   <ItemGroup>
-    <PackageReference Include="MintPlayer.Polyglot.MSBuild" Version="0.1.4" PrivateAssets="all" />
+    <PackageReference Include="MintPlayer.Polyglot.MSBuild" Version="0.3.1" PrivateAssets="all" />
   </ItemGroup>
 
   <!-- The generated solver types (PgFruitCakeWorld etc.) are internal; the public FruitCakeWorld facade wraps
diff --git a/src/MintPlayer.AI.ReinforcementLearning.Environments/MountainCar/polyglot/mountaincar_solver.pg b/src/MintPlayer.AI.ReinforcementLearning.Environments/MountainCar/polyglot/mountaincar_solver.pg
new file mode 100644
index 0000000..2c4572d
--- /dev/null
+++ b/src/MintPlayer.AI.ReinforcementLearning.Environments/MountainCar/polyglot/mountaincar_solver.pg
@@ -0,0 +1,152 @@
+// mountaincar_solver.pg — single-source MountainCar env + inference (M33), transpiled to C# and TS.
+//
+// ONE source for the classic-control dynamics + observation + the PPO policy forward pass, so the C# training/eval
+// env AND the browser "watch AI" run the same logic. Unlike FruitCake/Snake this uses transcendentals — `cos` in
+// the dynamics and `tanh` in the net (Polyglot 0.3.0+ std.math). Those are NOT byte-identical across .NET and JS
+// (~1 ULP), but there's no server twin after the cutover and the decision is argmax over 3 logits (robust to sub-ULP
+// drift), so it's harmless. The C# side is exact (same Math.Cos/Math.Tanh as before).
+//
+// Generated C# is transpiled at build; the TS is committed (mountaincar_solver.ts), regenerated on Windows:
+//   polyglot build mountaincar_solver.pg --target typescript --out <clientapp>
+
+import { List } from "std.collections"
+import { Math } from "std.math"
+
+fn clampF(v: f64, lo: f64, hi: f64): f64 => Math.min(hi, Math.max(lo, v))
+
+// ── PPO policy net (Mlp): Linear + Tanh per hidden layer, linear output; serving = argmax over the logits ──
+// Flat weights (all layers concatenated) with per-layer offsets derived from `sizes` = [in, h.., out].
+class PgMlpNet {
+  var sizes: List<i32>       // [inputSize, hidden…, outputSize]
+  var wFlat: List<f64>       // per layer, row-major [in, out], concatenated
+  var bFlat: List<f64>       // per layer [out], concatenated
+
+  init(sizes: List<i32>, wFlat: List<f64>, bFlat: List<f64>) {
+    this.sizes = sizes
+    this.wFlat = wFlat
+    this.bFlat = bFlat
+  }
+
+  // Single-observation forward → output logits (length sizes[last]).
+  fn forward(input: List<f64>): List<f64> {
+    var x = input
+    var wOff = 0
+    var bOff = 0
+    let layers = this.sizes.count - 1
+    for l in 0..layers {
+      let inDim = this.sizes[l]
+      let outDim = this.sizes[l + 1]
+      x = linear(x, this.wFlat, wOff, this.bFlat, bOff, inDim, outDim)
+      wOff += inDim * outDim
+      bOff += outDim
+      if l < layers - 1 { x = tanhv(x) } // hidden activation; output layer is linear
+    }
+    return x
+  }
+
+  static fn linear(x: List<f64>, w: List<f64>, wOff: i32, b: List<f64>, bOff: i32, inDim: i32, outDim: i32): List<f64> {
+    var out: List<f64> = List<f64>()
+    for o in 0..outDim {
+      var s = b[bOff + o]
+      for i in 0..inDim { s += x[i] * w[wOff + i * outDim + o] }
+      out.add(s)
+    }
+    return out
+  }
+
+  static fn tanhv(x: List<f64>): List<f64> {
+    var out: List<f64> = List<f64>()
+    for v in x { out.add(Math.tanh(v)) }
+    return out
+  }
+}
+
+// ── MountainCar-v0 (faithful port of MountainCarEnv.cs) ──────────────────────────────────────────────────────
+class PgMountainCarEnv {
+  const MinPosition: f64 = -1.2
+  const MaxPosition: f64 = 0.6
+  const MaxSpeed: f64 = 0.07
+  const GoalPosition: f64 = 0.5
+  const Force: f64 = 0.001
+  const Gravity: f64 = 0.0025
+  const ShapeScale: f64 = 13.0
+  const ActionCount: i32 = 3
+
+  var maxEpisodeSteps: i32
+  var shapeReward: bool
+  var position: f64
+  var velocity: f64
+  var elapsedSteps: i32
+  var done: bool
+  // Step outputs (read by the C# training facade).
+  var lastReward: f64
+  var lastTerminated: bool
+  var lastTruncated: bool
+
+  init(maxEpisodeSteps: i32, shapeReward: bool) {
+    this.maxEpisodeSteps = maxEpisodeSteps
+    this.shapeReward = shapeReward
+    this.position = 0.0
+    this.velocity = 0.0
+    this.elapsedSteps = 0
+    this.done = true
+    this.lastReward = 0.0
+    this.lastTerminated = false
+    this.lastTruncated = false
+  }
+
+  // Start a fresh episode at the given position (caller draws it ~U[-0.6,-0.4]; RNG stays host-side), velocity 0.
+  fn reset(startPos: f64) {
+    this.position = startPos
+    this.velocity = 0.0
+    this.elapsedSteps = 0
+    this.done = false
+  }
+
+  // Pin the physics state directly (golden-trajectory tests, demos).
+  fn setState(pos: f64, vel: f64) {
+    this.position = pos
+    this.velocity = vel
+    this.elapsedSteps = 0
+    this.done = false
+  }
+
+  fn step(action: i32) {
+    var velocity = this.velocity + f64(action - 1) * Force + Math.cos(3.0 * this.position) * (0.0 - Gravity)
+    velocity = clampF(velocity, 0.0 - MaxSpeed, MaxSpeed)
+    var position = clampF(this.position + velocity, MinPosition, MaxPosition)
+    if position <= MinPosition && velocity < 0.0 { velocity = 0.0 } // inelastic left wall
+
+    this.position = position
+    this.velocity = velocity
+    this.elapsedSteps = this.elapsedSteps + 1
+
+    let terminated = position >= GoalPosition
+    let truncated = !terminated && this.elapsedSteps >= this.maxEpisodeSteps
+    this.done = terminated || truncated
+
+    var reward = 0.0 - 1.0
+    if this.shapeReward { reward += ShapeScale * Math.abs(velocity) }
+    this.lastReward = reward
+    this.lastTerminated = terminated
+    this.lastTruncated = truncated
+  }
+
+  // Observation normalised to ~[-1,1]: position centred on −0.3 (half-range 0.9), velocity ÷ MaxSpeed.
+  fn buildObservation(): List<f64> {
+    var obs: List<f64> = List<f64>()
+    obs.add((this.position + 0.3) / 0.9)
+    obs.add(this.velocity / MaxSpeed)
+    return obs
+  }
+
+  // The full single-source decision: argmax over the policy logits (mirrors PolicyAgent.Act greedy → Categorical.Mode).
+  fn chooseAction(net: PgMlpNet): i32 {
+    let logits = net.forward(this.buildObservation())
+    var best = 0
+    for a in 1..logits.count {
+      if logits[a] > logits[best] { best = a }
+    }
+    return best
+  }
+}
diff --git a/src/MintPlayer.AI.ReinforcementLearning.Environments/MountainCarEnv.cs b/src/MintPlayer.AI.ReinforcementLearning.Environments/MountainCarEnv.cs
index 07668cd..c3fcf93 100644
--- a/src/MintPlayer.AI.ReinforcementLearning.Environments/MountainCarEnv.cs
+++ b/src/MintPlayer.AI.ReinforcementLearning.Environments/MountainCarEnv.cs
@@ -5,16 +5,14 @@
 namespace MintPlayer.AI.ReinforcementLearning.Environments;
 
 /// <summary>
-/// Faithful port of Gymnasium MountainCar-v0 (classic_control/mountain_car.py): an underpowered car must
-/// build momentum by swinging back and forth to escape a valley. State [position, velocity], 3 actions
-/// (push left / none / right), reward −1 every step, terminated at the goal (position ≥ 0.5), truncated at
-/// the step cap. Solved: mean return ≥ −110 over 100 episodes.
-/// <para>
-/// Two training aids (off by default to keep the env v0-faithful for eval): <c>maxEpisodeSteps</c>
-/// can be raised above 200 during training so a fresh high-entropy policy ever reaches the goal (the −1 reward
-/// is otherwise flat and PPO never bootstraps), and <c>shapeReward</c> adds a small speed-gain bonus as a
-/// fallback if plain PPO stalls. Gate/eval always use the standard 200-step, unshaped env.
-/// </para>
+/// Gymnasium MountainCar-v0 as an RL environment — a <b>public facade</b> over the single-source transpiled core
+/// (<c>MountainCar/polyglot/mountaincar_solver.pg</c> → <c>PgMountainCarEnv</c>): the dynamics + normalised
+/// observation live <b>once</b> in the <c>.pg</c>, shared with the browser's <c>mountaincar_solver.ts</c> (M33).
+/// The facade re-adds host concerns: the <see cref="IEnvironment{T,U}"/>/<see cref="IStatefulEnvironment"/> API, the
+/// start-state RNG (a seeded <see cref="Xoshiro256StarStar"/>, kept out of the single source), state (de)serialization,
+/// and the throw-on-illegal-action contract. The C# dynamics stay byte-identical to the original (same
+/// <c>Math.Cos</c>); the browser's <c>cos</c>/<c>tanh</c> differ by ≤1 ULP but that's harmless (argmax decision, no
+/// server twin). State [position, velocity], 3 actions (push left/none/right), reward −1/step, terminated at the goal.
 /// </summary>
 public sealed class MountainCarEnv : IEnvironment<float[], int>, IStatefulEnvironment
 {
@@ -25,25 +23,13 @@ public sealed class MountainCarEnv : IEnvironment<float[], int>, IStatefulEnviro
     public const double Force = 0.001;
     public const double Gravity = 0.0025;
     public const int DefaultMaxEpisodeSteps = 200;
-    // Speed bonus (training only): reward += ShapeScale·|velocity|, comparable in magnitude to the −1 step
-    // cost (|v| ≤ 0.07 → bonus ≤ ~0.9). Drives the back-and-forth that builds momentum to escape the valley.
-    private const double ShapeScale = 13.0;
-
-    private readonly int _maxEpisodeSteps;
-    private readonly bool _shapeReward;
 
     private Xoshiro256StarStar _rng = new(0);
-    private double _position, _velocity;
-    private int _elapsedSteps;
-    private bool _done = true;
+    private readonly PgMountainCarEnv _core;
 
     public MountainCarEnv(int maxEpisodeSteps = DefaultMaxEpisodeSteps, bool shapeReward = false)
     {
-        _maxEpisodeSteps = maxEpisodeSteps;
-        _shapeReward = shapeReward;
-        // Observation is NORMALISED to ~[-1,1] (see Observation): raw velocity (~0.07) is ~14× smaller than
-        // raw position, so an un-normalised dense net effectively can't see velocity — the signal it must
-        // condition on to pump correctly. Normalising both is what makes the swing-up learnable.
+        _core = new PgMountainCarEnv(maxEpisodeSteps, shapeReward);
         ObservationSpace = new BoxSpace([-1f, -1f], [1f, 1f]);
         ActionSpace = new DiscreteSpace(3);
     }
@@ -51,66 +37,47 @@ public MountainCarEnv(int maxEpisodeSteps = DefaultMaxEpisodeSteps, bool shapeRe
     public Space<float[]> ObservationSpace { get; }
     public Space<int> ActionSpace { get; }
 
-    public double Position => _position;
-    public double Velocity => _velocity;
+    public double Position => _core.position;
+    public double Velocity => _core.velocity;
 
     public (float[] Observation, EnvInfo Info) Reset(ulong? seed = null)
     {
         if (seed.HasValue)
             _rng = new Xoshiro256StarStar(seed.Value);
-        _position = _rng.NextDouble(-0.6, -0.4);
-        _velocity = 0.0;
-        _elapsedSteps = 0;
-        _done = false;
+        _core.reset(_rng.NextDouble(-0.6, -0.4));
         return (Observation(), EnvInfo.Empty);
     }
 
     public StepResult<float[]> Step(int action)
     {
-        if (_done)
+        if (_core.done)
             throw new InvalidOperationException("Episode is done; call Reset() before stepping.");
         if (!ActionSpace.Contains(action))
             throw new ArgumentOutOfRangeException(nameof(action));
 
-        double velocity = _velocity + (action - 1) * Force + Math.Cos(3 * _position) * -Gravity;
-        velocity = Math.Clamp(velocity, -MaxSpeed, MaxSpeed);
-        double position = Math.Clamp(_position + velocity, MinPosition, MaxPosition);
-        if (position <= MinPosition && velocity < 0) velocity = 0.0; // inelastic left wall
-
-        _position = position;
-        _velocity = velocity;
-        _elapsedSteps++;
-
-        bool terminated = position >= GoalPosition;
-        bool truncated = !terminated && _elapsedSteps >= _maxEpisodeSteps;
-        _done = terminated || truncated;
-
-        double reward = -1.0;
-        if (_shapeReward) reward += ShapeScale * Math.Abs(velocity); // speed bonus (training aid)
-        return new StepResult<float[]>(Observation(), reward, terminated, truncated, EnvInfo.Empty);
+        _core.step(action);
+        return new StepResult<float[]>(Observation(), _core.lastReward, _core.lastTerminated, _core.lastTruncated, EnvInfo.Empty);
     }
 
     /// <summary>Pins the physics state directly (golden-trajectory tests, demos).</summary>
-    public void SetState(double position, double velocity)
+    public void SetState(double position, double velocity) => _core.setState(position, velocity);
+
+    private float[] Observation()
     {
-        (_position, _velocity) = (position, velocity);
-        _elapsedSteps = 0;
-        _done = false;
+        var core = _core.buildObservation();
+        return [(float)core[0], (float)core[1]];
     }
 
-    // Normalised to ~[-1,1]: position centred on −0.3 (half-range 0.9), velocity scaled by MaxSpeed.
-    private float[] Observation() => [(float)((_position + 0.3) / 0.9), (float)(_velocity / MaxSpeed)];
-
     public byte[] SaveState()
     {
         using var stream = new MemoryStream();
         using var writer = new BinaryWriter(stream);
         var (s0, s1, s2, s3) = _rng.GetState();
         writer.Write(s0); writer.Write(s1); writer.Write(s2); writer.Write(s3);
-        writer.Write(_position);
-        writer.Write(_velocity);
-        writer.Write(_elapsedSteps);
-        writer.Write(_done);
+        writer.Write(_core.position);
+        writer.Write(_core.velocity);
+        writer.Write(_core.elapsedSteps);
+        writer.Write(_core.done);
         writer.Flush();
         return stream.ToArray();
     }
@@ -119,16 +86,16 @@ public void RestoreState(byte[] state)
     {
         using var reader = new BinaryReader(new MemoryStream(state));
         _rng.SetState(reader.ReadUInt64(), reader.ReadUInt64(), reader.ReadUInt64(), reader.ReadUInt64());
-        _position = reader.ReadDouble();
-        _velocity = reader.ReadDouble();
-        _elapsedSteps = reader.ReadInt32();
-        _done = reader.ReadBoolean();
+        _core.position = reader.ReadDouble();
+        _core.velocity = reader.ReadDouble();
+        _core.elapsedSteps = reader.ReadInt32();
+        _core.done = reader.ReadBoolean();
     }
 
     public string RenderString()
     {
         const int width = 41;
-        int col = (int)Math.Round((_position - MinPosition) / (MaxPosition - MinPosition) * (width - 1));
+        int col = (int)Math.Round((_core.position - MinPosition) / (MaxPosition - MinPosition) * (width - 1));
         var sb = new StringBuilder();
         for (int i = 0; i < width; i++) sb.Append(i == col ? 'O' : i == width - 1 ? '|' : '_');
         return sb.ToString();
diff --git a/src/MintPlayer.AI.ReinforcementLearning.Environments/Snake/SnakeEnv.cs b/src/MintPlayer.AI.ReinforcementLearning.Environments/Snake/SnakeEnv.cs
index 092610d..2a53f8d 100644
--- a/src/MintPlayer.AI.ReinforcementLearning.Environments/Snake/SnakeEnv.cs
+++ b/src/MintPlayer.AI.ReinforcementLearning.Environments/Snake/SnakeEnv.cs
@@ -5,27 +5,21 @@
 namespace MintPlayer.AI.ReinforcementLearning.Environments.Snake;
 
 /// <summary>
-/// Classic Snake on a configurable <see cref="Size"/>×<see cref="Size"/> grid, as an RL environment
-/// (PLAN M22; observation reworked in M27). The observation is <b>egocentric and grid-size-invariant</b>: a
-/// <see cref="PatchSide"/>×<see cref="PatchSide"/> obstacle+food patch centred on the head, plus food
-/// direction/distance, heading, length, and a flood-fill of the open space reachable through each move. The
-/// flood-fill is what lets a long snake avoid trapping itself — a fixed window alone can't see a coil beyond its
-/// radius. Four absolute-direction actions; the single illegal action (the 180° reversal onto the neck) is masked
-/// via <see cref="IActionMaskProvider"/>. Walls and the snake's own body are NOT masked — death stays learnable.
-/// <para>
-/// Episodes end on death, a board-full win, a starvation timeout (<see cref="StarveLimit"/> steps without food),
-/// or an absolute safety ceiling — never a flat step cap, so high-score (long-snake) games are reachable.
-/// </para>
+/// Classic Snake on a configurable <see cref="Size"/>×<see cref="Size"/> grid as an RL environment (PLAN M22;
+/// egocentric observation M27). This is a <b>public facade</b> over the single-source transpiled core
+/// (<c>polyglot/snake_solver.pg</c> → <c>PgSnakeEnv</c>): the dynamics, the 177-dim egocentric observation, and the
+/// action mask (incl. the anti-self-trap flood-fill shield) live <b>once</b> in the <c>.pg</c>, shared bit-for-bit
+/// with the browser's <c>snake_solver.ts</c> (M33). The facade re-adds host concerns the shared core leaves out: the
+/// <see cref="IEnvironment{T,U}"/>/<see cref="IStatefulEnvironment"/> API, the food RNG (a seeded
+/// <see cref="Xoshiro256StarStar"/> — kept out of the single source so C# stays deterministic and the browser can use
+/// its own RNG), state (de)serialization, and the throw-on-illegal-action contract.
+/// <para>Four absolute-direction actions; the 180° reversal onto the neck is masked via
+/// <see cref="IActionMaskProvider"/>. Walls/body are NOT masked — death stays learnable. Episodes end on death, a
+/// board-full win, a starvation timeout, or an absolute ceiling (all in the core).</para>
 /// </summary>
 public sealed class SnakeEnv : IEnvironment<float[], int>, IActionMaskProvider, IStatefulEnvironment
 {
     public const int ActionCount = 4;
-
-    // Egocentric, grid-size-invariant observation (PLAN M27). A (2R+1)×(2R+1) patch centred on the head — two
-    // channels (obstacle = wall or non-vacating body; food) so a CNN can read it spatially — followed by scalar
-    // features: food direction (2) + L1 distance (1), heading one-hot (4), normalized length (1), and the
-    // flood-fill count of free cells reachable through each of the 4 neighbours (4). The flood-fill is the
-    // anti-self-trap signal a fixed window can't give: it tells a long snake which moves keep open space reachable.
     public const int PatchRadius = 4;
     public const int PatchSide = 2 * PatchRadius + 1;                       // 9
     public const int PatchChannels = 2;                                     // 0 = obstacle, 1 = food
@@ -37,312 +31,96 @@ public sealed class SnakeEnv : IEnvironment<float[], int>, IActionMaskProvider,
     public const float StepPenalty = -0.01f;
     public const float DeathReward = -1f;
 
-    // Episode limits scale with the board so high-score games are possible: the snake dies only after this many
-    // steps WITHOUT eating (a starvation timeout, not a flat cap that would hard-limit food); a generous absolute
-    // ceiling guards a true infinite loop that keeps eating just often enough to never starve.
-    private int StarveLimit => 2 * Cells;
-    private int MaxEpisodeSteps => 100 * Cells;
-
-    // Action = absolute direction; (dRow, dCol) per action index.
-    private static readonly (int Dr, int Dc)[] Deltas = [(-1, 0), (1, 0), (0, -1), (0, 1)]; // Up, Down, Left, Right
-
     private Xoshiro256StarStar _rng = new(0);
-    private readonly LinkedList<int> _body = new(); // head = First, tail = Last (cell indices)
-    private readonly HashSet<int> _occupied = [];
-    private int _food;
-    private int _foodEaten;
-    private int _heading;
-    private int _elapsedSteps;
-    private int _stepsSinceFood;
-    private bool _done = true;
-    private readonly float _stepPenalty;
-    private readonly bool _safeMask;
+    private readonly PgSnakeEnv _core;
 
-    /// <param name="stepPenalty">
-    /// Per-non-eating-step reward (training only — inference is greedy and ignores reward). Defaults to
-    /// <see cref="StepPenalty"/>; pass ~0 to remove the efficiency pressure that makes pursuing distant food
-    /// (unavoidable for a long snake) barely net-positive and so encourages safe starvation.
-    /// </param>
-    /// <param name="safeMask">
-    /// When true, <see cref="CurrentActionMask"/> also forbids moves that would seal the snake into a region too
-    /// small to hold its body — a reactive flood-fill "shield" against self-trapping. Off by default (preserves
-    /// the reversal-only mask). Can be enabled for both training and inference.
-    /// </param>
+    /// <param name="stepPenalty">Per-non-eating-step reward (training only; inference is greedy). ~0 removes the
+    /// efficiency pressure that can encourage safe starvation.</param>
+    /// <param name="safeMask">When true, <see cref="CurrentActionMask"/> also forbids moves that would seal the snake
+    /// into a region too small for its body (a reactive flood-fill shield). The deployed net was trained with it on.</param>
     public SnakeEnv(int size = 12, float stepPenalty = StepPenalty, bool safeMask = false)
     {
         if (size < 5)
             throw new ArgumentOutOfRangeException(nameof(size), "Grid must be at least 5×5 (the length-3 start needs room).");
-        Size = size;
-        Cells = size * size;
-        _stepPenalty = stepPenalty;
-        _safeMask = safeMask;
+        _core = new PgSnakeEnv(size, stepPenalty, safeMask);
         ObservationSpace = new BoxSpace(0f, 1f, ObservationSize);
         ActionSpace = new DiscreteSpace(ActionCount);
     }
 
-    public int Size { get; }
-    public int Cells { get; }
+    public int Size => _core.size;
+    public int Cells => _core.cells;
     public Space<float[]> ObservationSpace { get; }
     public Space<int> ActionSpace { get; }
 
-    /// <summary>Snake cells, head first — for rendering / WS frame serialization.</summary>
-    public IReadOnlyCollection<int> Body => _body;
-    public int Food => _food;
-    public int FoodEaten => _foodEaten;
-    public int Length => _body.Count;
+    /// <summary>Snake cells, head first — for rendering / serialization. (The core stores head-at-end; this reverses.)</summary>
+    public IReadOnlyList<int> Body
+    {
+        get
+        {
+            int n = _core.body.Count;
+            var b = new int[n];
+            for (int k = 0; k < n; k++) b[k] = _core.body[n - 1 - k];
+            return b;
+        }
+    }
+    public int Food => _core.food;
+    public int FoodEaten => _core.foodEaten;
+    public int Length => _core.body.Count;
 
     public (float[] Observation, EnvInfo Info) Reset(ulong? seed = null)
     {
         if (seed.HasValue)
             _rng = new Xoshiro256StarStar(seed.Value);
-
-        _body.Clear();
-        _occupied.Clear();
-        // Length-3 snake, horizontal, centred, head pointing Right; body cells to its left.
-        int row = Size / 2, headCol = Size / 2;
-        for (int c = headCol; c >= headCol - 2; c--)
-        {
-            int cell = row * Size + c;
-            _body.AddLast(cell);
-            _occupied.Add(cell);
-        }
-        _heading = 3; // Right
-        _foodEaten = 0;
-        _elapsedSteps = 0;
-        _stepsSinceFood = 0;
-        _done = false;
-        SpawnFood();
+        _core.reset();
+        _core.spawnFood(_rng.NextInt(_core.freeCount()));
         return (Observation(), EnvInfo.Empty);
     }
 
     public StepResult<float[]> Step(int action)
     {
-        if (_done)
+        if (_core.done)
             throw new InvalidOperationException("Episode is done; call Reset() before stepping.");
         if (!ActionSpace.Contains(action))
             throw new ArgumentOutOfRangeException(nameof(action));
-        if (!CurrentActionMask()[action])
+        if (!_core.currentActionMask()[action])
             throw new ArgumentException($"Illegal action {action} (180° reversal); consult CurrentActionMask().", nameof(action));
 
-        int head = _body.First!.Value;
-        int headRow = head / Size, headCol = head % Size;
-        var (dr, dc) = Deltas[action];
-        int newRow = headRow + dr, newCol = headCol + dc;
-
-        if (newRow < 0 || newRow >= Size || newCol < 0 || newCol >= Size)
-            return Die();
-
-        int newHead = newRow * Size + newCol;
-        bool eating = newHead == _food;
-        int tail = _body.Last!.Value;
-        if (_occupied.Contains(newHead) && !(newHead == tail && !eating))
-            return Die();
-
-        _body.AddFirst(newHead);
-        _heading = action;
-        float reward;
-        bool terminated = false;
-        if (eating)
-        {
-            _occupied.Add(newHead);
-            _foodEaten++;
-            _stepsSinceFood = 0;
-            reward = FoodReward;
-            if (_occupied.Count == Cells)
-                terminated = true; // board full — a win
-            else
-                SpawnFood();
-        }
-        else
-        {
-            // Remove the vacating tail BEFORE marking the new head occupied. On a "tail-follow" move (the head
-            // steps onto the exact cell the tail is leaving — the snake's canonical survival move) newHead == tail,
-            // so adding first would be a no-op against the still-present tail and the subsequent removal would then
-            // drop the head's own cell, leaving it untracked in _occupied. Collision detection reads _occupied, so
-            // that phantom cell could later be entered again — the snake passing through its own body without dying.
-            _occupied.Remove(tail);
-            _body.RemoveLast();
-            _occupied.Add(newHead);
-            _stepsSinceFood++;
-            reward = _stepPenalty;
-        }
-
-        _elapsedSteps++;
-        // Starvation timeout (board-scaled) ends a snake that's wandering without progress; the absolute ceiling
-        // is just a safety net. A flat cap is deliberately avoided — it would hard-limit how much food is reachable.
-        bool truncated = !terminated && (_stepsSinceFood >= StarveLimit || _elapsedSteps >= MaxEpisodeSteps);
-        _done = terminated || truncated;
-        return new StepResult<float[]>(Observation(), reward, terminated, truncated, EnvInfo.Empty);
+        _core.step(action);
+        // The core signals when a move ate and left room; the facade owns the RNG and places the food (matching the
+        // exact free-count the core sees), so the Xoshiro sequence — and thus determinism — is preserved.
+        if (_core.needsFood)
+            _core.spawnFood(_rng.NextInt(_core.freeCount()));
 
-        StepResult<float[]> Die()
-        {
-            _done = true;
-            return new StepResult<float[]>(Observation(), DeathReward, true, false, EnvInfo.Empty);
-        }
+        return new StepResult<float[]>(Observation(), (float)_core.lastReward, _core.lastTerminated, _core.lastTruncated, EnvInfo.Empty);
     }
 
-    /// <summary>
-    /// Legal moves: every direction except the 180° reversal onto the neck. When <see cref="_safeMask"/> is on,
-    /// ALSO forbids any move that would seal the snake into a region smaller than its own body (a flood-fill from
-    /// the entered cell reaching fewer than <see cref="Length"/> free cells = a guaranteed trap) — a reactive
-    /// 1-ply "shield" that eliminates the self-trapping deaths which otherwise cap a long snake. If that would
-    /// leave no legal move, the shield is dropped for this step (pick the least-bad move rather than no move).
-    /// </summary>
-    public bool[] CurrentActionMask()
-    {
-        var mask = new[] { true, true, true, true };
-        if (_body.Count < 2) return mask;
-        int head = _body.First!.Value, neck = _body.First!.Next!.Value;
-        int headRow = head / Size, headCol = head % Size;
-        for (int a = 0; a < 4; a++)
-        {
-            var (dr, dc) = Deltas[a];
-            int r = headRow + dr, c = headCol + dc;
-            if (r >= 0 && r < Size && c >= 0 && c < Size && r * Size + c == neck)
-                mask[a] = false;
-        }
-
-        if (!_safeMask) return mask;
-
-        int tail = _body.Last!.Value, length = _body.Count;
-        var safe = (bool[])mask.Clone();
-        bool any = false;
-        for (int a = 0; a < 4; a++)
-        {
-            if (!mask[a]) continue;
-            var (dr, dc) = Deltas[a];
-            // A move is "safe" only if the space reachable after entering it can still hold the whole body.
-            if (ReachableFreeSpace(headRow + dr, headCol + dc, tail) >= length) any = true;
-            else safe[a] = false;
-        }
-        return any ? safe : mask; // never return an all-false mask
-    }
+    public bool[] CurrentActionMask() => [.. _core.currentActionMask()];
 
     public float[] CurrentObservation() => Observation();
 
     private float[] Observation()
     {
-        int head = _body.First!.Value;
-        int hr = head / Size, hc = head % Size;
-        int tail = _body.Last!.Value;
-        int fr = _food / Size, fc = _food % Size;
-
-        // A cell is lethal to enter (an "obstacle") if it is off the board or holds a body segment that will NOT
-        // vacate this step. The tail cell vacates when the snake doesn't eat, so it is passable.
-        bool Obstacle(int r, int c)
-        {
-            if (r < 0 || r >= Size || c < 0 || c >= Size) return true;
-            int cell = r * Size + c;
-            return _occupied.Contains(cell) && cell != tail;
-        }
-
-        var obs = new float[ObservationSize];
-
-        // ── channels 0..1: a (2R+1)×(2R+1) egocentric patch centred on the head ──
-        // Layout is channel-major (all obstacle cells, then all food cells), row-major within each channel, so a
-        // CNN can reshape it to [PatchChannels, PatchSide, PatchSide]. Cells off the board read as obstacle.
-        const int plane = PatchSide * PatchSide;
-        for (int dr = -PatchRadius, i = 0; dr <= PatchRadius; dr++)
-            for (int dc = -PatchRadius; dc <= PatchRadius; dc++, i++)
-            {
-                int r = hr + dr, c = hc + dc;
-                if ((dr != 0 || dc != 0) && Obstacle(r, c)) obs[i] = 1f; // centre is the head itself, not an obstacle
-                if (r == fr && c == fc) obs[plane + i] = 1f; // food channel
-            }
-
-        // ── scalar features (start after the two patch planes) ──
-        int s = PatchSize;
-        obs[s++] = (fc - hc) / (float)Size;                       // food Δcol (signed, normalized)
-        obs[s++] = (fr - hr) / (float)Size;                       // food Δrow (signed, normalized)
-        obs[s++] = (Math.Abs(fr - hr) + Math.Abs(fc - hc)) / (2f * Size); // L1 distance to food
-        obs[s++] = _heading == 0 ? 1f : 0f;
-        obs[s++] = _heading == 1 ? 1f : 0f;
-        obs[s++] = _heading == 2 ? 1f : 0f;
-        obs[s++] = _heading == 3 ? 1f : 0f;
-        obs[s++] = _body.Count / (float)Cells;                    // normalized length
-
-        // Flood-fill the open space reachable through each neighbour of the head (normalized by board area). This
-        // is the key anti-trap signal: a move into a region that can only reach a few cells is about to seal the
-        // snake in, even when the immediate cell looks safe.
-        for (int a = 0; a < 4; a++)
-        {
-            var (dr, dc) = Deltas[a];
-            obs[s++] = ReachableFreeSpace(hr + dr, hc + dc, tail) / (float)Cells;
-        }
-
-        // Direction + distance to the tail: chasing the tail is the canonical way a long snake stays alive (the
-        // cell the tail vacates is always safe to follow), so giving the agent the tail's bearing helps it learn it.
-        int tr = tail / Size, tc = tail % Size;
-        obs[s++] = (tc - hc) / (float)Size;
-        obs[s++] = (tr - hr) / (float)Size;
-        obs[s++] = (Math.Abs(tr - hr) + Math.Abs(tc - hc)) / (2f * Size);
+        var core = _core.buildObservation();
+        var obs = new float[core.Count];
+        for (int i = 0; i < obs.Length; i++) obs[i] = (float)core[i];
         return obs;
     }
 
-    /// <summary>
-    /// BFS flood-fill from <paramref name="r"/>,<paramref name="c"/> over cells that are on the board and not
-    /// occupied by a non-vacating body segment; returns the count of reachable free cells (0 if the start itself
-    /// is blocked). The tail cell counts as free (it vacates). Bounds the work at <see cref="Cells"/>.
-    /// </summary>
-    private int ReachableFreeSpace(int r, int c, int tail)
-    {
-        bool Free(int rr, int cc)
-        {
-            if (rr < 0 || rr >= Size || cc < 0 || cc >= Size) return false;
-            int cell = rr * Size + cc;
-            return !_occupied.Contains(cell) || cell == tail;
-        }
-        if (!Free(r, c)) return 0;
-
-        var seen = new bool[Cells];
-        var queue = new Queue<int>();
-        int start = r * Size + c;
-        seen[start] = true;
-        queue.Enqueue(start);
-        int count = 0;
-        while (queue.Count > 0)
-        {
-            int cell = queue.Dequeue();
-            count++;
-            int cr = cell / Size, cc2 = cell % Size;
-            foreach (var (dr, dc) in Deltas)
-            {
-                int nr = cr + dr, nc = cc2 + dc;
-                if (!Free(nr, nc)) continue;
-                int n = nr * Size + nc;
-                if (seen[n]) continue;
-                seen[n] = true;
-                queue.Enqueue(n);
-            }
-        }
-        return count;
-    }
-
-    private void SpawnFood()
-    {
-        int free = Cells - _occupied.Count;
-        int pick = _rng.NextInt(free);
-        for (int cell = 0; cell < Cells; cell++)
-        {
-            if (_occupied.Contains(cell)) continue;
-            if (pick-- == 0) { _food = cell; return; }
-        }
-    }
-
     public byte[] SaveState()
     {
         using var stream = new MemoryStream();
         using var writer = new BinaryWriter(stream);
         var (s0, s1, s2, s3) = _rng.GetState();
         writer.Write(s0); writer.Write(s1); writer.Write(s2); writer.Write(s3);
-        writer.Write(_body.Count);
-        foreach (int cell in _body) writer.Write(cell); // head first
-        writer.Write(_food);
-        writer.Write(_heading);
-        writer.Write(_foodEaten);
-        writer.Write(_elapsedSteps);
-        writer.Write(_stepsSinceFood);
-        writer.Write(_done);
+        var body = Body; // head first
+        writer.Write(body.Count);
+        foreach (int cell in body) writer.Write(cell);
+        writer.Write(_core.food);
+        writer.Write(_core.heading);
+        writer.Write(_core.foodEaten);
+        writer.Write(_core.elapsedSteps);
+        writer.Write(_core.stepsSinceFood);
+        writer.Write(_core.done);
         writer.Flush();
         return stream.ToArray();
     }
@@ -351,33 +129,36 @@ public void RestoreState(byte[] state)
     {
         using var reader = new BinaryReader(new MemoryStream(state));
         _rng.SetState(reader.ReadUInt64(), reader.ReadUInt64(), reader.ReadUInt64(), reader.ReadUInt64());
-        _body.Clear();
-        _occupied.Clear();
+        _core.body.Clear();
+        for (int i = 0; i < _core.occupied.Count; i++) _core.occupied[i] = false;
         int count = reader.ReadInt32();
-        for (int i = 0; i < count; i++)
+        var headFirst = new int[count];
+        for (int i = 0; i < count; i++) headFirst[i] = reader.ReadInt32();
+        // Core stores head-at-end, so add tail → head (reverse of the head-first buffer).
+        for (int i = count - 1; i >= 0; i--)
         {
-            int cell = reader.ReadInt32();
-            _body.AddLast(cell);
-            _occupied.Add(cell);
+            int cell = headFirst[i];
+            _core.body.Add(cell);
+            _core.occupied[cell] = true;
         }
-        _food = reader.ReadInt32();
-        _heading = reader.ReadInt32();
-        _foodEaten = reader.ReadInt32();
-        _elapsedSteps = reader.ReadInt32();
-        _stepsSinceFood = reader.ReadInt32();
-        _done = reader.ReadBoolean();
+        _core.food = reader.ReadInt32();
+        _core.heading = reader.ReadInt32();
+        _core.foodEaten = reader.ReadInt32();
+        _core.elapsedSteps = reader.ReadInt32();
+        _core.stepsSinceFood = reader.ReadInt32();
+        _core.done = reader.ReadBoolean();
     }
 
     public string RenderString()
     {
-        int head = _body.First!.Value;
+        int head = _core.headCell();
         var sb = new StringBuilder();
         for (int r = 0; r < Size; r++)
         {
             for (int c = 0; c < Size; c++)
             {
                 int cell = r * Size + c;
-                char glyph = cell == head ? '@' : _occupied.Contains(cell) ? 'o' : cell == _food ? '*' : '.';
+                char glyph = cell == head ? '@' : _core.occupied[cell] ? 'o' : cell == _core.food ? '*' : '.';
                 sb.Append(glyph);
             }
             sb.AppendLine();
diff --git a/src/MintPlayer.AI.ReinforcementLearning.Environments/Snake/polyglot/snake_solver.pg b/src/MintPlayer.AI.ReinforcementLearning.Environments/Snake/polyglot/snake_solver.pg
new file mode 100644
index 0000000..eb847d7
--- /dev/null
+++ b/src/MintPlayer.AI.ReinforcementLearning.Environments/Snake/polyglot/snake_solver.pg
@@ -0,0 +1,373 @@
+// snake_solver.pg — single-source Snake env + inference (M33), transpiled to C# and TS.
+//
+// ONE source for the game dynamics + observation + action mask (incl. the anti-self-trap flood-fill "shield")
+// + the dueling-Q forward pass, so the C# training/eval env AND the browser "watch AI" run identical logic.
+// f64 for the net; the env is pure integer + `+ − × ÷` math, so C# and TS are byte-identical.
+//
+// Collections: Polyglot's std.collections List has add / removeAt / [i] get+set / count / clear (no
+// removeFirst/removeLast/insert). So the snake body is a List<i32> with the HEAD AT THE END (add = grow head,
+// removeAt(0) = drop tail); occupancy is a List<bool> of size cells (occupied.count == body.count always); the
+// BFS uses a List<i32> + a cursor and a List<bool> seen-set. No HashSet/LinkedList/Queue.
+//
+// The generated C# is transpiled at build (MintPlayer.Polyglot.MSBuild); the TS is committed
+// (snake_solver.ts), regenerated on Windows:  polyglot build snake_solver.pg --target typescript --out <clientapp>
+
+import { List } from "std.collections"
+import { Math } from "std.math"
+
+// ── Dueling-Q net inference (PgSnakeNet: a deliberate copy of FruitCake's PgDuelingNet — same architecture. 
+// f64 forward pass over flat weight arrays. Q(s,a) = A(s,a) + (V(s) − mean_a A(s,a)); ReLU trunk; linear heads.
+// Weights (float32 in the .ckpt) are loaded into these f64 arrays by the per-platform parser.
+class PgSnakeNet {
+  var inputSize: i32
+  var actions: i32
+  var hidden: List<i32>
+  var trunkWFlat: List<f64>
+  var trunkBFlat: List<f64>
+  var valueW: List<f64>
+  var valueB: List<f64>
+  var advW: List<f64>
+  var advB: List<f64>
+
+  init(inputSize: i32, actions: i32, hidden: List<i32>, trunkWFlat: List<f64>, trunkBFlat: List<f64>, valueW: List<f64>, valueB: List<f64>, advW: List<f64>, advB: List<f64>) {
+    this.inputSize = inputSize
+    this.actions = actions
+    this.hidden = hidden
+    this.trunkWFlat = trunkWFlat
+    this.trunkBFlat = trunkBFlat
+    this.valueW = valueW
+    this.valueB = valueB
+    this.advW = advW
+    this.advB = advB
+  }
+
+  fn forward(obs: List<f64>): List<f64> {
+    var x = obs
+    var prev = this.inputSize
+    var wOff = 0
+    var bOff = 0
+    for l in 0..this.hidden.count {
+      let h = this.hidden[l]
+      x = relu(linear(x, this.trunkWFlat, wOff, this.trunkBFlat, bOff, prev, h))
+      wOff += prev * h
+      bOff += h
+      prev = h
+    }
+    let value = linear(x, this.valueW, 0, this.valueB, 0, prev, 1)
+    let adv = linear(x, this.advW, 0, this.advB, 0, prev, this.actions)
+
+    var sumA = 0.0
+    for k in 0..this.actions { sumA += adv[k] }
+    let meanA = sumA / this.actions
+    let v = value[0]
+
+    var q: List<f64> = List<f64>()
+    for k in 0..this.actions { q.add(adv[k] + (v - meanA)) }
+    return q
+  }
+
+  static fn linear(x: List<f64>, w: List<f64>, wOff: i32, b: List<f64>, bOff: i32, inDim: i32, outDim: i32): List<f64> {
+    var out: List<f64> = List<f64>()
+    for o in 0..outDim {
+      var s = b[bOff + o]
+      for i in 0..inDim { s += x[i] * w[wOff + i * outDim + o] }
+      out.add(s)
+    }
+    return out
+  }
+
+  static fn relu(x: List<f64>): List<f64> {
+    var out: List<f64> = List<f64>()
+    for v in x { out.add(Math.max(0.0, v)) }
+    return out
+  }
+}
+
+// ── Snake environment (port of SnakeEnv.cs) ─────────────────────────────────────────────────────────────────
+class PgSnakeEnv {
+  const ActionCount: i32 = 4
+  const PatchRadius: i32 = 4
+  const PatchSide: i32 = 9      // 2*PatchRadius+1
+  const PatchPlane: i32 = 81    // PatchSide*PatchSide
+  const PatchSize: i32 = 162    // PatchPlane*2 (obstacle + food channels)
+  const ObservationSize: i32 = 177   // PatchSize + 15 scalars
+  const FoodReward: f64 = 1.0
+  const DeathReward: f64 = -1.0
+
+  var size: i32
+  var cells: i32
+  var stepPenalty: f64
+  var safeMask: bool
+  var body: List<i32>        // head at END: body[count-1]=head, body[0]=tail
+  var occupied: List<bool>   // size cells; occupied.count invariant == body.count
+  var food: i32
+  var foodEaten: i32
+  var heading: i32
+  var elapsedSteps: i32
+  var stepsSinceFood: i32
+  var done: bool
+  // Step outputs (read by the C# training facade; the browser director only needs `done` + state).
+  var lastReward: f64
+  var lastTerminated: bool
+  var lastTruncated: bool
+  // After step(): true if this move ate and the board isn't full → the caller must spawnFood(rng.pick(freeCount)).
+  // Food RNG is kept OUT of the single source so the caller owns it (C# Xoshiro for determinism; TS Math.random).
+  var needsFood: bool
+
+  init(size: i32, stepPenalty: f64, safeMask: bool) {
+    this.size = size
+    this.cells = size * size
+    this.stepPenalty = stepPenalty
+    this.safeMask = safeMask
+    this.body = List<i32>()
+    this.occupied = List<bool>()
+    for i in 0..this.cells { this.occupied.add(false) }
+    this.food = 0
+    this.foodEaten = 0
+    this.heading = 3
+    this.elapsedSteps = 0
+    this.stepsSinceFood = 0
+    this.done = true
+    this.lastReward = 0.0
+    this.lastTerminated = false
+    this.lastTruncated = false
+    this.needsFood = false
+  }
+
+  // Action deltas: Up(0)=(-1,0) Down(1)=(1,0) Left(2)=(0,-1) Right(3)=(0,1).
+  static fn drOf(a: i32): i32 { if a == 0 { return -1 } if a == 1 { return 1 } return 0 }
+  static fn dcOf(a: i32): i32 { if a == 2 { return -1 } if a == 3 { return 1 } return 0 }
+  static fn iabs(x: i32): i32 { if x < 0 { return 0 - x } return x }
+
+  fn headCell(): i32 => this.body[this.body.count - 1]
+  fn neckCell(): i32 => this.body[this.body.count - 2]
+  fn tailCell(): i32 => this.body[0]
+  let length: i32 => this.body.count
+  fn freeCount(): i32 => this.cells - this.body.count
+
+  // Reset to a length-3 horizontal snake, centred, head pointing Right. Food is spawned separately by the caller
+  // (spawnFood) so the RNG stays out of the single source: C# rolls Xoshiro, the browser rolls Math.random.
+  fn reset() {
+    this.body.clear()
+    for i in 0..this.cells { this.occupied[i] = false }
+    let row = this.size / 2
+    let headCol = this.size / 2
+    // head-at-end: add tail → head, i.e. c = headCol-2, headCol-1, headCol.
+    for c in (headCol - 2)..(headCol + 1) {
+      let cell = row * this.size + c
+      this.body.add(cell)
+      this.occupied[cell] = true
+    }
+    this.heading = 3
+    this.foodEaten = 0
+    this.elapsedSteps = 0
+    this.stepsSinceFood = 0
+    this.done = false
+  }
+
+  // Place food at the pick'th free cell (pick in [0, freeCount)). Caller supplies the random index.
+  fn spawnFood(pick: i32) {
+    var p = pick
+    for cell in 0..this.cells {
+      if this.occupied[cell] { continue }
+      if p == 0 { this.food = cell; return }
+      p = p - 1
+    }
+  }
+
+  // Advance one step with the given action (assumed legal — call currentActionMask() first). Sets `needsFood`
+  // when this move ate and the board isn't full; the caller then rolls a pick and calls spawnFood before reading
+  // the observation. (Food RNG stays with the caller — see `needsFood`.)
+  fn step(action: i32) {
+    this.needsFood = false
+    let head = this.headCell()
+    let headRow = head / this.size
+    let headCol = head % this.size
+    let newRow = headRow + drOf(action)
+    let newCol = headCol + dcOf(action)
+
+    if newRow < 0 || newRow >= this.size || newCol < 0 || newCol >= this.size {
+      this.die()
+      return
+    }
+    let newHead = newRow * this.size + newCol
+    let eating = newHead == this.food
+    let tail = this.tailCell()
+    if this.occupied[newHead] && !(newHead == tail && !eating) {
+      this.die()
+      return
+    }
+
+    this.body.add(newHead) // grow head (head-at-end)
+    this.heading = action
+    var terminated = false
+    if eating {
+      this.occupied[newHead] = true
+      this.foodEaten = this.foodEaten + 1
+      this.stepsSinceFood = 0
+      this.lastReward = FoodReward
+      if this.body.count == this.cells {
+        terminated = true // board full — a win
+      } else {
+        this.needsFood = true // caller spawns food (owns the RNG)
+      }
+    } else {
+      // Remove the vacating tail BEFORE marking the new head occupied (tail-follow ordering; see SnakeEnv.cs).
+      this.occupied[tail] = false
+      this.body.removeAt(0)
+      this.occupied[newHead] = true
+      this.stepsSinceFood = this.stepsSinceFood + 1
+      this.lastReward = this.stepPenalty
+    }
+
+    this.elapsedSteps = this.elapsedSteps + 1
+    let starveLimit = 2 * this.cells
+    let maxSteps = 100 * this.cells
+    let truncated = !terminated && (this.stepsSinceFood >= starveLimit || this.elapsedSteps >= maxSteps)
+    this.done = terminated || truncated
+    this.lastTerminated = terminated
+    this.lastTruncated = truncated
+  }
+
+  fn die() {
+    this.done = true
+    this.lastReward = DeathReward
+    this.lastTerminated = true
+    this.lastTruncated = false
+  }
+
+  // A cell is an obstacle if off-board or a non-vacating body segment (the tail vacates on a non-eating move).
+  fn obstacle(r: i32, c: i32, tail: i32): bool {
+    if r < 0 || r >= this.size || c < 0 || c >= this.size { return true }
+    let cell = r * this.size + c
+    return this.occupied[cell] && cell != tail
+  }
+
+  fn freeCell(r: i32, c: i32, tail: i32): bool {
+    if r < 0 || r >= this.size || c < 0 || c >= this.size { return false }
+    let cell = r * this.size + c
+    return !this.occupied[cell] || cell == tail
+  }
+
+  // Flood-fill: count of free cells reachable from (r,c). Iterative relaxation over a `seen` bool-list (BFS-
+  // equivalent) rather than a growing queue — a queue whose pushed values derive from reads of the same list
+  // makes the transpiled TS an "evolving-any" array with circular element inference (TS7022). Scanning `seen`
+  // instead (values come from a fixed 0..cells range, never a list read) sidesteps that. Bounded at `cells`
+  // passes (each pass marks ≥1 new cell or stops); cells is small (≤ e.g. 144), so O(cells²) is fine.
+  fn reachableFreeSpace(r: i32, c: i32, tail: i32): i32 {
+    if !this.freeCell(r, c, tail) { return 0 }
+    var seen: List<bool> = List<bool>()
+    for i in 0..this.cells { seen.add(false) }
+    seen[r * this.size + c] = true
+    var changed = true
+    for _pass in 0..this.cells {
+      if !changed { break }
+      changed = false
+      for cell in 0..this.cells {
+        if !seen[cell] { continue }
+        let cr = cell / this.size
+        let cc = cell % this.size
+        for a in 0..ActionCount {
+          let nr = cr + drOf(a)
+          let nc = cc + dcOf(a)
+          if !this.freeCell(nr, nc, tail) { continue }
+          let n = nr * this.size + nc
+          if !seen[n] {
+            seen[n] = true
+            changed = true
+          }
+        }
+      }
+    }
+    var count = 0
+    for cell in 0..this.cells { if seen[cell] { count = count + 1 } }
+    return count
+  }
+
+  // The 177-dim observation (port of SnakeEnv.Observation): 9×9×2 egocentric patch (channel-major) + 15 scalars.
+  fn buildObservation(): List<f64> {
+    let head = this.headCell()
+    let hr = head / this.size
+    let hc = head % this.size
+    let tail = this.tailCell()
+    let fr = this.food / this.size
+    let fc = this.food % this.size
+
+    var obs: List<f64> = List<f64>()
+    for _pad in 0..ObservationSize { obs.add(0.0) }
+
+    var i = 0
+    for dr in (0 - PatchRadius)..(PatchRadius + 1) {
+      for dc in (0 - PatchRadius)..(PatchRadius + 1) {
+        let r = hr + dr
+        let c = hc + dc
+        if (dr != 0 || dc != 0) && this.obstacle(r, c, tail) { obs[i] = 1.0 }
+        if r == fr && c == fc { obs[PatchPlane + i] = 1.0 }
+        i = i + 1
+      }
+    }
+
+    var s = PatchSize
+    obs[s] = f64(fc - hc) / f64(this.size); s = s + 1
+    obs[s] = f64(fr - hr) / f64(this.size); s = s + 1
+    obs[s] = f64(iabs(fr - hr) + iabs(fc - hc)) / (2.0 * f64(this.size)); s = s + 1
+    obs[s] = if this.heading == 0 { 1.0 } else { 0.0 }; s = s + 1
+    obs[s] = if this.heading == 1 { 1.0 } else { 0.0 }; s = s + 1
+    obs[s] = if this.heading == 2 { 1.0 } else { 0.0 }; s = s + 1
+    obs[s] = if this.heading == 3 { 1.0 } else { 0.0 }; s = s + 1
+    obs[s] = f64(this.body.count) / f64(this.cells); s = s + 1
+    for a in 0..ActionCount {
+      obs[s] = f64(this.reachableFreeSpace(hr + drOf(a), hc + dcOf(a), tail)) / f64(this.cells); s = s + 1
+    }
+    let tr = tail / this.size
+    let tc = tail % this.size
+    obs[s] = f64(tc - hc) / f64(this.size); s = s + 1
+    obs[s] = f64(tr - hr) / f64(this.size); s = s + 1
+    obs[s] = f64(iabs(tr - hr) + iabs(tc - hc)) / (2.0 * f64(this.size)); s = s + 1
+    return obs
+  }
+
+  // Legal-move mask: forbid the 180° reversal onto the neck; with safeMask, also forbid moves that seal the snake
+  // into a region smaller than its length (flood-fill shield), never returning an all-false mask.
+  fn currentActionMask(): List<bool> {
+    var mask: List<bool> = List<bool>()
+    for a in 0..ActionCount { mask.add(true) }
+    if this.body.count < 2 { return mask }
+    let head = this.headCell()
+    let neck = this.neckCell()
+    let headRow = head / this.size
+    let headCol = head % this.size
+    for a in 0..ActionCount {
+      let r = headRow + drOf(a)
+      let c = headCol + dcOf(a)
+      if r >= 0 && r < this.size && c >= 0 && c < this.size && r * this.size + c == neck { mask[a] = false }
+    }
+    if !this.safeMask { return mask }
+
+    let tail = this.tailCell()
+    let len = this.body.count
+    var safe: List<bool> = List<bool>()
+    for a in 0..ActionCount { safe.add(mask[a]) }
+    var any = false
+    for a in 0..ActionCount {
+      if !mask[a] { continue }
+      if this.reachableFreeSpace(headRow + drOf(a), headCol + dcOf(a), tail) >= len { any = true }
+      else { safe[a] = false }
+    }
+    if any { return safe }
+    return mask
+  }
+
+  // The full single-source decision: masked greedy argmax over the net's Q-values (mirrors GreedyQAgent.Act).
+  fn chooseAction(net: PgSnakeNet): i32 {
+    let q = net.forward(this.buildObservation())
+    let mask = this.currentActionMask()
+    var best = -1
+    for a in 0..ActionCount {
+      if !mask[a] { continue }
+      if best < 0 { best = a }
+      else if q[a] > q[best] { best = a }
+    }
+    return best
+  }
+}
diff --git a/models/mountaincar.ppo.ckpt b/src/RLDemo.Web/ClientApp/public/mountaincar-net.ckpt
similarity index 100%
rename from models/mountaincar.ppo.ckpt
rename to src/RLDemo.Web/ClientApp/public/mountaincar-net.ckpt
diff --git a/models/snake.dqn.ckpt b/src/RLDemo.Web/ClientApp/public/snake-net.ckpt
similarity index 100%
rename from models/snake.dqn.ckpt
rename to src/RLDemo.Web/ClientApp/public/snake-net.ckpt
diff --git a/src/RLDemo.Web/ClientApp/src/app/mountaincar/mountaincar-api.ts b/src/RLDemo.Web/ClientApp/src/app/mountaincar/mountaincar-api.ts
deleted file mode 100644
index dfb1bed..0000000
--- a/src/RLDemo.Web/ClientApp/src/app/mountaincar/mountaincar-api.ts
+++ /dev/null
@@ -1,33 +0,0 @@
-import { Injectable } from '@angular/core';
-
-/** One streamed frame of an AI MountainCar episode (PRD §7.1 principle B). `action = -1` marks a reset. */
-export interface MountainCarFrame {
-  position: number;
-  velocity: number;
-  action: number;
-  reward: number;
-  done: boolean;
-}
-
-export interface MountainCarStatus {
-  status: 'loading' | 'ready' | 'failed';
-  error: string | null;
-}
-
-@Injectable({ providedIn: 'root' })
-export class MountainCarApi {
-  async status(): Promise<MountainCarStatus> {
-    const response = await fetch('/api/mountaincar/status');
-    return response.json();
-  }
-
-  /** Server-authoritative live stream — the backend drives the car and pushes frames; the caller renders. */
-  connectLive(onFrame: (frame: MountainCarFrame) => void, onClose: () => void): WebSocket {
-    const proto = location.protocol === 'https:' ? 'wss' : 'ws';
-    const socket = new WebSocket(`${proto}://${location.host}/api/mountaincar/live`);
-    socket.onmessage = e => onFrame(JSON.parse(e.data) as MountainCarFrame);
-    socket.onclose = onClose;
-    socket.onerror = onClose;
-    return socket;
-  }
-}
diff --git a/src/RLDemo.Web/ClientApp/src/app/mountaincar/mountaincar-director.ts b/src/RLDemo.Web/ClientApp/src/app/mountaincar/mountaincar-director.ts
new file mode 100644
index 0000000..64b4883
--- /dev/null
+++ b/src/RLDemo.Web/ClientApp/src/app/mountaincar/mountaincar-director.ts
@@ -0,0 +1,54 @@
+import { PgMlpNet, PgMountainCarEnv } from './mountaincar_solver';
+import { loadMountainCarNet } from './mountaincar-net';
+
+// Client-side "watch the AI" director — the whole MountainCar AI runs in the browser (M33): the single-source
+// PgMountainCarEnv dynamics + the PPO policy (PgMlpNet, argmax over logits) loaded from the shipped checkpoint.
+// No server, no WebSocket. Discrete-tick (one policy move per tick), so the component drives it on an interval.
+
+const MAX_STEPS = 200;      // v0 episode cap
+const DEAD_HOLD_TICKS = 12; // hold the terminal frame briefly before restarting
+
+export interface McAiFrame {
+  position: number;
+  done: boolean;
+  reachedGoal: boolean;
+}
+
+export class MountainCarDirector {
+  private readonly core = new PgMountainCarEnv(MAX_STEPS, false);
+  private net: PgMlpNet | null = null;
+  private ready = false;
+  private deadHold = 0;
+
+  constructor() {
+    void loadMountainCarNet().then(n => {
+      this.net = n; // null (missing checkpoint) → the car sits at the start; the checkpoint is shipped
+      this.newGame();
+      this.ready = true;
+    });
+  }
+
+  private newGame(): void {
+    this.core.reset(-0.6 + Math.random() * 0.2); // start ~U[-0.6,-0.4]; the browser owns the RNG
+    this.deadHold = 0;
+  }
+
+  /** Advance one policy step. Returns the current frame, or null while the checkpoint is still loading. */
+  step(): McAiFrame | null {
+    if (!this.ready) return null;
+    if (this.core.done) {
+      if (this.deadHold > 0) { this.deadHold--; return this.frame(); }
+      this.newGame();
+      return this.frame();
+    }
+    if (this.net === null) return this.frame();
+
+    this.core.step(this.core.chooseAction(this.net));
+    if (this.core.done) this.deadHold = DEAD_HOLD_TICKS;
+    return this.frame();
+  }
+
+  private frame(): McAiFrame {
+    return { position: this.core.position, done: this.core.done, reachedGoal: this.core.position >= 0.5 };
+  }
+}
diff --git a/src/RLDemo.Web/ClientApp/src/app/mountaincar/mountaincar-net.ts b/src/RLDemo.Web/ClientApp/src/app/mountaincar/mountaincar-net.ts
new file mode 100644
index 0000000..c79001f
--- /dev/null
+++ b/src/RLDemo.Web/ClientApp/src/app/mountaincar/mountaincar-net.ts
@@ -0,0 +1,68 @@
+// Loads the trained MountainCar PPO policy (an Mlp) checkpoint in the browser → the single-source PgMlpNet.
+// Mirrors the C# MlpCheckpoint / CheckpointFormat reader:
+//   uint32 magic "RLNC" · string kind "mlp" (7-bit-varint length + UTF-8) · int32 version
+//   int32 sizesCount + sizes[] · byte hiddenActivation · per layer: int32 count+float32[] weight, then bias
+// (PgMlpNet applies Tanh between hidden layers to match the shipped net's activation.)
+
+import { PgMlpNet } from './mountaincar_solver';
+
+const MAGIC = 0x434e4c52; // "RLNC"
+const KIND = 'mlp';
+
+/** Fetch + parse the shipped MountainCar policy. Returns null if missing/unreadable/incompatible. */
+export async function loadMountainCarNet(url = 'mountaincar-net.ckpt'): Promise<PgMlpNet | null> {
+  try {
+    const resp = await fetch(url);
+    if (!resp.ok) return null;
+    return parseMlp(await resp.arrayBuffer());
+  } catch {
+    return null;
+  }
+}
+
+export function parseMlp(buffer: ArrayBuffer): PgMlpNet {
+  const dv = new DataView(buffer);
+  let off = 0;
+  const i32 = () => { const v = dv.getInt32(off, true); off += 4; return v; };
+  const u32 = () => { const v = dv.getUint32(off, true); off += 4; return v; };
+  const u8 = () => dv.getUint8(off++);
+  const read7bit = () => {
+    let result = 0, shift = 0, b: number;
+    do { b = u8(); result |= (b & 0x7f) << shift; shift += 7; } while (b & 0x80);
+    return result;
+  };
+  const readString = () => {
+    const len = read7bit();
+    const bytes = new Uint8Array(buffer, off, len);
+    off += len;
+    return new TextDecoder().decode(bytes);
+  };
+  const readInts = () => {
+    const n = i32();
+    const a = new Array<number>(n);
+    for (let i = 0; i < n; i++) a[i] = i32();
+    return a;
+  };
+  const readFloats = () => {
+    const n = i32();
+    const a = new Array<number>(n);
+    for (let i = 0; i < n; i++) { a[i] = dv.getFloat32(off, true); off += 4; }
+    return a;
+  };
+
+  if (u32() !== MAGIC) throw new Error('mountaincar-net: not an RLNC checkpoint');
+  const kind = readString();
+  if (kind !== KIND) throw new Error(`mountaincar-net: expected kind '${KIND}', got '${kind}'`);
+  i32();          // version
+  const sizes = readInts();
+  u8();           // hidden activation (Tanh for the PPO actor; PgMlpNet is tanh-only)
+
+  const wFlat: number[] = [];
+  const bFlat: number[] = [];
+  const layers = sizes.length - 1;
+  for (let l = 0; l < layers; l++) {
+    for (const f of readFloats()) wFlat.push(f);
+    for (const f of readFloats()) bFlat.push(f);
+  }
+  return new PgMlpNet(sizes, wFlat, bFlat);
+}
diff --git a/src/RLDemo.Web/ClientApp/src/app/mountaincar/mountaincar.html b/src/RLDemo.Web/ClientApp/src/app/mountaincar/mountaincar.html
index 4379434..d3f54fd 100644
--- a/src/RLDemo.Web/ClientApp/src/app/mountaincar/mountaincar.html
+++ b/src/RLDemo.Web/ClientApp/src/app/mountaincar/mountaincar.html
@@ -1,18 +1,10 @@
 <h1>Mountain Car</h1>
 <p class="subtitle">
   An underpowered car has to swing back and forth to build the momentum to reach the flag. A <strong>PPO</strong>
-  agent learned the swing-up from scratch — <strong>watch it</strong> (the server drives the car live over a
-  WebSocket) or <strong>drive it yourself</strong> (runs in your browser).
+  agent learned the swing-up from scratch — <strong>watch it</strong> or <strong>drive it yourself</strong>, both
+  running <strong>entirely in your browser</strong> (no server).
 </p>
 
-@if (modelStatus(); as ms) {
-  @if (ms.status === 'loading') {
-    <div class="banner training">Loading the MountainCar agent… — drive it yourself meanwhile.</div>
-  } @else if (ms.status === 'failed') {
-    <div class="banner error">AI unavailable: {{ ms.error }}</div>
-  }
-}
-
 <div class="layout">
   <canvas #mcCanvas width="600" height="360" class="board"></canvas>
 
diff --git a/src/RLDemo.Web/ClientApp/src/app/mountaincar/mountaincar.ts b/src/RLDemo.Web/ClientApp/src/app/mountaincar/mountaincar.ts
index 11e6be9..60eebc9 100644
--- a/src/RLDemo.Web/ClientApp/src/app/mountaincar/mountaincar.ts
+++ b/src/RLDemo.Web/ClientApp/src/app/mountaincar/mountaincar.ts
@@ -1,11 +1,12 @@
 import { Component, DestroyRef, ElementRef, afterNextRender, inject, signal, viewChild } from '@angular/core';
-import { MountainCarApi, MountainCarStatus } from './mountaincar-api';
 import { GOAL, MAX_POS, MIN_POS, MountainCarGame } from './mountaincar-logic';
+import { MountainCarDirector } from './mountaincar-director';
 import { ScreenWakeLock } from '../screen-wake-lock';
 
 /**
- * MountainCar page (PRD §7.1): **Watch AI** = principle B (backend drives the episode over a WebSocket,
- * this component renders frames), **Drive yourself** = client-side physics on a JS timer with ←/→.
+ * MountainCar page. Both modes now run **entirely in the browser** (M33): **Watch AI** = the single-source
+ * dynamics + PPO policy run client-side (MountainCarDirector), **Drive yourself** = the same dynamics on a JS
+ * timer with ←/→. No server, no WebSocket.
  */
 @Component({
   selector: 'app-mountaincar',
@@ -18,43 +19,37 @@ import { ScreenWakeLock } from '../screen-wake-lock';
   },
 })
 export class MountainCar {
-  private readonly api = inject(MountainCarApi);
   private readonly wakeLock = inject(ScreenWakeLock);
   private readonly canvasRef = viewChild.required<ElementRef<HTMLCanvasElement>>('mcCanvas');
 
   protected readonly mode = signal<'idle' | 'watch' | 'human'>('idle');
   protected readonly status = signal('Watch the PPO agent swing its way up, or drive it yourself.');
-  protected readonly modelStatus = signal<MountainCarStatus | null>(null);
 
   private ctx: CanvasRenderingContext2D | null = null;
-  private socket: WebSocket | null = null;
   private timer: ReturnType<typeof setInterval> | null = null;
   private game: MountainCarGame | null = null;
+  private director: MountainCarDirector | null = null;
   private held = 1; // current human push: 0 left, 1 none, 2 right
 
   constructor() {
-    this.pollStatus();
     afterNextRender(() => { this.ctx = this.canvasRef().nativeElement.getContext('2d'); this.draw(-0.5); });
     inject(DestroyRef).onDestroy(() => this.stop());
   }
 
-  protected async watchAi(): Promise<void> {
+  protected watchAi(): void {
     this.stop();
-    const st = await this.api.status().catch(() => null);
-    this.modelStatus.set(st);
-    if (!st || st.status !== 'ready') {
-      this.status.set(st?.status === 'loading' ? 'The agent is still loading — try again shortly.' : 'AI unavailable.');
-      return;
-    }
     this.mode.set('watch');
-    void this.wakeLock.acquire(); // keep the phone screen on so an auto-lock doesn't freeze the stream
-    this.status.set('Watching the PPO agent (the server drives the car)…');
-    this.socket = this.api.connectLive(
-      f => {
-        this.draw(f.position);
-        if (f.done) this.status.set(f.position >= GOAL ? 'Reached the flag! Restarting…' : 'Ran out of time — restarting…');
-      },
-      () => { if (this.mode() === 'watch') this.status.set('Stream closed.'); });
+    void this.wakeLock.acquire(); // keep the phone screen on so an auto-lock doesn't freeze the game
+    this.status.set('Loading the agent…');
+    this.director = new MountainCarDirector();
+    this.timer = setInterval(() => {
+      const f = this.director?.step();
+      if (!f) return; // checkpoint still loading
+      this.draw(f.position);
+      this.status.set(f.done
+        ? (f.reachedGoal ? 'Reached the flag! Restarting…' : 'Ran out of time — restarting…')
+        : 'Watching the PPO agent — it runs in your browser.');
+    }, 45);
   }
 
   protected playHuman(): void {
@@ -86,19 +81,17 @@ export class MountainCar {
   }
 
   protected stop(): void {
-    this.socket?.close();
-    this.socket = null;
     this.clearTimer();
     this.game = null;
+    this.director = null;
     void this.wakeLock.release();
     if (this.mode() !== 'idle') this.mode.set('idle');
   }
 
-  // A backgrounded tab (phone lock / tab switch) gets frozen and the stream socket drops; when we return to
-  // the foreground still in watch mode, reopen it so the agent resumes instead of staying stopped.
+  // A backgrounded tab is throttled by the OS and drops the wake-lock; on returning to the foreground still in
+  // watch mode, re-acquire it (the director keeps ticking — no socket to reopen).
   protected onVisibilityChange(): void {
-    if (document.visibilityState !== 'visible' || this.mode() !== 'watch') return;
-    if (!this.socket || this.socket.readyState >= WebSocket.CLOSING) void this.watchAi();
+    if (document.visibilityState === 'visible' && this.mode() === 'watch') void this.wakeLock.acquire();
   }
 
   private clearTimer(): void {
@@ -141,16 +134,4 @@ export class MountainCar {
     ctx.arc(x2px(position), y2py(hill(position)) - 7, 7, 0, Math.PI * 2);
     ctx.fill();
   }
-
-  private pollStatus(): void {
-    void (async () => {
-      try {
-        const s = await this.api.status();
-        this.modelStatus.set(s);
-        if (s.status === 'loading') setTimeout(() => this.pollStatus(), 3000);
-      } catch {
-        // backend unreachable — leave status unknown
-      }
-    })();
-  }
 }
diff --git a/src/RLDemo.Web/ClientApp/src/app/mountaincar/mountaincar_solver.ts b/src/RLDemo.Web/ClientApp/src/app/mountaincar/mountaincar_solver.ts
new file mode 100644
index 0000000..90ac6f1
--- /dev/null
+++ b/src/RLDemo.Web/ClientApp/src/app/mountaincar/mountaincar_solver.ts
@@ -0,0 +1,128 @@
+export type Option<T> = { tag: "Some"; value: T } | { tag: "None" };
+export class PgMlpNet {
+    sizes: number[];
+    wFlat: number[];
+    bFlat: number[];
+    constructor(sizes: number[], wFlat: number[], bFlat: number[]) {
+        this.sizes = sizes;
+        this.wFlat = wFlat;
+        this.bFlat = bFlat;
+    }
+    forward(input: number[]): number[] {
+        let x = input;
+        let wOff = 0;
+        let bOff = 0;
+        const layers = (this.sizes.length - 1 | 0);
+        for (let l = 0; l < layers; l++) {
+            const inDim = this.sizes[l];
+            const outDim = this.sizes[(l + 1 | 0)];
+            x = PgMlpNet.linear(x, this.wFlat, wOff, this.bFlat, bOff, inDim, outDim);
+            wOff += Math.imul(inDim, outDim);
+            bOff += outDim;
+            if (l < (layers - 1 | 0)) {
+                x = PgMlpNet.tanhv(x);
+            }
+        }
+        return x;
+    }
+    static linear(x: number[], w: number[], wOff: number, b: number[], bOff: number, inDim: number, outDim: number): number[] {
+        let out = [];
+        for (let o = 0; o < outDim; o++) {
+            let s = b[(bOff + o | 0)];
+            for (let i = 0; i < inDim; i++) {
+                s += x[i] * w[((wOff + Math.imul(i, outDim) | 0) + o | 0)];
+            }
+            out.push(s);
+        }
+        return out;
+    }
+    static tanhv(x: number[]): number[] {
+        let out = [];
+        for (const v of x) {
+            out.push(Math.tanh(v));
+        }
+        return out;
+    }
+}
+export class PgMountainCarEnv {
+    static readonly MinPosition: number = -1.2;
+    static readonly MaxPosition: number = 0.6;
+    static readonly MaxSpeed: number = 0.07;
+    static readonly GoalPosition: number = 0.5;
+    static readonly Force: number = 0.001;
+    static readonly Gravity: number = 0.0025;
+    static readonly ShapeScale: number = 13.0;
+    static readonly ActionCount: number = 3;
+    maxEpisodeSteps: number;
+    shapeReward: boolean;
+    position: number;
+    velocity: number;
+    elapsedSteps: number;
+    done: boolean;
+    lastReward: number;
+    lastTerminated: boolean;
+    lastTruncated: boolean;
+    constructor(maxEpisodeSteps: number, shapeReward: boolean) {
+        this.maxEpisodeSteps = maxEpisodeSteps;
+        this.shapeReward = shapeReward;
+        this.position = 0.0;
+        this.velocity = 0.0;
+        this.elapsedSteps = 0;
+        this.done = true;
+        this.lastReward = 0.0;
+        this.lastTerminated = false;
+        this.lastTruncated = false;
+    }
+    reset(startPos: number): void {
+        this.position = startPos;
+        this.velocity = 0.0;
+        this.elapsedSteps = 0;
+        this.done = false;
+    }
+    setState(pos: number, vel: number): void {
+        this.position = pos;
+        this.velocity = vel;
+        this.elapsedSteps = 0;
+        this.done = false;
+    }
+    step(action: number): void {
+        let velocity = this.velocity + (action - 1 | 0) * PgMountainCarEnv.Force + Math.cos(3.0 * this.position) * (0.0 - PgMountainCarEnv.Gravity);
+        velocity = clampF(velocity, 0.0 - PgMountainCarEnv.MaxSpeed, PgMountainCarEnv.MaxSpeed);
+        let position = clampF(this.position + velocity, PgMountainCarEnv.MinPosition, PgMountainCarEnv.MaxPosition);
+        if (position <= PgMountainCarEnv.MinPosition && velocity < 0.0) {
+            velocity = 0.0;
+        }
+        this.position = position;
+        this.velocity = velocity;
+        this.elapsedSteps = (this.elapsedSteps + 1 | 0);
+        const terminated = position >= PgMountainCarEnv.GoalPosition;
+        const truncated = !terminated && this.elapsedSteps >= this.maxEpisodeSteps;
+        this.done = terminated || truncated;
+        let reward = 0.0 - 1.0;
+        if (this.shapeReward) {
+            reward += PgMountainCarEnv.ShapeScale * ((a) => (a < (a - a) ? -a : a))(velocity);
+        }
+        this.lastReward = reward;
+        this.lastTerminated = terminated;
+        this.lastTruncated = truncated;
+    }
+    buildObservation(): number[] {
+        let obs = [];
+        obs.push((this.position + 0.3) / 0.9);
+        obs.push(this.velocity / PgMountainCarEnv.MaxSpeed);
+        return obs;
+    }
+    chooseAction(net: PgMlpNet): number {
+        const logits = net.forward(this.buildObservation());
+        let best = 0;
+        for (let a = 1; a < logits.length; a++) {
+            if (logits[a] > logits[best]) {
+                best = a;
+            }
+        }
+        return best;
+    }
+}
+export function clampF(v: number, lo: number, hi: number): number {
+    return ((a, b) => (a <= b ? a : b))(hi, ((a, b) => (a >= b ? a : b))(lo, v));
+}
diff --git a/src/RLDemo.Web/ClientApp/src/app/snake/snake-api.ts b/src/RLDemo.Web/ClientApp/src/app/snake/snake-api.ts
deleted file mode 100644
index 2e99990..0000000
--- a/src/RLDemo.Web/ClientApp/src/app/snake/snake-api.ts
+++ /dev/null
@@ -1,38 +0,0 @@
-import { Injectable } from '@angular/core';
-
-/** One streamed frame of an AI game (PRD §7.1 principle B). `action = -1` marks a freshly reset start. */
-export interface SnakeFrame {
-  body: number[]; // head first, cell indices
-  food: number;
-  action: number;
-  reward: number;
-  done: boolean;
-  foodEaten: number;
-  length: number;
-}
-
-export interface SnakeStatus {
-  status: 'loading' | 'ready' | 'failed';
-  error: string | null;
-}
-
-@Injectable({ providedIn: 'root' })
-export class SnakeApi {
-  async status(): Promise<SnakeStatus> {
-    const response = await fetch('/api/snake/status');
-    return response.json();
-  }
-
-  /**
-   * Opens the server-authoritative live stream — the backend drives the game and pushes one frame per tick;
-   * the caller just renders. Returns the socket so the caller can close it on teardown.
-   */
-  connectLive(onFrame: (frame: SnakeFrame) => void, onClose: () => void): WebSocket {
-    const proto = location.protocol === 'https:' ? 'wss' : 'ws';
-    const socket = new WebSocket(`${proto}://${location.host}/api/snake/live`);
-    socket.onmessage = e => onFrame(JSON.parse(e.data) as SnakeFrame);
-    socket.onclose = onClose;
-    socket.onerror = onClose;
-    return socket;
-  }
-}
diff --git a/src/RLDemo.Web/ClientApp/src/app/snake/snake-director.ts b/src/RLDemo.Web/ClientApp/src/app/snake/snake-director.ts
new file mode 100644
index 0000000..dfd21d4
--- /dev/null
+++ b/src/RLDemo.Web/ClientApp/src/app/snake/snake-director.ts
@@ -0,0 +1,70 @@
+import { PgSnakeEnv, PgSnakeNet } from './snake_solver';
+import { loadSnakeNet } from './snake-net';
+
+// Client-side "watch the AI" director — the whole Snake AI runs in the browser (M33). It drives the single-source
+// PgSnakeEnv (dynamics + 177-dim observation + the anti-self-trap flood-fill action mask) and the masked-greedy
+// chooseAction over the trained net loaded from the shipped checkpoint — no server, no WebSocket. Discrete-tick
+// (one AI move per tick), so the component drives it on a plain interval, like human play.
+
+const SIZE = 12;                 // the shipped net was trained on a 12×12 board
+const SAFE_MASK = true;          // the deployed net was trained WITH the flood-fill shield — inference must match
+const STEP_PENALTY = -0.01;      // training-only; irrelevant to greedy inference
+const DEAD_HOLD_TICKS = 8;       // show the dead board briefly before auto-restarting
+
+export interface SnakeAiFrame {
+  body: number[]; // head first
+  food: number;
+  foodEaten: number;
+  done: boolean;
+  length: number;
+}
+
+export class SnakeDirector {
+  private readonly core = new PgSnakeEnv(SIZE, STEP_PENALTY, SAFE_MASK);
+  private net: PgSnakeNet | null = null;
+  private ready = false;
+  private deadHold = 0;
+
+  constructor() {
+    void loadSnakeNet().then(n => {
+      this.net = n; // null (missing checkpoint) → the board just sits; the checkpoint is shipped, so this is a safety net
+      this.newGame();
+      this.ready = true;
+    });
+  }
+
+  private randFree(): number {
+    return Math.floor(Math.random() * this.core.freeCount()); // the browser owns the food RNG now
+  }
+
+  private newGame(): void {
+    this.core.reset();
+    this.core.spawnFood(this.randFree());
+    this.deadHold = 0;
+  }
+
+  /** Advance one AI move. Returns the current frame, or null while the checkpoint is still loading. */
+  step(): SnakeAiFrame | null {
+    if (!this.ready) return null;
+    if (this.core.done) {
+      if (this.deadHold > 0) { this.deadHold--; return this.frame(); }
+      this.newGame();
+      return this.frame();
+    }
+    if (this.net === null) return this.frame();
+
+    const action = this.core.chooseAction(this.net);
+    if (action < 0) { this.deadHold = DEAD_HOLD_TICKS; return this.frame(); } // no legal move (shouldn't happen)
+    this.core.step(action);
+    if (this.core.needsFood) this.core.spawnFood(this.randFree());
+    if (this.core.done) this.deadHold = DEAD_HOLD_TICKS;
+    return this.frame();
+  }
+
+  private frame(): SnakeAiFrame {
+    const n = this.core.body.length;
+    const body = new Array<number>(n);
+    for (let k = 0; k < n; k++) body[k] = this.core.body[n - 1 - k]; // core stores head-at-end → head first
+    return { body, food: this.core.food, foodEaten: this.core.foodEaten, done: this.core.done, length: n };
+  }
+}
diff --git a/src/RLDemo.Web/ClientApp/src/app/snake/snake-net.ts b/src/RLDemo.Web/ClientApp/src/app/snake/snake-net.ts
new file mode 100644
index 0000000..c951853
--- /dev/null
+++ b/src/RLDemo.Web/ClientApp/src/app/snake/snake-net.ts
@@ -0,0 +1,79 @@
+// Loads the trained Snake DuelingQNet checkpoint in the browser and builds the single-source PgSnakeNet
+// (generated from snake_solver.pg). Mirrors the C# reader (DuelingQNetCheckpoint / CheckpointFormat) — same
+// byte layout as fruit-cake/fruitcake-net.ts (kind "dueling-q"); the only difference is it constructs Snake's
+// generated net type. (A shared ckpt.ts parser across games is a possible future refactor.)
+//
+//   uint32 magic "RLNC" · string kind "dueling-q" (7-bit-varint length + UTF-8) · int32 version
+//   int32 inputSize · int32 hiddenCount + hidden[] · int32 actions · byte noisy(v>=2)
+//   per parameter (trunk W/b…, value W/b, adv W/b): int32 count + count×float32
+// float32 read into a JS number is the exact f64 of that float32, matching the C# `(double)f` load.
+
+import { PgSnakeNet } from './snake_solver';
+
+const MAGIC = 0x434e4c52; // "RLNC"
+const KIND = 'dueling-q';
+
+/** Fetch + parse the shipped Snake checkpoint. Returns null if missing/unreadable/incompatible. */
+export async function loadSnakeNet(url = 'snake-net.ckpt'): Promise<PgSnakeNet | null> {
+  try {
+    const resp = await fetch(url);
+    if (!resp.ok) return null;
+    return parseSnakeNet(await resp.arrayBuffer());
+  } catch {
+    return null;
+  }
+}
+
+export function parseSnakeNet(buffer: ArrayBuffer): PgSnakeNet {
+  const dv = new DataView(buffer);
+  let off = 0;
+  const i32 = () => { const v = dv.getInt32(off, true); off += 4; return v; };
+  const u32 = () => { const v = dv.getUint32(off, true); off += 4; return v; };
+  const u8 = () => dv.getUint8(off++);
+  const read7bit = () => {
+    let result = 0, shift = 0, b: number;
+    do { b = u8(); result |= (b & 0x7f) << shift; shift += 7; } while (b & 0x80);
+    return result;
+  };
+  const readString = () => {
+    const len = read7bit();
+    const bytes = new Uint8Array(buffer, off, len);
+    off += len;
+    return new TextDecoder().decode(bytes);
+  };
+  const readFloats = () => {
+    const n = i32();
+    const a = new Array<number>(n);
+    for (let i = 0; i < n; i++) { a[i] = dv.getFloat32(off, true); off += 4; }
+    return a;
+  };
+
+  if (u32() !== MAGIC) throw new Error('snake-net: not an RLNC checkpoint');
+  const kind = readString();
+  if (kind !== KIND) throw new Error(`snake-net: expected kind '${KIND}', got '${kind}'`);
+  const version = i32();
+  const inputSize = i32();
+  const hiddenCount = i32();
+  const hidden: number[] = [];
+  for (let i = 0; i < hiddenCount; i++) hidden.push(i32());
+  const actions = i32();
+  const noisy = version >= 2 && u8() !== 0;
+
+  const trunkWFlat: number[] = [];
+  const trunkBFlat: number[] = [];
+  for (let l = 0; l < hiddenCount; l++) {
+    for (const f of readFloats()) trunkWFlat.push(f);
+    for (const f of readFloats()) trunkBFlat.push(f);
+  }
+  // Heads. Plain: W, b. Noisy: MeanW, SigmaW, MeanB, SigmaB — keep the Mean tensors (inference has noise off).
+  let valueW: number[], valueB: number[], advW: number[], advB: number[];
+  if (!noisy) {
+    valueW = readFloats(); valueB = readFloats();
+    advW = readFloats(); advB = readFloats();
+  } else {
+    valueW = readFloats(); readFloats(); valueB = readFloats(); readFloats();
+    advW = readFloats(); readFloats(); advB = readFloats(); readFloats();
+  }
+
+  return new PgSnakeNet(inputSize, actions, hidden, trunkWFlat, trunkBFlat, valueW, valueB, advW, advB);
+}
diff --git a/src/RLDemo.Web/ClientApp/src/app/snake/snake.html b/src/RLDemo.Web/ClientApp/src/app/snake/snake.html
index 6791d0b..e69a31e 100644
--- a/src/RLDemo.Web/ClientApp/src/app/snake/snake.html
+++ b/src/RLDemo.Web/ClientApp/src/app/snake/snake.html
@@ -1,18 +1,10 @@
 <h1>Snake</h1>
 <p class="subtitle">
-  A masked Double + Dueling DQN that learned Snake from scratch — <strong>watch it play</strong> (the server
-  drives the game live over a WebSocket) or <strong>play it yourself</strong> (runs entirely in your browser).
+  A masked Double + Dueling DQN that learned Snake from scratch — <strong>watch it play</strong> or
+  <strong>play it yourself</strong>, both running <strong>entirely in your browser</strong> (no server).
   Honest about its skill: it seeks food and dodges walls, but a from-scratch net eventually traps itself.
 </p>
 
-@if (modelStatus(); as ms) {
-  @if (ms.status === 'loading') {
-    <div class="banner training">Loading the Snake AI… — play yourself meanwhile.</div>
-  } @else if (ms.status === 'failed') {
-    <div class="banner error">AI unavailable: {{ ms.error }}</div>
-  }
-}
-
 <div class="layout">
   <div class="board" [style.--size]="size">
     @for (i of cells; track i) {
diff --git a/src/RLDemo.Web/ClientApp/src/app/snake/snake.ts b/src/RLDemo.Web/ClientApp/src/app/snake/snake.ts
index 281bd62..072e718 100644
--- a/src/RLDemo.Web/ClientApp/src/app/snake/snake.ts
+++ b/src/RLDemo.Web/ClientApp/src/app/snake/snake.ts
@@ -1,13 +1,13 @@
 import { Component, DestroyRef, inject, signal } from '@angular/core';
-import { SnakeApi, SnakeStatus } from './snake-api';
 import { CELLS, Dir, SIZE, SnakeGame } from './snake-logic';
+import { SnakeDirector } from './snake-director';
 import { ScreenWakeLock } from '../screen-wake-lock';
 
 /**
- * Snake page with the two interaction principles side by side (PRD §7.1):
- * - **Watch AI** = principle B: the backend drives a live game over a WebSocket and pushes frames;
- *   this component is a pure renderer (no game timer of its own).
- * - **Play yourself** = client-side: a JS timer ticks a local engine; the backend is not involved.
+ * Snake page. Both modes now run **entirely in the browser** (M33):
+ * - **Watch AI** = the single-source physics + net + masked-greedy policy run client-side (SnakeDirector) —
+ *   no server, no WebSocket.
+ * - **Play yourself** = a JS timer ticks the local engine.
  */
 @Component({
   selector: 'app-snake',
@@ -16,7 +16,6 @@ import { ScreenWakeLock } from '../screen-wake-lock';
   host: { '(window:keydown)': 'onKey($event)', '(document:visibilitychange)': 'onVisibilityChange()' },
 })
 export class Snake {
-  private readonly api = inject(SnakeApi);
   private readonly wakeLock = inject(ScreenWakeLock);
 
   protected readonly size = SIZE;
@@ -28,14 +27,12 @@ export class Snake {
   protected readonly food = signal(-1);
   protected readonly foodEaten = signal(0);
   protected readonly status = signal('Watch the self-taught AI play, or play it yourself.');
-  protected readonly modelStatus = signal<SnakeStatus | null>(null);
 
-  private socket: WebSocket | null = null;
   private timer: ReturnType<typeof setInterval> | null = null;
   private game: SnakeGame | null = null;
+  private director: SnakeDirector | null = null;
 
   constructor() {
-    this.pollStatus();
     inject(DestroyRef).onDestroy(() => this.stop());
   }
 
@@ -46,24 +43,21 @@ export class Snake {
     return 'cell';
   }
 
-  // --- Watch AI (principle B: backend drives, we render) ---
-  protected async watchAi(): Promise<void> {
+  // --- Watch AI: the whole AI (physics + net + masked-greedy policy) runs in the browser (M33) ---
+  protected watchAi(): void {
     this.stop();
-    const st = await this.api.status().catch(() => null);
-    this.modelStatus.set(st);
-    if (!st || st.status !== 'ready') {
-      this.status.set(st?.status === 'loading' ? 'The AI is still loading — try again shortly.' : 'AI unavailable.');
-      return;
-    }
     this.mode.set('watch');
-    void this.wakeLock.acquire(); // keep the phone screen on so an auto-lock doesn't freeze the stream
-    this.status.set('Watching the AI play (the server drives the game)…');
-    this.socket = this.api.connectLive(
-      f => {
-        this.render(f.body, f.food, f.foodEaten);
-        if (f.done) this.status.set(`AI died after eating ${f.foodEaten} (length ${f.length}). Restarting…`);
-      },
-      () => { if (this.mode() === 'watch') this.status.set('Stream closed.'); });
+    void this.wakeLock.acquire(); // keep the phone screen on so an auto-lock doesn't freeze the game
+    this.status.set('Loading the AI…');
+    this.director = new SnakeDirector();
+    this.timer = setInterval(() => {
+      const f = this.director?.step();
+      if (!f) return; // checkpoint still loading
+      this.render(f.body, f.food, f.foodEaten);
+      this.status.set(f.done
+        ? `AI died after eating ${f.foodEaten} (length ${f.length}). Restarting…`
+        : 'Watching the AI play — it all runs in your browser.');
+    }, 120);
   }
 
   // --- Human play (client-side, JS timer) ---
@@ -93,19 +87,17 @@ export class Snake {
   }
 
   protected stop(): void {
-    this.socket?.close();
-    this.socket = null;
     this.clearTimer();
     this.game = null;
+    this.director = null;
     void this.wakeLock.release();
     if (this.mode() !== 'idle') this.mode.set('idle');
   }
 
-  // A backgrounded tab (phone lock / tab switch) gets frozen and the stream socket drops; when we return to
-  // the foreground still in watch mode, reopen it so the AI resumes instead of staying stopped.
+  // A backgrounded tab is throttled by the OS and drops the wake-lock; on returning to the foreground still in
+  // watch mode, re-acquire it (the director just keeps ticking — no socket to reopen).
   protected onVisibilityChange(): void {
-    if (document.visibilityState !== 'visible' || this.mode() !== 'watch') return;
-    if (!this.socket || this.socket.readyState >= WebSocket.CLOSING) void this.watchAi();
+    if (document.visibilityState === 'visible' && this.mode() === 'watch') void this.wakeLock.acquire();
   }
 
   private render(body: number[], food: number, eaten: number): void {
@@ -118,16 +110,4 @@ export class Snake {
   private clearTimer(): void {
     if (this.timer !== null) { clearInterval(this.timer); this.timer = null; }
   }
-
-  private pollStatus(): void {
-    void (async () => {
-      try {
-        const s = await this.api.status();
-        this.modelStatus.set(s);
-        if (s.status === 'loading') setTimeout(() => this.pollStatus(), 3000);
-      } catch {
-        // backend unreachable — leave status unknown; buttons stay usable
-      }
-    })();
-  }
 }
diff --git a/src/RLDemo.Web/ClientApp/src/app/snake/snake_solver.ts b/src/RLDemo.Web/ClientApp/src/app/snake/snake_solver.ts
new file mode 100644
index 0000000..866549b
--- /dev/null
+++ b/src/RLDemo.Web/ClientApp/src/app/snake/snake_solver.ts
@@ -0,0 +1,411 @@
+export type Option<T> = { tag: "Some"; value: T } | { tag: "None" };
+export class PgSnakeNet {
+    inputSize: number;
+    actions: number;
+    hidden: number[];
+    trunkWFlat: number[];
+    trunkBFlat: number[];
+    valueW: number[];
+    valueB: number[];
+    advW: number[];
+    advB: number[];
+    constructor(inputSize: number, actions: number, hidden: number[], trunkWFlat: number[], trunkBFlat: number[], valueW: number[], valueB: number[], advW: number[], advB: number[]) {
+        this.inputSize = inputSize;
+        this.actions = actions;
+        this.hidden = hidden;
+        this.trunkWFlat = trunkWFlat;
+        this.trunkBFlat = trunkBFlat;
+        this.valueW = valueW;
+        this.valueB = valueB;
+        this.advW = advW;
+        this.advB = advB;
+    }
+    forward(obs: number[]): number[] {
+        let x = obs;
+        let prev = this.inputSize;
+        let wOff = 0;
+        let bOff = 0;
+        for (let l = 0; l < this.hidden.length; l++) {
+            const h = this.hidden[l];
+            x = PgSnakeNet.relu(PgSnakeNet.linear(x, this.trunkWFlat, wOff, this.trunkBFlat, bOff, prev, h));
+            wOff += Math.imul(prev, h);
+            bOff += h;
+            prev = h;
+        }
+        const value = PgSnakeNet.linear(x, this.valueW, 0, this.valueB, 0, prev, 1);
+        const adv = PgSnakeNet.linear(x, this.advW, 0, this.advB, 0, prev, this.actions);
+        let sumA = 0.0;
+        for (let k = 0; k < this.actions; k++) {
+            sumA += adv[k];
+        }
+        const meanA = sumA / this.actions;
+        const v = value[0];
+        let q = [];
+        for (let k = 0; k < this.actions; k++) {
+            q.push(adv[k] + (v - meanA));
+        }
+        return q;
+    }
+    static linear(x: number[], w: number[], wOff: number, b: number[], bOff: number, inDim: number, outDim: number): number[] {
+        let out = [];
+        for (let o = 0; o < outDim; o++) {
+            let s = b[(bOff + o | 0)];
+            for (let i = 0; i < inDim; i++) {
+                s += x[i] * w[((wOff + Math.imul(i, outDim) | 0) + o | 0)];
+            }
+            out.push(s);
+        }
+        return out;
+    }
+    static relu(x: number[]): number[] {
+        let out = [];
+        for (const v of x) {
+            out.push(((a, b) => (a >= b ? a : b))(0.0, v));
+        }
+        return out;
+    }
+}
+export class PgSnakeEnv {
+    static readonly ActionCount: number = 4;
+    static readonly PatchRadius: number = 4;
+    static readonly PatchSide: number = 9;
+    static readonly PatchPlane: number = 81;
+    static readonly PatchSize: number = 162;
+    static readonly ObservationSize: number = 177;
+    static readonly FoodReward: number = 1.0;
+    static readonly DeathReward: number = -1.0;
+    size: number;
+    cells: number;
+    stepPenalty: number;
+    safeMask: boolean;
+    body: number[];
+    occupied: boolean[];
+    food: number;
+    foodEaten: number;
+    heading: number;
+    elapsedSteps: number;
+    stepsSinceFood: number;
+    done: boolean;
+    lastReward: number;
+    lastTerminated: boolean;
+    lastTruncated: boolean;
+    needsFood: boolean;
+    constructor(size: number, stepPenalty: number, safeMask: boolean) {
+        this.size = size;
+        this.cells = Math.imul(size, size);
+        this.stepPenalty = stepPenalty;
+        this.safeMask = safeMask;
+        this.body = [];
+        this.occupied = [];
+        for (let i = 0; i < this.cells; i++) {
+            this.occupied.push(false);
+        }
+        this.food = 0;
+        this.foodEaten = 0;
+        this.heading = 3;
+        this.elapsedSteps = 0;
+        this.stepsSinceFood = 0;
+        this.done = true;
+        this.lastReward = 0.0;
+        this.lastTerminated = false;
+        this.lastTruncated = false;
+        this.needsFood = false;
+    }
+    static drOf(a: number): number {
+        if (a === 0) {
+            return (-1 | 0);
+        }
+        if (a === 1) {
+            return 1;
+        }
+        return 0;
+    }
+    static dcOf(a: number): number {
+        if (a === 2) {
+            return (-1 | 0);
+        }
+        if (a === 3) {
+            return 1;
+        }
+        return 0;
+    }
+    static iabs(x: number): number {
+        if (x < 0) {
+            return (0 - x | 0);
+        }
+        return x;
+    }
+    headCell(): number {
+        return this.body[(this.body.length - 1 | 0)];
+    }
+    neckCell(): number {
+        return this.body[(this.body.length - 2 | 0)];
+    }
+    tailCell(): number {
+        return this.body[0];
+    }
+    get length(): number {
+        return this.body.length;
+    }
+    freeCount(): number {
+        return (this.cells - this.body.length | 0);
+    }
+    reset(): void {
+        this.body = [];
+        for (let i = 0; i < this.cells; i++) {
+            this.occupied[i] = false;
+        }
+        const row = (this.size / 2 | 0);
+        const headCol = (this.size / 2 | 0);
+        for (let c = (headCol - 2 | 0); c < (headCol + 1 | 0); c++) {
+            const cell = (Math.imul(row, this.size) + c | 0);
+            this.body.push(cell);
+            this.occupied[cell] = true;
+        }
+        this.heading = 3;
+        this.foodEaten = 0;
+        this.elapsedSteps = 0;
+        this.stepsSinceFood = 0;
+        this.done = false;
+    }
+    spawnFood(pick: number): void {
+        let p = pick;
+        for (let cell = 0; cell < this.cells; cell++) {
+            if (this.occupied[cell]) {
+                continue;
+            }
+            if (p === 0) {
+                this.food = cell;
+                return;
+            }
+            p = (p - 1 | 0);
+        }
+    }
+    step(action: number): void {
+        this.needsFood = false;
+        const head = this.headCell();
+        const headRow = (head / this.size | 0);
+        const headCol = (head % this.size | 0);
+        const newRow = (headRow + PgSnakeEnv.drOf(action) | 0);
+        const newCol = (headCol + PgSnakeEnv.dcOf(action) | 0);
+        if (newRow < 0 || newRow >= this.size || newCol < 0 || newCol >= this.size) {
+            this.die();
+            return;
+        }
+        const newHead = (Math.imul(newRow, this.size) + newCol | 0);
+        const eating = newHead === this.food;
+        const tail = this.tailCell();
+        if (this.occupied[newHead] && !(newHead === tail && !eating)) {
+            this.die();
+            return;
+        }
+        this.body.push(newHead);
+        this.heading = action;
+        let terminated = false;
+        if (eating) {
+            this.occupied[newHead] = true;
+            this.foodEaten = (this.foodEaten + 1 | 0);
+            this.stepsSinceFood = 0;
+            this.lastReward = PgSnakeEnv.FoodReward;
+            if (this.body.length === this.cells) {
+                terminated = true;
+            } else {
+                this.needsFood = true;
+            }
+        } else {
+            this.occupied[tail] = false;
+            this.body.splice(0, 1);
+            this.occupied[newHead] = true;
+            this.stepsSinceFood = (this.stepsSinceFood + 1 | 0);
+            this.lastReward = this.stepPenalty;
+        }
+        this.elapsedSteps = (this.elapsedSteps + 1 | 0);
+        const starveLimit = Math.imul(2, this.cells);
+        const maxSteps = Math.imul(100, this.cells);
+        const truncated = !terminated && (this.stepsSinceFood >= starveLimit || this.elapsedSteps >= maxSteps);
+        this.done = terminated || truncated;
+        this.lastTerminated = terminated;
+        this.lastTruncated = truncated;
+    }
+    die(): void {
+        this.done = true;
+        this.lastReward = PgSnakeEnv.DeathReward;
+        this.lastTerminated = true;
+        this.lastTruncated = false;
+    }
+    obstacle(r: number, c: number, tail: number): boolean {
+        if (r < 0 || r >= this.size || c < 0 || c >= this.size) {
+            return true;
+        }
+        const cell = (Math.imul(r, this.size) + c | 0);
+        return this.occupied[cell] && cell !== tail;
+    }
+    freeCell(r: number, c: number, tail: number): boolean {
+        if (r < 0 || r >= this.size || c < 0 || c >= this.size) {
+            return false;
+        }
+        const cell = (Math.imul(r, this.size) + c | 0);
+        return !this.occupied[cell] || cell === tail;
+    }
+    reachableFreeSpace(r: number, c: number, tail: number): number {
+        if (!this.freeCell(r, c, tail)) {
+            return 0;
+        }
+        let seen = [];
+        for (let i = 0; i < this.cells; i++) {
+            seen.push(false);
+        }
+        seen[(Math.imul(r, this.size) + c | 0)] = true;
+        let changed = true;
+        for (let _pass = 0; _pass < this.cells; _pass++) {
+            if (!changed) {
+                break;
+            }
+            changed = false;
+            for (let cell = 0; cell < this.cells; cell++) {
+                if (!seen[cell]) {
+                    continue;
+                }
+                const cr = (cell / this.size | 0);
+                const cc = (cell % this.size | 0);
+                for (let a = 0; a < PgSnakeEnv.ActionCount; a++) {
+                    const nr = (cr + PgSnakeEnv.drOf(a) | 0);
+                    const nc = (cc + PgSnakeEnv.dcOf(a) | 0);
+                    if (!this.freeCell(nr, nc, tail)) {
+                        continue;
+                    }
+                    const n = (Math.imul(nr, this.size) + nc | 0);
+                    if (!seen[n]) {
+                        seen[n] = true;
+                        changed = true;
+                    }
+                }
+            }
+        }
+        let count = 0;
+        for (let cell = 0; cell < this.cells; cell++) {
+            if (seen[cell]) {
+                count = (count + 1 | 0);
+            }
+        }
+        return count;
+    }
+    buildObservation(): number[] {
+        const head = this.headCell();
+        const hr = (head / this.size | 0);
+        const hc = (head % this.size | 0);
+        const tail = this.tailCell();
+        const fr = (this.food / this.size | 0);
+        const fc = (this.food % this.size | 0);
+        let obs = [];
+        for (let _pad = 0; _pad < PgSnakeEnv.ObservationSize; _pad++) {
+            obs.push(0.0);
+        }
+        let i = 0;
+        for (let dr = (0 - PgSnakeEnv.PatchRadius | 0); dr < (PgSnakeEnv.PatchRadius + 1 | 0); dr++) {
+            for (let dc = (0 - PgSnakeEnv.PatchRadius | 0); dc < (PgSnakeEnv.PatchRadius + 1 | 0); dc++) {
+                const r = (hr + dr | 0);
+                const c = (hc + dc | 0);
+                if ((dr !== 0 || dc !== 0) && this.obstacle(r, c, tail)) {
+                    obs[i] = 1.0;
+                }
+                if (r === fr && c === fc) {
+                    obs[(PgSnakeEnv.PatchPlane + i | 0)] = 1.0;
+                }
+                i = (i + 1 | 0);
+            }
+        }
+        let s = PgSnakeEnv.PatchSize;
+        obs[s] = (fc - hc | 0) / this.size;
+        s = (s + 1 | 0);
+        obs[s] = (fr - hr | 0) / this.size;
+        s = (s + 1 | 0);
+        obs[s] = (PgSnakeEnv.iabs((fr - hr | 0)) + PgSnakeEnv.iabs((fc - hc | 0)) | 0) / (2.0 * this.size);
+        s = (s + 1 | 0);
+        obs[s] = (this.heading === 0 ? 1.0 : 0.0);
+        s = (s + 1 | 0);
+        obs[s] = (this.heading === 1 ? 1.0 : 0.0);
+        s = (s + 1 | 0);
+        obs[s] = (this.heading === 2 ? 1.0 : 0.0);
+        s = (s + 1 | 0);
+        obs[s] = (this.heading === 3 ? 1.0 : 0.0);
+        s = (s + 1 | 0);
+        obs[s] = this.body.length / this.cells;
+        s = (s + 1 | 0);
+        for (let a = 0; a < PgSnakeEnv.ActionCount; a++) {
+            obs[s] = this.reachableFreeSpace((hr + PgSnakeEnv.drOf(a) | 0), (hc + PgSnakeEnv.dcOf(a) | 0), tail) / this.cells;
+            s = (s + 1 | 0);
+        }
+        const tr = (tail / this.size | 0);
+        const tc = (tail % this.size | 0);
+        obs[s] = (tc - hc | 0) / this.size;
+        s = (s + 1 | 0);
+        obs[s] = (tr - hr | 0) / this.size;
+        s = (s + 1 | 0);
+        obs[s] = (PgSnakeEnv.iabs((tr - hr | 0)) + PgSnakeEnv.iabs((tc - hc | 0)) | 0) / (2.0 * this.size);
+        s = (s + 1 | 0);
+        return obs;
+    }
+    currentActionMask(): boolean[] {
+        let mask = [];
+        for (let a = 0; a < PgSnakeEnv.ActionCount; a++) {
+            mask.push(true);
+        }
+        if (this.body.length < 2) {
+            return mask;
+        }
+        const head = this.headCell();
+        const neck = this.neckCell();
+        const headRow = (head / this.size | 0);
+        const headCol = (head % this.size | 0);
+        for (let a = 0; a < PgSnakeEnv.ActionCount; a++) {
+            const r = (headRow + PgSnakeEnv.drOf(a) | 0);
+            const c = (headCol + PgSnakeEnv.dcOf(a) | 0);
+            if (r >= 0 && r < this.size && c >= 0 && c < this.size && (Math.imul(r, this.size) + c | 0) === neck) {
+                mask[a] = false;
+            }
+        }
+        if (!this.safeMask) {
+            return mask;
+        }
+        const tail = this.tailCell();
+        const len = this.body.length;
+        let safe = [];
+        for (let a = 0; a < PgSnakeEnv.ActionCount; a++) {
+            safe.push(mask[a]);
+        }
+        let any = false;
+        for (let a = 0; a < PgSnakeEnv.ActionCount; a++) {
+            if (!mask[a]) {
+                continue;
+            }
+            if (this.reachableFreeSpace((headRow + PgSnakeEnv.drOf(a) | 0), (headCol + PgSnakeEnv.dcOf(a) | 0), tail) >= len) {
+                any = true;
+            } else {
+                safe[a] = false;
+            }
+        }
+        if (any) {
+            return safe;
+        }
+        return mask;
+    }
+    chooseAction(net: PgSnakeNet): number {
+        const q = net.forward(this.buildObservation());
+        const mask = this.currentActionMask();
+        let best = (-1 | 0);
+        for (let a = 0; a < PgSnakeEnv.ActionCount; a++) {
+            if (!mask[a]) {
+                continue;
+            }
+            if (best < 0) {
+                best = a;
+            } else {
+                if (q[a] > q[best]) {
+                    best = a;
+                }
+            }
+        }
+        return best;
+    }
+}
diff --git a/src/RLDemo.Web/Controllers/MountainCarController.cs b/src/RLDemo.Web/Controllers/MountainCarController.cs
deleted file mode 100644
index 1b50d75..0000000
--- a/src/RLDemo.Web/Controllers/MountainCarController.cs
+++ /dev/null
@@ -1,57 +0,0 @@
-using Microsoft.AspNetCore.Mvc;
-using MintPlayer.AI.ReinforcementLearning.Environments;
-using RLDemo.Web.Services;
-
-namespace RLDemo.Web.Controllers;
-
-/// <summary>One streamed frame of an AI MountainCar episode (PRD §7.1 principle B). <c>Action = -1</c> marks a reset.</summary>
-public sealed record MountainCarFrameDto(float Position, float Velocity, int Action, double Reward, bool Done);
-
-[ApiController]
-[Route("api/mountaincar")]
-public sealed class MountainCarController(MountainCarModelService model) : ControllerBase
-{
-    private static int _seedCounter;
-
-    [HttpGet("status")]
-    public StatusResponse Status()
-    {
-        _ = model.Agent; // touch: lazily loads a stored checkpoint
-        return new(model.Status.ToString().ToLowerInvariant(), model.Error);
-    }
-
-    /// <summary>
-    /// Server-authoritative live stream of the trained AI driving MountainCar (PRD §7.1 principle B): the
-    /// backend owns the episode + clock and pushes one frame per tick; the browser renders. 503 (rejected
-    /// upgrade) = still training.
-    /// <para>Accepts GET (HTTP/1.1 Upgrade) AND CONNECT (HTTP/2 Extended CONNECT, RFC 8441) so the WebSocket
-    /// works over both — over HTTPS the browser negotiates HTTP/2, where a GET-only route returns 405.</para>
-    /// </summary>
-    [AcceptVerbs("GET", "CONNECT", Route = "live")]
-    public async Task Live()
-    {
-        if (!HttpContext.WebSockets.IsWebSocketRequest)
-        {
-            Response.StatusCode = StatusCodes.Status400BadRequest;
-            return;
-        }
-        var agent = model.Agent;
-        if (agent is null)
-        {
-            Response.StatusCode = StatusCodes.Status503ServiceUnavailable;
-            return;
-        }
-
-        using var socket = await HttpContext.WebSockets.AcceptWebSocketAsync();
-        var env = new MountainCarEnv(); // standard 200-step env for the live demo
-        ulong seed = (ulong)System.Threading.Interlocked.Increment(ref _seedCounter);
-        await EpisodeStreamer.RunAsync(
-            socket,
-            env,
-            act: (obs, _) => agent.Act(obs, greedy: true),
-            frame: (e, action, step) => new MountainCarFrameDto((float)e.Position, (float)e.Velocity, action, step.Reward, step.Done),
-            tickMs: 45, // smooth car motion
-            startSeed: seed,
-            ct: HttpContext.RequestAborted);
-    }
-}
diff --git a/src/RLDemo.Web/Controllers/SnakeController.cs b/src/RLDemo.Web/Controllers/SnakeController.cs
deleted file mode 100644
index 679db34..0000000
--- a/src/RLDemo.Web/Controllers/SnakeController.cs
+++ /dev/null
@@ -1,60 +0,0 @@
-using Microsoft.AspNetCore.Mvc;
-using MintPlayer.AI.ReinforcementLearning.Environments.Snake;
-using RLDemo.Web.Services;
-
-namespace RLDemo.Web.Controllers;
-
-/// <summary>One streamed frame of an AI Snake game (PRD §7.1 principle B). <c>Action = -1</c> marks a freshly reset start state.</summary>
-public sealed record SnakeFrameDto(int[] Body, int Food, int Action, double Reward, bool Done, int FoodEaten, int Length);
-
-[ApiController]
-[Route("api/snake")]
-public sealed class SnakeController(SnakeModelService model) : ControllerBase
-{
-    private static int _seedCounter;
-
-    [HttpGet("status")]
-    public StatusResponse Status()
-    {
-        _ = model.Agent; // touch: lazily loads a stored checkpoint so status reflects it
-        return new(model.Status.ToString().ToLowerInvariant(), model.Error);
-    }
-
-    /// <summary>
-    /// Server-authoritative live stream of the trained AI playing Snake (PRD §7.1 principle B). The backend
-    /// owns the episode + clock and pushes one frame per tick; the browser is a pure renderer. A 503 (rejected
-    /// upgrade) means the model is still training — the client polls <c>status</c> and connects when ready.
-    /// <para>Accepts GET (HTTP/1.1 Upgrade) AND CONNECT (HTTP/2 Extended CONNECT, RFC 8441) so the WebSocket
-    /// works over both — over HTTPS the browser negotiates HTTP/2, where a GET-only route returns 405.</para>
-    /// </summary>
-    [AcceptVerbs("GET", "CONNECT", Route = "live")]
-    public async Task Live()
-    {
-        if (!HttpContext.WebSockets.IsWebSocketRequest)
-        {
-            Response.StatusCode = StatusCodes.Status400BadRequest;
-            return;
-        }
-        var agent = model.Agent;
-        if (agent is null)
-        {
-            Response.StatusCode = StatusCodes.Status503ServiceUnavailable; // still training — reject the upgrade
-            return;
-        }
-
-        using var socket = await HttpContext.WebSockets.AcceptWebSocketAsync();
-        // Shield on: the deployed net is trained with the anti-self-trap action mask (M27), so the live demo
-        // must use the same mask the policy expects (and it makes the snake visibly stronger regardless).
-        var env = new SnakeEnv(safeMask: true);
-        ulong seed = (ulong)System.Threading.Interlocked.Increment(ref _seedCounter); // distinct game per connection
-        await EpisodeStreamer.RunAsync(
-            socket,
-            env,
-            act: (obs, mask) => agent.Act(obs, mask, greedy: true),
-            frame: (e, action, step) => new SnakeFrameDto(
-                [.. e.Body], e.Food, action, step.Reward, step.Done, e.FoodEaten, e.Length),
-            tickMs: 120,
-            startSeed: seed,
-            ct: HttpContext.RequestAborted);
-    }
-}
diff --git a/src/RLDemo.Web/Program.cs b/src/RLDemo.Web/Program.cs
index 97d1d7c..df72246 100644
--- a/src/RLDemo.Web/Program.cs
+++ b/src/RLDemo.Web/Program.cs
@@ -38,15 +38,11 @@
 builder.Services.AddSingleton<RushHourModelService>();
 builder.Services.AddSingleton<Game2048ModelService>();
 builder.Services.AddSingleton<CubeModelService>();
-builder.Services.AddSingleton<SnakeModelService>();
-builder.Services.AddSingleton<MountainCarModelService>();
 // FruitCake has no server model service: its AI (physics + net + depth-3 search) runs entirely in the browser
 // from the single-source Polyglot core + the shipped ClientApp/public/fruitcake-net.ckpt (M32). Zero server inference.
 builder.Services.AddSingleton<IModelStartupService>(sp => sp.GetRequiredService<RushHourModelService>());
 builder.Services.AddSingleton<IModelStartupService>(sp => sp.GetRequiredService<Game2048ModelService>());
 builder.Services.AddSingleton<IModelStartupService>(sp => sp.GetRequiredService<CubeModelService>());
-builder.Services.AddSingleton<IModelStartupService>(sp => sp.GetRequiredService<SnakeModelService>());
-builder.Services.AddSingleton<IModelStartupService>(sp => sp.GetRequiredService<MountainCarModelService>());
 builder.Services.AddSingleton<IModelStartupService, CubeSolverWarmupService>();
 
 // Integration tests control the model store themselves and host no SPA.
@@ -66,7 +62,8 @@
 
 app.UseStaticFiles();
 app.UseRouting();
-app.UseWebSockets(); // principle B (PRD §7.1): the live "watch the AI play" streams (e.g. Snake, MountainCar)
+// No server WebSockets: every game's "watch AI" now runs client-side (M32/M33). The remaining controllers are
+// request/response REST (2048/RushHour/Cube solvers + /api/version).
 app.MapControllers();
 
 if (hostSpa)
diff --git a/src/RLDemo.Web/Services/EpisodeStreamer.cs b/src/RLDemo.Web/Services/EpisodeStreamer.cs
deleted file mode 100644
index 71158ee..0000000
--- a/src/RLDemo.Web/Services/EpisodeStreamer.cs
+++ /dev/null
@@ -1,69 +0,0 @@
-using System.Net.WebSockets;
-using System.Text;
-using System.Text.Json;
-using MintPlayer.AI.ReinforcementLearning.Core.Environments;
-
-namespace RLDemo.Web.Services;
-
-/// <summary>
-/// The reusable server side of the "watch the AI play" interaction (PRD §7.1, principle B):
-/// <b>the backend owns the episode loop and the clock</b>. It runs a fresh env per connection
-/// (Reset → loop{ policy → Step → send frame } until done, then restart for continuous play),
-/// streaming one JSON frame per tick. The browser is a pure renderer with no timer of its own, so
-/// pacing is server-controlled and there is no client-timer race.
-/// <para>
-/// Each call owns its own <typeparamref name="TEnv"/> instance, so concurrent sockets are isolated
-/// automatically — the only shared thing is the (read-only) policy behind <paramref name="act"/>.
-/// The loop ends when the socket closes (client navigates away → <paramref name="ct"/> trips).
-/// </para>
-/// </summary>
-public static class EpisodeStreamer
-{
-    public static async Task RunAsync<TEnv>(
-        WebSocket socket,
-        TEnv env,
-        Func<float[], bool[]?, int> act,
-        Func<TEnv, int, StepResult<float[]>, object> frame,
-        int tickMs,
-        ulong startSeed,
-        CancellationToken ct)
-        where TEnv : IEnvironment<float[], int>
-    {
-        var masker = env as IActionMaskProvider;
-        ulong seed = startSeed;
-        try
-        {
-            while (socket.State == WebSocketState.Open && !ct.IsCancellationRequested)
-            {
-                var (obs, _) = env.Reset(seed++);
-                // Frame with action = -1 marks the freshly reset start state so the client draws it.
-                await Send(socket, frame(env, -1, new StepResult<float[]>(obs, 0, false, false, EnvInfo.Empty)), ct);
-                await Task.Delay(tickMs, ct);
-
-                while (socket.State == WebSocketState.Open && !ct.IsCancellationRequested)
-                {
-                    int action = act(obs, masker?.CurrentActionMask());
-                    var step = env.Step(action);
-                    obs = step.Observation;
-                    await Send(socket, frame(env, action, step), ct);
-                    if (step.Done)
-                    {
-                        await Task.Delay(tickMs * 5, ct); // brief pause on the final frame, then restart
-                        break;
-                    }
-                    await Task.Delay(tickMs, ct);
-                }
-            }
-        }
-        catch (OperationCanceledException) { /* client disconnected — expected */ }
-        catch (WebSocketException) { /* socket dropped mid-send — expected */ }
-    }
-
-    private static readonly JsonSerializerOptions Json = new(JsonSerializerDefaults.Web);
-
-    private static Task Send(WebSocket socket, object frame, CancellationToken ct)
-    {
-        var bytes = Encoding.UTF8.GetBytes(JsonSerializer.Serialize(frame, Json));
-        return socket.SendAsync(bytes, WebSocketMessageType.Text, endOfMessage: true, ct);
-    }
-}
diff --git a/src/RLDemo.Web/Services/MountainCarModelService.cs b/src/RLDemo.Web/Services/MountainCarModelService.cs
deleted file mode 100644
index 192ce22..0000000
--- a/src/RLDemo.Web/Services/MountainCarModelService.cs
+++ /dev/null
@@ -1,59 +0,0 @@
-using MintPlayer.AI.ReinforcementLearning.Core.Checkpoints;
-using MintPlayer.AI.ReinforcementLearning.Core.Random;
-using MintPlayer.AI.ReinforcementLearning.Core.Training;
-
-namespace RLDemo.Web.Services;
-
-/// <summary>
-/// Owns the MountainCar policy: loads the shipped PPO actor from the model store at startup (trained on a dev
-/// machine, PLAN M22, and committed to <c>models/</c> via Git LFS — the web never trains, PRD §14).
-/// </summary>
-public sealed class MountainCarModelService(IModelStore store, ILogger<MountainCarModelService> logger) : IModelStartupService
-{
-    public const string EnvironmentId = "mountaincar";
-    public const string AlgorithmId = "ppo";
-    public const ulong AgentSeed = 1; // seeds the loaded policy's sampling RNG
-
-    private readonly object _lock = new();
-    private PolicyAgent? _agent;
-
-    public ModelStatus Status { get; private set; } = ModelStatus.Loading;
-    public string? Error { get; private set; }
-
-    /// <summary>The greedy policy agent, or null while not ready. Loads lazily from the store.</summary>
-    public PolicyAgent? Agent
-    {
-        get
-        {
-            if (_agent is null && Status == ModelStatus.Loading) TryLoadFromStore();
-            return _agent;
-        }
-    }
-
-    public bool TryLoadFromStore()
-    {
-        lock (_lock)
-        {
-            if (_agent is not null) return true;
-            using var stream = store.TryOpenRead(EnvironmentId, AlgorithmId);
-            if (stream is null) return false;
-            var actor = MlpCheckpoint.Load(stream);
-            _agent = new PolicyAgent(actor, new Xoshiro256StarStar(AgentSeed));
-            Status = ModelStatus.Ready;
-            logger.LogInformation("Loaded MountainCar policy from the store.");
-            return true;
-        }
-    }
-
-    /// <summary>Loads the shipped checkpoint at startup. The web does not train (PRD §14).</summary>
-    public void Initialize(CancellationToken cancellationToken)
-    {
-        if (TryLoadFromStore()) return;
-        lock (_lock)
-        {
-            Status = ModelStatus.Failed;
-            Error = "No trained MountainCar model in the store.";
-        }
-        logger.LogWarning("No MountainCar model in the store — game unavailable. Train it on a dev machine and commit the checkpoint to models/ (Git LFS).");
-    }
-}
diff --git a/src/RLDemo.Web/Services/SnakeModelService.cs b/src/RLDemo.Web/Services/SnakeModelService.cs
deleted file mode 100644
index 1d9e329..0000000
--- a/src/RLDemo.Web/Services/SnakeModelService.cs
+++ /dev/null
@@ -1,69 +0,0 @@
-using MintPlayer.AI.ReinforcementLearning.Core.Checkpoints;
-using MintPlayer.AI.ReinforcementLearning.Core.Training;
-using MintPlayer.AI.ReinforcementLearning.Environments.Snake;
-
-namespace RLDemo.Web.Services;
-
-/// <summary>
-/// Owns the Snake Q-network: loads the shipped <see cref="DuelingQNet"/> checkpoint from the model store at
-/// startup (trained on a dev machine via the `--game snake` Lab campaign, PLAN M22, and committed to
-/// <c>models/</c> via Git LFS — the web never trains, PRD §14). Persists via <see cref="DuelingQNetCheckpoint"/>.
-/// </summary>
-public sealed class SnakeModelService(IModelStore store, ILogger<SnakeModelService> logger) : IModelStartupService
-{
-    public const string EnvironmentId = "snake";
-    public const string AlgorithmId = "dqn";
-
-    private readonly object _lock = new();
-    private GreedyQAgent? _agent;
-
-    public ModelStatus Status { get; private set; } = ModelStatus.Loading;
-    public string? Error { get; private set; }
-
-    /// <summary>The greedy inference agent, or null while not ready. Loads lazily from the store.</summary>
-    public GreedyQAgent? Agent
-    {
-        get
-        {
-            if (_agent is null && Status == ModelStatus.Loading) TryLoadFromStore();
-            return _agent;
-        }
-    }
-
-    public bool TryLoadFromStore()
-    {
-        lock (_lock)
-        {
-            if (_agent is not null) return true;
-            using var stream = store.TryOpenRead(EnvironmentId, AlgorithmId);
-            if (stream is null) return false;
-            var net = DuelingQNetCheckpoint.Load(stream);
-            // Guard against a stale net whose input width no longer matches the observation (e.g. a persistent
-            // volume holding a pre-observation-rework checkpoint). Feeding it the current obs would throw deep in
-            // the live stream ("stream closed"); instead reject it cleanly so /status reports the game unavailable.
-            if (net.InputSize != SnakeEnv.ObservationSize)
-            {
-                Status = ModelStatus.Failed;
-                Error = $"Stored Snake net expects {net.InputSize} inputs but the environment produces {SnakeEnv.ObservationSize}; the checkpoint is stale.";
-                logger.LogError("Snake model is incompatible ({Stored} vs {Expected} obs) — refusing to load it.", net.InputSize, SnakeEnv.ObservationSize);
-                return false;
-            }
-            _agent = new GreedyQAgent(net, SnakeEnv.ActionCount);
-            Status = ModelStatus.Ready;
-            logger.LogInformation("Loaded Snake model from the store.");
-            return true;
-        }
-    }
-
-    /// <summary>Loads the shipped checkpoint at startup. The web does not train (PRD §14).</summary>
-    public void Initialize(CancellationToken cancellationToken)
-    {
-        if (TryLoadFromStore()) return;
-        lock (_lock)
-        {
-            Status = ModelStatus.Failed;
-            Error = "No trained Snake model in the store.";
-        }
-        logger.LogWarning("No Snake model in the store — game unavailable. Train it via `--game snake` in the Lab and commit the checkpoint to models/ (Git LFS).");
-    }
-}
diff --git a/tests/MintPlayer.AI.ReinforcementLearning.Tests/MountainCarApiTests.cs b/tests/MintPlayer.AI.ReinforcementLearning.Tests/MountainCarApiTests.cs
deleted file mode 100644
index 556d098..0000000
--- a/tests/MintPlayer.AI.ReinforcementLearning.Tests/MountainCarApiTests.cs
+++ /dev/null
@@ -1,68 +0,0 @@
-using System.Net.Http.Json;
-using System.Net.WebSockets;
-using System.Text;
-using System.Text.Json;
-using MintPlayer.AI.ReinforcementLearning.Core.Checkpoints;
-using MintPlayer.AI.ReinforcementLearning.Core.Nn;
-using MintPlayer.AI.ReinforcementLearning.Core.Random;
-using RLDemo.Web.Controllers;
-using RLDemo.Web.Services;
-
-namespace MintPlayer.AI.ReinforcementLearning.Tests;
-
-/// <summary>MountainCar WS-upgrade contract with no model: the live stream rejects the upgrade (503).</summary>
-public class MountainCarApiNoModelTests(PlaygroundFactory factory) : IClassFixture<PlaygroundFactory>
-{
-    [Fact]
-    public async Task Live_WithoutModel_RejectsUpgrade()
-    {
-        var ws = factory.Server.CreateWebSocketClient();
-        using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(10));
-        await Assert.ThrowsAnyAsync<Exception>(() =>
-            ws.ConnectAsync(new Uri(factory.Server.BaseAddress, "api/mountaincar/live"), cts.Token));
-    }
-}
-
-/// <summary>Host fixture with a (deliberately untrained) MountainCar PPO actor in the store.</summary>
-public class MountainCarPlaygroundFactory : PlaygroundFactory
-{
-    public MountainCarPlaygroundFactory()
-    {
-        var actor = new Mlp([2, 32, 3], new Xoshiro256StarStar(7), Activation.Tanh);
-        new FileModelStore(DataDirectory).Save(
-            MountainCarModelService.EnvironmentId, MountainCarModelService.AlgorithmId, s => MlpCheckpoint.Save(actor, s));
-    }
-}
-
-public class MountainCarApiTests(MountainCarPlaygroundFactory factory) : IClassFixture<MountainCarPlaygroundFactory>
-{
-    private static readonly JsonSerializerOptions Json = new(JsonSerializerDefaults.Web);
-
-    [Fact]
-    public async Task Status_ReportsReady_WhenSeeded()
-    {
-        var status = await factory.CreateClient().GetFromJsonAsync<StatusResponse>("/api/mountaincar/status");
-        Assert.NotNull(status);
-        Assert.Equal("ready", status.Status);
-    }
-
-    [Fact]
-    public async Task Live_StreamsValidFrames()
-    {
-        var wsClient = factory.Server.CreateWebSocketClient();
-        using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(20));
-        using var socket = await wsClient.ConnectAsync(new Uri(factory.Server.BaseAddress, "api/mountaincar/live"), cts.Token);
-
-        var buffer = new byte[8 * 1024];
-        for (int i = 0; i < 3; i++)
-        {
-            var result = await socket.ReceiveAsync(buffer, cts.Token);
-            var frame = JsonSerializer.Deserialize<MountainCarFrameDto>(Encoding.UTF8.GetString(buffer, 0, result.Count), Json);
-            Assert.NotNull(frame);
-            Assert.InRange(frame.Position, -1.2f, 0.6f);   // within the track
-            Assert.InRange(frame.Velocity, -0.07f, 0.07f);
-        }
-
-        socket.Abort();
-    }
-}
diff --git a/tests/MintPlayer.AI.ReinforcementLearning.Tests/SnakeApiTests.cs b/tests/MintPlayer.AI.ReinforcementLearning.Tests/SnakeApiTests.cs
deleted file mode 100644
index 24f254b..0000000
--- a/tests/MintPlayer.AI.ReinforcementLearning.Tests/SnakeApiTests.cs
+++ /dev/null
@@ -1,105 +0,0 @@
-using System.Net.Http.Json;
-using System.Net.WebSockets;
-using System.Text;
-using System.Text.Json;
-using MintPlayer.AI.ReinforcementLearning.Core.Checkpoints;
-using MintPlayer.AI.ReinforcementLearning.Core.Nn;
-using MintPlayer.AI.ReinforcementLearning.Core.Random;
-using MintPlayer.AI.ReinforcementLearning.Environments.Snake;
-using RLDemo.Web.Controllers;
-using RLDemo.Web.Services;
-
-namespace MintPlayer.AI.ReinforcementLearning.Tests;
-
-/// <summary>Snake WS-upgrade contract with no model: the live stream rejects the upgrade (503).</summary>
-public class SnakeApiNoModelTests(PlaygroundFactory factory) : IClassFixture<PlaygroundFactory>
-{
-    [Fact]
-    public async Task Live_WithoutModel_RejectsUpgrade()
-    {
-        var ws = factory.Server.CreateWebSocketClient();
-        using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(10));
-        await Assert.ThrowsAnyAsync<Exception>(() =>
-            ws.ConnectAsync(new Uri(factory.Server.BaseAddress, "api/snake/live"), cts.Token));
-    }
-}
-
-/// <summary>Host fixture with a (deliberately untrained) Snake Dueling-DQN in the store.</summary>
-public class SnakeModelPlaygroundFactory : PlaygroundFactory
-{
-    public SnakeModelPlaygroundFactory()
-    {
-        var net = new DuelingQNet(SnakeEnv.ObservationSize, [32], SnakeEnv.ActionCount, new Xoshiro256StarStar(7));
-        new FileModelStore(DataDirectory).Save(
-            SnakeModelService.EnvironmentId, SnakeModelService.AlgorithmId, s => DuelingQNetCheckpoint.Save(net, s));
-    }
-}
-
-public class SnakeApiTests(SnakeModelPlaygroundFactory factory) : IClassFixture<SnakeModelPlaygroundFactory>
-{
-    private static readonly JsonSerializerOptions Json = new(JsonSerializerDefaults.Web);
-
-    [Fact]
-    public async Task Status_ReportsReady_WhenSeeded()
-    {
-        var status = await factory.CreateClient().GetFromJsonAsync<StatusResponse>("/api/snake/status");
-        Assert.NotNull(status);
-        Assert.Equal("ready", status.Status);
-    }
-
-    [Fact]
-    public async Task Live_StreamsValidFrames()
-    {
-        var wsClient = factory.Server.CreateWebSocketClient();
-        using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(20));
-        using var socket = await wsClient.ConnectAsync(new Uri(factory.Server.BaseAddress, "api/snake/live"), cts.Token);
-
-        var buffer = new byte[16 * 1024];
-        for (int i = 0; i < 3; i++) // first frame is the reset (action -1), then live moves
-        {
-            var result = await socket.ReceiveAsync(buffer, cts.Token);
-            var frame = JsonSerializer.Deserialize<SnakeFrameDto>(Encoding.UTF8.GetString(buffer, 0, result.Count), Json);
-            Assert.NotNull(frame);
-            const int demoCells = 12 * 12; // SnakeController serves a 12×12 grid
-            Assert.NotEmpty(frame.Body);                              // a real snake
-            Assert.InRange(frame.Food, 0, demoCells - 1);            // food on the demo grid
-            Assert.All(frame.Body, c => Assert.InRange(c, 0, demoCells - 1));
-        }
-
-        socket.Abort(); // the real teardown path: client drops, the server's next send fails and the handler exits
-    }
-}
-
-/// <summary>Host fixture with a STALE Snake net in the store — wrong input width (pre-observation-rework).</summary>
-public class SnakeStaleModelFactory : PlaygroundFactory
-{
-    public SnakeStaleModelFactory()
-    {
-        // 12 inputs on purpose (the old observation); the current env produces SnakeEnv.ObservationSize (177).
-        var net = new DuelingQNet(12, [32], SnakeEnv.ActionCount, new Xoshiro256StarStar(7));
-        new FileModelStore(DataDirectory).Save(
-            SnakeModelService.EnvironmentId, SnakeModelService.AlgorithmId, s => DuelingQNetCheckpoint.Save(net, s));
-    }
-}
-
-/// <summary>A stale/incompatible net must degrade gracefully (status not ready, WS upgrade rejected) — never the
-/// "stream closed" crash that the live handler showed when it fed the current obs to an old net.</summary>
-public class SnakeStaleModelTests(SnakeStaleModelFactory factory) : IClassFixture<SnakeStaleModelFactory>
-{
-    [Fact]
-    public async Task Status_IsNotReady_WhenStoredNetIsIncompatible()
-    {
-        var status = await factory.CreateClient().GetFromJsonAsync<StatusResponse>("/api/snake/status");
-        Assert.NotNull(status);
-        Assert.NotEqual("ready", status.Status); // refused to load the crashing net
-    }
-
-    [Fact]
-    public async Task Live_RejectsUpgrade_WhenStoredNetIsIncompatible()
-    {
-        var ws = factory.Server.CreateWebSocketClient();
-        using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(10));
-        await Assert.ThrowsAnyAsync<Exception>(() =>
-            ws.ConnectAsync(new Uri(factory.Server.BaseAddress, "api/snake/live"), cts.Token));
-    }
-}
diff --git a/tests/MintPlayer.AI.ReinforcementLearning.Tests/SnakeEnvTests.cs b/tests/MintPlayer.AI.ReinforcementLearning.Tests/SnakeEnvTests.cs
index eb1c278..208987d 100644
--- a/tests/MintPlayer.AI.ReinforcementLearning.Tests/SnakeEnvTests.cs
+++ b/tests/MintPlayer.AI.ReinforcementLearning.Tests/SnakeEnvTests.cs
@@ -27,8 +27,16 @@ private static byte[] State(int[] bodyHeadFirst, int food, int heading)
         return ms.ToArray();
     }
 
-    private static HashSet<int> Occupied(SnakeEnv e) =>
-        (HashSet<int>)typeof(SnakeEnv).GetField("_occupied", BindingFlags.NonPublic | BindingFlags.Instance)!.GetValue(e)!;
+    // Read the single-source core's occupancy (List<bool> over cells) as a set of occupied cell indices. SnakeEnv
+    // is now a facade over the generated PgSnakeEnv; the occupancy lives in the core, not a _occupied HashSet.
+    private static HashSet<int> Occupied(SnakeEnv e)
+    {
+        var core = (global::PgSnakeEnv)typeof(SnakeEnv).GetField("_core", BindingFlags.NonPublic | BindingFlags.Instance)!.GetValue(e)!;
+        var set = new HashSet<int>();
+        for (int i = 0; i < core.occupied.Count; i++)
+            if (core.occupied[i]) set.Add(i);
+        return set;
+    }
 
     [Fact]
     public void TailFollowMove_KeepsOccupiedTrackingInSyncWithBody()