@@ -51,6 +51,12 @@
 UNITS: dict[str, dict] = {
     'fields.mep': {
         'fns': ['field_mep', 'write_cube', 'prepare_mol'],
+        # The numbers that DECIDE THE GEOMETRY of the cube. They are read by
+        # field_mep and contained in none of the functions above, so before they
+        # were listed here a change to the box-growing rule left the version
+        # untouched and the servable view kept serving old-geometry cubes.
+        'consts': ['PAD_MAX', 'PAD_STEP', 'FIXED_ISO', 'GRID_MAX_DIM',
+                   'ISO_ENCLOSED_FRACTION', 'ISO_SLIDER_FLOOR'],
         'exec_class': 'interactive',
         'in_schema': {'type': 'object', 'required': ['molfile'],
                       'properties': {'molfile': {'type': 'string'},
@@ -70,6 +76,8 @@
     },
     'fields.mlp': {
         'fns': ['field_mlp', 'write_cube', 'prepare_mol'],
+        'consts': ['PAD_MAX', 'PAD_STEP', 'FIXED_ISO', 'GRID_MAX_DIM',
+                   'ISO_ENCLOSED_FRACTION', 'ISO_SLIDER_FLOOR'],
         'exec_class': 'interactive',
         'in_schema': {'type': 'object', 'required': ['molfile'],
                       'properties': {'molfile': {'type': 'string'}}},
@@ -109,6 +117,12 @@
 def _qm_unit(kind: str, quantity: str, units: str) -> dict:
     return {
         'fns': _QM_FNS,
+        # A quantum cube's grid comes from pyscf's cubegen at these fixed
+        # resolutions, and the cost model decides whether it runs at all. Both
+        # are numbers, both change the output or the refusal, and neither lives
+        # inside a listed function.
+        'consts': ['CUBE_GRID_MEP', 'CUBE_GRID_ORB', 'CUBE_MEP_FIXED',
+                   'CUBE_MEP_MARGINAL', 'CUBE_ORB_FIXED', 'CUBE_ORB_MARGINAL'],
         'exec_class': 'interactive',
         'in_schema': {'type': 'object', 'required': ['molfile'],
                       'properties': {'molfile': {'type': 'string'},
@@ -133,12 +147,29 @@ def _qm_unit(kind: str, quantity: str, units: str) -> dict:
 
 # ── version = hash of the compute unit, machine-derived ─────────────────────
 
-def unit_version(module, fns: Iterable[str]) -> tuple[str, bytes]:
-    """(short hex version, full sha256) over the SOURCE of the named functions.
-
-    Sorted, so declaration order in UNITS cannot change a version. Source only:
-    a docstring edit does change it, which is the conservative direction — the
-    dangerous direction is a behaviour change that does NOT change it.
+def unit_version(module, fns: Iterable[str],
+                 consts: Iterable[str] = ()) -> tuple[str, bytes]:
+    """(short hex version, full sha256) over the SOURCE of the named functions
+    AND THE VALUES of the named module-level constants.
+
+    Sorted, so declaration order in UNITS cannot change a version. Source only
+    for functions: a docstring edit does change the version, which is the
+    conservative direction — the dangerous direction is a behaviour change that
+    does NOT change it.
+
+    ⚠ CONSTANTS WERE THE HOLE, and it cost 22 cached rows that had to be deleted
+    by hand. The geometry of an MEP cube is decided by module-level numbers —
+    PAD_MAX, PAD_STEP, FIXED_ISO, GRID_MAX_DIM — that the listed functions READ
+    but do not CONTAIN. So the box-growing rule changed, every cube's geometry
+    changed with it, and the method version did not move: reads go through
+    app.v_field_cube_servable, which keys on method currency, and it happily
+    served cubes with the OLD geometry under the NEW rule. The failure is silent
+    by construction, because a stale cube is a perfectly valid cube.
+
+    Hashing source-but-not-constants means the version misses exactly the edit
+    most likely to happen. Tuning a number IS the common change; rewriting a
+    function is the rare one. `repr` is used deliberately: 12.0 and 12 are
+    different values here and must produce different versions.
     """
     h = hashlib.sha256()
     for name in sorted(fns):
@@ -149,6 +180,14 @@ def unit_version(module, fns: Iterable[str]) -> tuple[str, bytes]:
                 f'{module.__name__} — the UNITS table has drifted from the code')
         h.update(name.encode())
         h.update(inspect.getsource(fn).encode())
+    for name in sorted(consts):
+        if not hasattr(module, name):
+            raise LookupError(
+                f'compute unit names the constant {name!r}, which does not exist '
+                f'in {module.__name__} — a constant that vanished silently stops '
+                f'being part of the version, which is how this hole was made')
+        h.update(name.encode())
+        h.update(repr(getattr(module, name)).encode())
     digest = h.digest()
     return digest.hex()[:12], digest
 
@@ -157,7 +196,8 @@ def plan(module) -> list[dict]:
     """What register_all would write. Pure; no DB. This is the smoke test."""
     out = []
     for method_id, spec in sorted(UNITS.items()):
-        version, digest = unit_version(module, spec['fns'])
+        version, digest = unit_version(module, spec['fns'],
+                                       spec.get('consts', ()))
         out.append({'method_id': method_id, 'version': version, 'sha256': digest,
                     'exec_class': spec['exec_class'], 'fns': sorted(spec['fns']),
                     'in_schema': spec['in_schema'], 'out_schema': spec['out_schema'],
 
@@ -0,0 +1,125 @@
+#!/usr/bin/env python3
+"""A method version that hashes code but not the numbers the code READS is a
+version that misses the edit most likely to happen.
+
+THE INCIDENT, 2026-08-11: the MEP box-growing rule changed (the box now grows
+until the contour closes across the whole slider range). Every cube's GEOMETRY
+changed with it. The method version did not move, because the geometry is decided
+by module-level constants — PAD_MAX, PAD_STEP, FIXED_ISO, GRID_MAX_DIM — which
+the hashed functions read and do not contain. Reads go through
+app.v_field_cube_servable, which keys on METHOD currency, so it kept serving
+old-geometry cubes under the new rule and 22 rows had to be deleted by hand.
+
+The failure is silent by construction: a stale cube is a perfectly valid cube.
+Nothing crashes, nothing looks wrong, and the picture is of a box that today's
+code would not have drawn.
+
+Tuning a number IS the common change; rewriting a function is the rare one. So
+these tests assert the version moves for BOTH, and — the part that matters —
+that it moves for the right SCOPE: a classical geometry constant must not
+invalidate the quantum units, or every tuning pass throws away real SCF work.
+
+Run: backend/env/bin/python backend/tests/test_method_version_covers_constants.py
+"""
+from __future__ import annotations
+
+import os
+import sys
+
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..'))
+
+import field_server as fs                                            # noqa: E402
+import method_registry as mr                                         # noqa: E402
+
+PASS, FAIL = [], []
+
+
+def check(name, fn):
+    try:
+        fn()
+        PASS.append(name)
+        print(f'PASS    {name}')
+    except AssertionError as e:
+        FAIL.append(name)
+        print(f'FAIL    {name}\n        {e}')
+
+
+def versions() -> dict:
+    return {u['method_id']: u['version'] for u in mr.plan(fs)}
+
+
+def moved_when(attr: str, delta):
+    """Which method versions change when a module constant changes."""
+    before = versions()
+    original = getattr(fs, attr)
+    setattr(fs, attr, delta(original))
+    try:
+        after = versions()
+    finally:
+        setattr(fs, attr, original)
+    assert versions() == before, (
+        f'restoring {attr} did not restore the versions — this test mutates '
+        f'module state and must leave it exactly as found')
+    return {k for k in before if before[k] != after[k]}
+
+
+def test_a_geometry_constant_moves_the_classical_units():
+    moved = moved_when('PAD_MAX', lambda v: v + 1.0)
+    assert moved == {'fields.mep', 'fields.mlp'}, (
+        f'PAD_MAX moved {sorted(moved)}; expected exactly the two classical grid '
+        f'units. This is the exact hole that served 22 stale-geometry cubes: if '
+        f'this set is EMPTY the version does not cover constants at all.')
+
+
+def test_a_grid_constant_moves_the_quantum_units_and_only_those():
+    moved = moved_when('CUBE_GRID_ORB', lambda v: v + 1)
+    assert moved == {'fields.qm.homo', 'fields.qm.lumo', 'fields.qm.density',
+                     'fields.qm.mep_qm'}, (
+        f'CUBE_GRID_ORB moved {sorted(moved)}; expected exactly the four quantum '
+        f'units. SCOPE is the point: a classical tuning pass that invalidated '
+        f'converged SCF results would make everyone stop tuning.')
+
+
+def test_a_classical_constant_does_not_invalidate_quantum_work():
+    moved = moved_when('PAD_STEP', lambda v: v + 0.5)
+    quantum = {m for m in moved if m.startswith('fields.qm.')}
+    assert not quantum, (
+        f'a classical padding step invalidated {sorted(quantum)} — an Fe-heme SCF '
+        f'is minutes of CPU and must not be thrown away by a change that cannot '
+        f'affect it')
+
+
+def test_the_registry_refuses_a_constant_that_does_not_exist():
+    """A named constant that vanishes must RAISE, not silently stop counting.
+
+    Silent removal is how the original hole would come back: the name disappears
+    from the module, the hash quietly covers one thing less, and nothing says so.
+    """
+    try:
+        mr.unit_version(fs, ['field_mep'], ['NO_SUCH_CONSTANT_XYZ'])
+    except LookupError as e:
+        assert 'NO_SUCH_CONSTANT_XYZ' in str(e), (
+            f'the refusal does not name the missing constant: {e}')
+        return
+    raise AssertionError(
+        'unit_version accepted a constant that does not exist — a name that '
+        'vanishes would silently leave the version, which is the failure mode '
+        'this whole file is about')
+
+
+def test_every_declared_constant_exists_today():
+    """The declarations must be true right now, not aspirational."""
+    for method_id, spec in mr.UNITS.items():
+        for const in spec.get('consts', ()):
+            assert hasattr(fs, const), (
+                f'{method_id} declares the constant {const!r}, which is not in '
+                f'field_server today')
+
+
+for name, fn in list(globals().items()):
+    if name.startswith('test_'):
+        check(name, fn)
+
+print('─' * 100)
+print(f'{len(PASS)} passed · {len(FAIL)} failed')
+sys.exit(1 if FAIL else 0)