setiastrosuitepro 1.6.2__py3-none-any.whl → 1.6.12__py3-none-any.whl

setiastro/saspro/stacking_suite.py

@@ -16,6 +16,7 @@ import hashlib
 from numpy.lib.format import open_memmap 
 import tzlocal
 import weakref
+import ast
 import re
 import unicodedata
 import math            # used in compute_safe_chunk
@@ -152,65 +153,256 @@ _WINDOWS_RESERVED = {
 
 _FITS_EXTS = ('.fits', '.fit', '.fts', '.fits.gz', '.fit.gz', '.fts.gz', '.fz')
 
+def _coerce_fits_value(v):
+    """Convert XISF keyword 'value' strings to reasonable python scalars."""
+    if v is None:
+        return None
+    if isinstance(v, (int, float, bool)):
+        return v
+    s = str(v).strip()
+
+    # PixInsight often uses 'T'/'F'
+    if s in ("T", "TRUE", "True", "true"):
+        return True
+    if s in ("F", "FALSE", "False", "false"):
+        return False
+
+    # int?
+    try:
+        if s.isdigit() or (s.startswith(("+", "-")) and s[1:].isdigit()):
+            return int(s)
+    except Exception:
+        pass
+
+    # float?
+    try:
+        # handles "8.9669e+03", etc.
+        return float(s)
+    except Exception:
+        pass
+
+    # keep as string (strip surrounding quotes if present)
+    if (len(s) >= 2) and ((s[0] == s[-1]) and s[0] in ("'", '"')):
+        s = s[1:-1]
+    return s
+
+
+def xisf_fits_header(path: str, image_index: int = 0) -> fits.Header:
+    """
+    Extract FITS keywords from XISF file into astropy.io.fits.Header.
+
+    Your XISF structure has:
+      ims[0]["FITSKeywords"][KEY] = [ {"value": "...", "comment": "..."}, ... ]
+    Sometimes nested under ims[0]["xisf_meta"] (dict or stringified dict).
+    """
+    hdr = fits.Header()
+    if XISF is None:
+        return hdr
+
+    x = XISF(path)
+    ims = x.get_images_metadata() or []
+    if not ims:
+        return hdr
+
+    im = ims[min(max(image_index, 0), len(ims) - 1)]
+
+    # 1) direct
+    kw = im.get("FITSKeywords")
+
+    # 2) nested inside xisf_meta dict
+    if kw is None:
+        xm = im.get("xisf_meta")
+        if isinstance(xm, dict):
+            kw = xm.get("FITSKeywords")
+
+    # 3) xisf_meta stringified dict (your dump shows this exact situation)
+    if kw is None:
+        xm = im.get("xisf_meta")
+        if isinstance(xm, str) and "FITSKeywords" in xm:
+            try:
+                xm2 = ast.literal_eval(xm)
+                if isinstance(xm2, dict):
+                    kw = xm2.get("FITSKeywords")
+            except Exception:
+                kw = None
+
+    if not isinstance(kw, dict):
+        return hdr
+
+    # Build header
+    for key, entries in kw.items():
+        try:
+            k = str(key).strip()
+            if not k:
+                continue
+
+            # entries is usually a list of dicts: [{"value": "...", "comment":"..."}]
+            if isinstance(entries, list) and entries:
+                e0 = entries[0]
+                if isinstance(e0, dict):
+                    val = _coerce_fits_value(e0.get("value"))
+                    com = e0.get("comment")
+                else:
+                    val = _coerce_fits_value(e0)
+                    com = None
+            elif isinstance(entries, dict):
+                val = _coerce_fits_value(entries.get("value"))
+                com = entries.get("comment")
+            else:
+                val = _coerce_fits_value(entries)
+                com = None
+
+            if com is not None:
+                hdr[k] = (val, str(com))
+            else:
+                hdr[k] = val
+        except Exception:
+            # never let one bad keyword kill header extraction
+            pass
+
+    return hdr
+
 def get_valid_header(path: str):
     """
-    Return a robust FITS header for both normal and compressed FITS.
+    Fast header-only peek with targeted fallback.
 
-    - Opens the HDU list and picks the first image-like HDU (ndim >= 2).
-    - Forces NAXIS, NAXIS1, NAXIS2 from the actual data.shape if possible.
-    - Falls back to ZNAXIS1/2 for tile-compressed images.
+    FITS/FITS-like:
+      1) Header-only scan (lazy_load_hdus=True, never touches .data)
+      2) If NAXIS1/2 still missing/invalid, fallback to reading ONE image HDU's data
+         to infer shape, then patch NAXIS/NAXIS1/NAXIS2.
+
+    XISF:
+      - Parse XML header only (no pixel decode)
+      - Synthesize a FITS-like header dict with keys used by stacking ingest:
+        NAXIS1, NAXIS2, (optional NAXIS3), EXPOSURE/EXPTIME, IMAGETYP, FILTER, etc.
+
+    Returns: (hdr_like, ok_bool)
+      - hdr_like is an astropy Header for FITS, or a dict for XISF
     """
     try:
+        lp = (path or "").lower()
+
+        if lp.endswith(".xisf"):
+            from astropy.io import fits
+
+            # Grab FITS keywords from the XISF
+            hdr = xisf_fits_header(path)
+
+            # Still need geometry for NAXISn
+            x = XISF(path)
+            ims = x.get_images_metadata() or []
+            if ims:
+                im = ims[0]
+                w, h, chc = im.get("geometry", (0, 0, 0))
+                w = int(w or 0)
+                h = int(h or 0)
+                c = int(chc or 0)
+
+                hdr["NAXIS"]  = 3 if c > 1 else 2
+                hdr["NAXIS1"] = w
+                hdr["NAXIS2"] = h
+                if c > 1:
+                    hdr["NAXIS3"] = c
+
+            # Normalize exposure keyword convenience
+            if "EXPTIME" not in hdr and "EXPOSURE" in hdr:
+                hdr["EXPTIME"] = hdr["EXPOSURE"]
+            if "EXPOSURE" not in hdr and "EXPTIME" in hdr:
+                hdr["EXPOSURE"] = hdr["EXPTIME"]
+
+            return hdr, True
+
+        # ---------------------------
+        # FITS path (your existing logic)
+        # ---------------------------
         from astropy.io import fits
 
-        with fits.open(path, memmap=False) as hdul:
+        def _is_good_dim(v):
+            try:
+                return int(v) > 0
+            except Exception:
+                return False
+
+        # ---------------------------
+        # Pass 1: header-only
+        # ---------------------------
+        with fits.open(path, mode="readonly", memmap=True, lazy_load_hdus=True) as hdul:
             science_hdu = None
 
-            # Prefer the first HDU that actually has 2D+ image data
             for hdu in hdul:
-                data = getattr(hdu, "data", None)
-                if data is None:
-                    continue
-                if getattr(data, "ndim", 0) >= 2:
+                hdr = hdu.header
+
+                # Prefer HDUs that *declare* 2D+ via header
+                naxis = hdr.get("NAXIS", None)
+                znaxis = hdr.get("ZNAXIS", None)
+
+                looks_2d = False
+                try:
+                    if naxis is not None and int(naxis) >= 2:
+                        looks_2d = True
+                except Exception:
+                    pass
+                try:
+                    if znaxis is not None and int(znaxis) >= 2:
+                        looks_2d = True
+                except Exception:
+                    pass
+
+                if looks_2d:
                     science_hdu = hdu
                     break
 
             if science_hdu is None:
-                # Fallback: just use primary
                 science_hdu = hdul[0]
 
             hdr = science_hdu.header.copy()
-            data = science_hdu.data
 
-            # --- Ensure NAXIS / NAXIS1 / NAXIS2 are real numbers ---
-            try:
-                if data is not None and getattr(data, "ndim", 0) >= 2:
-                    shape = data.shape
-                    # FITS: final axes are X, Y
-                    ny, nx = shape[-2], shape[-1]
-                    hdr["NAXIS"] = int(data.ndim)
-                    hdr["NAXIS1"] = int(nx)
-                    hdr["NAXIS2"] = int(ny)
-            except Exception:
-                pass
+            # Prefer normal NAXISn; fallback to ZNAXISn for tile-compressed
+            if not _is_good_dim(hdr.get("NAXIS1")) and _is_good_dim(hdr.get("ZNAXIS1")):
+                hdr["NAXIS1"] = int(hdr["ZNAXIS1"])
+            if not _is_good_dim(hdr.get("NAXIS2")) and _is_good_dim(hdr.get("ZNAXIS2")):
+                hdr["NAXIS2"] = int(hdr["ZNAXIS2"])
 
-            # --- Extra fallback from ZNAXISn (tile-compressed FITS) ---
-            for ax in (1, 2):
-                key = f"NAXIS{ax}"
-                zkey = f"ZNAXIS{ax}"
-                val = hdr.get(key, None)
-                if (val is None or (isinstance(val, str) and not val.strip())) and zkey in hdr:
-                    try:
-                        hdr[key] = int(hdr[zkey])
-                    except Exception:
-                        pass
+            # FAST PATH
+            if _is_good_dim(hdr.get("NAXIS1")) and _is_good_dim(hdr.get("NAXIS2")):
+                return hdr, True
 
-        return hdr, True
+        # ---------------------------
+        # Pass 2: slow fallback (ONLY if needed)
+        # ---------------------------
+        with fits.open(path, mode="readonly", memmap=False) as hdul:
+            target_hdu = None
+            for hdu in hdul:
+                naxis = hdu.header.get("NAXIS", 0)
+                znaxis = hdu.header.get("ZNAXIS", 0)
 
-    except Exception:
-        return None, False
+                try:
+                    if int(naxis) >= 2 or int(znaxis) >= 2:
+                        target_hdu = hdu
+                        break
+                except Exception:
+                    continue
+
+            if target_hdu is None:
+                target_hdu = hdul[0]
+
+            data = getattr(target_hdu, "data", None)
+            hdr2 = target_hdu.header.copy()
+
+            if data is not None and getattr(data, "ndim", 0) >= 2:
+                try:
+                    ny, nx = data.shape[-2], data.shape[-1]
+                    hdr2["NAXIS"] = int(getattr(data, "ndim", hdr2.get("NAXIS", 2)))
+                    hdr2["NAXIS1"] = int(nx)
+                    hdr2["NAXIS2"] = int(ny)
+                    return hdr2, True
+                except Exception:
+                    pass
 
+            return hdr2, True
 
+    except Exception:
+        return None, False
 
 
 def _read_tile_stack(file_list, y0, y1, x0, x1, channels, out_buf):
@@ -1523,11 +1715,20 @@ class _MMFits:
             raise ValueError(f"Unsupported ndim={self.ndim} for {path}")
 
     def _apply_fixed_fits_scale(self, arr: np.ndarray) -> np.ndarray:
+        """
+        Map 8/16-bit FITS integer samples to [0,1] using a fixed divisor.
+        IMPORTANT: Only do this for integer dtypes. If Astropy already returned
+        float (e.g. BSCALE/BZERO applied), do NOT divide again.
+        """
+        # Only scale raw integer pixel arrays
+        if arr.dtype.kind not in ("u", "i"):
+            return arr
+
         bitpix = getattr(self, "_bitpix", 0)
         if bitpix == 8:
-            arr /= 255.0
+            return arr / 255.0
         elif bitpix == 16:
-            arr /= 65535.0
+            return arr / 65535.0
         return arr
 
     def read_tile(self, y0, y1, x0, x1) -> np.ndarray:
@@ -1655,9 +1856,9 @@ class ReferenceFrameReviewDialog(QDialog):
         self.initUI()
         self.loadImageArray()  # Load the image into self.original_image
         if self.original_image is not None:
-            self.updatePreview(self.original_image)  # Ensure the first image is shown
-        if self.original_image is not None:
-            QTimer.singleShot(0, self.zoomIn)            
+            QTimer.singleShot(0, lambda: self.updatePreview(self.original_image, fit=True))
+        #if self.original_image is not None:
+        #    QTimer.singleShot(0, self.zoomIn)            
 
 
     def initUI(self):
@@ -1715,6 +1916,89 @@ class ReferenceFrameReviewDialog(QDialog):
         self.setLayout(main_layout)
         self.zoomIn()
     
+    def _ensure_hwc(self, x: np.ndarray) -> np.ndarray:
+        """Ensure HWC for RGB, HW for mono."""
+        if x is None:
+            return None
+        x = np.asarray(x)
+        # CHW -> HWC
+        if x.ndim == 3 and x.shape[0] == 3 and x.shape[-1] != 3:
+            x = np.transpose(x, (1, 2, 0))
+        # squeeze HWC with singleton
+        if x.ndim == 3 and x.shape[-1] == 1:
+            x = np.squeeze(x, axis=-1)
+        return x
+
+
+    def _robust_preview_stretch(self, img: np.ndarray,
+                            lo_pct: float = 0.25,
+                            hi_pct: float = 99.75,
+                            gamma: float = 0.65) -> np.ndarray:
+        """
+        Robust preview stretch:
+        - nan/inf safe
+        - pedestal remove per channel (img - min)
+        - percentile clip to kill outliers
+        - scale to 0..1
+        - gentle gamma (default <1 brightens)
+        Returns float32 in [0,1] and preserves mono vs RGB.
+        """
+        x = self._ensure_hwc(img)
+        if x is None:
+            return None
+
+        x = np.asarray(x, dtype=np.float32)
+        x = np.nan_to_num(x, nan=0.0, posinf=0.0, neginf=0.0)
+
+        # Mono
+        if x.ndim == 2:
+            x = x - float(x.min())
+            # percentile clip on non-flat data
+            p_lo = float(np.percentile(x, lo_pct))
+            p_hi = float(np.percentile(x, hi_pct))
+            if p_hi > p_lo:
+                x = np.clip(x, p_lo, p_hi)
+                x = (x - p_lo) / (p_hi - p_lo)
+            else:
+                mx = float(x.max())
+                if mx > 0:
+                    x = x / mx
+            if gamma is not None and gamma > 0:
+                x = np.power(np.clip(x, 0.0, 1.0), gamma)
+            return np.clip(x, 0.0, 1.0).astype(np.float32, copy=False)
+
+        # RGB (HWC)
+        if x.ndim == 3 and x.shape[2] == 3:
+            out = np.empty_like(x, dtype=np.float32)
+            for c in range(3):
+                ch = x[..., c]
+                ch = ch - float(ch.min())
+                p_lo = float(np.percentile(ch, lo_pct))
+                p_hi = float(np.percentile(ch, hi_pct))
+                if p_hi > p_lo:
+                    ch = np.clip(ch, p_lo, p_hi)
+                    ch = (ch - p_lo) / (p_hi - p_lo)
+                else:
+                    mx = float(ch.max())
+                    if mx > 0:
+                        ch = ch / mx
+                out[..., c] = ch
+
+            if gamma is not None and gamma > 0:
+                out = np.power(np.clip(out, 0.0, 1.0), gamma)
+
+            return np.clip(out, 0.0, 1.0).astype(np.float32, copy=False)
+
+        # Fallback: treat as scalar field
+        x = x - float(x.min())
+        mx = float(x.max())
+        if mx > 0:
+            x = x / mx
+        if gamma is not None and gamma > 0:
+            x = np.power(np.clip(x, 0.0, 1.0), gamma)
+        return np.clip(x, 0.0, 1.0).astype(np.float32, copy=False)
+
+
     def fitToPreview(self):
         """Calculate and set the zoom factor so that the image fills the preview area."""
         if self.original_image is None:
@@ -1741,32 +2025,46 @@ class ReferenceFrameReviewDialog(QDialog):
 
     def _normalize_preview_01(self, img: np.ndarray) -> np.ndarray:
         """
-        Normalize image to [0,1] for preview/stretch:
-
-        1. Handle NaNs/inf safely.
-        2. If min < 0 or max > 1, do (img - min) / (max - min).
-        3. Always return float32 in [0,1].
+        Always normalize to [0,1]:
+        img = img - min(img)
+        img = img / max(img)
+        Per-channel if RGB, global if mono.
         """
         if img is None:
             return None
 
-        img = np.asarray(img, dtype=np.float32)
-        img = np.nan_to_num(img, nan=0.0, posinf=0.0, neginf=0.0)
-
-        finite = np.isfinite(img)
-        if not finite.any():
-            return np.zeros_like(img, dtype=np.float32)
-
-        mn = float(img[finite].min())
-        mx = float(img[finite].max())
-        if mx == mn:
-            # flat frame → just zero it
-            return np.zeros_like(img, dtype=np.float32)
+        x = np.asarray(img, dtype=np.float32)
+        x = np.nan_to_num(x, nan=0.0, posinf=0.0, neginf=0.0)
 
-        if mn < 0.0 or mx > 1.0:
-            img = (img - mn) / (mx - mn)
+        if x.ndim == 2:
+            mn = float(x.min())
+            x = x - mn
+            mx = float(x.max())
+            if mx > 0:
+                x = x / mx
+            return np.clip(x, 0.0, 1.0).astype(np.float32, copy=False)
+
+        if x.ndim == 3 and x.shape[2] == 3:
+            # per-channel pedestal remove + normalize
+            out = x.copy()
+            for c in range(3):
+                ch = out[..., c]
+                mn = float(ch.min())
+                ch = ch - mn
+                mx = float(ch.max())
+                if mx > 0:
+                    ch = ch / mx
+                out[..., c] = ch
+            return np.clip(out, 0.0, 1.0).astype(np.float32, copy=False)
+
+        # fallback
+        mn = float(x.min())
+        x = x - mn
+        mx = float(x.max())
+        if mx > 0:
+            x = x / mx
+        return np.clip(x, 0.0, 1.0).astype(np.float32, copy=False)
 
-        return np.clip(img, 0.0, 1.0)
 
 
     def loadImageArray(self):
@@ -1789,22 +2087,44 @@ class ReferenceFrameReviewDialog(QDialog):
 
         self.original_image = img
 
+    def _fit_zoom_to_viewport(self, image: np.ndarray):
+        """Set zoom_factor so image fits inside the scrollArea viewport."""
+        if image is None:
+            return
+
+        img = self._ensure_hwc(image)
+
+        if img.ndim == 2:
+            h, w = img.shape
+        elif img.ndim == 3 and img.shape[2] == 3:
+            h, w = img.shape[:2]
+        else:
+            return
+
+        vp = self.scrollArea.viewport().size()
+        if vp.width() <= 0 or vp.height() <= 0 or w <= 0 or h <= 0:
+            return
+
+        # Fit-to-viewport zoom
+        self.zoom_factor = min(vp.width() / w, vp.height() / h)
     
-    def updatePreview(self, image):
-        """
-        Convert a given image array to a QPixmap and update the preview label.
-        """
+    def updatePreview(self, image, *, fit: bool = False):
         self.current_preview_image = image
+
+        if fit:
+            self._fit_zoom_to_viewport(image)
+
         pixmap = self.convertArrayToPixmap(image)
         if pixmap is None or pixmap.isNull():
             self.previewLabel.setText(self.tr("Unable to load preview."))
-        else:
-            available_size = self.scrollArea.viewport().size()
-            new_size = QSize(int(available_size.width() * self.zoom_factor),
-                             int(available_size.height() * self.zoom_factor))
-            scaled_pixmap = pixmap.scaled(new_size, Qt.AspectRatioMode.KeepAspectRatio,
-                                          Qt.TransformationMode.SmoothTransformation)
-            self.previewLabel.setPixmap(scaled_pixmap)
+            return
+
+        scaled = pixmap.scaled(
+            pixmap.size() * self.zoom_factor,
+            Qt.AspectRatioMode.KeepAspectRatio,
+            Qt.TransformationMode.SmoothTransformation
+        )
+        self.previewLabel.setPixmap(scaled)
     
     def _preview_boost(self, img: np.ndarray) -> np.ndarray:
         """Robust, very gentle stretch for display when image would quantize to black."""
@@ -1822,62 +2142,48 @@ class ReferenceFrameReviewDialog(QDialog):
         if image is None:
             return None
 
-        img = image.astype(np.float32, copy=False)
-
-        # If image is so dim or flat that 8-bit will zero-out, boost for preview
-        ptp = float(img.max() - img.min())
-        needs_boost = (float(img.max()) <= (1.0 / 255.0)) or (ptp < 1e-6) or (not np.isfinite(img).all())
-        if needs_boost:
-            img = self._preview_boost(np.nan_to_num(img, nan=0.0, posinf=0.0, neginf=0.0))
+        # ALWAYS normalize to [0,1]
+        img = self._normalize_preview_01(image)
 
         # Convert to 8-bit for QImage
         display_image = (img * 255.0).clip(0, 255).astype(np.uint8)
 
+        # IMPORTANT: ensure contiguous memory
+        display_image = np.ascontiguousarray(display_image)
+
+        # Keep a reference so Qt's QImage always has valid backing memory
+        self._last_preview_u8 = display_image
+
         if display_image.ndim == 2:
             h, w = display_image.shape
-            q_image = QImage(display_image.data, w, h, w, QImage.Format.Format_Grayscale8)
+            q_image = QImage(self._last_preview_u8.data, w, h, w, QImage.Format.Format_Grayscale8)
+            q_image = q_image.copy()  # detach from numpy buffer (extra safety)
         elif display_image.ndim == 3 and display_image.shape[2] == 3:
             h, w, _ = display_image.shape
-            q_image = QImage(display_image.data, w, h, 3 * w, QImage.Format.Format_RGB888)
+            q_image = QImage(self._last_preview_u8.data, w, h, 3 * w, QImage.Format.Format_RGB888)
+            q_image = q_image.copy()  # detach
         else:
             return None
+
         return QPixmap.fromImage(q_image)
-    
+
     def toggleAutostretch(self):
         if self.original_image is None:
             QMessageBox.warning(self, self.tr("Error"), self.tr("Reference image not loaded."))
             return
 
-        # 🔹 Ensure the image we feed to Statistical Stretch is in [0,1]
-        base = self._normalize_preview_01(self.original_image)
-
         self.autostretch_enabled = not self.autostretch_enabled
+
         if self.autostretch_enabled:
-            if base.ndim == 2:
-                new_image = stretch_mono_image(
-                    base,
-                    target_median=0.3,
-                    normalize=True,
-                    apply_curves=False
-                )
-            elif base.ndim == 3 and base.shape[2] == 3:
-                new_image = stretch_color_image(
-                    base,
-                    target_median=0.3,
-                    linked=False,
-                    normalize=True,
-                    apply_curves=False
-                )
-            else:
-                new_image = base
+            new_image = self._robust_preview_stretch(self.original_image)
             self.toggleAutoStretchButton.setText(self.tr("Disable Autostretch"))
         else:
-            new_image = base
+            new_image = self._normalize_preview_01(self.original_image)
             self.toggleAutoStretchButton.setText(self.tr("Enable Autostretch"))
 
-        self.updatePreview(new_image)
+        self.updatePreview(new_image, fit=True)
 
-    
+        
     def zoomIn(self):
         self.zoom_factor *= 1.2
         if self.current_preview_image is not None:
@@ -3340,7 +3646,8 @@ class _MMImage:
         self._orig_dtype = None
         self._color_axis = None
         self._spat_axes = (0, 1)
-
+        self._dbg = bool(os.environ.get("SASPRO_MMIMAGE_DEBUG", "0") == "1")
+        self._dbg_count = 0
         self._xisf = None
         self._xisf_memmap = None   # np.memmap when possible
         self._xisf_arr = None      # decompressed ndarray when needed
@@ -3362,6 +3669,11 @@ class _MMImage:
             self._open_fits(path)
             self._kind = "fits"
 
+    def _dbg_log(self, msg: str):
+        if not getattr(self, "_dbg", False):
+            return
+        print(msg)  # or your logger
+
     # ---------------- FITS ----------------
     def _open_fits(self, path: str):
         """
@@ -3467,17 +3779,27 @@ class _MMImage:
     # ---------------- common API ----------------
     def _apply_fixed_fits_scale(self, arr: np.ndarray) -> np.ndarray:
         """
-        Map 8/16-bit FITS (already BZERO/BSCALE-scaled by Astropy) to [0,1]
-        using a fixed divisor. No per-frame img/max(img) normalization.
+        Map 8/16-bit FITS integer samples to [0,1] using a fixed divisor.
+        IMPORTANT: Only do this for integer dtypes. If Astropy already returned
+        float (e.g. BSCALE/BZERO applied), do NOT divide again.
         """
+        # Only scale raw integer pixel arrays
+        if arr.dtype.kind not in ("u", "i"):
+            return arr
+
         bitpix = getattr(self, "_bitpix", 0)
         if bitpix == 8:
-            arr /= 255.0
+            return arr / 255.0
         elif bitpix == 16:
-            arr /= 65535.0
+            return arr / 65535.0
         return arr
 
+
     def read_tile(self, y0, y1, x0, x1) -> np.ndarray:
+        import os
+        import numpy as np
+
+        # ---- FITS / XISF tile read (unchanged) ----
         if self._kind == "fits":
             d = self._fits_data
             if self.ndim == 2:
@@ -3491,23 +3813,23 @@ class _MMImage:
                     tile = np.moveaxis(tile, self._color_axis, -1)
         else:
             if self._xisf_memmap is not None:
-                # memmapped (C,H,W) → slice, then move to (H,W,C)
                 C = 1 if self.ndim == 2 else self.shape[2]
                 if C == 1:
                     tile = self._xisf_memmap[0, y0:y1, x0:x1]
                 else:
-                    tile = np.moveaxis(
-                        self._xisf_memmap[:, y0:y1, x0:x1], 0, -1
-                    )
+                    tile = np.moveaxis(self._xisf_memmap[:, y0:y1, x0:x1], 0, -1)
             else:
                 tile = self._xisf_arr[y0:y1, x0:x1]
 
-        # Cast to float32
+        # Cast to float32 copy (what you actually feed the stacker)
         out = np.array(tile, dtype=np.float32, copy=True, order="C")
 
-        # For FITS, apply fixed 8/16-bit normalization
+
+        # ---- APPLY FIXED SCALE (your real suspect) ----
         if self._kind == "fits":
-            out = self._apply_fixed_fits_scale(out)
+            out2 = self._apply_fixed_fits_scale(out)
+
+            out = out2
 
         # ensure (h,w,3) or (h,w)
         if out.ndim == 3 and out.shape[-1] not in (1, 3):
@@ -3515,6 +3837,7 @@ class _MMImage:
                 out = np.moveaxis(out, 0, -1)
         if out.ndim == 3 and out.shape[-1] == 1:
             out = np.squeeze(out, axis=-1)
+
         return out
 
     def read_full(self) -> np.ndarray:
@@ -3905,6 +4228,175 @@ def _bias_to_match_light(light_data, master_bias):
             return b[:, :, 0][None, :, :]  # (H,W,1) -> (1,H,W)
     return b
 
+def _read_center_patch_via_mmimage(path: str, y0: int, y1: int, x0: int, x1: int):
+    src = _MMImage(path)
+    try:
+        sub = src.read_tile(y0, y1, x0, x1)
+        return sub
+    finally:
+        try:
+            src.close()
+        except Exception:
+            pass
+
+def _get_key_float(hdr: fits.Header, key: str):
+    try:
+        v = hdr.get(key, None)
+        if v is None:
+            return None
+        # handle strings like "-10.0" or "-10 C"
+        if isinstance(v, str):
+            v = v.strip().replace("C", "").replace("°", "").strip()
+        return float(v)
+    except Exception:
+        return None
+
+def _collect_temp_stats(file_list: list[str]):
+    ccd = []
+    setp = []
+    n_ccd = 0
+    n_set = 0
+
+    for p in file_list:
+        try:
+            hdr = fits.getheader(p, memmap=True)
+        except Exception:
+            continue
+
+        v1 = _get_key_float(hdr, "CCD-TEMP")
+        v2 = _get_key_float(hdr, "SET-TEMP")
+
+        if v1 is not None:
+            ccd.append(v1); n_ccd += 1
+        if v2 is not None:
+            setp.append(v2); n_set += 1
+
+    def _stats(arr):
+        if not arr:
+            return None, None, None, None
+        a = np.asarray(arr, dtype=np.float32)
+        return float(np.median(a)), float(np.min(a)), float(np.max(a)), float(np.std(a))
+
+    c_med, c_min, c_max, c_std = _stats(ccd)
+    s_med, s_min, s_max, s_std = _stats(setp)
+
+    return {
+        "ccd_med": c_med, "ccd_min": c_min, "ccd_max": c_max, "ccd_std": c_std, "ccd_n": n_ccd,
+        "set_med": s_med, "set_min": s_min, "set_max": s_max, "set_std": s_std, "set_n": n_set,
+        "n_files": len(file_list),
+    }
+
+def _temp_to_stem_tag(temp_c: float, *, prefix: str = "") -> str:
+    """
+    Filename-safe temperature token:
+      -10.0  -> 'm10p0C'
+      +5.25  -> 'p5p3C' (rounded to 0.1C if you pass that in)
+    Uses:
+      m = minus, p = plus/decimal separator
+    Never produces '_-' which your _normalize_master_stem would collapse.
+    """
+    try:
+        t = float(temp_c)
+    except Exception:
+        return ""
+
+    sign = "m" if t < 0 else "p"
+    t_abs = abs(t)
+
+    # keep one decimal place (match your earlier plan)
+    s = f"{t_abs:.1f}"          # e.g. "10.0"
+    s = s.replace(".", "p")     # e.g. "10p0"
+    return f"{prefix}{sign}{s}C"
+
+
+def _arr_stats(a: np.ndarray):
+    a = np.asarray(a)
+    fin = np.isfinite(a)
+    if fin.any():
+        v = a[fin]
+        return dict(
+            dtype=str(a.dtype),
+            shape=tuple(a.shape),
+            finite=int(fin.sum()),
+            nan=int(np.isnan(a).sum()),
+            inf=int(np.isinf(a).sum()),
+            min=float(v.min()),
+            max=float(v.max()),
+            p01=float(np.percentile(v, 1)),
+            p50=float(np.percentile(v, 50)),
+            p99=float(np.percentile(v, 99)),
+            mean=float(v.mean()),
+        )
+    return dict(dtype=str(a.dtype), shape=tuple(a.shape), finite=0, nan=int(np.isnan(a).sum()), inf=int(np.isinf(a).sum()))
+
+def _print_stats(tag: str, a: np.ndarray, *, bit_depth=None, hdr=None):
+    s = _arr_stats(a)
+    bd = f", bit_depth={bit_depth}" if bit_depth is not None else ""
+    print(f"🧪 {tag}{bd} dtype={s['dtype']} shape={s['shape']} finite={s['finite']} nan={s['nan']} inf={s['inf']}")
+    if s["finite"] > 0:
+        print(f"    min={s['min']:.6f}  p01={s['p01']:.6f}  p50={s['p50']:.6f}  p99={s['p99']:.6f}  max={s['max']:.6f}  mean={s['mean']:.6f}")
+    # Header hints (best-effort)
+    if hdr is not None:
+        try:
+            # FITS-ish
+            if hasattr(hdr, "get"):
+                print(f"    hdr: BITPIX={hdr.get('BITPIX', 'NA')}  BSCALE={hdr.get('BSCALE', 'NA')}  BZERO={hdr.get('BZERO', 'NA')}")
+        except Exception:
+            pass
+
+def _warn_if_units_mismatch(light: np.ndarray, dark: np.ndarray | None, flat: np.ndarray | None):
+    # Heuristic: if one is ~0..1 and another is hundreds/thousands, you’ve got mixed scaling.
+    def _range_kind(a):
+        if a is None:
+            return None
+        fin = np.isfinite(a)
+        if not fin.any():
+            return None
+        mx = float(np.max(a[fin]))
+        mn = float(np.min(a[fin]))
+        return (mn, mx)
+
+    lr = _range_kind(light)
+    dr = _range_kind(dark)
+    fr = _range_kind(flat)
+
+    def _is_01(r):
+        if r is None: return False
+        mn, mx = r
+        return mx <= 2.5 and mn >= -0.5
+
+    def _is_aduish(r):
+        if r is None: return False
+        mn, mx = r
+        return mx >= 50.0  # conservative
+
+    if lr and dr and _is_01(lr) and _is_aduish(dr):
+        print("🚨 UNITS MISMATCH: light looks ~0–1, but dark looks like ADU (tens/hundreds/thousands). Expect huge negatives after subtraction.")
+    if lr and fr and _is_01(lr) and _is_aduish(fr):
+        print("🚨 UNITS MISMATCH: light looks ~0–1, but flat looks like ADU. Flat division will be wrong unless normalized to ~1 first.")
+
+def _maybe_normalize_16bit_float(a: np.ndarray, *, name: str = "") -> np.ndarray:
+    """
+    Fast guard:
+    - If float array has max > 10, assume it's really 16-bit ADU data stored as float,
+      and normalize to 0..1 by dividing by 65535.
+    """
+    if a is None:
+        return a
+    if not np.issubdtype(a.dtype, np.floating):
+        return a
+
+    fin = np.isfinite(a)
+    if not fin.any():
+        return a
+
+    mx = float(a[fin].max())  # fast reduction
+
+    if mx > 10.0:
+        print(f"🛡️ Units-guard: {name or 'array'} max={mx:.3f} (>10). Assuming 16-bit ADU-in-float; normalizing /65535.")
+        return (a / 65535.0).astype(np.float32, copy=False)
+
+    return a
 
 class StackingSuiteDialog(QDialog):
     requestRelaunch = pyqtSignal(str, str)  # old_dir, new_dir
@@ -3916,7 +4408,11 @@ class StackingSuiteDialog(QDialog):
         self._wrench_path = wrench_path
         self._spinner_path = spinner_path
         self._post_progress_label = None
-
+        self._dark_group_item = {}   # key -> QTreeWidgetItem
+        self._flat_filter_item = {}  # filter_name -> QTreeWidgetItem
+        self._flat_exp_item = {}     # (filter_name, want_label) -> QTreeWidgetItem
+        self._light_filter_item = {} # filter_name -> QTreeWidgetItem
+        self._light_exp_item = {}    # (filter_name, want_label) -> QTreeWidgetItem
 
         self.setWindowTitle(self.tr("Stacking Suite"))
         self.setGeometry(300, 200, 800, 600)
@@ -4040,7 +4536,7 @@ class StackingSuiteDialog(QDialog):
         self.image_integration_tab = self.create_image_registration_tab()
 
         # Add tabs
-        self.tabs.addTab(self.conversion_tab, self.tr("Convert Non-FITS Formats"))
+        self.tabs.addTab(self.conversion_tab, self.tr("Convert Camera RAW/TIFF Formats"))
         self.tabs.addTab(self.dark_tab, self.tr("Darks"))
         self.tabs.addTab(self.flat_tab, self.tr("Flats"))
         self.tabs.addTab(self.light_tab, self.tr("Lights"))
@@ -5123,8 +5619,9 @@ class StackingSuiteDialog(QDialog):
         disto_form.addRow(self.tr("Max control points:"), self.align_max_cp)
 
         self.align_downsample = QSpinBox()
-        self.align_downsample.setRange(1, 8)
-        self.align_downsample.setValue(self.settings.value("stacking/align/downsample", 2, type=int))
+        self.align_downsample.setRange(1, 64)  # or 1..32; 64 if you want “any integer”
+        self.align_downsample.setValue(self.settings.value("stacking/align/downsample", 3, type=int))
+        self.align_downsample.setToolTip(self.tr("Alignment solve downsample. 1 = full res; higher = faster but less accurate."))
         disto_form.addRow(self.tr("Solve downsample:"), self.align_downsample)
 
         # Homography / Similarity-specific RANSAC reprojection threshold
@@ -6012,12 +6509,19 @@ class StackingSuiteDialog(QDialog):
                 w.blockSignals(True); w.setValue(v); w.blockSignals(False)
 
     def _get_drizzle_scale(self) -> float:
-        # Accepts "1x/2x/3x" or numeric
-        val = self.settings.value("stacking/drizzle_scale", "2x", type=str)
-        if isinstance(val, str) and val.endswith("x"):
-            try: return float(val[:-1])
-            except: return 2.0
-        return float(val)
+        val = self.settings.value("stacking/drizzle_scale", "2x")
+        if isinstance(val, (int, float)):
+            return float(val)
+        if isinstance(val, str):
+            s = val.strip().lower()
+            if s.endswith("x"):
+                s = s[:-1]
+            try:
+                return float(s)
+            except Exception:
+                return 2.0
+        return 2.0
+
 
     def _set_drizzle_scale(self, r: float | str) -> None:
         if isinstance(r, str):
@@ -6033,6 +6537,25 @@ class StackingSuiteDialog(QDialog):
                 self.drizzle_scale_combo.setCurrentText(txt)
                 self.drizzle_scale_combo.blockSignals(False)
 
+    def _get_drizzle_enabled(self) -> bool:
+        # UI checkbox wins if it exists (most “live” truth)
+        cb = getattr(self, "drizzle_checkbox", None)
+        if cb is not None:
+            try:
+                return bool(cb.isChecked())
+            except Exception:
+                pass
+        # fallback to settings (headless / older flows)
+        return bool(self.settings.value("stacking/drizzle_enabled", False, type=bool))
+
+    def _set_drizzle_enabled(self, on: bool) -> None:
+        on = bool(on)
+        self.settings.setValue("stacking/drizzle_enabled", on)
+        cb = getattr(self, "drizzle_checkbox", None)
+        if cb is not None and cb.isChecked() != on:
+            cb.blockSignals(True)
+            cb.setChecked(on)
+            cb.blockSignals(False)
 
     def closeEvent(self, e):
         # Graceful shutdown for any running workers
@@ -6426,6 +6949,22 @@ class StackingSuiteDialog(QDialog):
 
         return tab
     
+    def _bucket_temp(self, t: float | None, step: float = 3.0) -> float | None:
+        """Round to stable bucket. Example: -10.2 -> -10.0 when step=1.0"""
+        if t is None:
+            return None
+        try:
+            return round(float(t) / float(step)) * float(step)
+        except Exception:
+            return None
+
+    def _temp_label(self, t: float | None, step: float = 1.0) -> str:
+        if t is None:
+            return "Temp: Unknown"
+        # show fewer decimals if step is 1.0
+        return f"Temp: {t:+.0f}C" if step >= 1.0 else f"Temp: {t:+.1f}C"
+
+
     def _tree_for_type(self, t: str):
         t = (t or "").upper()
         if t == "LIGHT": return getattr(self, "light_tree", None)
@@ -8088,13 +8627,18 @@ class StackingSuiteDialog(QDialog):
         mf_row3.addWidget(self.mf_Huber_hint)
 
         mf_row3.addSpacing(16)
+
         self.mf_use_star_mask_cb = QCheckBox(self.tr("Auto Star Mask"))
         self.mf_use_noise_map_cb = QCheckBox(self.tr("Auto Noise Map"))
-        self.mf_use_star_mask_cb.setChecked(self.settings.value("stacking/mfdeconv/use_star_masks", False, type=bool))
-        self.mf_use_noise_map_cb.setChecked(self.settings.value("stacking/mfdeconv/use_noise_maps", False, type=bool))
+
+        # Always ON by default (session-only toggles)
+        self.mf_use_star_mask_cb.setChecked(True)
+        self.mf_use_noise_map_cb.setChecked(True)
+
         mf_row3.addWidget(self.mf_use_star_mask_cb)
         mf_row3.addWidget(self.mf_use_noise_map_cb)
         mf_row3.addStretch(1)
+
         mf_v.addLayout(mf_row3)
 
         # persist
@@ -8873,9 +9417,13 @@ class StackingSuiteDialog(QDialog):
         # ensure attrs exist
         if not hasattr(self, "_reg_excluded_files"):
             self._reg_excluded_files = set()
-        if not hasattr(self, "deleted_calibrated_files"):
-            self.deleted_calibrated_files = []
 
+        # Track "removed from Registration tab" for this session so stacking won't use them
+        if (not hasattr(self, "deleted_calibrated_files")) or (self.deleted_calibrated_files is None):
+            self.deleted_calibrated_files = set()
+        elif isinstance(self.deleted_calibrated_files, list):
+            # backward compat if you previously used list
+            self.deleted_calibrated_files = set(self.deleted_calibrated_files)
         removed_paths = []
 
         for item in selected_items:
@@ -8931,18 +9479,23 @@ class StackingSuiteDialog(QDialog):
         # If you want a separate "Exclude" feature later, keep _reg_excluded_files for that.
         # For now, removing should be reversible via "Add Light Files".
 
+        # Persist "removed from registration" list (session)
+        dead = {os.path.normcase(os.path.abspath(p)) for p in removed_paths if isinstance(p, str)}
+        if dead:
+            self.deleted_calibrated_files |= dead
+
         # Also prune manual list so it doesn't re-inject removed files *in this session*
         if hasattr(self, "manual_light_files") and self.manual_light_files:
-            dead = {os.path.normcase(os.path.abspath(p)) for p in removed_paths if isinstance(p, str)}
             self.manual_light_files = [
                 p for p in self.manual_light_files
                 if os.path.normcase(os.path.abspath(p)) not in dead
             ]
 
         # refresh UI
-        self.populate_calibrated_lights()
+        # IMPORTANT: do NOT call populate_calibrated_lights() here, it can resurrect removed items
         self._refresh_reg_tree_summaries()
 
+
     def rebuild_flat_tree(self):
         """Regroup flat frames in the flat_tree based on the exposure tolerance."""
         self.flat_tree.clear()
@@ -9287,6 +9840,22 @@ class StackingSuiteDialog(QDialog):
         return (f"Drizzle: True, Scale: {scale:g}x, Drop: {drop:.2f}"
                 if enabled else "Drizzle: False")
 
+    def _get_group_key(self, top_item) -> str:
+        """Stable key for a group item; survives UI text decoration."""
+        key = top_item.data(0, Qt.ItemDataRole.UserRole)
+        if key:
+            return str(key)
+        # fallback to visible text if older items don't have it yet
+        return str(top_item.text(0)).strip()
+
+    def _ensure_group_key(self, top_item, group_key: str | None = None) -> str:
+        """Set canonical key on item if missing."""
+        if group_key is None:
+            group_key = str(top_item.text(0)).strip()
+        if not top_item.data(0, Qt.ItemDataRole.UserRole):
+            top_item.setData(0, Qt.ItemDataRole.UserRole, group_key)
+        return str(group_key)
+
     def _set_drizzle_on_items(self, items, enabled: bool, scale: float, drop: float):
         txt_on  = self._format_drizzle_text(True,  scale, drop)
         txt_off = self._format_drizzle_text(False, scale, drop)
@@ -9294,7 +9863,8 @@ class StackingSuiteDialog(QDialog):
             # dedupe child selection → parent group
             if it.parent() is not None:
                 it = it.parent()
-            group_key = it.text(0)
+            # Canonical key stored on the item (NOT display label)
+            group_key = self._ensure_group_key(it)
             it.setText(2, txt_on if enabled else txt_off)
             self.per_group_drizzle[group_key] = {
                 "enabled": bool(enabled),
@@ -9319,11 +9889,10 @@ class StackingSuiteDialog(QDialog):
             return
 
         for item in selected_items:
-            # If the user selected a child row, go up to its parent group
             if item.parent() is not None:
                 item = item.parent()
 
-            group_key = item.text(0)
+            group_key = self._ensure_group_key(item)  # ✅ stable key
 
             if drizzle_enabled:
                 # Show scale + drop shrink
@@ -9355,7 +9924,7 @@ class StackingSuiteDialog(QDialog):
             seen, targets = set(), []
             for it in sel:
                 top = it if it.parent() is None else it.parent()
-                key = top.text(0)
+                key = self._ensure_group_key(top)
                 if key not in seen:
                     seen.add(key); targets.append(top)
         else:
@@ -9378,7 +9947,7 @@ class StackingSuiteDialog(QDialog):
 
         out = {}
         for top in self._iter_group_items():
-            group_key = top.text(0)
+            group_key = self._ensure_group_key(top)   # ✅ stable key
             state = self.per_group_drizzle.get(group_key)
             if not state:
                 state = {"enabled": global_enabled, "scale": global_scale, "drop": global_drop}
@@ -9554,7 +10123,10 @@ class StackingSuiteDialog(QDialog):
     def load_master_dark(self):
         """ Loads a Master Dark and updates the UI. """
         last_dir = self.settings.value("last_opened_folder", "", type=str)  # Get last folder
-        files, _ = QFileDialog.getOpenFileNames(self, "Select Master Dark", last_dir, "FITS Files (*.fits *.fit)")
+        files, _ = QFileDialog.getOpenFileNames(
+            self, "Select Master Dark", last_dir,
+            "Master Calibration (*.fits *.fit *.xisf);;All Files (*)"
+        )
         
         if files:
             self.settings.setValue("last_opened_folder", os.path.dirname(files[0]))  # Save last used folder
@@ -9569,7 +10141,10 @@ class StackingSuiteDialog(QDialog):
 
     def load_master_flat(self):
         last_dir = self.settings.value("last_opened_folder", "", type=str)
-        files, _ = QFileDialog.getOpenFileNames(self, "Select Master Flat", last_dir, "FITS Files (*.fits *.fit)")
+        files, _ = QFileDialog.getOpenFileNames(
+            self, "Select Master Flat", last_dir,
+            "Master Calibration (*.fits *.fit *.xisf);;All Files (*)"
+        )
 
         if files:
             self.settings.setValue("last_opened_folder", os.path.dirname(files[0]))
@@ -9582,7 +10157,7 @@ class StackingSuiteDialog(QDialog):
         last_dir = self.settings.value("last_opened_folder", "", type=str)
         files, _ = QFileDialog.getOpenFileNames(
             self, title, last_dir,
-            "FITS Files (*.fits *.fit *.fts *.fits.gz *.fit.gz *.fz)"
+            "Images (*.fits *.fit *.fts *.fits.gz *.fit.gz *.fz *.xisf);;All Files (*)"
         )
         if not files:
             return
@@ -9661,7 +10236,7 @@ class StackingSuiteDialog(QDialog):
 
     # --- Directory walking ---------------------------------------------------------
     def _collect_fits_paths(self, root: str, recursive: bool = True) -> list[str]:
-        exts = (".fits", ".fit", ".fts", ".fits.gz", ".fit.gz", ".fz")
+        exts = (".fits", ".fit", ".fts", ".fits.gz", ".fit.gz", ".fz", ".xisf")
         paths = []
         if recursive:
             for d, _subdirs, files in os.walk(root):
@@ -10000,24 +10575,32 @@ class StackingSuiteDialog(QDialog):
             manual_session_name = self._resolve_manual_session_name_for_ingest()
 
         added = 0
-        for i, path in enumerate(paths, start=1):
-            if dlg.wasCanceled():
-                break
-            try:
-                base = os.path.basename(path)
-                dlg.setLabelText(f"{base}  ({i}/{total})")
-                QCoreApplication.processEvents()
+        tree.setUpdatesEnabled(False)
+        tree.blockSignals(True)
+        try:        
+            for i, path in enumerate(paths, start=1):
+                if dlg.wasCanceled():
+                    break
+                try:
+                    base = os.path.basename(path)
+                    dlg.setLabelText(f"{base}  ({i}/{total})")
+                    QCoreApplication.processEvents()
 
-                self.process_fits_header(
-                    path, tree, expected_type,
-                    manual_session_name=manual_session_name
-                )
-                added += 1
-            except Exception:
-                pass
+                    self.process_fits_header(
+                        path, tree, expected_type,
+                        manual_session_name=manual_session_name
+                    )
+                    added += 1
+                except Exception:
+                    pass
+
+                dlg.setValue(i)
+                QCoreApplication.processEvents()
+        finally:
+            tree.blockSignals(False)
+            tree.setUpdatesEnabled(True)
+            tree.viewport().update()
 
-            dlg.setValue(i)
-            QCoreApplication.processEvents()
 
         dlg.setValue(total)
         QCoreApplication.processEvents()
@@ -10096,14 +10679,14 @@ class StackingSuiteDialog(QDialog):
         try:
             expected_type_u = (expected_type or "").upper()
 
-            # Ensure caches exist
             if not hasattr(self, "_mismatch_policy") or self._mismatch_policy is None:
                 self._mismatch_policy = {}
             if not hasattr(self, "session_tags") or self.session_tags is None:
                 self.session_tags = {}
 
-            # --- Read header only (fast) ---
-            header, _ = get_valid_header(path)
+            header, ok = get_valid_header(path)
+            if not ok or header is None:
+                raise RuntimeError("Header read failed")
 
             # --- Basic image size ---
             try:
@@ -10111,7 +10694,9 @@ class StackingSuiteDialog(QDialog):
                 height = int(header.get("NAXIS2", 0))
                 image_size = f"{width}x{height}" if (width > 0 and height > 0) else "Unknown"
             except Exception as e:
-                self.update_status(self.tr(f"Warning: Could not read dimensions for {os.path.basename(path)}: {e}"))
+                self.update_status(self.tr(
+                    f"Warning: Could not read dimensions for {os.path.basename(path)}: {e}"
+                ))
                 width = height = None
                 image_size = "Unknown"
 
@@ -10128,7 +10713,6 @@ class StackingSuiteDialog(QDialog):
                     exposure_text = f"{fexp:g}s"
                 except Exception:
                     exposure_text = str(exp_val)
-
             # --- Mismatch prompt (redirect/keep/skip with 'apply to all') ---
             if expected_type_u == "DARK":
                 forbidden = ["light", "flat"]
@@ -10201,58 +10785,116 @@ class StackingSuiteDialog(QDialog):
 
             # --- Resolve session tag (auto vs keyword-driven) ---
             auto_session = self.settings.value("stacking/auto_session", True, type=bool)
-
             if auto_session:
                 session_tag = self._auto_session_from_path(path, header) or "Default"
             else:
-                # NOTE: this is a keyword now, not a literal session name
                 keyword = self.settings.value("stacking/session_keyword", "Default", type=str)
                 session_tag = self._session_from_manual_keyword(path, keyword) or "Default"
 
-            # --- Filter name normalization ---
-            filter_name_raw = header.get("FILTER", "Unknown")
-            filter_name     = self._sanitize_name(filter_name_raw)
+            # --- Temperature (fast: header already loaded) ---
+            ccd_temp = header.get("CCD-TEMP", None)
+            set_temp = header.get("SET-TEMP", None)
+
+            def _to_float_temp(v):
+                try:
+                    if v is None:
+                        return None
+                    if isinstance(v, (int, float)):
+                        return float(v)
+                    s = str(v).strip()
+                    s = s.replace("°", "").replace("C", "").replace("c", "").strip()
+                    return float(s)
+                except Exception:
+                    return None
+
+            ccd_temp_f = _to_float_temp(ccd_temp)
+            set_temp_f = _to_float_temp(set_temp)
+            use_temp_f = ccd_temp_f if ccd_temp_f is not None else set_temp_f
+
+            # --- Common metadata string for leaf rows ---
+            meta_text = f"Size: {image_size} | Session: {session_tag}"
+            if use_temp_f is not None:
+                meta_text += f" | Temp: {use_temp_f:.1f}C"
+                if set_temp_f is not None:
+                    meta_text += f" (Set: {set_temp_f:.1f}C)"
 
             # --- Common metadata string for leaf rows ---
             meta_text = f"Size: {image_size} | Session: {session_tag}"
 
             # === DARKs ===
             if expected_type_u == "DARK":
-                key = f"{exposure_text} ({image_size})"
-                self.dark_files.setdefault(key, []).append(path)
-                self.session_tags[path] = session_tag  # not strictly needed, but consistent
+                # --- temperature for grouping (prefer CCD-TEMP else SET-TEMP) ---
+                ccd_t = _get_key_float(header, "CCD-TEMP")
+                set_t = _get_key_float(header, "SET-TEMP")
+                chosen_t = ccd_t if ccd_t is not None else set_t
 
-                items = tree.findItems(key, Qt.MatchFlag.MatchExactly, 0)
-                exposure_item = items[0] if items else QTreeWidgetItem([key])
-                if not items:
-                    tree.addTopLevelItem(exposure_item)
+                temp_step = self.settings.value("stacking/temp_group_step", 1.0, type=float)
+                temp_bucket = self._bucket_temp(chosen_t, step=temp_step)
+                temp_label = self._temp_label(temp_bucket, step=temp_step)
 
-                leaf = QTreeWidgetItem([os.path.basename(path), meta_text])
+                # --- tree grouping: exposure/size -> temp bucket -> files ---
+                base_key = f"{exposure_text} ({image_size})"
+
+                # ensure caches exist
+                if not hasattr(self, "_dark_group_item") or self._dark_group_item is None:
+                    self._dark_group_item = {}
+                if not hasattr(self, "_dark_temp_item") or self._dark_temp_item is None:
+                    self._dark_temp_item = {}  # (base_key, temp_label) -> QTreeWidgetItem
+
+                # top-level exposure group
+                exposure_item = self._dark_group_item.get(base_key)
+                if exposure_item is None:
+                    exposure_item = QTreeWidgetItem([base_key, ""])
+                    tree.addTopLevelItem(exposure_item)
+                    self._dark_group_item[base_key] = exposure_item
+
+                # second-level temp group under that exposure group
+                temp_key = (base_key, temp_label)
+                temp_item = self._dark_temp_item.get(temp_key)
+                if temp_item is None:
+                    temp_item = QTreeWidgetItem([temp_label, ""])
+                    exposure_item.addChild(temp_item)
+                    self._dark_temp_item[temp_key] = temp_item
+
+                # --- store in dict for stacking ---
+                # Key includes session + temp bucket so create_master_dark can split properly.
+                # (We keep compatibility: your create_master_dark already handles tuple keys.)
+                composite_key = (base_key, session_tag, temp_bucket)
+                self.dark_files.setdefault(composite_key, []).append(path)
+
+                # --- leaf row ---
+                # Also add temp info to metadata text so user can see it per file
+                meta_text_dark = f"Size: {image_size} | Session: {session_tag} | {temp_label}"
+                leaf = QTreeWidgetItem([os.path.basename(path), meta_text_dark])
                 leaf.setData(0, Qt.ItemDataRole.UserRole, path)
-                leaf.setData(0, Qt.ItemDataRole.UserRole + 1, session_tag)  # ✅ helpful later for retag/rekey
-                exposure_item.addChild(leaf)
+                leaf.setData(0, Qt.ItemDataRole.UserRole + 1, session_tag)
+                leaf.setData(0, Qt.ItemDataRole.UserRole + 2, temp_bucket)   # handy later
+                temp_item.addChild(leaf)
 
             # === FLATs ===
             elif expected_type_u == "FLAT":
+                filter_name_raw = header.get("FILTER") or "Unknown"
+                filter_name = self._sanitize_name(filter_name_raw)
+
                 flat_key = f"{filter_name} - {exposure_text} ({image_size})"
                 composite_key = (flat_key, session_tag)
                 self.flat_files.setdefault(composite_key, []).append(path)
                 self.session_tags[path] = session_tag
 
-                filter_items = tree.findItems(filter_name, Qt.MatchFlag.MatchExactly, 0)
-                filter_item = filter_items[0] if filter_items else QTreeWidgetItem([filter_name])
-                if not filter_items:
+                filter_item = self._flat_filter_item.get(filter_name)
+                if filter_item is None:
+                    filter_item = QTreeWidgetItem([filter_name])
                     tree.addTopLevelItem(filter_item)
+                    self._flat_filter_item[filter_name] = filter_item
 
                 want_label = f"{exposure_text} ({image_size})"
-                exposure_item = None
-                for i in range(filter_item.childCount()):
-                    if filter_item.child(i).text(0) == want_label:
-                        exposure_item = filter_item.child(i)
-                        break
+                exp_key = (filter_name, want_label)
+
+                exposure_item = self._flat_exp_item.get(exp_key)
                 if exposure_item is None:
                     exposure_item = QTreeWidgetItem([want_label])
                     filter_item.addChild(exposure_item)
+                    self._flat_exp_item[exp_key] = exposure_item
 
                 leaf = QTreeWidgetItem([os.path.basename(path), meta_text])
                 leaf.setData(0, Qt.ItemDataRole.UserRole, path)
@@ -10261,28 +10903,31 @@ class StackingSuiteDialog(QDialog):
 
             # === LIGHTs ===
             elif expected_type_u == "LIGHT":
+                filter_name_raw = header.get("FILTER") or "Unknown"
+                filter_name = self._sanitize_name(filter_name_raw)
+
                 light_key = f"{filter_name} - {exposure_text} ({image_size})"
                 composite_key = (light_key, session_tag)
                 self.light_files.setdefault(composite_key, []).append(path)
                 self.session_tags[path] = session_tag
 
-                filter_items = tree.findItems(filter_name, Qt.MatchFlag.MatchExactly, 0)
-                filter_item = filter_items[0] if filter_items else QTreeWidgetItem([filter_name])
-                if not filter_items:
+                filter_item = self._light_filter_item.get(filter_name)
+                if filter_item is None:
+                    filter_item = QTreeWidgetItem([filter_name])
                     tree.addTopLevelItem(filter_item)
+                    self._light_filter_item[filter_name] = filter_item
 
                 want_label = f"{exposure_text} ({image_size})"
-                exposure_item = None
-                for i in range(filter_item.childCount()):
-                    if filter_item.child(i).text(0) == want_label:
-                        exposure_item = filter_item.child(i)
-                        break
+                exp_key = (filter_name, want_label)
+
+                exposure_item = self._light_exp_item.get(exp_key)
                 if exposure_item is None:
                     exposure_item = QTreeWidgetItem([want_label])
                     filter_item.addChild(exposure_item)
+                    self._light_exp_item[exp_key] = exposure_item
 
                 leaf = QTreeWidgetItem([os.path.basename(path), meta_text])
-                leaf.setData(0, Qt.ItemDataRole.UserRole, path)          # ✅ needed for date-aware flat fallback
+                leaf.setData(0, Qt.ItemDataRole.UserRole, path)
                 leaf.setData(0, Qt.ItemDataRole.UserRole + 1, session_tag)
                 exposure_item.addChild(leaf)
 
@@ -10302,7 +10947,7 @@ class StackingSuiteDialog(QDialog):
         for file_path in files:
             try:
                 # Read only the FITS header (fast)
-                header = fits.getheader(file_path)
+                header, _kind = get_valid_header(file_path)
                 
                 # Check for both EXPOSURE and EXPTIME
                 exposure = header.get("EXPOSURE", header.get("EXPTIME", "Unknown"))
@@ -10318,7 +10963,13 @@ class StackingSuiteDialog(QDialog):
                 
                 # Construct key based on file type
                 if file_type.upper() == "DARK":
-                    key = f"{exposure}s ({image_size})"
+                    try:
+                        exposure_f = float(exposure)
+                        exposure_text = f"{exposure_f:g}s"
+                    except Exception:
+                        exposure_text = f"{exposure}s" if str(exposure).endswith("s") else str(exposure)
+
+                    key = f"{exposure_text} ({image_size})"
                     self.master_files[key] = file_path  # Store master dark
                     self.master_sizes[file_path] = image_size  # Store size
                 elif file_type.upper() == "FLAT":
@@ -10380,14 +11031,39 @@ class StackingSuiteDialog(QDialog):
         exposure_tolerance = self.exposure_tolerance_spinbox.value()
 
         # -------------------------------------------------------------------------
-        # Group darks by (exposure +/- tolerance, image size string, session)
-        # self.dark_files can be either:
-        #   legacy:  exposure_key -> [paths]
-        #   session: (exposure_key, session) -> [paths]
+        # Temp helpers
         # -------------------------------------------------------------------------
-        dark_files_by_group: dict[tuple[float, str, str], list[str]] = {}  # (exp, size, session)->list
+        def _bucket_temp(t: float | None, step: float = 3.0) -> float | None:
+            """Round temperature to a stable bucket (e.g. -10.2 -> -10.0 if step=1.0)."""
+            if t is None:
+                return None
+            try:
+                return round(float(t) / step) * step
+            except Exception:
+                return None
+
+        def _read_temp_quick(path: str) -> tuple[float | None, float | None, float | None]:
+            """Fast temp read (CCD, SET, chosen). Uses fits.getheader(memmap=True)."""
+            try:
+                hdr = fits.getheader(path, memmap=True)
+            except Exception:
+                return None, None, None
+            ccd = _get_key_float(hdr, "CCD-TEMP")
+            st  = _get_key_float(hdr, "SET-TEMP")
+            chosen = ccd if ccd is not None else st
+            return ccd, st, chosen
+
+        # -------------------------------------------------------------------------
+        # Group darks by (exposure +/- tolerance, image size, session, temp_bucket)
+        # TEMP_STEP is the rounding bucket (1.0C default)
+        # -------------------------------------------------------------------------
+        TEMP_STEP = self.settings.value("stacking/temp_group_step", 1.0, type=float)
+
+        dark_files_by_group: dict[tuple[float, str, str, float | None], list[str]] = {}  # (exp,size,session,temp)->list
 
         for key, file_list in (self.dark_files or {}).items():
+            # Support both legacy dark_files (key=str) and newer tuple keys.
+            # We DO NOT assume dark_files already contains temp in key — we re-bucket from headers anyway.
             if isinstance(key, tuple) and len(key) >= 2:
                 exposure_key = str(key[0])
                 session = str(key[1]) if str(key[1]).strip() else "Default"
@@ -10399,10 +11075,9 @@ class StackingSuiteDialog(QDialog):
                 exposure_time_str, image_size = exposure_key.split(" (", 1)
                 image_size = image_size.rstrip(")")
             except ValueError:
-                # If some malformed key got in, skip safely
                 continue
 
-            if "Unknown" in exposure_time_str:
+            if "Unknown" in (exposure_time_str or ""):
                 exposure_time = 0.0
             else:
                 try:
@@ -10410,21 +11085,31 @@ class StackingSuiteDialog(QDialog):
                 except Exception:
                     exposure_time = 0.0
 
-            matched_group = None
-            for (existing_exposure, existing_size, existing_session) in list(dark_files_by_group.keys()):
-                if (
-                    existing_session == session
-                    and existing_size == image_size
-                    and abs(existing_exposure - exposure_time) <= exposure_tolerance
-                ):
-                    matched_group = (existing_exposure, existing_size, existing_session)
-                    break
+            # Split the incoming list by temp bucket so mixed temps do not merge.
+            bucketed: dict[float | None, list[str]] = {}
+            for p in (file_list or []):
+                _, _, chosen = _read_temp_quick(p)
+                tb = _bucket_temp(chosen, step=TEMP_STEP)
+                bucketed.setdefault(tb, []).append(p)
+
+            # Apply exposure tolerance grouping PER temp bucket
+            for temp_bucket, paths_in_bucket in bucketed.items():
+                matched_group = None
+                for (existing_exposure, existing_size, existing_session, existing_temp) in list(dark_files_by_group.keys()):
+                    if (
+                        existing_session == session
+                        and existing_size == image_size
+                        and existing_temp == temp_bucket
+                        and abs(existing_exposure - exposure_time) <= exposure_tolerance
+                    ):
+                        matched_group = (existing_exposure, existing_size, existing_session, existing_temp)
+                        break
 
-            if matched_group is None:
-                matched_group = (exposure_time, image_size, session)
-                dark_files_by_group[matched_group] = []
+                if matched_group is None:
+                    matched_group = (exposure_time, image_size, session, temp_bucket)
+                    dark_files_by_group[matched_group] = []
 
-            dark_files_by_group[matched_group].extend(file_list or [])
+                dark_files_by_group[matched_group].extend(paths_in_bucket)
 
         master_dir = os.path.join(self.stacking_directory, "Master_Calibration_Files")
         os.makedirs(master_dir, exist_ok=True)
@@ -10433,11 +11118,11 @@ class StackingSuiteDialog(QDialog):
         # Informative status about discovery
         # -------------------------------------------------------------------------
         try:
-            n_groups = sum(1 for _, v in dark_files_by_group.items() if len(v) >= 2)
+            n_groups_eligible = sum(1 for _, v in dark_files_by_group.items() if len(v) >= 2)
             total_files = sum(len(v) for v in dark_files_by_group.values())
             self.update_status(self.tr(
                 f"🔎 Discovered {len(dark_files_by_group)} grouped exposures "
-                f"({n_groups} eligible to stack) — {total_files} files total."
+                f"({n_groups_eligible} eligible to stack) — {total_files} files total."
             ))
         except Exception:
             pass
@@ -10447,12 +11132,12 @@ class StackingSuiteDialog(QDialog):
         # Pre-count tiles for progress bar (per-group safe chunk sizes)
         # -------------------------------------------------------------------------
         total_tiles = 0
-        group_shapes: dict[tuple[float, str, str], tuple[int, int, int, int, int]] = {}  # (exp,size,session)->(H,W,C,ch,cw)
+        group_shapes: dict[tuple[float, str, str, float | None], tuple[int, int, int, int, int]] = {}
         pref_chunk_h = self.chunk_height
         pref_chunk_w = self.chunk_width
         DTYPE = np.float32
 
-        for (exposure_time, image_size, session), file_list in dark_files_by_group.items():
+        for (exposure_time, image_size, session, temp_bucket), file_list in dark_files_by_group.items():
             if len(file_list) < 2:
                 continue
 
@@ -10470,7 +11155,8 @@ class StackingSuiteDialog(QDialog):
             except MemoryError:
                 chunk_h, chunk_w = pref_chunk_h, pref_chunk_w
 
-            group_shapes[(exposure_time, image_size, session)] = (H, W, C, chunk_h, chunk_w)
+            gk = (exposure_time, image_size, session, temp_bucket)
+            group_shapes[gk] = (H, W, C, chunk_h, chunk_w)
             total_tiles += _count_tiles(H, W, chunk_h, chunk_w)
 
         if total_tiles == 0:
@@ -10483,7 +11169,7 @@ class StackingSuiteDialog(QDialog):
         QApplication.processEvents()
 
         # -------------------------------------------------------------------------
-        # Local CPU reducers (unchanged)
+        # Local CPU reducers
         # -------------------------------------------------------------------------
         def _select_reducer(kind: str, N: int):
             if kind == "dark":
@@ -10527,10 +11213,10 @@ class StackingSuiteDialog(QDialog):
             # ---------------------------------------------------------------------
             # Per-group stacking loop
             # ---------------------------------------------------------------------
-            for (exposure_time, image_size, session), file_list in dark_files_by_group.items():
+            for (exposure_time, image_size, session, temp_bucket), file_list in dark_files_by_group.items():
                 if len(file_list) < 2:
                     self.update_status(self.tr(
-                        f"⚠️ Skipping {exposure_time}s ({image_size}) [{session}] - Not enough frames to stack."
+                        f"⚠️ Skipping {exposure_time:g}s ({image_size}) [{session}] - Not enough frames to stack."
                     ))
                     QApplication.processEvents()
                     continue
@@ -10539,14 +11225,17 @@ class StackingSuiteDialog(QDialog):
                     self.update_status(self.tr("⛔ Master Dark creation cancelled."))
                     break
 
+                temp_txt = "Unknown" if temp_bucket is None else f"{float(temp_bucket):+.1f}C"
                 self.update_status(self.tr(
-                    f"🟢 Processing {len(file_list)} darks for {exposure_time}s ({image_size}) in session '{session}'…"
+                    f"🟢 Processing {len(file_list)} darks for {exposure_time:g}s ({image_size}) "
+                    f"in session '{session}' at {temp_txt}…"
                 ))
                 QApplication.processEvents()
 
                 # --- reference shape and per-group chunk size ---
-                if (exposure_time, image_size, session) in group_shapes:
-                    height, width, channels, chunk_height, chunk_width = group_shapes[(exposure_time, image_size, session)]
+                gk = (exposure_time, image_size, session, temp_bucket)
+                if gk in group_shapes:
+                    height, width, channels, chunk_height, chunk_width = group_shapes[gk]
                 else:
                     ref_data, _, _, _ = load_image(file_list[0])
                     if ref_data is None:
@@ -10586,8 +11275,11 @@ class StackingSuiteDialog(QDialog):
                     QApplication.processEvents()
                     continue
 
-                # Include session to prevent collisions
-                memmap_path = os.path.join(master_dir, f"temp_dark_{session}_{exposure_time}_{image_size}.dat")
+                # Create temp memmap (stem-safe normalization)
+                tb_tag = "notemp" if temp_bucket is None else _temp_to_stem_tag(float(temp_bucket))
+                memmap_base = f"temp_dark_{session}_{exposure_time:g}s_{image_size}_{tb_tag}.dat"
+                memmap_base = self._normalize_master_stem(memmap_base)
+                memmap_path = os.path.join(master_dir, memmap_base)
 
                 self.update_status(self.tr(
                     f"🗂️ Creating temp memmap: {os.path.basename(memmap_path)} "
@@ -10599,6 +11291,7 @@ class StackingSuiteDialog(QDialog):
 
                 tiles = _tile_grid(height, width, chunk_height, chunk_width)
                 total_tiles_group = len(tiles)
+
                 self.update_status(self.tr(
                     f"📦 {total_tiles_group} tiles to process for this group (chunk {chunk_height}×{chunk_width})."
                 ))
@@ -10640,7 +11333,7 @@ class StackingSuiteDialog(QDialog):
                         fut = tp.submit(_read_tile_into, (buf1 if use0 else buf0), ny0, ny1, nx0, nx1)
 
                     pd.set_label(
-                        f"{int(exposure_time)}s ({image_size}) [{session}] — "
+                        f"{int(exposure_time)}s ({image_size}) [{session}] [{temp_txt}] — "
                         f"tile {t_idx}/{total_tiles_group} y:{y0}-{y1} x:{x0}-{x1}"
                     )
 
@@ -10670,6 +11363,7 @@ class StackingSuiteDialog(QDialog):
 
                     if tile_result.ndim == 2:
                         tile_result = tile_result[:, :, None]
+
                     expected_shape = (th, tw, channels)
                     if tile_result.shape != expected_shape:
                         if tile_result.shape[:2] == (th, tw):
@@ -10704,37 +11398,115 @@ class StackingSuiteDialog(QDialog):
                         pass
                     break
 
+                # -------------------------------------------------------------
+                # Materialize final memmap to ndarray for save
+                # -------------------------------------------------------------
                 master_dark_data = np.asarray(final_stacked, dtype=np.float32)
-                del final_stacked
+                try:
+                    del final_stacked
+                except Exception:
+                    pass
                 gc.collect()
+
                 try:
                     os.remove(memmap_path)
                 except Exception:
                     pass
 
-                # Include session in output name
-                master_dark_stem = f"MasterDark_{session}_{int(exposure_time)}s_{image_size}"
+                # -------------------------------------------------------------
+                # Collect temperature stats from input dark headers
+                # -------------------------------------------------------------
+                temp_info = {}
+                try:
+                    temp_info = _collect_temp_stats(file_list) or {}
+                except Exception:
+                    temp_info = {}
+
+                # -------------------------------------------------------------
+                # Build output filename (include session + exposure + size + temp bucket tag)
+                # -------------------------------------------------------------
+                temp_tag = ""
+                try:
+                    if temp_bucket is not None:
+                        temp_tag = "_" + _temp_to_stem_tag(float(temp_bucket))
+                    elif temp_info.get("ccd_med") is not None:
+                        temp_tag = "_" + _temp_to_stem_tag(float(temp_info["ccd_med"]))
+                    elif temp_info.get("set_med") is not None:
+                        temp_tag = "_" + _temp_to_stem_tag(float(temp_info["set_med"]), prefix="set")
+                except Exception:
+                    temp_tag = ""
+
+                master_dark_stem = f"MasterDark_{session}_{int(exposure_time)}s_{image_size}{temp_tag}"
+                master_dark_stem = self._normalize_master_stem(master_dark_stem)
                 master_dark_path = self._build_out(master_dir, master_dark_stem, "fit")
 
+                # -------------------------------------------------------------
+                # Header
+                # -------------------------------------------------------------
                 master_header = fits.Header()
                 master_header["IMAGETYP"] = "DARK"
-                master_header["EXPTIME"] = (exposure_time, "User-specified or from grouping")
-                master_header["SESSION"] = (session, "User session tag")  # optional but useful
-                master_header["NAXIS"] = 3 if channels == 3 else 2
-                master_header["NAXIS1"] = master_dark_data.shape[1]
-                master_header["NAXIS2"] = master_dark_data.shape[0]
+                master_header["EXPTIME"]  = (float(exposure_time), "Exposure time (s)")
+                master_header["SESSION"]  = (str(session), "User session tag")
+                master_header["NCOMBINE"] = (int(N), "Number of darks combined")
+                master_header["NSTACK"]   = (int(N), "Alias of NCOMBINE (SetiAstro)")
+
+                # Temperature provenance (only write keys that exist)
+                if temp_info.get("ccd_med") is not None:
+                    master_header["CCD-TEMP"] = (float(temp_info["ccd_med"]), "Median CCD temp of input darks (C)")
+                    if temp_info.get("ccd_min") is not None:
+                        master_header["CCDTMIN"] = (float(temp_info["ccd_min"]), "Min CCD temp in input darks (C)")
+                    if temp_info.get("ccd_max") is not None:
+                        master_header["CCDTMAX"] = (float(temp_info["ccd_max"]), "Max CCD temp in input darks (C)")
+                    if temp_info.get("ccd_std") is not None:
+                        master_header["CCDTSTD"] = (float(temp_info["ccd_std"]), "Std CCD temp in input darks (C)")
+                    if temp_info.get("ccd_n") is not None:
+                        master_header["CCDTN"] = (int(temp_info["ccd_n"]), "Count of frames with CCD-TEMP")
+
+                if temp_info.get("set_med") is not None:
+                    master_header["SET-TEMP"] = (float(temp_info["set_med"]), "Median setpoint temp of input darks (C)")
+                    if temp_info.get("set_min") is not None:
+                        master_header["SETTMIN"] = (float(temp_info["set_min"]), "Min setpoint in input darks (C)")
+                    if temp_info.get("set_max") is not None:
+                        master_header["SETTMAX"] = (float(temp_info["set_max"]), "Max setpoint in input darks (C)")
+                    if temp_info.get("set_std") is not None:
+                        master_header["SETTSTD"] = (float(temp_info["set_std"]), "Std setpoint in input darks (C)")
+                    if temp_info.get("set_n") is not None:
+                        master_header["SETTN"] = (int(temp_info["set_n"]), "Count of frames with SET-TEMP")
+
+                # Dimensions (save_image usually writes these, but keep your existing behavior)
+                master_header["NAXIS"]  = 3 if channels == 3 else 2
+                master_header["NAXIS1"] = int(master_dark_data.shape[1])
+                master_header["NAXIS2"] = int(master_dark_data.shape[0])
                 if channels == 3:
                     master_header["NAXIS3"] = 3
 
-                save_image(master_dark_data, master_dark_path, "fit", "32-bit floating point", master_header, is_mono=(channels == 1))
+                save_image(
+                    master_dark_data,
+                    master_dark_path,
+                    "fit",
+                    "32-bit floating point",
+                    master_header,
+                    is_mono=(channels == 1)
+                )
+
+                # Tree label includes temp for visibility
+                tree_label = f"{exposure_time:g}s ({image_size}) [{session}]"
+                if temp_info.get("ccd_med") is not None:
+                    tree_label += f" [CCD {float(temp_info['ccd_med']):+.1f}C]"
+                elif temp_info.get("set_med") is not None:
+                    tree_label += f" [SET {float(temp_info['set_med']):+.1f}C]"
+                elif temp_bucket is not None:
+                    tree_label += f" [TEMP {float(temp_bucket):+.1f}C]"
 
-                self.add_master_dark_to_tree(f"{exposure_time}s ({image_size}) [{session}]", master_dark_path)
+                self.add_master_dark_to_tree(tree_label, master_dark_path)
                 self.update_status(self.tr(f"✅ Master Dark saved: {master_dark_path}"))
                 QApplication.processEvents()
 
+                # Refresh assignments + persistence
                 self.assign_best_master_files()
                 self.save_master_paths_to_settings()
 
+            # Post pass refresh (unchanged behavior)
             self.assign_best_master_dark()
             self.update_override_dark_combo()
             self.assign_best_master_files()
@@ -10747,7 +11519,6 @@ class StackingSuiteDialog(QDialog):
                 logging.debug(f"Exception suppressed: {type(e).__name__}: {e}")
             pd.close()
 
-      
     def add_master_dark_to_tree(self, exposure_label: str, master_dark_path: str):
         """
         Adds the newly created Master Dark to the Master Dark TreeBox and updates the dropdown.
@@ -11147,22 +11918,17 @@ class StackingSuiteDialog(QDialog):
             dark_data: np.ndarray | None,
             pattern: str,
         ):
