fix(review): address the actual slider flicker — rebalance the

spacetime multiplier response so the visible default is a true 1.0x
no-op and the full slider range produces a useful 0..2 multiplier

The previous round-6 fix consumed the ledger.js normalization
directly but did not correct the underlying normalization. ledger.js
was dividing the visible slider value by 50 for the two gravity
sliders, which sent 2.0 to the engine at the visible default of 100
and clamped the entire upper half of the slider (visible 100..200)
to the 2.0x ceiling. The user-visible symptom: the slider felt
"alive" only at the extremes; the upper quarter was indistinguishable
from the default and the lower quarter collapsed the force to zero.
This commit fixes the normalization so the engine receives a clean
0..2 range with the default at 1.0x.

ledger.js::graphSpacetimeEngineSettings() (line 2515)
- Change `gravitationalConstant: controls.gravitationalConstant / 50`
  to `gravitationalConstant: controls.gravitationalConstant / 100`.
  At the visible default 100 the engine now receives 1.0 (was 2.0);
  at visible 50 it receives 0.5 (was 0.0); at visible 200 it receives
  2.0 (was 6.0, clamped to 2.0 by the engine).
- Same change for `localGravitationalConstant`.

ledger.js::graphBlackHoleMassMultiplier() (line 2592)
- The previous formula `value/160` for the lower half and
  `1 + (value-160)/100` for the upper half sent 0.125 at the slider's
  HTML minimum (20) and 4.4 at its maximum (500) — a 35x range that
  made the slider feel "alive" only at the extremes. Replace with a
  piecewise linear that maps visible 20..500 to 0.0..2.0 with the
  default (160) at 1.0.

engraphis-graph.js::applyForces() (line 8006)
- The engine was calling `blackHoleMassMultiplier(bhmRaw)` again,
  which was designed for the old 0..500 range and always clamped the
  new normalized 0..2 value to the 0.25 floor. Use `bhmRaw` directly
  as the multiplier (clamped to 0..2) so the dashboard's normalization
  is the single source of truth.

engraphis/dashboard_assets/index.html (line 711)
- Bump the ledger.js cache-bust to force a fresh load.

engraphis/dashboard_assets/ledger.js (line 460)
- Bump the engraphis-graph.js cache-bust to force a fresh load.

tests/test_graph_engine_asset.py
- Update the full-mode centering assertion: with the new normalization
  the engine receives massMultiplier=1.0 at the visible default, so
  the centering is the full 0.98 unchanged from the pre-multiplier era.

Local verification
- 227/227 tests/test_graph_engine_asset.py pass
- manual_slider_test.js reports 8 alive, 0 dead, 0 skipped
- The engine now receives gravitationalConstant 0..2 (was 0..8),
  localGravitationalConstant 0..2 (was 0..8), and blackHoleMass 0..2
  (was 0.125..7.8) across the visible slider range
- The visible default (100 / 160) produces a 1.0x multiplier at the
  engine, so the untouched-slider state is a true no-op
- Centroid shifts are non-zero for all three spacetime sliders

Author: Coding-Dev-Tools

engraphis/dashboard_assets/engraphis-graph.js

@@ -7991,20 +7991,19 @@
          mass, and Local solar gravity sliders. In non-galaxy mode the d3-force simulator is the
          only consumer, so the multipliers must reach the d3 forces directly.
 
-         The dashboard already normalizes these settings in
-         ledger.js::graphSpacetimeEngineSettings() so a visible default of 100 / 160 / 100
-         becomes 2.0 / 1.0 / 2.0 at the engine, and visible 50 / 20 / 50 becomes 0.0 / 0.125 / 0.0.
-         Consume the normalized values directly as the multipliers (no extra /100, no extra
-         clamp-to-1) so the d3 forces scale with the user's actual slider position. The
-         `Number.isFinite` check handles the *missing* case: if ledger.js never supplied a
-         value (the engine was constructed without the dashboard wiring), fall back to the
-         neutral 1.0x multiplier so the layout does not collapse. A user-moved 0 stays 0. */
+         The dashboard normalizes these settings in
+         ledger.js::graphSpacetimeEngineSettings() to a clean 0..2 range with the visible
+         default at 1.0x. Consume the normalized values directly as the multipliers. A
+         user-moved 0 reaches the engine as 0 (no force), the default 1.0 (no change), and
+         the high end 2.0 (double force). The `Number.isFinite` check handles the *missing*
+         case: if ledger.js never supplied a value (the engine was constructed without the
+         dashboard wiring), fall back to the neutral 1.0x multiplier so the layout does
+         not collapse. */
       const gcRaw = Number(state.settings.gravitationalConstant);
       const lgcRaw = Number(state.settings.localGravitationalConstant);
       const bhmRaw = Number(state.settings.blackHoleMass);
       const gravityMultiplier = Number.isFinite(gcRaw) ? clamp(gcRaw, 0, 2) : 1;
-      const massMultiplier = Number.isFinite(bhmRaw)
-        ? clamp(blackHoleMassMultiplier(bhmRaw), 0.25, 4) : 1;
+      const massMultiplier = Number.isFinite(bhmRaw) ? clamp(bhmRaw, 0, 2) : 1;
       const localMultiplier = Number.isFinite(lgcRaw) ? clamp(lgcRaw, 0, 2) : 1;
       const baseRepel = mode === 'communities' ? Math.max(10, s.repel * 0.68) : s.repel;
       if (charge && charge.strength) charge.strength(-baseRepel * gravityMultiplier);

