feat(site): derive what the rig can RESOLVE, so a tie is not published as a ranking

The board can rank two gateways 1.2% apart. It could not say whether that 1.2% was a finding or which
box each landed on. This derives the answer from the board itself.

MEASURED, NOT CHOSEN. Every box runs the same qualification before it measures anything, and
`box_qualify.drift_pct` records how far it landed from the shared baseline. Those boxes are identical
by construction - same instance type, same image, same mock - so the spread between the luckiest and
unluckiest box IS what the rig cannot tell apart. On the 2026-07-30 field that is 8.27%
(-6.22% to +2.05% across 13 boxes).

A hard-coded 1% or 2% would have been an undeclared rule deciding which published comparisons count,
and this project's position is that no undeclared rule may author a number. The figure also moves with
the fleet: a tighter fleet resolves finer, and a noisier one honestly admits it resolves less.

WHAT IT SAYS ABOUT TONIGHT'S BOARD, and it is uncomfortable: busbar 46,031 vs litellm-rust 48,394 is
4.9% apart on the one cell both serve, and the rig resolved 8.27%. That comparison did not
demonstrate a difference. The wider gaps still stand - 25,101 vs 48,394 is far outside it.

Relative to the LARGER value, so the rule means the same at the bottom of the board as at the top:
19 vs 20 is 5% and 49,000 vs 50,000 is 2%, both correctly tied, while their ABSOLUTE gaps differ by
three orders of magnitude - which is precisely why an absolute threshold could not serve this board.

Null with fewer than two boxes: with one sample there is no spread to observe, and inventing a floor
from it would be the magic number this exists to avoid. Nothing may be called indistinguishable
without a resolution, since that would assert a tie on a figure we just said we could not derive.

One test bug caught writing these: I asserted 19 vs 20 was resolvable, reasoning 1/19 = 5.3%. It is
5% of the larger value, inside the rig's 8.27%, so the code was right and the expectation was wrong.

206 site tests, 0 failures.

Author: MattJackson

site/app.js

@@ -1071,6 +1071,44 @@ function hasCost(data = (typeof state !== "undefined" ? state.data : null)) {
   COST_CACHE.set(data, yes);
   return yes;
 }