-            """
-            Returns scales shape (N,4): [R, G1, G2, B] where scale = frame_plane_median / group_plane_median.
-            """
             pat = (pattern or "RGGB").strip().upper()
             if pat not in ("RGGB", "BGGR", "GRBG", "GBRG"):
                 pat = "RGGB"
 
-            # Central patch
             th = min(512, H); tw = min(512, W)
             y0 = (H - th) // 2; y1 = y0 + th
             x0 = (W - tw) // 2; x1 = x0 + tw
 
             N = len(file_list)
-            meds = np.empty((N, 4), dtype=np.float64)  # R,G1,G2,B
+            meds = np.empty((N, 4), dtype=np.float64)
 
-            # parity → plane label
             if pat == "RGGB":
                 m = {(0,0):"R",  (0,1):"G1", (1,0):"G2", (1,1):"B"}
             elif pat == "BGGR":
@@ -11179,9 +11945,24 @@ class StackingSuiteDialog(QDialog):
                 d = float(np.median(v))
                 return d if np.isfinite(d) and d > 0 else 1.0
 
+            # Make dark/bias subtractor into 2D for bayer mosaics (important for XISF HWC darks)
+            dd2 = None
+            if dark_data is not None:
+                dd2 = dark_data
+                if dd2.ndim == 3:
+                    # CHW -> HWC
+                    if dd2.shape[0] in (1, 3):
+                        dd2 = dd2.transpose(1, 2, 0)
+                    # HWC -> take first plane for mosaic subtraction
+                    dd2 = dd2[:, :, 0]
+                dd2 = dd2.astype(np.float32, copy=False)
+
             from concurrent.futures import ThreadPoolExecutor, as_completed
             with ThreadPoolExecutor(max_workers=min(os.cpu_count() or 4, 8)) as exe:
