feat(games): iteration 4 — final polish from three-reviewer ship-readiness pass

Independent review + ECE-hardware lens + education reviewer all
converged on a small set of precision-level fixes. This commit ships
them and declares the iteration loop converged.

  1. Roofline catch window fix

     Independent reviewer spotted that the catch check ran every
     frame while a kernel was inside a 24px window (targetX+16 to
     targetX-8), meaning the catcher could drift into position
     over multiple frames and still register a catch. The ghost
     reticle promised 'land here'; the code didn't enforce it.

     New logic resolves the catch atomically when the kernel
     crosses its targetX (single frame, single decision). Either
     you're at the reticle when the kernel arrives, or you miss.
     Honors the visual promise.

  2. Prune threshold alignment

     Penalty fired at magnitude > 0.45 but visual tier rendered
     'solid blue' only above 0.55. Players clicking a medium-
     visible weight got punished without warning — 'that wasn't
     fair' response in reviewer notes.

     Changed isBright threshold to > 0.55 so the visual cue and
     the penalty threshold match. What looks bright IS bright.

  3. Prune aha card: explicit what-the-game-skips caveat

     Education reviewer: 'the aha card should explicitly say real
     pruning requires fine-tuning after — the game skips this, to
     prevent the wrong mental model.' Added that plus a note
     about 2:4 structured sparsity being required for actual GPU
     acceleration (per Lisa's hardware review).

     Now the card is honest about what the player learned vs what
     they didn't.

  4. Quantization Cliff: actually cliffs

     Independent reviewer: the game is called 'Cliff' but drops
     are purely linear — there's no moment where accuracy falls
     off. Either rename or add a nonlinearity.

     Added nonlinear penalty: int4 on an edge layer (first or
     last) triggers a 1.8× drop multiplier. Now the game has an
     actual cliff — and this matches real quantization behavior
     better (embedding and output heads collapse hard at very low
     precision, which is why LLM.int8 and AWQ keep them higher).

Convergence declaration:

  Round 1 reviewers found 6 critical architectural issues.
  Round 2 reviewers found 4 design-level issues.
  Round 3 reviewers found 4 precision-level issues.
  Each iteration caught smaller, more local issues than the last
  — the classic pattern of diminishing returns. Stopping here is
  the right call.

site/assets/games/prune.js

@@ -70,7 +70,9 @@ MLSP.games.prune = function(canvas, opts) {
 
     var mx = (w.from.x + w.to.x) / 2;
     var my = (w.from.y + w.to.y) / 2;
-    var isBright = w.magnitude > 0.45;
+    // Aligned with the visual tier threshold (> 0.55 renders as solid blue).
+    // Previously 0.45, which punished weights that looked "medium" — unfair.
+    var isBright = w.magnitude > 0.55;
     if (isBright) {
       w.wasCriticalCut = true;
       shake(7, 260);

site/assets/games/quantization.js

@@ -91,6 +91,10 @@ MLSP.games.quantization = function(canvas, opts) {
       var prec = PRECISIONS[layer.precisionIdx];
       var bitsReduction = (32 - prec.bits) / 4;
       var drop = bitsReduction * state.sensitivity[i] * 4;
+      // The actual cliff: int4 on an edge layer triggers nonlinear collapse.
+      // First and last layer at int4 = 1.8× penalty. Earns the game's name.
+      var isEdge = (i === 0 || i === NUM_LAYERS - 1);
+      if (layer.precisionIdx === 3 && isEdge) drop *= 1.8;
       state.pendingDrops.push(drop);
       state.pendingTotalDrop += drop;
       layer.revealed = false;