+/* rigResolutionPct(data): the smallest DIFFERENCE this rig can actually resolve, derived from the
+   board itself rather than chosen.
+
+   Every box runs the SAME qualification before it measures anything, and `box_qualify.drift_pct` is
+   how far that box landed from the shared baseline. Those boxes are identical by construction - same
+   instance type, same image, same mock - so the spread between the luckiest and unluckiest box is a
+   direct measurement of what the rig cannot tell apart. Two gateways closer than that did not
+   demonstrate a difference; they demonstrated which box they happened to land on.
+
+   DERIVED, NOT PICKED. A hard-coded "1%" or "2%" would be a rule nobody measured deciding which
+   published comparisons count - and this project's whole position is that no undeclared rule may
+   author a number. The figure moves with the fleet: a tighter fleet resolves finer, and a noisier one
+   honestly admits it resolves less.
+
+   Null when fewer than two boxes report a drift: with one box there is no spread to observe, and
+   inventing a floor from a single sample would be the magic number this exists to avoid. */
+const RESOLUTION_CACHE = new WeakMap();
+function rigResolutionPct(data = (typeof state !== "undefined" ? state.data : null)) {
+  if (!data || typeof data !== "object") return null;
+  if (RESOLUTION_CACHE.has(data)) return RESOLUTION_CACHE.get(data);
+  const drifts = (data.gateways || [])
+    .map((g) => g && g.rig && g.rig.box_qualify && g.rig.box_qualify.drift_pct)
+    .filter((v) => typeof v === "number" && Number.isFinite(v));
+  const out = drifts.length >= 2 ? Math.max(...drifts) - Math.min(...drifts) : null;
+  RESOLUTION_CACHE.set(data, out);
+  return out;
+}
+
+/* indistinguishable(a, b, pct): are two published values closer than the rig can resolve?
+   Relative to the LARGER value, so the comparison means the same thing at 19 rps and at 49,000. */
+function indistinguishable(a, b, pct) {
+  if (typeof pct !== "number" || !(pct > 0)) return false;
+  if (typeof a !== "number" || typeof b !== "number") return false;
+  const hi = Math.max(Math.abs(a), Math.abs(b));
+  if (hi === 0) return true;                       // two measured zeros are the same measurement
+  return (Math.abs(a - b) / hi) * 100 < pct;
+}
+
 // The data bundle a (possibly synthetic) state refers to; falls back to the live state's.
 function stateData(st) {
   return (st && st.data) || (typeof state !== "undefined" ? state.data : null);
@@ -4887,7 +4925,7 @@ if (NODE) {
     perCellMemory, memoryCells, hasPerCellMemory, widestDialect, chosenMemory, memoryFor,
     idleAcrossCells, neverPlateaued, worstGrowth, memCellTip, neverPlateauedPill,
     idleStatic, memShape, memGrowing, memShaped,
-    hasMatrixGrid, matrixFailureReason, matrixRoster, hasCost,
+    hasMatrixGrid, matrixFailureReason, matrixRoster, hasCost, rigResolutionPct, indistinguishable,
     laneRecord, lanePathNote, perfSweepSeries, concAt,
     // THE FRONTIER: the constants (mirrored from seal.mjs and checked against it), the readers every
     // surface goes through, and the two renderers that make the curve's SHAPE legible. Exported because the

site/test.mjs

@@ -2246,6 +2246,48 @@ test("stripRigPaths scrubs absolute bench-box paths from diagnostic notes", () =
   assert.ok(!na.note.includes("/home/"));
 });
 
+test("NOISE: the rig's resolution is DERIVED from box qualification, never a chosen constant", () => {
+  // Every box runs the same qualification before measuring, and identical boxes still land apart.
+  // That spread IS what the rig cannot resolve - a measurement, not a policy. A hard-coded 1% or 2%
+  // would be an undeclared rule deciding which published comparisons count.
+  const board = (drifts) => ({
+    gateways: drifts.map((d, i) => ({ key: `g${i}`, rig: { box_qualify: { drift_pct: d } } })),
+  });
+  // The real 2026-07-30 field: 13 identical boxes spanning -6.22%..+2.05%.
+  assert.ok(Math.abs(app.rigResolutionPct(board([-6.22, -1.04, 1.86, 2.05, -0.38])) - 8.27) < 1e-9);
+
+  // ONE box has no spread to observe. Inventing a floor from a single sample is exactly the magic
+  // number this exists to avoid, so it reports that it cannot say.
+  assert.equal(app.rigResolutionPct(board([1.5])), null);
+  assert.equal(app.rigResolutionPct({ gateways: [] }), null);
+
+  // A gateway whose qualification is absent contributes nothing rather than counting as 0 drift -
+  // a missing measurement is not a perfectly-calibrated box.
+  const mixed = { gateways: [{ key: "a", rig: { box_qualify: { drift_pct: -3 } } }, { key: "b" }, { key: "c", rig: { box_qualify: { drift_pct: 2 } } }] };
+  assert.equal(app.rigResolutionPct(mixed), 5);
+});
+
+test("NOISE: two values closer than the rig can resolve are NOT a ranking", () => {
+  // busbar 46,031 vs litellm-rust 48,394 is 4.9% apart, and the 2026-07-30 fleet could only resolve
+  // 8.27%. Presenting that as a ranking claims a difference the rig never demonstrated.
+  assert.equal(app.indistinguishable(46031, 48394, 8.27), true);
+  // A gap wider than the rig's own spread IS a finding.
+  assert.equal(app.indistinguishable(25101, 48394, 8.27), false);
+  // RELATIVE TO THE LARGER VALUE, so the rule means the same thing at the bottom of the board as at
+  // the top. 19 vs 20 is 5% apart and 49,000 vs 50,000 is 2% - both inside a rig that resolves 8.27%,
+  // and both correctly tied. The absolute gaps (1 and 1,000) differ by three orders of magnitude,
+  // which is exactly why an absolute threshold could not serve this board.
+  assert.equal(app.indistinguishable(19, 20, 8.27), true);
+  assert.equal(app.indistinguishable(49000, 50000, 8.27), true);
+  // And a small-value pair that IS resolvable stays resolvable: 19 vs 25 is 24% apart.
+  assert.equal(app.indistinguishable(19, 25, 8.27), false);
+  // Two MEASURED zeros are the same measurement, not an undefined ratio.
+  assert.equal(app.indistinguishable(0, 0, 8.27), true);
+  // With no resolution known (a single box), nothing may be declared indistinguishable: that would
+  // be asserting a tie on the strength of a figure we just said we could not derive.
+  assert.equal(app.indistinguishable(100, 101, null), false);
+});
+
 test("COST: the cost columns appear only on a board that can answer them, and read through the envelope", () => {
   // ADDITIVE, NOT A REPLACEMENT. The existing columns are untouched; these follow the per-cell-memory
   // precedent and appear only when the board carries the field.