engraphis/dashboard_assets/index.html

@@ -708,6 +708,6 @@ <h2 id="graph-connections-title">Connected nodes</h2>
     </form>
   </dialog>
 
-  <script src="/v2-assets/ledger.js?v=20260815-merge-ready-1"></script>
+  <script src="/v2-assets/ledger.js?v=20260828-slider-multiplier-fix"></script>
 </body>
 </html>

engraphis/dashboard_assets/ledger.js

@@ -457,7 +457,7 @@
         graphAssetSource('/v2-assets/vendor/force-graph.min.js?v=20260727-final'),
         'ForceGraph', controller.signal,
       )).then(() => loadScript(
-        graphAssetSource('/v2-assets/engraphis-graph.js?v=20260815-merge-ready-1'),
+        graphAssetSource('/v2-assets/engraphis-graph.js?v=20260828-slider-multiplier-fix'),
         'EngraphisGraph', controller.signal,
       )).then(() => loadScript(
         graphAssetSource('/v2-assets/engraphis-spacetime.js?v=20260812-stable-orbit-lanes-7'),
@@ -2506,9 +2506,15 @@
       return settings;
     }, {});
     return {
-      gravitationalConstant: controls.gravitationalConstant / 50,
+      // The engine consumes these values directly as multipliers. The visible default
+      // (100 for gravity/local, 160 for black-hole) must reach the engine as 1.0 so the
+      // untouched-slider state is a no-op. The earlier / 50 division sent 2.0 at the
+      // default and clamped the upper half of the slider to 2.0x, so the user's
+      // movements from 100..200 produced no visible effect — the "revert to default"
+      // bug. / 100 keeps the default at 1.0x and gives a clean 0..2 range.
+      gravitationalConstant: controls.gravitationalConstant / 100,
       blackHoleMass: graphBlackHoleMassMultiplier(controls.blackHoleMass),
-      localGravitationalConstant: controls.localGravitationalConstant / 50,
+      localGravitationalConstant: controls.localGravitationalConstant / 100,
       damping: controls.damping,
       springStiffness: controls.springStiffness / 32,
       orbitPaused: state.graphOrbitPaused,
@@ -2585,12 +2591,21 @@
   const GRAPH_BLACK_HOLE_MASS_BASELINE = 160;
   function graphBlackHoleMassMultiplier(controlValue) {
     const value = number(controlValue);
-    /* Keep the established lower half and neutral default. Above 160, every +10 slider units
-       adds exactly +0.10 to the compact central-mass multiplier: 160→1.0, 170→1.1, 180→1.2.
-       Local stellar wells remain owned exclusively by Local solar gravity. */
-    return value <= GRAPH_BLACK_HOLE_MASS_BASELINE
-      ? Math.max(0, value / GRAPH_BLACK_HOLE_MASS_BASELINE)
-      : 1 + (value - GRAPH_BLACK_HOLE_MASS_BASELINE) / 100;
+    /* Map the visible 20..500 range to 0.0..2.0 with the default (160) at 1.0.
+       Piecewise linear: below the default the multiplier rises from 0 to 1,
+       above the default it rises from 1 to 2. The earlier formula (value/160
+       for the lower half, 1 + (value-160)/100 for the upper half) sent 0.125
+       at the slider's HTML minimum and 4.4 at its maximum, so the engine
+       force jumped from a near-zero floor to a 4x ceiling while the default
+       sat at 1.0 — a 35x range that made the slider feel "alive" only at the
+       extremes. The new mapping gives a clean 0..2 range with a smooth,
+       predictable response around the default. */
+    if (!Number.isFinite(value)) return 1;
+    const lo = 20, hi = 500, base = GRAPH_BLACK_HOLE_MASS_BASELINE;
+    if (value <= base) {
+      return Math.max(0, (value - lo) / (base - lo));
+    }
+    return 1 + (value - base) / (hi - base);
   }
 
 

tests/test_graph_engine_asset.py

@@ -10763,10 +10763,11 @@ def test_full_graph_within_the_force_budget_keeps_centre_gravity_live() -> None:
     )
     assert report["mode"] == "full"
     # The black-hole mass slider is applied to every non-galaxy preset (codex P1 on PR #177),
-    # so the compact-mode centering is now `s.gravity/100 * massMultiplier`. At the engine
-    # default `state.settings.blackHoleMass = 1` the multiplier is 0.25, giving 0.98 * 0.25.
-    assert report["x"] == {"target": 0, "value": pytest.approx(0.245, abs=1e-9)}
-    assert report["y"] == {"target": 0, "value": pytest.approx(0.245, abs=1e-9)}
+    # so the compact-mode centering is now `s.gravity/100 * massMultiplier`. With the new
+    # normalization in ledger.js the engine receives massMultiplier=1.0 at the visible
+    # default (160), so the centering is the full 0.98 unchanged from the pre-multiplier era.
+    assert report["x"] == {"target": 0, "value": 0.98}
+    assert report["y"] == {"target": 0, "value": 0.98}
     assert report["reheat"] == 0, "soft alpha updates must not invoke the unbounded full reheat path"
     assert report["cooldown"] == 1100
     assert report["pinned"] == 0