@@ -227,18 +227,25 @@ def plot_periodicity(meas):
     keep = np.abs(f) <= lim
     fig, ax = plt.subplots()
     fig.set_label("Grid Periodicity")
+    logp = np.log10(meas["power"][np.ix_(keep, keep)] + np.finfo(float).tiny)
+    # stretch from the noise floor to the strongest peak. the full range reaches down to near-empty bins many decades
+    # below the noise and leaves everything that matters a flat, dark grey.
     ax.imshow(
-        np.log10(meas["power"][np.ix_(keep, keep)] + np.finfo(float).tiny),
+        logp,
         origin="lower",
         cmap="Greys",
+        vmin=np.median(logp),
+        vmax=logp.max(),
         extent=(f[keep][0], f[keep][-1], f[keep][0], f[keep][-1]),
     )
     t = np.linspace(0, 2 * np.pi, 361)
     for rad in (fmin, fmax):
         ax.plot(rad * np.cos(t), rad * np.sin(t), color="blue", lw=0.8)
     for (fx, fy), snr, sp in zip(meas["freqs"], meas["snr"], meas["spacing"]):
         ax.scatter([fx, -fx], [fy, -fy], facecolors="none", edgecolors="red", s=80)
-        ax.annotate(f"{sp:.3f} px (SNR {snr:.0f})", (fx, fy), color="red", fontsize=8)
+        ax.annotate(
+            f"{sp:.3f} px (SNR {snr:.0f})", (fx, fy), xytext=(8, 8), textcoords="offset points", color="red", fontsize=8
+        )
     ax.set_xlabel("f$_x$ (cycles/pixel)")
     ax.set_ylabel("f$_y$ (cycles/pixel)")
     ax.set_title("Grid period (focus-only fallback)")
 
@@ -108,6 +108,11 @@ def test_plot_periodicity():
     m = measure_grid_period(img, CENTER, RADIUS, PITCH, inner=INNER)
     fig = plot_periodicity(m)
     assert fig.get_label() == "Grid Periodicity"
+    # the stretch runs from the noise floor (median) to the strongest peak, not from the near-empty minimum, which
+    # leaves the whole spectrum a dark, flat grey
+    im = fig.axes[0].images[0]
+    shown = np.asarray(im.get_array())
+    assert im.get_clim() == pytest.approx((np.median(shown), shown.max()))
     plt.close("all")
 
 
 
@@ -228,6 +228,10 @@ def test_frosted_donut():
     assert results["method"] == "periodicity"
     assert abs(results["grid"]["scale"] - 0.899) < 5e-3
     assert -40.0 < results["pending_focus"].to_value(u.um) < -24.0
+    # the Z04 error carried through the same gains as the correction
+    z04_err = results["zernike"].errorbars["Z04"]
+    expected = wfs.m2_gain_periodicity * wfs.m2_gain * z04_err / wfs.secondary.focus_trans
+    assert results["focus_err"].to_value(u.um) == pytest.approx(expected.to_value(u.um), abs=0.01)
     plt.close("all")
 
 
@@ -524,6 +528,8 @@ def test_focus_from_scale_matches_analytic():
     expected = k * 0.01 - zref["Z04"].value
     assert np.isclose(zv["Z04"].value, expected, rtol=0.02)
     assert np.isclose(zv.errorbars["Z04"].value, abs(k) * 1e-4, rtol=0.02)
+    # only defocus is measured; the reference's other terms would show up as if they had been
+    assert list(zv.coeffs) == ["Z04"]
 
 
 def test_focus_from_scale_gain():
 
@@ -1317,6 +1317,9 @@ def focus_from_scale(self, scale, scale_err, mode, rotator, hdr=None):
 
         raw.rotate(angle=-(self.rotation - rotator))
         zv = raw - self.reference_aberrations(mode, hdr=hdr)
+        # only defocus is measured. the subtraction leaves the reference's other terms (sign-flipped) and ~0 tilts,
+        # which would read as measured aberrations, so keep Z04 alone.
+        zv = ZernikeVector(Z04=zv["Z04"].value, errorbars={"Z04": zv.errorbars["Z04"].value}, units=zv.units)
 
         focus = self.m2_gain_periodicity * self.calculate_focus(zv.copy())
         fmax = self.periodicity_focus_max.to_value(u.um)
@@ -1349,8 +1352,18 @@ def periodicity_focus(self, data, mode, center, rotator, hdr=None, plot=True):
         grid["center"] = tuple(center)
 
         zv, focus = self.focus_from_scale(grid["scale"], grid["scale_err"], mode, rotator, hdr=hdr)
+        # the Z04 error bar through the same gains as the correction, before the (1 - frac_error) down-weighting
+        zd = zv.copy()
+        zd.denormalize()
+        focus_err = np.abs(self.m2_gain_periodicity * self.m2_gain * zd.errorbars["Z04"] / self.secondary.focus_trans)
         fig = plot_periodicity(meas) if plot else None
-        return {"grid": grid, "zernike": zv, "pending_focus": focus, "figure": fig}
+        return {
+            "grid": grid,
+            "zernike": zv,
+            "pending_focus": focus,
+            "focus_err": focus_err.to(u.um).round(2),
+            "figure": fig,
+        }
 
     def process_image(self, fitsfile):
         """
@@ -1505,15 +1518,17 @@ def measure_slopes(
                     fallback = None
                 if fallback is not None:
                     grid = fallback["grid"]
-                    log.warning(
-                        f"Using focus-only periodicity fallback: scale = {grid['scale']:.5f} +/- "
-                        f"{grid['scale_err']:.5f}, SNR = {grid['snr'].min():.0f}, focus = {fallback['pending_focus']}"
-                    )
+                    # one value per line so the focus correction isn't lost off the right edge of a log window
+                    log.warning("Using focus-only periodicity fallback:")
+                    log.warning(f"    grid scale = {grid['scale']:.5f} +/- {grid['scale_err']:.5f}")
+                    log.warning(f"    SNR = {grid['snr'].min():.0f}")
+                    log.warning(f"    focus = {fallback['pending_focus']} +/- {fallback['focus_err']}")
                     results["focus_only"] = True
                     results["method"] = "periodicity"
                     results["grid"] = grid
                     results["zernike"] = fallback["zernike"]
                     results["pending_focus"] = fallback["pending_focus"]
+                    results["focus_err"] = fallback["focus_err"]
                     results["figures"]["periodicity"] = fallback["figure"]
             return results
         except Exception as e: