@@ -127,12 +127,14 @@
 # this version is re-registered with different source — a forgotten bump is a
 # loud startup error, never a silently stale cache (design: migration 006).
 PRODUCER_SERVICE = 'dirac-fields'
-PRODUCER_VERSION = '1.8'
+PRODUCER_VERSION = '1.9'
 PRODUCER_NOTES = ('wall-clock deadline inside the SCF loop + measured cube-cost '
                   'refusal; open-shell d/f metals refused without an explicit '
                   'spin (group 12 exempt); salt stripping refuses to discard a '
                   'coordination metal; iso_suggest = 97th percentile of |field| '
-                  'for mep/mlp; _eri dropped and the SCF cache bounded to 6 LRU; '
+                  'for mep/mlp RETIRED — it was a measurement of the padding (7.6x '
+                  'swing on aspirin); fixed physical contour + adaptive box instead; '
+                  '_eri dropped and the SCF cache bounded to 6 LRU; '
                   'molblock refusals name the defect')
 
 
@@ -595,32 +597,47 @@ def field_mep(mol: Chem.Mol, spacing=0.4, pad=4.0):
         raise ValueError('all Gasteiger charges are zero — classical MEP would '
                          'be an empty picture; use mep_qm')
 
-    lo = coords.min(axis=0) - pad
-    hi = coords.max(axis=0) + pad
-    dims = np.maximum(np.ceil((hi - lo) / spacing).astype(int) + 1, 8)
-    dims = np.minimum(dims, GRID_MAX_DIM)  # hard cap: 128³ ≈ 2M voxels
-    axes = np.diag((hi - lo) / (dims - 1))
-
-    xs = np.linspace(lo[0], hi[0], dims[0])
-    ys = np.linspace(lo[1], hi[1], dims[1])
-    zs = np.linspace(lo[2], hi[2], dims[2])
-    gx, gy, gz = np.meshgrid(xs, ys, zs, indexing='ij')
-    pts = np.stack([gx, gy, gz], axis=-1)  # (nx,ny,nz,3)
-
-    v = np.zeros(tuple(dims), dtype=float)
-    for q, c in zip(charges, coords):
-        r = np.linalg.norm(pts - c, axis=-1)
-        v += q / np.maximum(r, 0.5)
-    v *= 332.06  # kcal/mol per (e²/Å)
+    iso = FIXED_ISO['mep']
+
+    def evaluate(pad_a: float):
+        lo = coords.min(axis=0) - pad_a
+        hi = coords.max(axis=0) + pad_a
+        dims = np.maximum(np.ceil((hi - lo) / spacing).astype(int) + 1, 8)
+        dims = np.minimum(dims, GRID_MAX_DIM)
+        xs = np.linspace(lo[0], hi[0], dims[0])
+        ys = np.linspace(lo[1], hi[1], dims[1])
+        zs = np.linspace(lo[2], hi[2], dims[2])
+        gx, gy, gz = np.meshgrid(xs, ys, zs, indexing='ij')
+        pts = np.stack([gx, gy, gz], axis=-1)
+        vv = np.zeros(tuple(dims), dtype=float)
+        for q, c in zip(charges, coords):
+            r = np.linalg.norm(pts - c, axis=-1)
+            vv += q / np.maximum(r, 0.5)
+        return lo, hi, dims, vv * 332.06   # kcal/mol per (e²/Å)
+
+    # Grow the BOX, not the ruler, until the contour closes inside it.
+    pad_used = pad
+    lo, hi, dims, v = evaluate(pad_used)
+    while wall_max(v) >= iso and pad_used < PAD_MAX:
+        pad_used = min(pad_used + PAD_STEP, PAD_MAX)
+        lo, hi, dims, v = evaluate(pad_used)
+    clear = wall_max(v) < iso
 
