@@ -1257,6 +1257,8 @@ def field_quantum(mol: Chem.Mol, kind: str, basis: str,
 _charge_table: dict[tuple[str, str], float] | None = None
 _charge_table_lock = threading.Lock()
 CHARGE_FORCEFIELD = 'AMBER'
+# Excluded from a pocket source unless the caller supplies hydrogens.
+WATER_RESNAMES = {'HOH', 'WAT', 'DOD', 'H2O', 'TIP', 'TP3', 'SOL'}
 
 
 def charge_table() -> dict[tuple[str, str], float]:
@@ -1293,6 +1295,20 @@ def resolve_charges(sources: list[dict]) -> tuple[list[float], list[str]]:
     charges: list[float] = []
     missing: list[str] = []
     for a in sources:
+        # WATER IS EXCLUDED, and mapping it would be worse than refusing it.
+        # AMBER's water is WAT:OW -0.834 plus two WAT:HW +0.417 — neutral, as
+        # it must be. A crystallographic water is ONE OXYGEN: the hydrogens
+        # were never resolved. Mapping HOH:O onto OW therefore contributes a
+        # fictitious -0.834 MONOPOLE per water, and an electrostatic field is
+        # dominated by its monopoles — six pocket waters would be five charge
+        # units of invention sitting on top of the answer.
+        #
+        # Placing the hydrogens is not a repair either: a water's entire
+        # electrostatic identity is the direction of its dipole, so inventing
+        # an orientation points it confidently the wrong way.
+        if str(a.get('resname', '')).upper() in WATER_RESNAMES:
+            charges.append(0.0)
+            continue
         if a.get('charge') is not None:
             charges.append(float(a['charge']))
             continue
@@ -1358,6 +1374,11 @@ def field_region(sources, lo, hi, spacing: float, kind: str):
 
     # Charges come from the residue template when the caller sent residue
     # identity instead of a number. Unresolved atoms are named, not zeroed.
+    n_water = sum(1 for a in sources
+                  if str(a.get('resname', '')).upper() in WATER_RESNAMES)
+    if kind == 'mep' and n_water:
+        sources = [a for a in sources
+                   if str(a.get('resname', '')).upper() not in WATER_RESNAMES]
     resolved, missing = (resolve_charges(sources) if kind == 'mep'
                          else ([None] * len(sources), []))
     if missing:
@@ -1433,6 +1454,12 @@ def field_region(sources, lo, hi, spacing: float, kind: str):
         'net_charge': round(float(weights.sum()), 3),
         'charge_model': (f'{CHARGE_FORCEFIELD} residue templates (pdb2pqr)'
                          if kind == 'mep' else 'caller-supplied'),
+        'waters_excluded': n_water,
+        'waters_note': (f'{n_water} crystallographic water(s) left OUT: their '
+                        f'hydrogens were never resolved, and a bare oxygen would '
+                        f'contribute a fictitious monopole while an invented '
+                        f'orientation would point the dipole confidently wrong.'
+                        if n_water else None),
         'dims': dims.tolist(), **grid_spacing_meta(lo, hi, dims, spacing),
         'vmin': float(v.min()), 'vmax': float(v.max()),
         'iso_fixed': iso,
 
@@ -64,22 +64,32 @@ cat > "$STAGE/index.html.driver" <<EOF
     if (/no ligand/i.test(summary)) {
       log.push('NO LIGAND — nothing to precompute');
     } else {
-      for (var f = 0; f < FIELDS.length; f++) {
-        var btn = document.querySelector('.field-btn[data-field="' + FIELDS[f] + '"]');
-        if (!btn) { log.push(FIELDS[f] + ':no-button'); continue; }
-        for (var w = 0; w < 30 && btn.disabled; w++) await wait(1000);
-        if (btn.disabled) { log.push(FIELDS[f] + ':still-disabled'); continue; }
-        btn.click();
-        var done = false;
-        for (var k = 0; k < 240; k++) {
-          await wait(1000);
-          var st = txt('#field-status');
-          if (/rendered/i.test(st)) { log.push(FIELDS[f] + ':OK'); done = true; break; }
-          if (/refus|unreach|cannot|exceed|budget|not quotable/i.test(st)) {
-            log.push(FIELDS[f] + ':REFUSED(' + st.slice(0, 60) + ')'); done = true; break;
-          }
+      // POST DIRECTLY, with the app's own molfile and a budget no interactive
+      // click should ever have. Clicking the buttons warms the same rows but
+      // inherits the panel's 60 s client budget — which is why lapatinib came
+      // back "SCF exceeded its 60 s budget after 10 cycles" and cached nothing.
+      // A warm is not an interaction: nobody is waiting, so the only correct
+      // budget is a generous one.
+      var hook = window.diracFields;
+      if (!hook || !hook.molfile) {
+        log.push('NO MOLFILE HOOK');
+      } else {
+        for (var f = 0; f < FIELDS.length; f++) {
+          var kind = FIELDS[f];
+          try {
+            var r = await fetch(hook.backend + '/field', {
+              method: 'POST', headers: { 'Content-Type': 'application/json' },
+              body: JSON.stringify({ molfile: hook.molfile, kind: kind,
+                                     basis: 'sto-3g', store: true,
+                                     max_seconds: 900 }),
+            });
+            var j = await r.json();
+            log.push(kind + (j.ok ? ':OK' : ':REFUSED(' + String(j.error).slice(0, 50) + ')'));
+          } catch (e) { log.push(kind + ':ERR(' + e + ')'); }
         }
-        if (!done) log.push(FIELDS[f] + ':TIMEOUT');
+        // and render one so the screenshot shows a real field
+        var b0 = document.querySelector('.field-btn[data-field="mep"]');
+        if (b0 && !b0.disabled) { b0.click(); await wait(6000); }
       }
       // The physics panel too — same molecule, same session, both daemons warm.
       var pt = document.querySelector('[data-jump="physics"]');
 
@@ -857,6 +857,12 @@ export function updateFieldWellsLigand(nextMolfile: string | null, label: string
     const changed = nextMolfile !== molfile;
     molfile = nextMolfile;
     ligandLabel = label;
+    // Debug/warm hook: exposes the EXACT molfile the panel would send. The
+    // durable cache is keyed on sha256(molfile), so a warmer that generates its
+    // own molfile writes rows the app can never hit. Reading this one makes the
+    // warm exact, and lets it use a budget no interactive click should have.
+    (window as unknown as { diracFields: unknown }).diracFields =
+        { molfile, label: ligandLabel, backend: BACKEND };
     const summary = byId('fields-summary');
     if (summary) summary.textContent = molfile ? (label ?? 'Ligand') : 'No ligand loaded';
     if (changed) {
 
@@ -76,6 +76,24 @@ let molfile: string | null = null;
 let ligandLabel: string | null = null;
 let inFlight: AbortController | null = null;
 let busy = false;
+/**
+ * Monotonic ligand generation. A multi-second SCF that lands after the user
+ * has moved on must be DISCARDED, not rendered: it would put a confident
+ * number from molecule A into molecule B's scene, which is the worst kind of
+ * stale result because nothing about it looks wrong.
+ *
+ * field-wells has carried this guard since this morning; this facet, written
+ * hours later, did not — the same "fix lands on one path of two" that bit the
+ * iodine ECP and the SCF deadline today. Found by a peer's state audit.
+ *
+ * Exported so the physics-contract gate can mechanise ONE invariant — every
+ * SCF-reaching path is bounded AND its result is checked before it lands —
+ * instead of two, only one of which is currently enforced.
+ */
+let ligandGeneration = 0;
+export function isCurrentLigandGeneration(g: number): boolean {
+    return g === ligandGeneration;
+}
 /**
  * The extrema markers currently in the scene, so a re-run replaces them
  * instead of stacking. Typed loosely on purpose: the concrete
@@ -295,14 +313,37 @@ async function markExtrema(extrema: Extremum[]) {
     lastMarkers = repr;
 }
 
+/**
+ * The basis the refusal already prescribes.
+ *
+ * The cost gate declines a large ligand with a specific, correct remedy — "use a smaller
+ * basis (sto-3g is ~31 s here)" — and until this control existed the panel offered no way
+ * to take it. An honest refusal that names an action the interface cannot perform is a
+ * dead end wearing the manners of a good error message; measured on lapatinib, which is
+ * 66 atoms and 698 basis functions against a 90 s budget, that dead end was the only
+ * outcome available.
+ */
+function selectedBasis(): string {
+    const el = document.getElementById('phys-basis') as HTMLSelectElement | null;
+    return el?.value || 'def2-svp';
+}
+
 async function runSurface() {
     if (!molfile || busy) return;
     setBusy(true);
+    const basis = selectedBasis();
     setStatus('phys-surface-status',
-        `Solving surface electrostatics on ${ligandLabel ?? 'ligand'}… `
+        `Solving surface electrostatics on ${ligandLabel ?? 'ligand'} in ${basis}… `
         + `(gives up at ${BUDGET_SECONDS} s · Cancel to stop now)`, 'busy');
+    const generation = ligandGeneration;
     try {
-        const out = await post('/surface/mep', { molfile }, BUDGET_SECONDS);
+        const out = await post('/surface/mep', { molfile, basis }, BUDGET_SECONDS);
+        if (!isCurrentLigandGeneration(generation)) {
+            setStatus('phys-surface-status',
+                'Ligand changed while solving — result discarded rather than '
+                + 'rendered into the wrong molecule.', 'idle');
+            return;
+        }
         if (!out.ok) {
             setStatus('phys-surface-status', out.error, 'error');
             return;
@@ -334,8 +375,15 @@ async function runTorsion() {
     if (!molfile || busy) return;
     setBusy(true);
     setStatus('phys-torsion-status', `Scanning rotatable bonds on ${ligandLabel ?? 'ligand'}…`, 'busy');
+    const generation = ligandGeneration;
     try {
         const out = await post('/torsion/strain', { molfile }, BUDGET_SECONDS);
+        if (!isCurrentLigandGeneration(generation)) {
+            setStatus('phys-torsion-status',
+                'Ligand changed while scanning — result discarded rather than '
+                + 'rendered into the wrong molecule.', 'idle');
+            return;
+        }
         if (!out.ok) {
             setStatus('phys-torsion-status', out.error, 'error');
             return;
@@ -404,6 +452,7 @@ export function updateLigandPhysics(nextMolfile: string | null, label: string |
     const summary = byId('phys-summary');
     if (summary) summary.textContent = molfile ? (label ?? 'Ligand') : 'No ligand loaded';
     if (changed) {
+        ligandGeneration++;   // invalidates every in-flight result
         inFlight?.abort();
         inFlight = null;
         for (const id of ['phys-surface-body', 'phys-torsion-body']) {