diff --git a/common/Reflection.h b/common/Reflection.h
index e3e86ec17..e1bb0c772 100644
--- a/common/Reflection.h
+++ b/common/Reflection.h
@@ -33,6 +33,13 @@ struct Reflection {
     // a scale: the fitted per-image scale and the partiality stay out of it and are divided in
     // separately below. (Named after DIALS's prescaling_correction, which holds the same product.)
     float prescaling_corr;
+    // The sensor-efficiency part of prescaling_corr on its own: QE(0)/QE(alpha), always <= 1, and 1
+    // where the sensor is opaque or its material and thickness are unknown. The one term singled out
+    // of the product above, and only so the written files can say which part of it is
+    // Lorentz-polarization and which is detector response: LP means L/P everywhere else in the
+    // field, and prescaling_corr / qe_corr is that. Defaulted to 1 so a reflection read from a file
+    // written before this existed is a no-op rather than a zero.
+    float qe_corr = 1.0f;
     float partiality;     // fraction of the reflection recorded in the sampled (rocking) slice
     float zeta;
     float image_scale_corr; // I_true = image_scale_corr * I; = prescaling_corr / (partiality * image_scale)
diff --git a/docs/CBOR.md b/docs/CBOR.md
index 8be543079..522f1542d 100644
--- a/docs/CBOR.md
+++ b/docs/CBOR.md
@@ -168,6 +168,7 @@ See [DECTRIS documentation](https://github.com/dectris/documentation/tree/main/s
 | - image                     | float                 | image number (present for each spot)                                                                                              |                           |          |
 | - rp                        | float                 | Distance to Ewald sphere \[Angstrom^-1\]                                                                                          |                           |          |
 | - rlp                       | float                 | Prescaling correction: the product of every deterministic per-reflection correction (reciprocal Lorentz, reciprocal polarization, sensor efficiency). The key name is historical and kept for compatibility |                           |          |
+| - qe                        | float                 | The sensor-efficiency part of `rlp` on its own, QE(0)/QE(alpha); 1 where the sensor is opaque or unknown. Optional                 |                           |          |
 | - partiality                | float                 | Partiality of the reflection                                                                                                      |                           |          |
 | - phi                       | float                 | phi angle from XDS: difference from middle of current frame, not absolute \[deg\]                                                 |                           |          |
 | - zeta                      | float                 | Lorentz zeta factor (reciprocal-space geometry term)                                                                              |                           |          |
diff --git a/docs/CHANGELOG.md b/docs/CHANGELOG.md
index 1ec333f6b..80b284329 100644
--- a/docs/CHANGELOG.md
+++ b/docs/CHANGELOG.md
@@ -13,6 +13,7 @@
 
 * `rugnux` corrects each reflection for the sensor's quantum efficiency at the angle the diffracted beam meets the detector.
 * `rugnux` applies the sensor quantum-efficiency correction to still images processed on a GPU, which were left uncorrected while the same data on a CPU-only machine was corrected.
+* The unmerged MTZ keeps the sensor efficiency out of its `LP` column and records it in a new `QE` column, as XDS and DIALS do, so raw counts are `I / LP * QE`; the merged intensities are unchanged, and `_process.h5` gains a matching optional `qe` dataset.
 * `rugnux` takes the sensor attenuation length from tabulated coefficients rather than a wavelength-cubed approximation, which corrects the parallax term of the spot-width variance on CdTe sensors.
 * `rugnux --model` treats the model as a hypothesis: it decides the enantiomorph and the indexing only where its R-work beats that of the same model in random orientations, and a model the data reject is still scored, placed and mapped, but leaves the reflection files byte for byte what a run with no model writes.
 * `rugnux --model` places the model against the data as a rigid body before scoring it, writes sigma_A-weighted 2mFo-DFc and mFo-DFc maps in place of the unweighted 2Fo-Fc and Fo-Fc, and writes the model as it was placed - `<prefix>_model.cif`, and `<prefix>_model.pdb` where the PDB format can express the cell - in the cell and space group of the reflection files beside it.
diff --git a/docs/HDF5.md b/docs/HDF5.md
index 2b5c4c7ea..d3345709f 100644
--- a/docs/HDF5.md
+++ b/docs/HDF5.md
@@ -436,6 +436,7 @@ mostly onto the standard
 | `observed_x`, `observed_y` | pixel | name standard, units differ | observed centroid (pixels; standard pixel form is `observed_px_x/_y`) |
 | `observed_frame` | | standard | image number of the reflection |
 | `lp` | | standard | reciprocal of the prescaling correction (stored as `1/prescaling_corr`). The NXreflections name is `lp`, but the stored product also carries the sensor efficiency term |
+| `qe` | | **extension** | the sensor-efficiency part of `lp` on its own, in the same reciprocal convention, so `lp / qe` is the pure Lorentz–polarization reciprocal. Absent in files written before it existed; the reader then takes the whole of `lp` for Lorentz–polarization, which is what those files mean |
 | `partiality` | | standard | recorded fraction of the reflection |
 | `delta_phi` | deg | **extension** | XDS Δφ: offset from the centre of the current frame |
 | `zeta` | | **extension** | Lorentz ζ factor (reciprocal-space geometry term) |
diff --git a/docs/RUGNUX_ADVANCED.md b/docs/RUGNUX_ADVANCED.md
index 8649a450e..c1e30bdbd 100644
--- a/docs/RUGNUX_ADVANCED.md
+++ b/docs/RUGNUX_ADVANCED.md
@@ -335,7 +335,7 @@ Scaling and merging:
 | `--reference-column <label>` | Reference MTZ column to use (default: auto — F-model, else IMEAN/I/…) |
 | `--model <file>` | Validate the merged intensities against this atomic model (PDB or mmCIF, gzipped or not; the format is taken from the file's content) — R-work / R-free and maps (see [Validating against a model](#validating-against-a-model-rugnux-model)). It also settles the frame the reflections are written in: the enantiomorph, and the [indexing ambiguity](#the-indexing-ambiguity) where no `-z` did. For serial stills given `-C` / `-S`, the model's structure factors become the per-image reference |
 | `--write-process-h5` | Also write the (large) `_process.h5` when merging (default: only `.mtz`/`.cif`) |
-| `--export-unmerged` | Write `<prefix>_unmerged.mtz`, an unmerged MTZ (POINTLESS column layout) of the integrated observations, for aimless / pointless / careless. **On by default** whenever there is an output prefix. Rotation partials are summed into one full per reflection. Intensities carry the Lorentz, polarization and sensor-efficiency corrections and nothing else, with the applied factor in the `LP` column — the partiality is not divided out and the per-image scale is not applied. Written in `--mode mx` and `--mode scale`, and with `--no-merge`. See [The unmerged export](RUGNUX_INTEGRATION.md#the-unmerged-export) |
+| `--export-unmerged` | Write `<prefix>_unmerged.mtz`, an unmerged MTZ (POINTLESS column layout) of the integrated observations, for aimless / pointless / careless. **On by default** whenever there is an output prefix. Rotation partials are summed into one full per reflection. Intensities carry the deterministic per-reflection corrections and nothing else — Lorentz and polarization in `LP`, sensor efficiency in `QE` — while the partiality is not divided out and the per-image scale is not applied. Written in `--mode mx` and `--mode scale`, and with `--no-merge`. See [The unmerged export](RUGNUX_INTEGRATION.md#the-unmerged-export) |
 | `--no-export-unmerged` | Do not write `<prefix>_unmerged.mtz`. It is the largest file a run produces, so a run whose observations are not going to another scaling program can skip it |
 | `--no-p1-crosscheck` | Do not write `<prefix>_P1.mtz`, the P1 cross-check merge described under [Output files](RUGNUX_TUTORIAL.md#output-files). Every rotation run that determines its own space group writes it; a run given `-S` writes none either way |
 | `--export-unmerged-partials` | Write `<prefix>_unmerged_partials.mtz`, the same observations with each partial as its own row (one batch per image) for the reading program to sum. Off by default, and independent of `--export-unmerged` |
diff --git a/docs/RUGNUX_INTEGRATION.md b/docs/RUGNUX_INTEGRATION.md
index 4226dba15..c739e7258 100644
--- a/docs/RUGNUX_INTEGRATION.md
+++ b/docs/RUGNUX_INTEGRATION.md
@@ -119,11 +119,18 @@ leaves an unmerged file in, and the order AIMLESS requires of its input — so b
 file directly.
 
 **What has been applied to the intensities, and what has not.** `I` and `SIGI` carry the
-**prescaling correction and nothing else** — the reciprocal Lorentz factor, the reciprocal
-polarization factor and the sensor's angle-dependent efficiency. The factor itself is in the `LP`
-column, so raw counts are `I/LP`. It is applied because it is per-observation geometry and instrument
-response that varies by more than two orders of magnitude across a sweep and no reader can
-reconstruct it. Deliberately *not* applied:
+**deterministic per-reflection corrections and nothing else**. Two columns record them: `LP` is
+Lorentz x polarization, and `QE` is the sensor's quantum efficiency at the angle the diffracted beam
+meets the detector — a **divisor**, normalised to 1 at normal incidence — so raw counts are
+`I / LP * QE`. They are applied because they are per-observation geometry that varies by more than
+two orders of magnitude across a sweep and no reader can reconstruct them.
+
+`QE` is kept out of `LP` because that is what the field means by `LP`: XDS's `RLP` is Lorentz x
+polarization alone (its own column is flat to 0.1% across a detector over which the efficiency term
+spans 7%), and DIALS fills `LP` from lorentz/polarization only and writes `QE` as a separate column —
+a column of ones where it has no correction. rugnux normalises `QE` to normal incidence where DIALS
+stores the un-normalised absorbed fraction; the two differ by a per-dataset constant, i.e. by an
+overall scale. Deliberately *not* applied:
 the **partiality is not divided out** (it is reported in `FRACTIONCALC`), and the **per-image scale is
 not applied at all** — those programs fit their own scale model, and handing them pre-scaled data
 would have them fit a correction to a correction. No resolution cut, outlier rejection or ice-ring
diff --git a/frame_serialize/CBORStream2Deserializer.cpp b/frame_serialize/CBORStream2Deserializer.cpp
index 3329d7066..33ce28e56 100644
--- a/frame_serialize/CBORStream2Deserializer.cpp
+++ b/frame_serialize/CBORStream2Deserializer.cpp
@@ -517,6 +517,8 @@ namespace {
                 r.image_number = GetCBORFloat(map_value);
             else if (key == "rlp")
                 r.prescaling_corr = GetCBORFloat(map_value);
+            else if (key == "qe")
+                r.qe_corr = GetCBORFloat(map_value);
             else if (key == "rp")
                 r.dist_ewald = GetCBORFloat(map_value);
             else if (key == "partiality")
diff --git a/frame_serialize/CBORStream2Serializer.cpp b/frame_serialize/CBORStream2Serializer.cpp
index 01cab10ab..1897e2847 100644
--- a/frame_serialize/CBORStream2Serializer.cpp
+++ b/frame_serialize/CBORStream2Serializer.cpp
@@ -272,6 +272,7 @@ inline void CBOR_ENC(CborEncoder &encoder, const Reflection& r) {
     CBOR_ENC(mapEncoder, "image", r.image_number);
     CBOR_ENC(mapEncoder, "rp", r.dist_ewald);
     CBOR_ENC(mapEncoder, "rlp", r.prescaling_corr);
+    CBOR_ENC(mapEncoder, "qe", r.qe_corr);
     CBOR_ENC(mapEncoder, "partiality", r.partiality);
     CBOR_ENC(mapEncoder, "zeta", r.zeta);
     CBOR_ENC(mapEncoder, "image_scale_corr", r.image_scale_corr);
diff --git a/image_analysis/WriteReflections.cpp b/image_analysis/WriteReflections.cpp
index 77da3d3b5..8896c04ee 100644
--- a/image_analysis/WriteReflections.cpp
+++ b/image_analysis/WriteReflections.cpp
@@ -666,8 +666,8 @@ std::vector<Reflection> SumRockingEvents(const std::vector<IntegrationOutcome> &
             ++j;
 
         double sum_p = 0.0, sum_I = 0.0, sum_var = 0.0, sum_var_bkg = 0.0;
-        double p_corr = 0.0, p_frame = 0.0, p_x = 0.0, p_y = 0.0, p_delta_phi = 0.0, p_zeta = 0.0,
-               p_bkg = 0.0;
+        double p_corr = 0.0, p_qe = 0.0, p_frame = 0.0, p_x = 0.0, p_y = 0.0, p_delta_phi = 0.0,
+               p_zeta = 0.0, p_bkg = 0.0;
         for (size_t m = i; m < j; ++m) {
             const Reflection &r = *parts[m].r;
             const double p = r.partiality;
@@ -676,6 +676,7 @@ std::vector<Reflection> SumRockingEvents(const std::vector<IntegrationOutcome> &
             sum_var += static_cast<double>(r.sigma) * r.sigma * r.prescaling_corr * r.prescaling_corr;
             sum_var_bkg += static_cast<double>(r.var_bkg) * r.prescaling_corr * r.prescaling_corr;
             p_corr += p * r.prescaling_corr;
+            p_qe += p * r.qe_corr;
             p_frame += p * r.image_number;
             p_x += p * DetectorX(r);
             p_y += p * DetectorY(r);
@@ -688,16 +689,14 @@ std::vector<Reflection> SumRockingEvents(const std::vector<IntegrationOutcome> &
         if (sum_p < min_partiality || sum_p < min_captured_fraction)
             continue;
 
-        // The prescaling correction is applied by the writer, which multiplies I by prescaling_corr,
-        // so divide the event's own factor back out of the sums here. Every term in it - Lorentz,
-        // polarization, sensor efficiency - is a function of the reflection's position and rocking
-        // geometry, which move by almost nothing between the parts of one event (median 2e-4 on the
-        // Lorentz term), so the file's I/LP is still the raw count sum.
+        // The prescaling factor is applied by the writer, which multiplies I by prescaling_corr, so divide the
+        // event's own factor back out of the sums here. It is the same geometry for every part of
+        // one event to a median 2e-4, so the file's I / LP * QE is still the raw count sum.
         full.prescaling_corr = static_cast<float>(p_corr / sum_p);
+        full.qe_corr = static_cast<float>(p_qe / sum_p);
         full.I = static_cast<float>(sum_I / full.prescaling_corr);
         full.sigma = static_cast<float>(std::sqrt(sum_var) / full.prescaling_corr);
-        full.var_bkg = static_cast<float>(sum_var_bkg
-                                         / (static_cast<double>(full.prescaling_corr) * full.prescaling_corr));
+        full.var_bkg = static_cast<float>(sum_var_bkg / (static_cast<double>(full.prescaling_corr) * full.prescaling_corr));
         full.partiality = static_cast<float>(sum_p);
         full.image_number = static_cast<float>(p_frame / sum_p);
         full.observed_x = static_cast<float>(p_x / sum_p);
@@ -728,9 +727,23 @@ void WriteUnmergedMtzReflections(const std::vector<IntegrationOutcome> &outcomes
     ds.wavelength = experiment.GetWavelength_A();
 
     // Every data column belongs to HKL_base and only the batches carry a dataset id, as in a
-    // POINTLESS file. Down to FLAG this is POINTLESS's own column set; the four after it are what
-    // rugnux measures beyond it - the offset of the reflection from the centre of its rocking curve,
-    // the Lorentz geometry of that curve, and the background that was subtracted.
+    // POINTLESS file. Down to FLAG this is POINTLESS's own column set, plus QE; the four after it
+    // are what rugnux measures beyond it - the offset of the reflection from the centre of its
+    // rocking curve, the Lorentz geometry of that curve, and the background that was subtracted.
+    //
+    // QE is not POINTLESS's, it is DIALS's: the detector's angle-dependent quantum efficiency, kept
+    // OUT of LP and given its own column because that is what both reference implementations do.
+    // LP here is Lorentz x polarization and nothing else, as XDS's RLP is (measured: XDS's column is
+    // flat to 0.1% across a detector over which the efficiency term spans 7%) and as DIALS's is
+    // (its LP comes from Corrections::lp(), lorentz/polarization, and it writes QE separately -
+    // a column of ones when it has no correction to report). Folding the sensor response into LP
+    // made this file assert something false about itself: a program that divided LP out to recover
+    // raw counts stripped the efficiency with it, and on an ordinary 13 keV geometry that term
+    // spans 13% end to end.
+    // Direction: QE is a DIVISOR, as in DIALS, and is normalised to 1 at normal incidence, so it
+    // rises above 1 toward the detector edge where a longer crossing makes the sensor more
+    // efficient. DIALS stores the un-normalised absorbed fraction instead; the two differ by the
+    // per-dataset constant QE(0), which is an overall scale.
     mtz.add_column("M/ISYM", 'Y', 0, -1, false);
     mtz.add_column("BATCH", 'B', 0, -1, false);
     mtz.add_column("I", 'J', 0, -1, false);
@@ -740,6 +753,7 @@ void WriteUnmergedMtzReflections(const std::vector<IntegrationOutcome> &outcomes
     mtz.add_column("YDET", 'R', 0, -1, false);
     mtz.add_column("ROT", 'R', 0, -1, false);
     mtz.add_column("LP", 'R', 0, -1, false);
+    mtz.add_column("QE", 'R', 0, -1, false);
     mtz.add_column("FLAG", 'I', 0, -1, false);
     mtz.add_column("DELPHI", 'R', 0, -1, false);
     mtz.add_column("ZETA", 'R', 0, -1, false);
@@ -765,16 +779,13 @@ void WriteUnmergedMtzReflections(const std::vector<IntegrationOutcome> &outcomes
     // them there, so the index the reflection was actually measured at is recoverable - that is the
     // crystal-frame information careless scales on, and what makes the file unmerged rather than a
     // merge waiting to happen.
-    // I and SIGI are the integrated intensity with the prescaling correction applied and nothing
-    // else, which is what IOBS means in every unmerged format, and LP records the factor that was
-    // applied, so the raw counts are I/LP. That factor is geometry and instrument response, not a
-    // scale, and a program reading this file has no way to recompute it. The partiality is NOT
-    // divided out - that is a scale, FRACTIONCALC carries it, and every program this file is for
-    // wants to handle it its own way.
-    // Note that LP therefore carries slightly more than its name says: the prescaling correction now
-    // also holds the sensor's angle-dependent efficiency, for which DIALS writes a separate QE column
-    // and AIMLESS calls LP "the Lorentz/polarization correction (already applied)". A consumer that
-    // divides LP out to recover raw counts removes the efficiency term with it.
+    // I and SIGI are the integrated intensity with every deterministic per-reflection correction
+    // applied and nothing else, which is what IOBS means in every unmerged format. Two columns
+    // record what was applied, so the raw count sum is recoverable exactly as I / LP * QE:
+    // LP is Lorentz x polarization and QE the sensor efficiency (a divisor, hence the multiply).
+    // Neither is a scale, and a program that reads this file has no way to recompute them. The
+    // partiality is NOT divided out - that IS a scale, FRACTIONCALC carries it, and every program
+    // this file is for wants to handle it its own way.
     gemmi::UnmergedHklMover hkl_mover(mtz.spacegroup);
     // The batch headers are written for every image the observations span, not only for the images
     // that produced one. AIMLESS starts a new run wherever the phi series jumps, so an image that
@@ -814,7 +825,10 @@ void WriteUnmergedMtzReflections(const std::vector<IntegrationOutcome> &outcomes
         mtz.data.push_back(DetectorX(r));
         mtz.data.push_back(DetectorY(r));
         mtz.data.push_back(phi_start_deg(r.image_number) + wedge_deg / 2.0f);
-        mtz.data.push_back(r.prescaling_corr);
+        // prescaling_corr is the whole prescaling product; qe_corr is its sensor-efficiency part. LP is what
+        // is left when that part is divided out, and QE is that part in the divide-by direction.
+        mtz.data.push_back(r.prescaling_corr / r.qe_corr);
+        mtz.data.push_back(1.0f / r.qe_corr);
         mtz.data.push_back(0.0f);            // FLAG: nothing here is a rejected observation
         mtz.data.push_back(r.delta_phi_deg);
         mtz.data.push_back(r.zeta);
diff --git a/image_analysis/WriteReflections.h b/image_analysis/WriteReflections.h
index a2c471e2a..9b439f3d0 100644
--- a/image_analysis/WriteReflections.h
+++ b/image_analysis/WriteReflections.h
@@ -56,11 +56,10 @@ void WriteShelxHklReflections(const std::vector<MergedReflection> &reflections,
 // rotation program writes, over the events the combine would assemble (--min-partiality). False
 // writes one row per integrated box instead, flagged as partials for the reading program to sum.
 // Stills have no rocking events and are unaffected either way.
-// The intensities carry the prescaling correction and nothing else - the partiality and the
-// per-image scale are left for the reading program to fit, since every program this file is for fits
-// a scale model of its own. The factor that was applied is in the LP column, so raw counts are I/LP;
-// note that the prescaling correction now also carries the sensor efficiency term, which XDS keeps
-// out of RLP and DIALS writes in a separate QE column.
+// The intensities carry the deterministic per-reflection corrections and nothing else - Lorentz,
+// polarization and the sensor's angle-dependent efficiency, recorded in the LP and QE columns, so
+// raw counts are I / LP * QE. The partiality and the per-image scale are left for the reading
+// program to fit, since every program this file is for fits a scale model of its own.
 void WriteUnmergedMtzReflections(const std::vector<IntegrationOutcome> &outcomes,
                                  const UnitCell &unitCell,
                                  const DiffractionExperiment &experiment,
diff --git a/image_analysis/bragg_prediction/BraggPrediction.cpp b/image_analysis/bragg_prediction/BraggPrediction.cpp
index 54892778f..2d29b573a 100644
--- a/image_analysis/bragg_prediction/BraggPrediction.cpp
+++ b/image_analysis/bragg_prediction/BraggPrediction.cpp
@@ -211,6 +211,7 @@ int BraggPrediction::Calc(const DiffractionExperiment &experiment, const Crystal
                         .d = d,
                         .dist_ewald = dist_ewald_sphere,
                         .prescaling_corr = qe_corr,
+                        .qe_corr = qe_corr,
                         .partiality = 1.0f,
                         .zeta = 1.0,
                         .image_scale_corr = qe_corr
diff --git a/image_analysis/bragg_prediction/BraggPredictionGPU.cu b/image_analysis/bragg_prediction/BraggPredictionGPU.cu
index d0ea647ad..28eb59ed7 100644
--- a/image_analysis/bragg_prediction/BraggPredictionGPU.cu
+++ b/image_analysis/bragg_prediction/BraggPredictionGPU.cu
@@ -143,6 +143,7 @@ namespace {
         out.d = 1.0f / sqrtf(recip_sq);
         out.dist_ewald = dist_ewald;
         out.prescaling_corr = qe_corr;
+        out.qe_corr = qe_corr;
         out.partiality = 1.0f;
         out.zeta = 1.0f;
         out.image_scale_corr = qe_corr;
diff --git a/image_analysis/bragg_prediction/BraggPredictionRot.cpp b/image_analysis/bragg_prediction/BraggPredictionRot.cpp
index e98ee3fab..9b9643da3 100644
--- a/image_analysis/bragg_prediction/BraggPredictionRot.cpp
+++ b/image_analysis/bragg_prediction/BraggPredictionRot.cpp
@@ -196,6 +196,7 @@ int BraggPredictionRot::Calc(const DiffractionExperiment &experiment, const Crys
                         .d = d,
                         .dist_ewald = dist_ewald_sphere,
                         .prescaling_corr = lorentz_reciprocal * qe_corr,
+                        .qe_corr = qe_corr,
                         .partiality = partiality,
                         .zeta = zeta_abs,
                         .image_scale_corr = lorentz_reciprocal * qe_corr / partiality,
diff --git a/image_analysis/bragg_prediction/BraggPredictionRotGPU.cu b/image_analysis/bragg_prediction/BraggPredictionRotGPU.cu
index 8cef93159..513059635 100644
--- a/image_analysis/bragg_prediction/BraggPredictionRotGPU.cu
+++ b/image_analysis/bragg_prediction/BraggPredictionRotGPU.cu
@@ -191,6 +191,7 @@ namespace {
             out[count].d = 1.0f / sqrtf(p0_sq);
             out[count].dist_ewald = dist_ewald;
             out[count].prescaling_corr = lorentz * qe_corr;
+            out[count].qe_corr = qe_corr;
             out[count].partiality = partiality;
             out[count].zeta = zeta_abs;
             out[count].image_scale_corr = lorentz * qe_corr / partiality;
diff --git a/reader/HDF5MetadataSource.cpp b/reader/HDF5MetadataSource.cpp
index 6909fe50f..ea72588b9 100644
--- a/reader/HDF5MetadataSource.cpp
+++ b/reader/HDF5MetadataSource.cpp
@@ -325,6 +325,10 @@ bool ReadReflectionsFromGroup(HDF5Object &file,
     // Written since the merge stopped back-deriving it; older _process.h5 do not carry it.
     auto var_bkg = file.ReadOptVector<float>(image_group_name + "/background_variance");
     auto lp = file.ReadOptVector<float>(image_group_name + "/lp");
+    // The sensor-efficiency part of lp, written since the correction existed. Absent in every
+    // older file, and there the whole of lp is taken for Lorentz-polarization - which is what
+    // those files mean, since nothing had corrected for the sensor when they were written.
+    auto qe = file.ReadOptVector<float>(image_group_name + "/qe");
     auto partiality = file.ReadOptVector<float>(image_group_name + "/partiality");
     auto phi = file.ReadOptVector<float>(image_group_name + "/delta_phi");
     auto zeta = file.ReadOptVector<float>(image_group_name + "/zeta");
@@ -350,6 +354,10 @@ bool ReadReflectionsFromGroup(HDF5Object &file,
         if (lp.size() > i && lp[i] != 0.0f)
             lp_val = 1.0f / lp[i];
 
+        float qe_val = 1.0f;
+        if (qe.size() > i && qe[i] != 0.0f)
+            qe_val = 1.0f / qe[i];
+
         float partiality_val = -1.0f;
         if (partiality.size() > i && partiality[i] >= 0.0f)
             partiality_val = partiality[i];
@@ -397,6 +405,7 @@ bool ReadReflectionsFromGroup(HDF5Object &file,
             .var_bkg = var_bkg_val,
             .sigma = int_err.at(i),
             .prescaling_corr = lp_val,
+            .qe_corr = qe_val,
             .partiality = partiality_val,
             .zeta = zeta_val,
             .image_scale_corr = image_scale_corr_val
diff --git a/rugnux/rugnux_cli.cpp b/rugnux/rugnux_cli.cpp
index 17c6a2095..2166b47b0 100644
--- a/rugnux/rugnux_cli.cpp
+++ b/rugnux/rugnux_cli.cpp
@@ -174,7 +174,7 @@ void print_usage() {
     std::cout << "   -z, --reference-mtz <file>      Reference MTZ file" << std::endl;
     std::cout << "   --reference-column <label>      Reference MTZ column to use (default: auto - F-model, else IMEAN/I, else FP/FOBS/F)" << std::endl;
     std::cout << "   --model <file>                  After merging, validate vs this atomic model: R-free, sigma_A-weighted 2mFo-DFc/mFo-DFc maps, the model as placed (written beside them), and - where the merge kept the Bijvoet split - an anomalous difference map with the strongest anomalous scatterers named by the atom they sit on. PDB or mmCIF, gzipped or not, recognised by content rather than by extension" << std::endl;
-    std::cout << "   --export-unmerged               Write <prefix>_unmerged.mtz, an unmerged MTZ (POINTLESS column layout) of the integrated observations, for aimless / pointless / careless. On by default, whenever there is an output prefix. On a rotation run the partials of each reflection are summed into one full, written at the batch its rocking curve is centred on, with the summed rocking-curve fraction in FRACTIONCALC; an event that caught less of its rocking curve than --min-captured-fraction (or --min-partiality) is not written, exactly as in the merge, since a full is what the reading program is told these rows are. Intensities carry the Lorentz, polarization and sensor-efficiency corrections and nothing else, with the applied factor in the LP column: the partiality is not divided out and the per-image scale is not applied at all, since those programs scale the data themselves. Written in --mode mx and --mode scale, and with --no-merge" << std::endl;
+    std::cout << "   --export-unmerged               Write <prefix>_unmerged.mtz, an unmerged MTZ (POINTLESS column layout) of the integrated observations, for aimless / pointless / careless. On by default, whenever there is an output prefix. On a rotation run the partials of each reflection are summed into one full, written at the batch its rocking curve is centred on, with the summed rocking-curve fraction in FRACTIONCALC; an event that caught less of its rocking curve than --min-captured-fraction (or --min-partiality) is not written, exactly as in the merge, since a full is what the reading program is told these rows are. Intensities carry the deterministic per-reflection corrections and nothing else - Lorentz and polarization in the LP column, the sensor's angle-dependent efficiency in QE, so raw counts are I / LP * QE - while the partiality is not divided out and the per-image scale is not applied at all, since those programs scale the data themselves. Written in --mode mx and --mode scale, and with --no-merge" << std::endl;
     std::cout << "   --no-export-unmerged            Do not write <prefix>_unmerged.mtz. It is the largest file a run produces, so a run whose observations are not going to another scaling program - a regression battery, say - can skip writing it" << std::endl;
     std::cout << "   --export-unmerged-partials      Write <prefix>_unmerged_partials.mtz, the same observations with each partial as its own row (one batch per image) flagged for the reading program to sum, instead of summed here. Off by default and independent of --export-unmerged; both can be written in one run" << std::endl;
     std::cout << "   --no-p1-crosscheck              Do not write <prefix>_P1.mtz. That file is the same observations merged in P1 instead of the space group the run determined, so a wrong space group can be re-merged, re-solved or re-refined without processing the images again. Every rotation run that determines its own space group writes it - including one that determined P1, where it repeats the merged output - so it is there to be harvested whatever the run decided. Not written when -S fixed the space group: that run never integrated the group's centring absences, so its P1 merge would be missing whole classes of reflections. It is a full merge, not the degraded one the search runs on, and it costs one extra merge" << std::endl;
diff --git a/tests/CBORTest.cpp b/tests/CBORTest.cpp
index 7b9935f39..3af96be90 100644
--- a/tests/CBORTest.cpp
+++ b/tests/CBORTest.cpp
@@ -1078,7 +1078,7 @@ TEST_CASE("CBORSerialize_Image_Reflections") {
         .predicted_x = 1024.5f, .predicted_y = 768.25f,
         .observed_x = 1024.75f, .observed_y = 768.5f,
         .d = 2.345f, .I = 1234.5f, .bkg = 3.25f, .var_bkg = 41.5f, .sigma = 37.125f,
-        .dist_ewald = 0.0025f, .prescaling_corr = 1.75f, .partiality = 0.875f, .zeta = 0.625f,
+        .dist_ewald = 0.0025f, .prescaling_corr = 1.75f, .qe_corr = 0.9375f, .partiality = 0.875f, .zeta = 0.625f,
         .image_scale_corr = 1.125f
     });
     refs_in.push_back(Reflection{
@@ -1087,7 +1087,7 @@ TEST_CASE("CBORSerialize_Image_Reflections") {
         .predicted_x = 5.0f, .predicted_y = 10.0f,
         .observed_x = 5.5f, .observed_y = 10.5f,
         .d = 4.0f, .I = 12.0f, .bkg = 0.5f, .var_bkg = 6.75f, .sigma = 4.25f,
-        .dist_ewald = -0.001f, .prescaling_corr = 2.5f, .partiality = 0.5f, .zeta = 0.25f,
+        .dist_ewald = -0.001f, .prescaling_corr = 2.5f, .qe_corr = 0.8125f, .partiality = 0.5f, .zeta = 0.25f,
         .image_scale_corr = 0.875f
     });
     refs_in.push_back(Reflection{
@@ -1096,7 +1096,7 @@ TEST_CASE("CBORSerialize_Image_Reflections") {
         .predicted_x = 0.0f, .predicted_y = 0.0f,
         .observed_x = 0.25f, .observed_y = 0.5f,
         .d = 10.0f, .I = -1.5f, .bkg = 0.125f, .var_bkg = 0.875f, .sigma = 1.5f,
-        .dist_ewald = 0.0f, .prescaling_corr = 1.0f, .partiality = 1.0f, .zeta = 1.0f,
+        .dist_ewald = 0.0f, .prescaling_corr = 1.0f, .qe_corr = 1.0f, .partiality = 1.0f, .zeta = 1.0f,
         .image_scale_corr = 1.0f
     });
 
@@ -1147,6 +1147,7 @@ TEST_CASE("CBORSerialize_Image_Reflections") {
         CHECK(b.sigma == Catch::Approx(a.sigma).margin(1e-6f));
         CHECK(b.dist_ewald == Catch::Approx(a.dist_ewald).margin(1e-6f));
         CHECK(b.prescaling_corr == Catch::Approx(a.prescaling_corr).margin(1e-6f));
+        CHECK(b.qe_corr == Catch::Approx(a.qe_corr).margin(1e-6f));
         CHECK(b.partiality == Catch::Approx(a.partiality).margin(1e-6f));
         CHECK(b.zeta == Catch::Approx(a.zeta).margin(1e-6f));
         CHECK(b.image_scale_corr == Catch::Approx(a.image_scale_corr).margin(1e-6f));
diff --git a/tests/JFJochReaderTest.cpp b/tests/JFJochReaderTest.cpp
index 9b085e239..49f830a65 100644
--- a/tests/JFJochReaderTest.cpp
+++ b/tests/JFJochReaderTest.cpp
@@ -2432,6 +2432,7 @@ static Reflection MakeTestReflection(int i, int j) {
         .bkg = 10.0f + f,
         .sigma = 2.0f + 0.5f * f,
         .prescaling_corr = 1.0f + 0.125f * f,
+        .qe_corr = 1.0f / (1.0f + 0.01f * f),   // always in (0, 1], as the correction itself is
         .partiality = 0.5f + 0.01f * f,
         .zeta = 0.01f + 0.001f * f,
         .image_scale_corr = 1.0f + 0.25f * f
@@ -2459,6 +2460,7 @@ static void CheckReflectionRoundTrip(const Reflection &got, int i, int j) {
     CHECK(got.bkg == Catch::Approx(want.bkg));
     CHECK(got.sigma == Catch::Approx(want.sigma));
     CHECK(got.prescaling_corr == Catch::Approx(want.prescaling_corr));           // stored as 1/prescaling_corr, inverted again on read
+    CHECK(got.qe_corr == Catch::Approx(want.qe_corr));   // likewise stored as its reciprocal
     CHECK(got.partiality == Catch::Approx(want.partiality));
     CHECK(got.zeta == Catch::Approx(want.zeta));
     CHECK(got.image_scale_corr == Catch::Approx(want.image_scale_corr));
diff --git a/tests/WriteReflectionsTest.cpp b/tests/WriteReflectionsTest.cpp
index 1508145f3..e458f836b 100644
--- a/tests/WriteReflectionsTest.cpp
+++ b/tests/WriteReflectionsTest.cpp
@@ -10,6 +10,8 @@
 
 #include "../common/DiffractionExperiment.h"
 #include "../image_analysis/WriteReflections.h"
+#include "../image_analysis/IntegrationOutcome.h"
+#include <cmath>
 #include "SyntheticMergedReflections.h"
 
 namespace {
@@ -70,3 +72,59 @@ TEST_CASE("Merged MTZ: the data dataset is id 1 and carries the wavelength", "[w
 
     CHECK(mtz.nreflections == static_cast<int>(reflections.size()));
 }
+
+TEST_CASE("Unmerged MTZ: LP is Lorentz-polarization and QE carries the sensor efficiency",
+          "[write_reflections]") {
+    // The whole point of the split: LP must mean what XDS and DIALS mean by it, and the raw count
+    // sum must still be recoverable from the file alone, as I / LP * QE.
+    auto experiment = TestExperiment();
+    experiment.Goniometer(GoniometerAxis("omega", 0.0f, 0.1f, Coord(-1, 0, 0), {}));
+
+    IntegrationOutcome outcome;
+    const float raw[3] = {1000.0f, 250.0f, 40.0f};
+    const float corr[3] = {1.75f, 2.50f, 0.90f};   // the whole prescaling product
+    const float qe[3]  = {0.9375f, 0.8125f, 1.0f};    // 1.0 = the sensor said nothing to correct
+    for (int i = 0; i < 3; ++i) {
+        Reflection r{};
+        r.h = 4 + i; r.k = 2; r.l = 6;
+        r.image_number = static_cast<float>(i);
+        r.d = 5.0f + i;
+        r.I = raw[i];                                 // the writer is what applies the factor
+        r.sigma = std::sqrt(raw[i]);
+        r.prescaling_corr = corr[i];
+        r.qe_corr = qe[i];
+        r.partiality = 1.0f;
+        r.predicted_x = 100.0f + i; r.predicted_y = 200.0f + i;
+        r.observed_x = NAN; r.observed_y = NAN;
+        outcome.reflections.push_back(r);
+    }
+
+    const auto path = (std::filesystem::temp_directory_path() / "rugnux_unmerged_qe.mtz").string();
+    WriteUnmergedMtzReflections({outcome}, TETRAGONAL_CELL, experiment, false, path);
+    const gemmi::Mtz mtz = gemmi::read_mtz_file(path);
+    std::filesystem::remove(path);
+
+    const gemmi::Mtz::Column *c_I = mtz.column_with_label("I");
+    const gemmi::Mtz::Column *c_lp = mtz.column_with_label("LP");
+    const gemmi::Mtz::Column *c_qe = mtz.column_with_label("QE");
+    REQUIRE(c_I != nullptr);
+    REQUIRE(c_lp != nullptr);
+    REQUIRE(c_qe != nullptr);          // DIALS writes this column even when there is nothing in it
+    REQUIRE(mtz.nreflections == 3);
+
+    for (int i = 0; i < 3; ++i) {
+        const float I = mtz.data[i * mtz.columns.size() + c_I->idx];
+        const float LP = mtz.data[i * mtz.columns.size() + c_lp->idx];
+        const float QE = mtz.data[i * mtz.columns.size() + c_qe->idx];
+        INFO("row " << i);
+        // LP holds Lorentz x polarization alone: the sensor term has been divided out of it.
+        CHECK(LP == Catch::Approx(corr[i] / qe[i]).epsilon(1e-5));
+        // QE is a divisor normalised to 1 at normal incidence, so it never drops below 1.
+        CHECK(QE == Catch::Approx(1.0f / qe[i]).epsilon(1e-5));
+        CHECK(QE >= 1.0f);
+        // ... and the two together put the raw counts back.
+        CHECK(I / LP * QE == Catch::Approx(raw[i]).epsilon(1e-4));
+        // The intensity itself did not move: it is still the fully corrected value.
+        CHECK(I == Catch::Approx(raw[i] * corr[i]).epsilon(1e-5));
+    }
+}
diff --git a/writer/HDF5DataFilePluginReflection.cpp b/writer/HDF5DataFilePluginReflection.cpp
index a3b74f307..7e03460ff 100644
--- a/writer/HDF5DataFilePluginReflection.cpp
+++ b/writer/HDF5DataFilePluginReflection.cpp
@@ -15,7 +15,7 @@ void HDF5DataFilePluginReflection::Write(const DataMessage &msg, uint64_t image_
         return;
 
     std::vector<int32_t> h, k, l;
-    std::vector<float> I, sigma, d, lp;
+    std::vector<float> I, sigma, d, lp, qe;
     std::vector<float> image, phi, pred_x, pred_y, obs_x, obs_y, bkg, var_bkg, partiality, zeta,
             scale_factor;
 
@@ -32,6 +32,7 @@ void HDF5DataFilePluginReflection::Write(const DataMessage &msg, uint64_t image_
     bkg.reserve(msg.reflections.size());
     var_bkg.reserve(msg.reflections.size());
     lp.reserve(msg.reflections.size());
+    qe.reserve(msg.reflections.size());
     partiality.reserve(msg.reflections.size());
     image.reserve(msg.reflections.size());
     phi.reserve(msg.reflections.size());
@@ -53,6 +54,7 @@ void HDF5DataFilePluginReflection::Write(const DataMessage &msg, uint64_t image_
         bkg.emplace_back(refl.bkg);
         var_bkg.emplace_back(refl.var_bkg);
         lp.emplace_back(1.0/refl.prescaling_corr);
+        qe.emplace_back(1.0/refl.qe_corr);
         partiality.emplace_back(refl.partiality);
         phi.emplace_back(refl.delta_phi_deg);
         zeta.emplace_back(refl.zeta);
@@ -77,6 +79,7 @@ void HDF5DataFilePluginReflection::Write(const DataMessage &msg, uint64_t image_
     image_group.SaveVector("background_variance", var_bkg);
     image_group.SaveVector("observed_frame", image);
     image_group.SaveVector("lp", lp);
+    image_group.SaveVector("qe", qe);
     image_group.SaveVector("partiality", partiality);
     image_group.SaveVector("zeta", zeta);
     image_group.SaveVector("image_scale_corr", scale_factor);