+    axes = np.diag((hi - lo) / (dims - 1))
     cube = write_cube(lo, axes, dims, v, syms, coords,
                       'kind=mep units=kcal/mol charges=gasteiger')
     meta = {
         'kind': 'mep', 'units': 'kcal/mol', 'charges': 'gasteiger',
         'net_charge': int(round(charges.sum())),
         'dims': dims.tolist(), **grid_spacing_meta(lo, hi, dims, spacing),
         'vmin': float(v.min()), 'vmax': float(v.max()),
-        'iso_suggest': suggest_iso(v),
+        'iso_fixed': iso,
+        'pad_used_angstrom': round(pad_used, 1),
+        'wall_max': round(wall_max(v), 3),
+        # False means the surface still runs off the edge of the grid and is
+        # being drawn as a flat face. Stated, not hidden: a charged ligand's
+        # monopole does not decay fast enough to close inside any usable box.
+        'contour_closes_in_box': bool(clear),
     }
     return cube, meta
 
@@ -641,30 +658,49 @@ def field_mlp(mol: Chem.Mol, spacing=0.4, pad=4.0):
         raise ValueError('Crippen contributions undefined for this molecule')
     syms, coords = mol_atoms(mol)
 
-    lo = coords.min(axis=0) - pad
-    hi = coords.max(axis=0) + pad
-    dims = np.maximum(np.ceil((hi - lo) / spacing).astype(int) + 1, 8)
-    dims = np.minimum(dims, GRID_MAX_DIM)
-    axes = np.diag((hi - lo) / (dims - 1))
-    xs = np.linspace(lo[0], hi[0], dims[0])
-    ys = np.linspace(lo[1], hi[1], dims[1])
-    zs = np.linspace(lo[2], hi[2], dims[2])
-    gx, gy, gz = np.meshgrid(xs, ys, zs, indexing='ij')
-    pts = np.stack([gx, gy, gz], axis=-1)
-
-    v = np.zeros(tuple(dims), dtype=float)
-    for fi, c in zip(f, coords):
-        d = np.linalg.norm(pts - c, axis=-1)
-        v += fi * np.exp(-d / 2.0)
+    iso = FIXED_ISO['mlp']
+
+    def evaluate(pad_a: float):
+        lo = coords.min(axis=0) - pad_a
+        hi = coords.max(axis=0) + pad_a
+        dims = np.maximum(np.ceil((hi - lo) / spacing).astype(int) + 1, 8)
+        dims = np.minimum(dims, GRID_MAX_DIM)
+        xs = np.linspace(lo[0], hi[0], dims[0])
+        ys = np.linspace(lo[1], hi[1], dims[1])
+        zs = np.linspace(lo[2], hi[2], dims[2])
+        gx, gy, gz = np.meshgrid(xs, ys, zs, indexing='ij')
+        pts = np.stack([gx, gy, gz], axis=-1)
+        vv = np.zeros(tuple(dims), dtype=float)
+        for fi, c in zip(f, coords):
+            d = np.linalg.norm(pts - c, axis=-1)
+            vv += fi * np.exp(-d / 2.0)
+        return lo, hi, dims, vv
+
+    pad_used = pad
+    lo, hi, dims, v = evaluate(pad_used)
+    while wall_max(v) >= iso and pad_used < PAD_MAX:
+        pad_used = min(pad_used + PAD_STEP, PAD_MAX)
+        lo, hi, dims, v = evaluate(pad_used)
+    clear = wall_max(v) < iso
 
+    axes = np.diag((hi - lo) / (dims - 1))
     cube = write_cube(lo, axes, dims, v, syms, coords,
                       'kind=mlp units=logP kernel=fauchere_exp_d_over_2 charges=crippen')
     meta = {
         'kind': 'mlp', 'units': 'MLP (Crippen/Fauchère)', 'method': 'crippen',
         'total_logp': float(f.sum()),
         'dims': dims.tolist(), **grid_spacing_meta(lo, hi, dims, spacing),
         'vmin': float(v.min()), 'vmax': float(v.max()),
-        'iso_suggest': suggest_iso(v),
+        'iso_fixed': iso,
+        'pad_used_angstrom': round(pad_used, 1),
+        'wall_max': round(wall_max(v), 4),
+        'contour_closes_in_box': bool(clear),
+        # The Fauchere kernel decays over ~2 A, so every atom contributes
+        # everywhere and the field is one-signed for most drug-like molecules.
+        # Measured: aspirin is 99.9% positive, ibuprofen 100%. Calling it
+        # "diverging" and drawing a negative lobe that does not exist is a
+        # claim about the molecule; this states the truth instead.
+        'single_signed': bool(v.min() >= 0 or v.max() <= 0),
     }
     return cube, meta
 
 