-                fut2i = {exe.submit(load_fits_tile, fp, y0, y1, x0, x1): i for i, fp in enumerate(file_list)}
+                fut2i = {
+                    exe.submit(_read_center_patch_via_mmimage, fp, y0, y1, x0, x1): i
+                    for i, fp in enumerate(file_list)
+                }
                 for fut in as_completed(fut2i):
                     i = fut2i[fut]
                     sub = fut.result()
@@ -11190,16 +11971,14 @@ class StackingSuiteDialog(QDialog):
                         continue
 
                     # Ensure 2D mosaic
-                    if sub.ndim == 3 and sub.shape[0] in (1, 3):
-                        sub = sub[0] if sub.shape[0] == 1 else sub.transpose(1, 2, 0)[:, :, 0]
+                    if sub.ndim == 3:
+                        if sub.shape[0] in (1, 3):  # CHW
+                            sub = sub.transpose(1, 2, 0)
+                        sub = sub[:, :, 0]  # first plane
                     sub = sub.astype(np.float32, copy=False)
 
-                    # Dark subtract patch if present
-                    if dark_data is not None:
-                        dd = dark_data
-                        if dd.ndim == 3 and dd.shape[0] in (1, 3):
-                            dd = dd.transpose(1, 2, 0)[:, :, 0]
-                        d_tile = dd[y0:y1, x0:x1].astype(np.float32, copy=False)
+                    if dd2 is not None:
+                        d_tile = dd2[y0:y1, x0:x1].astype(np.float32, copy=False)
                         sub = sub - d_tile
 
                     planes = {
@@ -11218,15 +11997,11 @@ class StackingSuiteDialog(QDialog):
             gmed = np.median(meds, axis=0)
             gmed = np.where(np.isfinite(gmed) & (gmed > 0), gmed, 1.0)
 
-            scales = meds / gmed  # (N,4)
-            scales = np.clip(scales, 1e-3, 1e3).astype(np.float32)
-            return scales
+            scales = meds / gmed
+            return np.clip(scales, 1e-3, 1e3).astype(np.float32)
+
 
         def _estimate_flat_scales(file_list: list[str], H: int, W: int, C: int, dark_data: np.ndarray | None):
-            """
-            Read one central patch (min(512, H/W)) from each frame, subtract dark (if present),
-            compute per-frame median, and normalize scales to overall median.
-            """
             th = min(512, H); tw = min(512, W)
             y0 = (H - th) // 2; y1 = y0 + th
             x0 = (W - tw) // 2; x1 = x0 + tw
@@ -11234,9 +12009,20 @@ class StackingSuiteDialog(QDialog):
             N = len(file_list)
             meds = np.empty((N,), dtype=np.float64)
 
+            # Normalize subtractor to HWC or 2D
+            dd = None
+            if dark_data is not None:
+                dd = dark_data
+                if dd.ndim == 3 and dd.shape[0] in (1, 3):  # CHW -> HWC
+                    dd = dd.transpose(1, 2, 0)
+                dd = dd.astype(np.float32, copy=False)
+
             from concurrent.futures import ThreadPoolExecutor, as_completed
             with ThreadPoolExecutor(max_workers=min(os.cpu_count() or 4, 8)) as exe:
-                fut2i = {exe.submit(load_fits_tile, fp, y0, y1, x0, x1): i for i, fp in enumerate(file_list)}
+                fut2i = {
+                    exe.submit(_read_center_patch_via_mmimage, fp, y0, y1, x0, x1): i
+                    for i, fp in enumerate(file_list)
+                }
                 for fut in as_completed(fut2i):
                     i = fut2i[fut]
                     sub = fut.result()
@@ -11251,22 +12037,22 @@ class StackingSuiteDialog(QDialog):
                         sub = sub.transpose(1, 2, 0)
                     sub = sub.astype(np.float32, copy=False)
 
-                    if dark_data is not None:
-                        dd = dark_data
-                        if dd.ndim == 3 and dd.shape[0] in (1, 3):
-                            dd = dd.transpose(1, 2, 0)
-                        d_tile = dd[y0:y1, x0:x1].astype(np.float32, copy=False)
+                    if dd is not None:
+                        d_tile = dd[y0:y1, x0:x1]
                         if d_tile.ndim == 2 and sub.shape[2] == 3:
                             d_tile = np.repeat(d_tile[..., None], 3, axis=2)
-                        sub = sub - d_tile
+                        elif d_tile.ndim == 3 and sub.shape[2] == 1:
+                            d_tile = d_tile[:, :, :1]
+                        sub = sub - d_tile.astype(np.float32, copy=False)
 
-                    meds[i] = np.median(sub, axis=(0, 1, 2))
+                    meds[i] = float(np.median(sub))
 
-            gmed = np.median(meds) if np.all(np.isfinite(meds)) else 1.0
-            gmed = 1.0 if gmed == 0.0 else gmed
+            gmed = float(np.median(meds)) if np.all(np.isfinite(meds)) else 1.0
+            if not np.isfinite(gmed) or gmed == 0.0:
+                gmed = 1.0
             scales = meds / gmed
-            scales = np.clip(scales, 1e-3, 1e3).astype(np.float32)
-            return scales
+            return np.clip(scales, 1e-3, 1e3).astype(np.float32)
+
 
         def _apply_bayer_scales_stack_inplace(ts_np: np.ndarray, scales4: np.ndarray, pat: str, y0: int, x0: int):
             """
@@ -11780,6 +12566,140 @@ class StackingSuiteDialog(QDialog):
         master_item = QTreeWidgetItem([os.path.basename(master_flat_path)])
         filter_item.addChild(master_item)
 
+    def _parse_float(self, v):
+        try:
+            if v is None:
+                return None
+            if isinstance(v, (int, float)):
+                return float(v)
+            s = str(v).strip()
+            # handle " -10.0 C" or "-10.0C"
+            s = s.replace("°", "").replace("C", "").replace("c", "").strip()
+            return float(s)
+        except Exception:
+            return None
+
+
+    def _read_ccd_set_temp_from_fits(self, path: str) -> tuple[float|None, float|None]:
+        """Read CCD-TEMP and SET-TEMP from FITS header (primary HDU)."""
+        try:
+            with fits.open(path) as hdul:
+                hdr = hdul[0].header
+                ccd = self._parse_float(hdr.get("CCD-TEMP", None))
+                st  = self._parse_float(hdr.get("SET-TEMP", None))
+                return ccd, st
+        except Exception:
+            return None, None
+
+
+    def _temp_for_matching(self, ccd: float|None, st: float|None) -> float|None:
+        """Prefer CCD-TEMP; else SET-TEMP; else None."""
+        return ccd if ccd is not None else (st if st is not None else None)
+
+
+    def _parse_masterdark_name(self, stem: str):
+        """
+        From filename like:
+        MasterDark_Session_300s_4144x2822_m10p0C.fit
+        Return dict fields; temp is optional.
+        """
+        out = {"session": None, "exp": None, "size": None, "temp": None}
+
+        base = os.path.basename(stem)
+        base = os.path.splitext(base)[0]
+
+        # session is between MasterDark_ and _<exp>s_
+        # exp is <num>s
+        # size is <WxH> like 4144x2822
+        m = re.match(r"^MasterDark_(?P<session>.+?)_(?P<exp>[\d._]+)s_(?P<size>\d+x\d+)(?:_(?P<temp>.*))?$", base)
+        if not m:
+            return out
+
+        out["session"] = (m.group("session") or "").strip()
+        # exp might be "2_5" from _normalize_master_stem; convert back
+        exp_txt = (m.group("exp") or "").replace("_", ".")
+        try:
+            out["exp"] = float(exp_txt)
+        except Exception:
+            out["exp"] = None
+
+        out["size"] = m.group("size")
+
+        # temp token like m10p0C / p5p0C / setm10p0C
+        t = (m.group("temp") or "").strip()
+        if t:
+            # pick the first temp-ish token ending in C
+            mt = re.search(r"(set)?([mp])(\d+)p(\d)C", t)
+            if mt:
+                sign = -1.0 if mt.group(2) == "m" else 1.0
+                whole = float(mt.group(3))
+                frac = float(mt.group(4)) / 10.0
+                out["temp"] = sign * (whole + frac)
+
+        return out
+
+
+    def _get_master_dark_meta(self, path: str) -> dict:
+        """
+        Cached metadata for a master dark.
+        Prefers FITS header for temp; falls back to filename temp token.
+        """
+        if not hasattr(self, "_master_dark_meta_cache"):
+            self._master_dark_meta_cache = {}
+        cache = self._master_dark_meta_cache
+
+        p = os.path.normpath(path)
+        if p in cache:
+            return cache[p]
+
+        meta = {"path": p, "session": None, "exp": None, "size": None,
+                "ccd": None, "set": None, "temp": None}
+
+        # filename parse (fast)
+        fn = self._parse_masterdark_name(p)
+        meta["session"] = fn.get("session") or None
+        meta["exp"]     = fn.get("exp")
+        meta["size"]    = fn.get("size")
+        meta["temp"]    = fn.get("temp")
+
+        # header parse (authoritative for temps)
+        ccd, st = self._read_ccd_set_temp_from_fits(p)
+        meta["ccd"] = ccd
+        meta["set"] = st
+        meta["temp"] = self._temp_for_matching(ccd, st) if (ccd is not None or st is not None) else meta["temp"]
+
+        # size from header if missing
+        if not meta["size"]:
+            try:
+                with fits.open(p) as hdul:
+                    data = hdul[0].data
+                    if data is not None:
+                        meta["size"] = f"{data.shape[1]}x{data.shape[0]}"
+            except Exception:
+                pass
+
+        cache[p] = meta
+        return meta
+
+
+    def _get_light_temp(self, light_path: str) -> tuple[float|None, float|None, float|None]:
+        """Return (ccd, set, chosen) with caching."""
+        if not hasattr(self, "_light_temp_cache"):
+            self._light_temp_cache = {}
+        cache = self._light_temp_cache
+
+        p = os.path.normpath(light_path or "")
+        if not p:
+            return None, None, None
+        if p in cache:
+            return cache[p]
+
+        ccd, st = self._read_ccd_set_temp_from_fits(p)
+        chosen = self._temp_for_matching(ccd, st)
+        cache[p] = (ccd, st, chosen)
+        return cache[p]
+
+
     def assign_best_master_files(self, fill_only: bool = True):
         """
         Assign best matching Master Dark and Flat to each Light leaf.
@@ -11839,32 +12759,57 @@ class StackingSuiteDialog(QDialog):
                         if fill_only and curr_dark and curr_dark.lower() != "none":
                             dark_choice = curr_dark
                         else:
-                            # 3) Auto-pick by size+closest exposure
-                            best_dark_match = None
-                            best_dark_diff = float("inf")
-                            for master_key, master_path in self.master_files.items():
-                                dmatch = re.match(r"^([\d.]+)s\b", master_key)  # darks start with "<exp>s"
-                                if not dmatch:
+                            # 3) Auto-pick by size + closest exposure + closest temperature (and prefer same session)
+                            light_path = leaf_item.data(0, Qt.ItemDataRole.UserRole)
+                            l_ccd, l_set, l_temp = self._get_light_temp(light_path)
+
+                            best_path = None
+                            best_score = None
+
+                            for mk, mp in (self.master_files or {}).items():
+                                if not mp:
                                     continue
-                                master_dark_exposure_time = float(dmatch.group(1))
 
-                                # Ensure size known/cached
-                                md_size = master_sizes.get(master_path)
-                                if not md_size:
-                                    try:
-                                        with fits.open(master_path) as hdul:
-                                            md_size = f"{hdul[0].data.shape[1]}x{hdul[0].data.shape[0]}"
-                                    except Exception:
-                                        md_size = "Unknown"
-                                    master_sizes[master_path] = md_size
+                                bn = os.path.basename(mp)
+                                # Only consider MasterDark_* files (cheap gate)
+                                if not bn.startswith("MasterDark_"):
+                                    continue
+
+                                md = self._get_master_dark_meta(mp)
+                                md_size = md.get("size") or "Unknown"
+                                if md_size != image_size:
+                                    continue
 
-                                if md_size == image_size:
-                                    diff = abs(master_dark_exposure_time - exposure_time)
-                                    if diff < best_dark_diff:
-                                        best_dark_diff = diff
-                                        best_dark_match = master_path
+                                md_exp = md.get("exp")
+                                if md_exp is None:
+                                    continue
+
+                                # exposure closeness
+                                exp_diff = abs(float(md_exp) - float(exposure_time))
+
+                                # session preference: exact match beats mismatch
+                                md_sess = (md.get("session") or "Default").strip()
+                                sess_mismatch = 0 if md_sess == session_name else 1
+
+                                # temperature closeness (if both known)
+                                md_temp = md.get("temp")
+                                if (l_temp is not None) and (md_temp is not None):
+                                    temp_diff = abs(float(md_temp) - float(l_temp))
+                                    temp_unknown = 0
+                                else:
+                                    # if light has temp but dark doesn't (or vice versa), penalize
+                                    temp_diff = 9999.0
+                                    temp_unknown = 1
 
-                            dark_choice = os.path.basename(best_dark_match) if best_dark_match else ("None" if not curr_dark else curr_dark)
+                                # Score tuple: lower is better
+                                # Priority: session match -> exposure diff -> temp availability -> temp diff
+                                score = (sess_mismatch, exp_diff, temp_unknown, temp_diff)
+
+                                if best_score is None or score < best_score:
+                                    best_score = score
+                                    best_path = mp
+
+                            dark_choice = os.path.basename(best_path) if best_path else ("None" if not curr_dark else curr_dark)
 
                     # ---------- FLAT RESOLUTION ----------
                     flat_key_full  = f"{filter_name_raw} - {exposure_text}"
@@ -12000,22 +12945,57 @@ class StackingSuiteDialog(QDialog):
 
 
     def override_selected_master_dark(self):
-        """ Override Dark for selected Light exposure group or individual files. """
+        """Override Dark for selected Light exposure group or individual files."""
         selected_items = self.light_tree.selectedItems()
         if not selected_items:
             print("⚠️ No light item selected for dark frame override.")
             return
 
-        file_path, _ = QFileDialog.getOpenFileName(self, "Select Master Dark", "", "FITS Files (*.fits *.fit)")
+        # --- pick a good starting directory ---
+        last_dir = self.settings.value("stacking/last_master_dark_dir", "", type=str) if hasattr(self, "settings") else ""
+        if not last_dir:
+            # try stacking dir
+            last_dir = getattr(self, "stacking_directory", "") or ""
+
+        # try selected leaf path folder (best UX)
+        try:
+            it0 = selected_items[0]
+            # leaf stores path in UserRole, groups do not
+            p0 = it0.data(0, Qt.ItemDataRole.UserRole)
+            if isinstance(p0, str) and os.path.exists(p0):
+                last_dir = os.path.dirname(p0)
+        except Exception:
+            pass
+
+        if not last_dir:
+            last_dir = os.path.expanduser("~")
+
+        file_path, _ = QFileDialog.getOpenFileName(
+            self,
+            "Select Master Dark",
+            last_dir,
+            "Master Calibration (*.fits *.fit *.xisf);;All Files (*)"
+        )
         if not file_path:
             return
 
+        # remember for next time
+        try:
+            if hasattr(self, "settings"):
+                self.settings.setValue("stacking/last_master_dark_dir", os.path.dirname(file_path))
+        except Exception:
+            pass
+
+        # Ensure dict exists
+        if not hasattr(self, "manual_dark_overrides") or self.manual_dark_overrides is None:
+            self.manual_dark_overrides = {}
+
         for item in selected_items:
-            # If the user clicked a group (exposure row), push override to all leaves:
+            # If the user clicked an exposure row under a filter
             if item.parent() and item.childCount() > 0:
-                # exposure row under a filter
                 filter_name = item.parent().text(0)
                 exposure_text = item.text(0)
+
                 # store override under BOTH keys
                 self.manual_dark_overrides[f"{filter_name} - {exposure_text}"] = file_path
                 self.manual_dark_overrides[exposure_text] = file_path
@@ -12023,17 +13003,20 @@ class StackingSuiteDialog(QDialog):
                 for i in range(item.childCount()):
                     leaf = item.child(i)
                     leaf.setText(2, os.path.basename(file_path))
-            # If the user clicked a leaf, just set that leaf and still store under both keys
+
+            # If the user clicked a leaf under an exposure row
             elif item.parent() and item.parent().parent():
                 exposure_item = item.parent()
                 filter_name = exposure_item.parent().text(0)
                 exposure_text = exposure_item.text(0)
+
                 self.manual_dark_overrides[f"{filter_name} - {exposure_text}"] = file_path
                 self.manual_dark_overrides[exposure_text] = file_path
                 item.setText(2, os.path.basename(file_path))
 
         print("✅ DEBUG: Light Dark override applied.")
 
+
     def _auto_pick_master_dark(self, image_size: str, exposure_time: float):
         best_path, best_diff = None, float("inf")
         for key, path in self.master_files.items():
@@ -12416,6 +13399,7 @@ class StackingSuiteDialog(QDialog):
 
                     # ---------- LOAD LIGHT ----------
                     light_data, hdr, bit_depth, is_mono = load_image(light_file)
+                    #_print_stats("LIGHT raw", light_data, bit_depth=bit_depth, hdr=hdr)
                     if light_data is None or hdr is None:
                         self.update_status(self.tr(f"❌ ERROR: Failed to load {os.path.basename(light_file)}"))
                         continue
@@ -12440,7 +13424,10 @@ class StackingSuiteDialog(QDialog):
 
                     # ---------- APPLY DARK (if resolved) ----------
                     if master_dark_path:
-                        dark_data, _, _, dark_is_mono = load_image(master_dark_path)
+                        dark_data, _, dark_bit_depth, dark_is_mono = load_image(master_dark_path)
+                        #_print_stats("DARK raw", dark_data, bit_depth=dark_bit_depth)
+                        dark_data = _maybe_normalize_16bit_float(dark_data, name=os.path.basename(master_dark_path))
+                        #_print_stats("DARK normalized", dark_data, bit_depth=dark_bit_depth)
                         if dark_data is not None:
                             if not dark_is_mono and dark_data.ndim == 3 and dark_data.shape[-1] == 3:
                                 dark_data = dark_data.transpose(2, 0, 1)  # HWC -> CHW
@@ -12456,7 +13443,10 @@ class StackingSuiteDialog(QDialog):
 
                     # ---------- APPLY FLAT (if resolved) ----------
                     if master_flat_path:
-                        flat_data, _, _, flat_is_mono = load_image(master_flat_path)
+                        flat_data, _, flat_bit_depth, flat_is_mono = load_image(master_flat_path)
+                        #_print_stats("FLAT raw", flat_data, bit_depth=flat_bit_depth)
+                        flat_data = _maybe_normalize_16bit_float(flat_data, name=os.path.basename(master_flat_path))
+                        #_print_stats("FLAT normalized", flat_data, bit_depth=flat_bit_depth)
                         if flat_data is not None:
 
                             # Make flat layout match your working light layout:
@@ -12570,13 +13560,19 @@ class StackingSuiteDialog(QDialog):
                     max_val = float(np.max(light_data))
                     self.update_status(self.tr(f"Before saving: min = {min_val:.4f}, max = {max_val:.4f}"))
                     print(f"Before saving: min = {min_val:.4f}, max = {max_val:.4f}")
+                    
+                    _warn_if_units_mismatch(light_data, dark_data if master_dark_path else None, flat_data if master_flat_path else None)
+                    _print_stats("LIGHT final", light_data)
                     QApplication.processEvents()
-
                     # Annotate header
                     try:
-                        hdr['HISTORY'] = 'Calibrated: bias/dark sub, flat division'
-                        hdr['CALMIN']  = (min_val, 'Min pixel before save (float)')
-                        hdr['CALMAX']  = (max_val, 'Max pixel before save (float)')
+                        if hasattr(hdr, "add_history"):
+                            hdr.add_history("Calibrated: bias/dark sub, flat division")
+                        else:
+                            hdr["HISTORY"] = "Calibrated: bias/dark sub, flat division"
+
+                        hdr["CALMIN"] = (min_val, "Min pixel before save (float)")
+                        hdr["CALMAX"] = (max_val, "Max pixel before save (float)")
                     except Exception:
                         pass
 
@@ -12816,6 +13812,20 @@ class StackingSuiteDialog(QDialog):
             "drop": float(self.drizzle_drop_shrink_spin.value())
         }
 