@@ -107,7 +107,16 @@ export type FieldKind = 'mep' | 'mep_qm' | 'homo' | 'lumo' | 'density' | 'mlp';
 
 interface KindSpec {
     label: string;
+    /** The FIXED contour, in `unit`. Identical across molecules by design. */
     iso: number;
+    /**
+     * display unit -> cube unit. The QM potential's cube is in Ha/e while the
+     * classical one is in kcal/mol, and both were being contoured with their
+     * own bare number — so toggling between two renderings of the SAME
+     * physical quantity silently moved the contour from 18 to 31.4 kcal/mol.
+     * One unit on screen, converted here.
+     */
+    cubeScale: number;
     diverging: boolean;
     unit: string;
     /** Theme token names; the numbers beside them are the fallback only. */
@@ -125,14 +134,14 @@ interface KindSpec {
 // only chroma was cut. Divergent pairs verified ≥0.10 ΔE apart by
 // design/check_palette.py — run it after touching any value here.
 const Kinds: Record<FieldKind, KindSpec> = {
-    mep: { label: 'Electrostatic well', iso: 8, diverging: true, unit: 'kcal/mol', posToken: '--viz-mep-pos', negToken: '--viz-mep-neg', posColor: 0x6788bc, negColor: 0xbd777b, quantum: false },
-    mep_qm: { label: 'QM potential well', iso: 0.05, diverging: true, unit: 'Ha/e', posToken: '--viz-mep-pos', negToken: '--viz-mep-neg', posColor: 0x6788bc, negColor: 0xbd777b, quantum: true },
-    homo: { label: 'HOMO', iso: 0.04, diverging: true, unit: 'amp', posToken: '--viz-orb-pos', negToken: '--viz-orb-neg', posColor: 0x7fc7a5, negColor: 0xa397d3, quantum: true },
-    lumo: { label: 'LUMO', iso: 0.04, diverging: true, unit: 'amp', posToken: '--viz-orb-pos', negToken: '--viz-orb-neg', posColor: 0x7fc7a5, negColor: 0xa397d3, quantum: true },
-    density: { label: 'e⁻ density', iso: 0.05, diverging: false, unit: 'e/Bohr³', posToken: '--viz-density', negToken: '--viz-density', posColor: 0xd8aa75, negColor: 0xd8aa75, quantum: true },
+    mep: { label: 'Electrostatic well', iso: 10, cubeScale: 1, diverging: true, unit: 'kcal/mol', posToken: '--viz-mep-pos', negToken: '--viz-mep-neg', posColor: 0x6788bc, negColor: 0xbd777b, quantum: false },
+    mep_qm: { label: 'QM potential well', iso: 10, cubeScale: 1 / 627.5094740631, diverging: true, unit: 'kcal/mol', posToken: '--viz-mep-pos', negToken: '--viz-mep-neg', posColor: 0x6788bc, negColor: 0xbd777b, quantum: true },
+    homo: { label: 'HOMO', iso: 0.04, cubeScale: 1, diverging: true, unit: 'amp', posToken: '--viz-orb-pos', negToken: '--viz-orb-neg', posColor: 0x7fc7a5, negColor: 0xa397d3, quantum: true },
+    lumo: { label: 'LUMO', iso: 0.04, cubeScale: 1, diverging: true, unit: 'amp', posToken: '--viz-orb-pos', negToken: '--viz-orb-neg', posColor: 0x7fc7a5, negColor: 0xa397d3, quantum: true },
+    density: { label: 'e⁻ density', iso: 0.05, cubeScale: 1, diverging: false, unit: 'e/Bohr³', posToken: '--viz-density', negToken: '--viz-density', posColor: 0xd8aa75, negColor: 0xd8aa75, quantum: true },
     // Default iso must sit BELOW the hydrophilic side's typical |min| (~0.06
     // on aspirin) or the cyan lobes never exist and the field looks all-grease.
-    mlp: { label: 'Lipophilicity', iso: 0.05, diverging: true, unit: 'MLP', posToken: '--viz-mlp-pos', negToken: '--viz-mlp-neg', posColor: 0xd5b979, negColor: 0x74ccdd, quantum: false },
+    mlp: { label: 'Lipophilicity', iso: 0.25, cubeScale: 1, diverging: true, unit: 'MLP', posToken: '--viz-mlp-pos', negToken: '--viz-mlp-neg', posColor: 0xd5b979, negColor: 0x74ccdd, quantum: false },
 };
 
 interface FieldMeta {
@@ -149,15 +158,22 @@ interface FieldMeta {
     units?: string;
     natoms?: number;
     nbasis?: number;
-    /** Measured from the cube for MEP/MLP, whose scale is molecule-dependent. */
-    iso_suggest?: number;
+    /** The fixed contour the backend grew the box around. */
+    iso_fixed?: number;
+    pad_used_angstrom?: number;
+    wall_max?: number;
+    /** False = the surface runs off the grid and is drawn as a flat face. */
+    contour_closes_in_box?: boolean;
+    /** MLP is one-signed for most drug-like molecules; measured, not assumed. */
+    single_signed?: boolean;
 }
 
 let plugin: PluginContext | null = null;
 let molfile: string | null = null;
 let ligandLabel: string | null = null;
 let activeKind: FieldKind | null = null;
 let activeVolume: Volume | null = null;
+let lastMeta: FieldMeta | null = null;
 let busy = false;
 
 /**
@@ -386,61 +402,51 @@ function isoMultiplier(): number {
  * The isovalue the slider's 1.0x position means.
  *
  * MEP and MLP are sums of atomic contributions, so their scale belongs to the
- * molecule and the backend measures it from the cube (`iso_suggest`, the ~97th
- * percentile of |field|). A constant there produced a surface that enclosed
- * the whole padded grid and clipped against the box wall — on retinoic acid
- * the lipophilicity field rendered as a gold crate with the ligand inside it.
- *
- * Orbitals and density keep their constants on purpose: a wavefunction is
- * normalised, which is exactly why the conventional values work for them.
+ * molecule. Both earlier answers were wrong in opposite directions: a
+ * hand-tuned constant clipped the grid wall on every molecule tried, and the
+ * per-molecule percentile that replaced it was a function of the PADDING —
+ * 7.6x swing on aspirin from pad alone. The contour is fixed now and the
+ * BACKEND grows the box until it closes.
  */
-let isoBase: number | null = null;
-
 /**
- * The isovalue, LOCKED across molecules once it has been fitted.
+ * The contour, in the field's own display units.
  *
- * Fitting per molecule is automatic gain control: two analogues render equally
- * hot even when one carries three times the potential, and the panel is built
- * to invite exactly that comparison. A fixed constant is not the alternative —
- * measured, the old one clipped the grid wall on every molecule tried, which
- * is how the lipophilicity field came to render as a box.
+ * It is a CONSTANT, and that is the point. Two earlier attempts moved it:
+ * a hand-tuned value that clipped the grid wall on every molecule tried, then
+ * a per-molecule percentile that never clipped and was a function of the
+ * PADDING — measured, 7.6x swing on aspirin from pad alone, with the physics
+ * identical. A ruler derived from the box is a measurement of the box.
  *
- * So: MEASURE it once, then HOLD it. The first molecule of a session fits the
- * scale from its own field; every molecule after that is drawn on the same
- * absolute surface and is therefore comparable. Re-fit is a deliberate act
- * with a button, and the readout always says which regime it is in — a scale
- * that changed silently underneath a comparison is the failure being fixed.
+ * The crate was a BOX problem, so the backend grows the box until the contour
+ * closes inside it and reports whether it succeeded. The ruler holds still, so
+ * the same colour means the same kcal/mol on every molecule in a series.
  */
-const isoLock = new Map<FieldKind, { value: number, fittedOn: string }>();
-
 function currentIso(): number {
     if (!activeKind) return 0;
-    return (isoBase ?? Kinds[activeKind].iso) * isoMultiplier();
+    return Kinds[activeKind].iso * isoMultiplier();
+}
+
+/** The same contour expressed in the cube's own units. */
+function currentIsoCube(): number {
+    if (!activeKind) return 0;
+    return currentIso() * Kinds[activeKind].cubeScale;
 }
 
 function updateIsoReadout() {
     const el = byId('field-iso-readout');
     if (!el) return;
     if (!activeKind) { el.textContent = ''; return; }
     const sign = Kinds[activeKind].diverging ? '±' : '';
-    const lock = isoLock.get(activeKind);
-    let provenance = '';
-    if (lock && lock.fittedOn !== (ligandLabel ?? '')) {
-        provenance = ` · locked (fitted on ${lock.fittedOn})`;
-    } else if (lock) {
-        provenance = ' · fitted to this molecule';
+    let note = '';
+    // Whether the surface actually closes is a fact about this picture, and it
+    // is the one the crate bug turned on. Stated, not inferred from the shape.
+    if (lastMeta && lastMeta.contour_closes_in_box === false) {
+        note = ` · open surface (field is ${lastMeta.wall_max ?? '?'} at the box edge)`;
+    } else if (lastMeta && lastMeta.single_signed) {
+        note = ' · field is single-signed — no negative lobe exists';
     }
     el.textContent =
-        `${sign}${currentIso().toPrecision(3)} ${Kinds[activeKind].unit}${provenance}`;
-    const refit = byId<HTMLButtonElement>('field-refit');
-    if (refit) refit.hidden = !lock || lock.fittedOn === (ligandLabel ?? '');
-}
-
-/** Drop the held scale so the next render fits this molecule instead. */
-function refitIso() {
-    if (activeKind) isoLock.delete(activeKind);
-    const kind = activeKind;
-    if (kind) void requestField(kind);
+        `${sign}${currentIso().toPrecision(3)} ${Kinds[activeKind].unit}${note}`;
 }
 
 function setButtonsEnabled() {
@@ -488,7 +494,7 @@ function reprParams(kind: FieldKind, sign: 1 | -1, shell: number) {
     return createVolumeRepresentationParams(plugin!, activeVolume ?? undefined, {
         type: 'isosurface',
         typeParams: {
-            isoValue: Volume.IsoValue.absolute(sign * currentIso() * s.fraction),
+            isoValue: Volume.IsoValue.absolute(sign * currentIsoCube() * s.fraction),
             visuals: s.visuals as ('solid' | 'wireframe')[],
             alpha: s.alpha,
             xrayShaded: s.visuals.includes('solid'),
@@ -518,17 +524,7 @@ async function renderCube(cubeText: string, kind: FieldKind, meta?: FieldMeta) {
     // Adopt the backend's measured isovalue when it sent one; fall back to the
     // kind's constant otherwise. Set BEFORE the representations are built, or
     // the first frame is drawn at the old scale and corrected a tick later.
-    // Fit once, then hold. A held scale is what makes two molecules comparable;
-    // re-fitting each time is the gain control this exists to avoid.
-    const held = isoLock.get(kind);
-    if (held) {
-        isoBase = held.value;
-    } else if (typeof meta?.iso_suggest === 'number') {
-        isoBase = meta.iso_suggest;
-        isoLock.set(kind, { value: meta.iso_suggest, fittedOn: ligandLabel ?? '' });
-    } else {
-        isoBase = null;   // orbital/density: a normalised quantity keeps its constant
-    }
+    lastMeta = meta ?? null;
     if (!plugin) return;
     if (plugin.state.data.cells.has(REF_DATA)) {
         await plugin.build().delete(REF_DATA).commit();
@@ -736,7 +732,6 @@ export function initFieldWellsPanel(p: PluginContext) {
     // panel said "Solving…" for 36 minutes with every control disabled. The
     // daemon now stops itself too, but a bound the user cannot reach is not a
     // control, it is a promise.
-    byId('field-refit')?.addEventListener('click', () => refitIso());
     byId('field-cancel')?.addEventListener('click', () => {
         abortInFlight();
         busy = false;