+    def _global_drizzle_state(self) -> dict:
+        # UI is the source of truth at runtime
+        enabled = bool(self.drizzle_checkbox.isChecked())
+
+        # Scale from combo text like "1x", "2x", "3x"
+        try:
+            scale = float(self.drizzle_scale_combo.currentText().replace("x", "", 1).strip())
+        except Exception:
+            scale = 1.0
+
+        drop = float(self.drizzle_drop_shrink_spin.value())
+
+        return {"enabled": enabled, "scale": scale, "drop": drop}
+
     def _split_dual_band_osc(self, selected_groups=None):
         """
         Create mono Ha/SII/OIII frames from dual-band OSC files and
@@ -13547,23 +14557,23 @@ class StackingSuiteDialog(QDialog):
         self.update_status(self.tr("🧹 Doing a little tidying up..."))
         user_ref_locked = bool(getattr(self, "_user_ref_locked", False))
 
-        # Only clear derived geometry/maps when NOT locked
+        # ALWAYS clear derived geometry/maps for this run (mapping is run-specific)
+        self._norm_target_hw = None
+        self._orig2norm = {}
+
+        # Only clear the UI reference label when NOT locked
         if not user_ref_locked:
-            self._norm_target_hw = None
-            self._orig2norm = {}
             try:
                 if hasattr(self, "ref_frame_path") and self.ref_frame_path:
                     self.ref_frame_path.setText("Auto (not set)")
             except Exception:
                 pass
         else:
-            # Keep the UI showing the user’s chosen ref (basename for display)
             try:
                 if hasattr(self, "ref_frame_path") and self.ref_frame_path and self.reference_frame:
                     self.ref_frame_path.setText(os.path.basename(self.reference_frame))
             except Exception:
                 pass
-
         # 🚫 Do NOT remove persisted user ref here; that defeats locking.
         # (No settings.remove() and no reference_frame = None if locked)
 
@@ -13578,6 +14588,24 @@ class StackingSuiteDialog(QDialog):
             self.update_status(self.tr("🔄 Image Registration Started..."))
             self.extract_light_files_from_tree(debug=True)
 
+            # --- Apply "removed from Registration tab" exclusions (session-level) ---
+            dead = set()
+            if hasattr(self, "deleted_calibrated_files") and self.deleted_calibrated_files:
+                dead = set(self.deleted_calibrated_files)
+
+            if dead:
+                for g in list(self.light_files.keys()):
+                    self.light_files[g] = [
+                        p for p in self.light_files[g]
+                        if os.path.normcase(os.path.abspath(p)) not in dead
+                    ]
+                    if not self.light_files[g]:
+                        del self.light_files[g]
+
+                self.update_status(self.tr(f"🚫 Excluding {len(dead)} removed frame(s) from registration/stacking."))
+                QApplication.processEvents()
+
+
             comet_mode = bool(getattr(self, "comet_cb", None) and self.comet_cb.isChecked())
             if comet_mode:
                 self.update_status(self.tr("🌠 Comet mode: please click the comet center to continue…"))
@@ -14430,7 +15458,28 @@ class StackingSuiteDialog(QDialog):
 
             from os import path
             ref_path = path.normpath(self.reference_frame)
-            self.update_status(self.tr(f"📌 Reference for alignment (verbatim): {ref_path}"))
+            from os import path
+
+            # Prefer the normalized FIT reference if we produced one
+            ref_key = path.normcase(path.normpath(self.reference_frame))
+            ref_norm = self._orig2norm.get(ref_key)
+
+            # If mapping missing, attempt the predictable filename in norm_dir
+            if not ref_norm:
+                base = os.path.basename(self.reference_frame)
+                if base.lower().endswith(".fits"):
+                    n_name = base[:-5] + "_n.fit"
+                elif base.lower().endswith(".fit"):
+                    n_name = base[:-4] + "_n.fit"
+                else:
+                    n_name = base + "_n.fit"
+                candidate = path.normpath(path.join(norm_dir, n_name))
+                if path.exists(candidate):
+                    ref_norm = candidate
+
+            ref_path = path.normpath(ref_norm or self.reference_frame)
+
+            self.update_status(self.tr(f"📌 Reference for alignment: {ref_path}"))
             if not path.exists(ref_path):
                 self.update_status(self.tr(f"🚨 Reference file does not exist: {ref_path}"))
                 return
@@ -14446,6 +15495,14 @@ class StackingSuiteDialog(QDialog):
 
             normalized_files = [path.normpath(p) for p in normalized_files]
 
+            ref_key = path.normcase(path.normpath(self.reference_frame))
+            ref_path = self._orig2norm.get(ref_key, path.normpath(self.reference_frame))
+
+            self.update_status(self.tr(f"📌 Reference for alignment (normalized if available): {ref_path}"))
+            if not path.exists(ref_path):
+                self.update_status(self.tr(f"🚨 Reference file does not exist: {ref_path}"))
+                return
+
             self.alignment_thread = StarRegistrationThread(
                 ref_path,  
                 normalized_files,
@@ -15051,6 +16108,41 @@ class StackingSuiteDialog(QDialog):
         # Threshold is only used in normal mode
         accept_thresh = float(self.settings.value("stacking/accept_shift_px", 2.0, type=float))
 
+        def _mf_ref_path_for_masks() -> str | None:
+            """
+            Return the best reference path for MFDeconv star masks:
+            aligned FITS if possible, else normalized FITS, else original.
+            """
+            if not getattr(self, "reference_frame", None):
+                return None
+
+            from os import path
+            ref_orig = path.normpath(self.reference_frame)
+            ref_key  = path.normcase(ref_orig)
+
+            # original -> normalized
+            ref_norm = self._orig2norm.get(ref_key)
+
+            # normalized -> aligned
+            ref_aligned = None
+            if ref_norm:
+                ref_aligned = self.valid_transforms.get(path.normpath(ref_norm))
+
+            # If we couldn’t map via orig->norm (e.g. user picked a normalized path already)
+            if not ref_norm and ref_orig in self.valid_transforms:
+                ref_norm = ref_orig
+                ref_aligned = self.valid_transforms.get(ref_norm)
+
+            # Prefer aligned if it exists on disk
+            if ref_aligned and path.exists(ref_aligned):
+                return ref_aligned
+            if ref_norm and path.exists(ref_norm):
+                return ref_norm
+            if path.exists(ref_orig):
+                return ref_orig
+            return None
+
+
         def _accept(k: str) -> bool:
             """Accept criteria for a frame."""
             if all_transforms.get(k) is None:
@@ -15190,6 +16282,14 @@ class StackingSuiteDialog(QDialog):
             # Snapshot UI-dependent settings (your existing code)
             # ----------------------------
             drizzle_dict = self.gather_drizzle_settings_from_tree()
+            try:
+                self.update_status(self.tr(
+                    "🧾 Drizzle dict: " + ", ".join(f"{k}:{'ON' if v.get('drizzle_enabled') else 'off'}"
+                                                for k, v in drizzle_dict.items())
+                ))
+            except Exception:
+                pass
+            QApplication.processEvents()
             try:
                 autocrop_enabled = self.autocrop_cb.isChecked()
                 autocrop_pct = float(self.autocrop_pct.value())
@@ -15426,7 +16526,9 @@ class StackingSuiteDialog(QDialog):
                     }
 
                     self._mf_thread = QThread(self)
-                    star_mask_ref = self.reference_frame if use_star_masks else None
+                    star_mask_ref = _mf_ref_path_for_masks() if use_star_masks else None
+                    if use_star_masks:
+                        self.update_status(self.tr(f"🌟 MFDeconv star-mask reference → {star_mask_ref or '(none)'}"))                    
 
                     # ── choose engine plainly (Normal / cuDNN-free / High Octane) ─────────────
                     # Expect a setting saved by your radio buttons: "normal" | "cudnn" | "sport"
@@ -15604,6 +16706,22 @@ class StackingSuiteDialog(QDialog):
 
         self._set_registration_busy(False)
 
+    def _on_after_align_finished(self, success: bool, message: str):
+        # Stop thread/progress UI first (whatever you already do)
+
+        if success:
+            QMessageBox.information(
+                self,
+                self.tr("Stacking Complete"),
+                message
+            )
+        else:
+            QMessageBox.critical(
+                self,
+                self.tr("Stacking Failed"),
+                message
+            )
+
     def _on_mf_progress(self, s: str):
         # Mirror non-token messages
         if not s.startswith("__PROGRESS__"):
@@ -15632,25 +16750,48 @@ class StackingSuiteDialog(QDialog):
 
     @pyqtSlot(bool, str)
     def _on_post_pipeline_finished(self, ok: bool, message: str):
+        # ---- close progress dialog ----
         try:
-            if getattr(self, "post_progress", None):
+            if getattr(self, "post_progress", None) is not None:
                 self.post_progress.close()
+                self.post_progress.deleteLater()
                 self.post_progress = None
         except Exception:
             pass
 
+        # ---- stop thread ----
         try:
-            self.post_thread.quit()
-            self.post_thread.wait()
+            if getattr(self, "post_thread", None) is not None:
+                self.post_thread.quit()
+                self.post_thread.wait()
         except Exception:
             pass
+
+        # ---- cleanup objects ----
         try:
-            self.post_worker.deleteLater()
-            self.post_thread.deleteLater()
+            if getattr(self, "post_worker", None) is not None:
+                self.post_worker.deleteLater()
+                self.post_worker = None
+            if getattr(self, "post_thread", None) is not None:
+                self.post_thread.deleteLater()
+                self.post_thread = None
         except Exception:
             pass
 
-        self.update_status(self.tr(message))
+        # ---- update status (keep this behavior) ----
+        try:
+            # message already includes "Post-alignment complete..." text
+            self.update_status(self.tr(message))
+        except Exception:
+            pass
+
+        # ---- popup summary ----
+        # (Do this after progress dialog is gone so it doesn't hide behind it)
+        if ok:
+            QMessageBox.information(self, self.tr("Post-Alignment Complete"), message)
+        else:
+            QMessageBox.critical(self, self.tr("Post-Alignment Failed"), message)
+
         self._cfa_for_this_run = None
         QApplication.processEvents()
 
@@ -15757,6 +16898,8 @@ class StackingSuiteDialog(QDialog):
         log(f"📁 Post-align: {n_groups} group(s), {n_frames} aligned frame(s).")
         QApplication.processEvents()
 
+        drizzle_enabled_global = self._get_drizzle_enabled()
+
         # Precompute a single global crop rect if enabled (pure computation, no UI).
         global_rect = None
         if autocrop_enabled:
@@ -15840,6 +16983,10 @@ class StackingSuiteDialog(QDialog):
             hdr_orig["CREATOR"]  = "SetiAstroSuite"
             hdr_orig["DATE-OBS"] = datetime.utcnow().isoformat()
 
+            n_frames_group = len(file_list)
+            hdr_orig["NCOMBINE"] = (int(n_frames_group), "Number of frames combined")
+            hdr_orig["NSTACK"]   = (int(n_frames_group), "Alias of NCOMBINE (SetiAstro)")
+
             is_mono_orig = (integrated_image.ndim == 2)
             if is_mono_orig:
                 hdr_orig["NAXIS"]  = 2
@@ -15959,6 +17106,8 @@ class StackingSuiteDialog(QDialog):
                     scale=1.0,
                     rect_override=group_rect if group_rect is not None else global_rect
                 )
+                hdr_crop["NCOMBINE"] = (int(n_frames_group), "Number of frames combined")
+                hdr_crop["NSTACK"]   = (int(n_frames_group), "Alias of NCOMBINE (SetiAstro)")
                 is_mono_crop = (cropped_img.ndim == 2)
                 Hc, Wc = (cropped_img.shape[:2] if cropped_img.ndim >= 2 else (H, W))
                 display_group_crop = self._label_with_dims(group_key, Wc, Hc)
@@ -16102,6 +17251,12 @@ class StackingSuiteDialog(QDialog):
                         algo_override=COMET_ALGO  # << comet-friendly reducer
                     )
 
+                    n_usable = int(len(usable))
+                    ref_header_c = ref_header_c or ref_header or fits.Header()
+                    ref_header_c["NCOMBINE"] = (n_usable, "Number of frames combined (comet)")
+                    ref_header_c["NSTACK"]   = (n_usable, "Alias of NCOMBINE (SetiAstro)")
+                    ref_header_c["COMETFR"]  = (n_usable, "Frames used for comet-aligned stack")
+
                     # Save CometOnly
                     Hc, Wc = comet_only.shape[:2]
                     display_group_c = self._label_with_dims(group_key, Wc, Hc)
@@ -16126,6 +17281,10 @@ class StackingSuiteDialog(QDialog):
                             scale=1.0,
                             rect_override=group_rect if group_rect is not None else global_rect
                         )
+                        comet_only_crop, hdr_c_crop = self._apply_autocrop(...)
+                        hdr_c_crop["NCOMBINE"] = (n_usable, "Number of frames combined (comet)")
+                        hdr_c_crop["NSTACK"]   = (n_usable, "Alias of NCOMBINE (SetiAstro)")
+                        hdr_c_crop["COMETFR"]  = (n_usable, "Frames used for comet-aligned stack")                        
                         Hcc, Wcc = comet_only_crop.shape[:2]
                         display_group_cc = self._label_with_dims(group_key, Wcc, Hcc)
                         comet_path_crop = self._build_out(
@@ -16190,8 +17349,7 @@ class StackingSuiteDialog(QDialog):
                             log(f"✂️ Saved CometBlend (auto-cropped) → {blend_path_crop}")
 
             # ---- Drizzle bookkeeping for this group ----
-            dconf = drizzle_dict.get(group_key, {})
-            if dconf.get("drizzle_enabled", False):
+            if drizzle_enabled_global:
                 sasr_path = os.path.join(self.stacking_directory, f"{group_key}_rejections.sasr")
                 self.save_rejection_map_sasr(rejection_map, sasr_path)
                 log(f"✅ Saved rejection map to {sasr_path}")
@@ -16223,17 +17381,17 @@ class StackingSuiteDialog(QDialog):
             originals_by_group[group] = orig_list
         # ---- Drizzle pass (only for groups with drizzle enabled) ----
         for group_key, file_list in grouped_files.items():
-            dconf = drizzle_dict.get(group_key)
-            if not (dconf and dconf.get("drizzle_enabled", False)):
-                log(f"✅ Group '{group_key}' not set for drizzle. Integrated image already saved.")
+            if not drizzle_enabled_global:
+                log(f"✅ Drizzle disabled (checkbox off). Group '{group_key}' integrated image already saved.")
                 continue
 
+            # Use your existing getters (they can read UI/settings)
             scale_factor = self._get_drizzle_scale()
             drop_shrink  = self._get_drizzle_pixfrac()
 
-            # Optional: also read kernel for logging/branching
             kernel = (self.settings.value("stacking/drizzle_kernel", "square", type=str) or "square").lower()
-            status_cb(f"Drizzle cfg → scale={scale_factor}×, pixfrac={drop_shrink:.3f}, kernel={kernel}")
+            log(f"Drizzle cfg → scale={scale_factor}×, pixfrac={drop_shrink:.3f}, kernel={kernel}")
+
             rejections_for_group = group_integration_data[group_key]["rejection_map"]
             n_frames_group = group_integration_data[group_key]["n_frames"]
 
@@ -16241,8 +17399,8 @@ class StackingSuiteDialog(QDialog):
 
             self.drizzle_stack_one_group(
                 group_key=group_key,
-                file_list=file_list,                          # registered (for headers/labels)
-                original_list=originals_by_group.get(group_key, []),  # <-- NEW
+                file_list=file_list,
+                original_list=originals_by_group.get(group_key, []),
                 transforms_dict=transforms_dict,
                 frame_weights=frame_weights,
                 scale_factor=scale_factor,
@@ -16714,246 +17872,6 @@ class StackingSuiteDialog(QDialog):
             views[p] = np.load(npy, mmap_mode="r")  # returns numpy.memmap
         return views
 
-
-    def stack_registered_images_chunked(
-        self,
-        grouped_files,
-        frame_weights,
-        chunk_height=2048,
-        chunk_width=2048
-    ):
-        self.update_status(self.tr(f"✅ Chunked stacking {len(grouped_files)} group(s)..."))
-        QApplication.processEvents()
-
-        all_rejection_coords = []
-
-        for group_key, file_list in grouped_files.items():
-            num_files = len(file_list)
-            self.update_status(self.tr(f"📊 Group '{group_key}' has {num_files} aligned file(s)."))
-            QApplication.processEvents()
-            if num_files < 2:
-                self.update_status(self.tr(f"⚠️ Group '{group_key}' does not have enough frames to stack."))
-                continue
-
-            # Reference shape/header (unchanged)
-            ref_file = file_list[0]
-            if not os.path.exists(ref_file):
-                self.update_status(self.tr(f"⚠️ Reference file '{ref_file}' not found, skipping group."))
-                continue
-
-            ref_data, ref_header, _, _ = load_image(ref_file)
-            if ref_data is None:
-                self.update_status(self.tr(f"⚠️ Could not load reference '{ref_file}', skipping group."))
-                continue
-
-            is_color = (ref_data.ndim == 3 and ref_data.shape[2] == 3)
-            height, width = ref_data.shape[:2]
-            channels = 3 if is_color else 1
-
-            # Final output memmap (unchanged)
-            memmap_path = self._build_out(self.stacking_directory, f"chunked_{group_key}", "dat")
-            final_stacked = np.memmap(memmap_path, dtype=np.float32, mode='w+', shape=(height, width, channels))
-
-            # Valid files + weights
-            aligned_paths, weights_list = [], []
-            for fpath in file_list:
-                if os.path.exists(fpath):
-                    aligned_paths.append(fpath)
-                    weights_list.append(frame_weights.get(fpath, 1.0))
-                else:
-                    self.update_status(self.tr(f"⚠️ File not found: {fpath}, skipping."))
-            if len(aligned_paths) < 2:
-                self.update_status(self.tr(f"⚠️ Not enough valid frames in group '{group_key}' to stack."))
-                continue
-
-            weights_list = np.array(weights_list, dtype=np.float32)
-
-            # ⬇️ NEW: open read-only memmaps for all aligned frames (float32 [0..1], HxWxC)
-            mm_views = self._open_memmaps_readonly(aligned_paths)
-
-            self.update_status(self.tr(f"📊 Stacking group '{group_key}' with {self.rejection_algorithm}"))
-            QApplication.processEvents()
-
-            rejection_coords = []
-            N = len(aligned_paths)
-            DTYPE  = self._dtype()
-            pref_h = self.chunk_height
-            pref_w = self.chunk_width
-
-            try:
-                chunk_h, chunk_w = compute_safe_chunk(height, width, N, channels, DTYPE, pref_h, pref_w)
-                self.update_status(self.tr(f"🔧 Using chunk size {chunk_h}×{chunk_w} for {self._dtype()}"))
-            except MemoryError as e:
-                self.update_status(self.tr(f"⚠️ {e}"))
-                return None, {}, None
-
-            # Tile loop (same structure, but tile loading reads from memmaps)
-            from concurrent.futures import ThreadPoolExecutor, as_completed
-            LOADER_WORKERS = min(max(2, (os.cpu_count() or 4) // 2), 8)  # tuned for memory bw
-
-            for y_start in range(0, height, chunk_h):
-                y_end  = min(y_start + chunk_h, height)
-                tile_h = y_end - y_start
-
-                for x_start in range(0, width, chunk_w):
-                    x_end  = min(x_start + chunk_w, width)
-                    tile_w = x_end - x_start
-
-                    # Preallocate tile stack
-                    tile_stack = np.empty((N, tile_h, tile_w, channels), dtype=np.float32)
-
-                    # ⬇️ NEW: fill tile_stack from the memmaps (parallel copy)
-                    def _copy_one(i, path):
-                        v = mm_views[path][y_start:y_end, x_start:x_end]  # view on disk
-                        if v.ndim == 2:
-                            # mono memmap stored as (H,W,1); but if legacy mono npy exists as (H,W),
-                            # make it (H,W,1) here:
-                            vv = v[..., None]
-                        else:
-                            vv = v
-                        if vv.shape[2] == 1 and channels == 3:
-                            vv = np.repeat(vv, 3, axis=2)
-                        tile_stack[i] = vv
-
-                    with ThreadPoolExecutor(max_workers=LOADER_WORKERS) as exe:
-                        futs = {exe.submit(_copy_one, i, p): i for i, p in enumerate(aligned_paths)}
-                        for _ in as_completed(futs):
-                            pass
-
-                    # Rejection (unchanged – uses your Numba kernels)
-                    algo = self.rejection_algorithm
-                    if algo == "Simple Median (No Rejection)":
-                        tile_result  = np.median(tile_stack, axis=0)
-                        tile_rej_map = np.zeros(tile_stack.shape[1:3], dtype=np.bool_)
-                    elif algo == "Simple Average (No Rejection)":
-                        tile_result  = np.average(tile_stack, axis=0, weights=weights_list)
-                        tile_rej_map = np.zeros(tile_stack.shape[1:3], dtype=np.bool_)
-                    elif algo == "Weighted Windsorized Sigma Clipping":
-                        tile_result, tile_rej_map = windsorized_sigma_clip_weighted(
-                            tile_stack, weights_list, lower=self.sigma_low, upper=self.sigma_high
-                        )
-                    elif algo == "Kappa-Sigma Clipping":
-                        tile_result, tile_rej_map = kappa_sigma_clip_weighted(
-                            tile_stack, weights_list, kappa=self.kappa, iterations=self.iterations
-                        )
-                    elif algo == "Trimmed Mean":
-                        tile_result, tile_rej_map = trimmed_mean_weighted(
-                            tile_stack, weights_list, trim_fraction=self.trim_fraction
-                        )
-                    elif algo == "Extreme Studentized Deviate (ESD)":
-                        tile_result, tile_rej_map = esd_clip_weighted(
-                            tile_stack, weights_list, threshold=self.esd_threshold
-                        )
-                    elif algo == "Biweight Estimator":
-                        tile_result, tile_rej_map = biweight_location_weighted(
-                            tile_stack, weights_list, tuning_constant=self.biweight_constant
-                        )
-                    elif algo == "Modified Z-Score Clipping":
-                        tile_result, tile_rej_map = modified_zscore_clip_weighted(
-                            tile_stack, weights_list, threshold=self.modz_threshold
-                        )
-                    elif algo == "Max Value":
-                        tile_result, tile_rej_map = max_value_stack(
-                            tile_stack, weights_list
-                        )
-                    else:
-                        tile_result, tile_rej_map = windsorized_sigma_clip_weighted(
-                            tile_stack, weights_list, lower=self.sigma_low, upper=self.sigma_high
-                        )
-
-                    # Ensure tile_result has correct shape
-                    if tile_result.ndim == 2:
-                        tile_result = tile_result[:, :, None]
-                    expected_shape = (tile_h, tile_w, channels)
-                    if tile_result.shape != expected_shape:
-                        if tile_result.shape[2] == 0:
-                            tile_result = np.zeros(expected_shape, dtype=np.float32)
-                        elif tile_result.shape[:2] == (tile_h, tile_w):
-                            if tile_result.shape[2] > channels:
-                                tile_result = tile_result[:, :, :channels]
-                            else:
-                                tile_result = np.repeat(tile_result, channels, axis=2)[:, :, :channels]
-
-                    # Commit tile
-                    final_stacked[y_start:y_end, x_start:x_end, :] = tile_result
-
-                    # Collect per-tile rejection coords (unchanged logic)
-                    if tile_rej_map.ndim == 3:          # (N, tile_h, tile_w)
-                        combined_rej = np.any(tile_rej_map, axis=0)
-                    elif tile_rej_map.ndim == 4:        # (N, tile_h, tile_w, C)
-                        combined_rej = np.any(tile_rej_map, axis=0)
-                        combined_rej = np.any(combined_rej, axis=-1)
-                    else:
-                        combined_rej = np.zeros((tile_h, tile_w), dtype=np.bool_)
-
-                    ys_tile, xs_tile = np.where(combined_rej)
-                    for dy, dx in zip(ys_tile, xs_tile):
-                        rejection_coords.append((x_start + dx, y_start + dy))
-
-            # Finish/save (unchanged from your version) …
-            final_array = np.array(final_stacked)
-            del final_stacked
-
-            final_array = self._normalize_stack_01(final_array)
-
-            if final_array.ndim == 3 and final_array.shape[-1] == 1:
-                final_array = final_array[..., 0]
-            is_mono = (final_array.ndim == 2)
-
-            if ref_header is None:
-                ref_header = fits.Header()
-            ref_header["IMAGETYP"] = "MASTER STACK"
-            ref_header["BITPIX"] = -32
-            ref_header["STACKED"] = (True, "Stacked using chunked approach")
-            ref_header["CREATOR"] = "SetiAstroSuite"
-            ref_header["DATE-OBS"] = datetime.utcnow().isoformat()
-            if is_mono:
-                ref_header["NAXIS"]  = 2
-                ref_header["NAXIS1"] = final_array.shape[1]
-                ref_header["NAXIS2"] = final_array.shape[0]
-                if "NAXIS3" in ref_header: del ref_header["NAXIS3"]
-            else:
-                ref_header["NAXIS"]  = 3
-                ref_header["NAXIS1"] = final_array.shape[1]
-                ref_header["NAXIS2"] = final_array.shape[0]
-                ref_header["NAXIS3"] = 3
-
-            output_stem = f"MasterLight_{group_key}_{len(aligned_paths)}stacked"
-            output_path  = self._build_out(self.stacking_directory, output_stem, "fit")
-
-            save_image(
-                img_array=final_array,
-                filename=output_path,
-                original_format="fit",
-                bit_depth="32-bit floating point",
-                original_header=ref_header,
-                is_mono=is_mono
-            )
-
-            self.update_status(self.tr(f"✅ Group '{group_key}' stacked {len(aligned_paths)} frame(s)! Saved: {output_path}"))
-
-            print(f"✅ Master Light saved for group '{group_key}': {output_path}")
-
-            # Optionally, you might want to store or log 'rejection_coords' (here appended to all_rejection_coords)
-            all_rejection_coords.extend(rejection_coords)
-
-            # Clean up memmap file
-            try:
-                os.remove(memmap_path)
-            except OSError:
-                pass
-
-        QMessageBox.information(
-            self,
-            "Stacking Complete",
-            f"All stacking finished successfully.\n"
-            f"Frames per group:\n" +
-            "\n".join([f"{group_key}: {len(files)} frame(s)" for group_key, files in grouped_files.items()])
-        )
-
-        # Optionally, you could return the global rejection coordinate list.
-        return all_rejection_coords        
-
     def _start_after_align_worker(self, aligned_light_files: dict[str, list[str]]):
         # Snapshot UI settings
         if getattr(self, "_suppress_normal_integration_once", False):
@@ -17127,7 +18045,37 @@ class StackingSuiteDialog(QDialog):
 
             # Thread + worker
             self._mf_thread = QThread(self)
-            star_mask_ref = self.reference_frame if use_star_masks else None
+
+            def _pick_mf_ref_from_frames(frames: list[str]) -> str | None:
+                """Pick a reference path for MFDeconv masks from the aligned frames list."""
+                from os import path
+                if not frames:
+                    return None
+
+                # Prefer the weighted-best frame if weights exist
+                w = getattr(self, "frame_weights", None) or {}
+                best = None
+                bestw = -1.0
+                for p in frames:
+                    pn = path.normpath(p)
+                    if not path.exists(pn):
+                        continue
+                    ww = float(w.get(pn, w.get(p, 0.0)) or 0.0)
+                    if ww > bestw:
+                        bestw, best = ww, pn
+
+                # Otherwise fall back to first existing frame
+                if best:
+                    return best
+                for p in frames:
+                    pn = path.normpath(p)
+                    if path.exists(pn):
+                        return pn
+                return None
+
+            star_mask_ref = _pick_mf_ref_from_frames(frames) if use_star_masks else None
+            if use_star_masks:
+                self.update_status(self.tr(f"🌟 MFDeconv star-mask reference → {star_mask_ref or '(none)'}"))
 
             # ── choose engine plainly (Normal / cuDNN-free / High Octane) ─────────────
             # Expect a setting saved by your radio buttons: "normal" | "cudnn" | "sport"
@@ -17272,6 +18220,87 @@ class StackingSuiteDialog(QDialog):
 
             self.update_status(self.tr(f"📊 Found {len(cand)} aligned/normalized frames. Measuring in parallel previews…"))
 
+            # ─────────────────────────────────────────────────────────────────────
+            # XISF safety: convert any .xisf to float32 FITS once up-front so the
+            # downstream integration pipeline is guaranteed to be FITS-based.
+            # ─────────────────────────────────────────────────────────────────────
+            prep_dir = os.path.join(self.stacking_directory, "Prepared_Registered")
+            os.makedirs(prep_dir, exist_ok=True)
+
+            orig2prep = {}  # optional, for debugging or later mapping
+
+            def _prep_path_for(fp: str) -> str:
+                base = os.path.basename(fp)
+                stem, _ext = os.path.splitext(base)
+                return os.path.normpath(os.path.join(prep_dir, stem + "_prep.fit"))
+
+            prepared = []
+            for fp in cand:
+                ext = os.path.splitext(fp)[1].lower()
+                if ext != ".xisf":
+                    prepared.append(fp)
+                    continue
+
+                outp = _prep_path_for(fp)
+
+                # reuse if already created this run
+                if os.path.exists(outp):
+                    orig2prep[os.path.normcase(os.path.normpath(fp))] = outp
+                    prepared.append(outp)
+                    continue
+
+                try:
+                    img, hdr = self._load_image_any(fp)   # must support XISF
+                    if img is None:
+                        self.update_status(self.tr(f"⚠️ Could not read XISF: {fp}"))
+                        continue
+
+                    img = _to_writable_f32(img)
+                    if img.ndim == 3 and img.shape[-1] == 1:
+                        img = np.squeeze(img, axis=-1)
+
+                    # Minimal header: keep what you can if hdr is a fits.Header
+                    try:
+                        h = hdr if isinstance(hdr, fits.Header) else fits.Header()
+                    except Exception:
+                        h = fits.Header()
+
+                    h["SAS_PREP"] = (True, "Prepared from XISF for integration")
+                    h["SRCFILE"]  = (os.path.basename(fp), "Original source filename")
+                    if isinstance(img, np.ndarray) and img.ndim == 3 and img.shape[-1] == 3:
+                        h["DEBAYERED"] = (True, "Color frame")
+                    else:
+                        h["DEBAYERED"] = (False, "Mono frame")
+
+                    fits.PrimaryHDU(data=img.astype(np.float32), header=h).writeto(outp, overwrite=True)
+
+                    orig2prep[os.path.normcase(os.path.normpath(fp))] = outp
+                    prepared.append(outp)
+
+                except Exception as e:
+                    self.update_status(self.tr(f"⚠️ XISF→FITS prepare failed for {fp}: {e}"))
+
+            # Swap cand to prepared paths
+            cand = prepared
+
+            # Also update light_files to match these prepared paths so the rest of the
+            # pipeline only ever sees FITS paths.
+            prep_map = orig2prep
+            new_light_files = {}
+            for g, lst in self.light_files.items():
+                out = []
+                for p in lst:
+                    k = os.path.normcase(os.path.normpath(p))
+                    out.append(prep_map.get(k, p))
+                new_light_files[g] = out
+            self.light_files = new_light_files
+
+            # If reference_frame was set and is XISF, redirect it too
+            if getattr(self, "reference_frame", None):
+                k = os.path.normcase(os.path.normpath(self.reference_frame))
+                if k in prep_map:
+                    self.reference_frame = prep_map[k]
+
             # 2) Chunked preview measurement (mean + star count/ecc)
             self.frame_weights = {}
             mean_values = {}
@@ -17301,7 +18330,8 @@ class StackingSuiteDialog(QDialog):
                 paths_ok = []
 
                 def _preview_job(fp: str):
-                    return _quick_preview_from_path(fp, target_xbin=1, target_ybin=1)
+                    # Use the unified reader (FITS/XISF/TIFF/etc) like registration does
+                    return self._quick_preview_any(fp, target_xbin=1, target_ybin=1)
 
                 with ThreadPoolExecutor(max_workers=max_workers) as ex:
                     futs = {ex.submit(_preview_job, fp): fp for fp in chunk}
@@ -17856,6 +18886,10 @@ class StackingSuiteDialog(QDialog):
         hdr_orig["CREATOR"]    = "SetiAstroSuite"
         hdr_orig["DATE-OBS"]   = datetime.utcnow().isoformat()
 
+        n_frames = int(len(file_list))
+        hdr_orig["NCOMBINE"] = (n_frames, "Number of frames combined")
+        hdr_orig["NSTACK"]   = (n_frames, "Alias of NCOMBINE (SetiAstro)")
+
         if final_drizzle.ndim == 2:
             hdr_orig["NAXIS"]  = 2
             hdr_orig["NAXIS1"] = final_drizzle.shape[1]
@@ -17885,10 +18919,12 @@ class StackingSuiteDialog(QDialog):
             cropped_drizzle, hdr_crop = self._apply_autocrop(
                 final_drizzle,
                 file_list,
-                hdr.copy() if hdr is not None else fits.Header(),
+                hdr_orig.copy(),
                 scale=float(scale_factor),
                 rect_override=rect_override
             )
+            hdr_crop["NCOMBINE"] = (n_frames, "Number of frames combined")
+            hdr_crop["NSTACK"]   = (n_frames, "Alias of NCOMBINE (SetiAstro)")            
             is_mono_crop = (cropped_drizzle.ndim == 2)
             display_group_driz_crop = self._label_with_dims(group_key, cropped_drizzle.shape[1], cropped_drizzle.shape[0])
             base_crop = f"MasterLight_{display_group_driz_crop}_{len(file_list)}stacked_drizzle_autocrop"