@@ -9,6 +9,7 @@ inversion:
   nnls_jacobi_preconditioning: true   # If True (default), the curvature matrix passed to jaxnnls.solve_nnls_primal is Jacobi-preconditioned (D Q D y = D q, x = D y). Fixes NaN backward-pass gradients on ill-conditioned Q and roughly halves forward solve time. Set False to restore the raw unpreconditioned solve.
   nnls_target_kappa: 1.0e-11          # Central-path relaxation parameter passed to jaxnnls.solve_nnls_primal. Larger values smooth the relaxed-KKT backward pass and prevent NaN gradients on ill-conditioned Q; smaller values tighten the primal solve. Verified finite gradients across all MGE/rectangular/delaunay pipelines (imaging + interferometer) with scale invariance over 5 orders of magnitude in noise. jaxnnls's own default (1e-3) is too aggressive for the backward pass.
   nnls_warm_start_memo: true         # If True (default), the NumPy/numba positive-only (fnnls) solve warm-starts its active set from the previous likelihood evaluation's passive set, cutting active-set iterations on successive sampler evaluations. The NNLS optimum is unique so the reconstruction is unchanged. On by default as of PyAutoArray#498, measured on the euclid+hst Delaunay-1250 fiducial (9.9x / 4.0x fewer active-set iterations on successive evaluations, reconstruction unchanged). Set false, or AUTOARRAY_NNLS_WARM_START=0, to disable. JAX path unaffected.
+  nnls_warm_start_error_tolerance: 1.5 # Relative quality guard on a warm-start memo seed. Each memo entry remembers the error fraction of the most recent dense-sign-started solve for that key; a seeded solve whose own error fraction exceeds this multiple of that reference is dropped, so the next solve restarts from the dense-sign start and refreshes the reference. Default 1.5 sits above the worst seed/dense error-fraction ratio seen in the PyAutoArray#498 32-cell robustness matrix (1.42), so it is protective against unmeasured regimes rather than flapping. Any non-finite or non-positive value (e.g. .inf) disables the guard. NumPy/numba fnnls path only.
   reconstruction_vmax_factor: 0.5     # Plots of an Inversion's reconstruction use the reconstructed data's bright value multiplied by this factor.
   log_det_method: cholesky            # How the Bayesian-evidence log-determinant terms are computed. "cholesky" (default) is the historical 2*sum(log(diag(cholesky(M)))); "slogdet" uses logabsdet of slogdet(M), which is identical where M is positive-definite but finite (not NaN) where the Cholesky fails, for gradient-based searches (opt-in, non-default; does not change the default evidence). Under "slogdet" the kernel regularization schemes (Matern/Gaussian/Exponential) also compute the regularization log-det analytically from a Cholesky of their covariance instead of factorizing the formed inverse. See PyAutoArray#391.
   regularization_term_method: matmul  # How the Bayesian-evidence regularization term s^T H s is computed. "matmul" (default) is the historical s @ (H @ s) against the explicitly formed regularization matrix; "cho_solve" evaluates coefficient * s^T C^-1 s for the kernel schemes (Matern/Gaussian/Exponential/MaternAdapt) via one Cholesky solve of their covariance C, avoiding the explicit inverse whose round-off is amplified by cond(C) (~1e9 on clustered traced mesh vertices). Opt-in, non-default; does not change the default evidence. Schemes with no such factorization fall back to the formed matrix.
 
@@ -301,6 +301,16 @@ def reconstruction_positive_only_from(
         Identifies the index space this solve's passive set lives in, enabling the cross-evaluation warm-start
         memo (`Settings.nnls_warm_start_memo`) on the NumPy path. `None` disables the memo for this call.
 
+    Notes
+    -----
+    On the NumPy path this function writes two keys into the `stats` dict it passes to `fnnls_cholesky`
+    that `fnnls_cholesky` itself knows nothing about: ``seed_source`` (``"memo"`` if the solve that
+    produced the returned reconstruction started from a memo seed, ``"dense"`` if it started from the
+    sign of the unconstrained dense solve) and ``warm_start_fallback`` (`True` if a memo seed breached
+    `Settings.nnls_warm_start_error_tolerance` and its entry was dropped, so the next solve for that key
+    restarts dense). They are set after `fnnls_cholesky` returns, so a diagnostic wrapping the solver
+    must read the dict it handed in *after* the evaluation, not at the point the solver returns.
+
     Returns
     -------
     Non-negative S that minimizes the Eq.(2) of https://arxiv.org/pdf/astro-ph/0302587.pdf.
@@ -392,20 +402,22 @@ def reconstruction_positive_only_from(
             else None
         )
 
-        warm_start = (
-            nnls_memo.passive_set_get(key=key, n=data_vector.shape[0])
-            if use_memo
-            else None
-        )
+        n = data_vector.shape[0]
+
+        entry = nnls_memo.passive_set_get(key=key, n=n) if use_memo else None
 
-        if warm_start is not None:
+        stats["seed_source"] = "dense"
+        stats["warm_start_fallback"] = False
+
+        if entry is not None:
             try:
                 reconstruction = fnnls_cholesky(
                     curvature_reg_matrix,
                     (data_vector).T,
-                    P_initial=warm_start,
+                    P_initial=entry.passive_set,
                     stats=stats,
                 )
+                stats["seed_source"] = "memo"
             except (RuntimeError, np.linalg.LinAlgError, ValueError):
                 # A seed from a previous evaluation is a guess about a
                 # different matrix, so it can factorise badly where the
@@ -423,9 +435,46 @@ def reconstruction_positive_only_from(
                 P_initial=np.linalg.solve(curvature_reg_matrix, data_vector) > 0,
                 stats=stats,
             )
+            stats["seed_source"] = "dense"
 
         if use_memo:
-            nnls_memo.passive_set_put(key=key, passive_set=stats["passive_set"])
+            error_fraction = stats["warm_start_errors"] / max(n, 1)
+
+            if stats["seed_source"] == "memo":
+                # A memo seed is judged against the dense-sign start it
+                # replaced, not against an absolute error count: the absolute
+                # fraction does not separate seeds that save iterations from
+                # seeds that cost them, the ratio to the dense-sign reference
+                # does. A seed that breaches the tolerance is discarded, so the
+                # next solve for this key restarts dense and refreshes the
+                # reference -- no stale seed can be dragged through a run in a
+                # regime the reference was never measured in.
+                tolerance = settings.nnls_warm_start_error_tolerance
+
+                guard_active = (
+                    tolerance is not None and np.isfinite(tolerance) and tolerance > 0.0
+                )
+
+                if (
+                    guard_active
+                    and error_fraction > tolerance * entry.dense_error_fraction
+                ):
+                    nnls_memo.memo_drop(key=key)
+                    stats["warm_start_fallback"] = True
+                else:
+                    # The reference describes the dense-sign start, so it is
+                    # carried forward unchanged; only a dense solve refreshes it.
+                    nnls_memo.passive_set_put(
+                        key=key,
+                        passive_set=stats["passive_set"],
+                        dense_error_fraction=entry.dense_error_fraction,
+                    )
+            else:
+                nnls_memo.passive_set_put(
+                    key=key,
+                    passive_set=stats["passive_set"],
+                    dense_error_fraction=error_fraction,
+                )
 
         return reconstruction
 
 
@@ -1,7 +1,7 @@
 import os
 
 import numpy as np
-from typing import Dict, Optional
+from typing import Dict, NamedTuple, Optional
 
 # Cross-evaluation memo for the positive-only (fnnls) solve's passive set.
 #
@@ -22,8 +22,36 @@
 # stale entry costs iterations, not correctness. Forked pool workers inherit a
 # copy at fork and diverge from there, which is fine for the same reason.
 #
+# An entry therefore carries TWO things: the passive set to seed from, and
+# `dense_error_fraction` -- the error fraction of the most recent solve for
+# that key that started from the DENSE-SIGN guess. That number is the
+# reference the fallback guard in `reconstruction_positive_only_from` measures
+# a seed against: the PyAutoArray#498 robustness matrix showed the absolute
+# error fraction of a seed does NOT separate seeds that save iterations from
+# seeds that cost them (helpful and unhelpful cells overlap at 0.048-0.138),
+# but the ratio of the seed's fraction to the dense-sign start's does (helpful
+# cells never exceed 0.89, the worst seed reaches 1.42). The reference is
+# per-key and self-calibrating, so a solve regime far outside anything the
+# matrix probed cannot drag a stale seed through a whole run: once a seed is
+# that much worse than the dense-sign start, the entry is dropped
+# (`memo_drop`) and the next solve for that key restarts dense, refreshing the
+# reference.
+#
 # Disable with AUTOARRAY_NNLS_WARM_START=0.
-_nnls_passive_set_memo: Dict[str, np.ndarray] = {}
+
+
+class MemoEntry(NamedTuple):
+    """
+    One memoized solve: the passive set to seed the next solve for this key
+    from, and the error fraction of the most recent dense-sign-started solve
+    for the same key (the reference the fallback guard compares a seed to).
+    """
+
+    passive_set: np.ndarray
+    dense_error_fraction: float
+
+
+_nnls_passive_set_memo: Dict[str, MemoEntry] = {}
 
 _NNLS_PASSIVE_SET_MEMO_MAX_ENTRIES = 8
 
@@ -43,31 +71,35 @@ def memo_key(n: int, fingerprint) -> str:
     return f"{n}:{fingerprint}"
 
 
-def passive_set_get(key: str, n: int) -> Optional[np.ndarray]:
+def passive_set_get(key: str, n: int) -> Optional[MemoEntry]:
     """
-    The memoized passive set for `key`, or None on a miss.
+    The memoized entry for `key` -- its passive set and dense-sign reference
+    error fraction -- or None on a miss.
 
     An entry whose indices do not all fit a size-`n` solve is a miss, not a
     hit: `n` is already part of the key, so this only fires if a caller
     fingerprints two different index spaces identically, and a miss is always
     a safe outcome.
     """
-    passive_set = _nnls_passive_set_memo.get(key)
+    entry = _nnls_passive_set_memo.get(key)
 
-    if passive_set is None:
+    if entry is None:
         return None
 
-    if passive_set.size and passive_set.max() >= n:
+    if entry.passive_set.size and entry.passive_set.max() >= n:
         return None
 
-    return passive_set
+    return entry
 
 
-def passive_set_put(key: str, passive_set: np.ndarray) -> None:
+def passive_set_put(
+    key: str, passive_set: np.ndarray, dense_error_fraction: float
+) -> None:
     """
-    Store a solve's final passive set, evicting the oldest entry once the memo
-    is full (FIFO; the memo tracks one inversion's recent history, not a
-    working set worth ranking).
+    Store a solve's final passive set alongside the dense-sign reference error
+    fraction to carry forward, evicting the oldest entry once the memo is full
+    (FIFO; the memo tracks one inversion's recent history, not a working set
+    worth ranking).
     """
     stored = np.asarray(passive_set, dtype=int).copy()
     stored.setflags(write=False)
@@ -78,4 +110,14 @@ def passive_set_put(key: str, passive_set: np.ndarray) -> None:
     ):
         _nnls_passive_set_memo.pop(next(iter(_nnls_passive_set_memo)))
 
-    _nnls_passive_set_memo[key] = stored
+    _nnls_passive_set_memo[key] = MemoEntry(
+        passive_set=stored, dense_error_fraction=float(dense_error_fraction)
+    )
+
+
+def memo_drop(key: str) -> None:
+    """
+    Forget `key`, so the next solve for it restarts from the dense-sign guess
+    and refreshes the reference error fraction. A no-op if the key is absent.
+    """
+    _nnls_passive_set_memo.pop(key, None)
@@ -18,6 +18,7 @@ def __init__(
         nnls_solver_tol: Optional[float] = None,
         nnls_max_iter: Optional[int] = None,
         nnls_warm_start_memo: Optional[bool] = None,
+        nnls_warm_start_error_tolerance: Optional[float] = None,
         log_det_method: Optional[str] = None,
         regularization_term_method: Optional[str] = None,
     ):
@@ -110,6 +111,21 @@ def __init__(
             (`true`); setting ``AUTOARRAY_NNLS_WARM_START=0`` is the process-wide kill-switch that disables the
             memo whatever this setting says. Only the NumPy (`xp=np`) fnnls path honors this; the JAX path
             ignores it.
+        nnls_warm_start_error_tolerance
+            The relative guard on a memo seed's quality. Each memo entry carries a reference: the error
+            fraction (warm-start errors / solve size) of the most recent solve for that key which started
+            from the dense-sign guess. A memo-seeded solve whose own error fraction exceeds
+            ``tolerance * reference`` is judged worse than simply starting dense, so its entry is discarded
+            and the next solve for that key restarts from the dense-sign start, refreshing the reference.
+            The guard is relative because the absolute error fraction does not separate helpful from
+            unhelpful seeds (the two populations overlap at 0.048-0.138 in the PyAutoArray#498 32-cell
+            robustness matrix) whereas the ratio to the dense-sign start does (helpful cells top out at
+            0.89, the worst seed measured reaches 1.42). `None` (default) reads the packaged value
+            (``1.5``), chosen above that worst observed ratio so the guard is protective against regimes
+            far outside the matrix rather than flapping inside it. The guard is **disabled** by any value
+            that is not finite and positive -- ``float("inf")`` is the idiomatic choice, and ``0`` or a
+            negative value disables it too rather than meaning "drop everything". Only the NumPy
+            (`xp=np`) fnnls path honors this; the JAX path ignores it.
         log_det_method
             Which computation is used for the two Bayesian-evidence log-determinant terms
             (``log_det_curvature_reg_matrix_term`` and ``log_det_regularization_matrix_term``). `None`
@@ -163,6 +179,7 @@ def __init__(
         self.nnls_solver_tol = nnls_solver_tol
         self.nnls_max_iter = nnls_max_iter
         self._nnls_warm_start_memo = nnls_warm_start_memo
+        self._nnls_warm_start_error_tolerance = nnls_warm_start_error_tolerance
         self._use_positive_only_solver = use_positive_only_solver
         self._use_edge_zeroed_pixels = use_edge_zeroed_pixels
         self._use_border_relocator = use_border_relocator
@@ -229,6 +246,28 @@ def nnls_warm_start_memo(self) -> bool:
 
         return self._nnls_warm_start_memo
 
+    @property
+    def nnls_warm_start_error_tolerance(self) -> float:
+        """
+        How much worse than the dense-sign start a memo seed may be before its entry is dropped.
+
+        A seeded solve whose error fraction exceeds this multiple of the entry's dense-sign reference
+        fraction is discarded, so the next solve for that key restarts dense. Any value that is not
+        finite and positive disables the guard.
+        """
+        if self._nnls_warm_start_error_tolerance is None:
+            try:
+                return conf.instance["general"]["inversion"][
+                    "nnls_warm_start_error_tolerance"
+                ]
+            except KeyError:
+                # Workspaces ship their own general.yaml that shadows autoarray's
+                # and will not carry this key, so in practice this fallback *is*
+                # the production default, matching the packaged value.
+                return 1.5
+
+        return self._nnls_warm_start_error_tolerance
+
     @property
     def log_det_method(self):
         if self._log_det_method is None:
 
@@ -18,6 +18,7 @@
 from autoarray.inversion.inversion.nnls_memo import (
     _NNLS_PASSIVE_SET_MEMO_MAX_ENTRIES,
     _nnls_passive_set_memo,
+    memo_drop,
     memo_key,
     passive_set_get,
     passive_set_put,
@@ -53,7 +54,9 @@ def solve_ids_to_keep(self):
         return self._ids_to_keep
 
 
-def _inversion_from(curvature_reg_matrix, data_vector, memo, ids_to_keep=None):
+def _inversion_from(
+    curvature_reg_matrix, data_vector, memo, ids_to_keep=None, tolerance=None
+):
     n = data_vector.shape[0]
 
     kwargs = dict(
@@ -66,6 +69,7 @@ def _inversion_from(curvature_reg_matrix, data_vector, memo, ids_to_keep=None):
             use_positive_only_solver=True,
             use_edge_zeroed_pixels=False,
             nnls_warm_start_memo=memo,
+            nnls_warm_start_error_tolerance=tolerance,
         ),
     )
 
@@ -115,7 +119,7 @@ def test__memoized_reconstruction__subset_branch__matches_unmemoized(seed):
     # the subset -- not the full parameter vector.
     (key,) = _nnls_passive_set_memo
     assert key.startswith(f"{len(ids_to_keep)}:")
-    assert np.all(_nnls_passive_set_memo[key] < len(ids_to_keep))
+    assert np.all(_nnls_passive_set_memo[key].passive_set < len(ids_to_keep))
 
 
 def test__fingerprint__changes_with_ids_to_keep():
@@ -141,36 +145,51 @@ def test__fingerprint__changes_with_ids_to_keep():
 
 def test__passive_set_put__evicts_the_oldest_entry_when_full():
     for i in range(_NNLS_PASSIVE_SET_MEMO_MAX_ENTRIES + 2):
-        passive_set_put(key=f"key_{i}", passive_set=np.array([i]))
+        passive_set_put(
+            key=f"key_{i}", passive_set=np.array([i]), dense_error_fraction=0.1
+        )
 
     assert len(_nnls_passive_set_memo) == _NNLS_PASSIVE_SET_MEMO_MAX_ENTRIES
     assert "key_0" not in _nnls_passive_set_memo
     assert "key_1" not in _nnls_passive_set_memo
     assert f"key_{_NNLS_PASSIVE_SET_MEMO_MAX_ENTRIES + 1}" in _nnls_passive_set_memo
 
 
-def test__passive_set_put__stores_a_read_only_copy():
+def test__passive_set_put__stores_a_read_only_copy_and_the_reference_fraction():
     passive_set = np.array([0, 3, 4])
 
-    passive_set_put(key="key", passive_set=passive_set)
+    passive_set_put(key="key", passive_set=passive_set, dense_error_fraction=0.25)
 
     passive_set[0] = 99
 
-    stored = passive_set_get(key="key", n=5)
+    entry = passive_set_get(key="key", n=5)
 
-    assert np.array_equal(stored, np.array([0, 3, 4]))
+    assert np.array_equal(entry.passive_set, np.array([0, 3, 4]))
+    assert entry.dense_error_fraction == 0.25
     with pytest.raises(ValueError):
-        stored[0] = 1
+        entry.passive_set[0] = 1
 
 
 def test__passive_set_get__miss_on_out_of_range_indices_and_unknown_key():
-    passive_set_put(key="key", passive_set=np.array([0, 3, 4]))
+    passive_set_put(
+        key="key", passive_set=np.array([0, 3, 4]), dense_error_fraction=0.0
+    )
 
     assert passive_set_get(key="key", n=5) is not None
     assert passive_set_get(key="key", n=4) is None
     assert passive_set_get(key="other", n=5) is None
 
 
+def test__memo_drop__forgets_the_key_and_is_a_no_op_when_absent():
+    passive_set_put(key="key", passive_set=np.array([0, 2]), dense_error_fraction=0.1)
+
+    memo_drop(key="key")
+
+    assert passive_set_get(key="key", n=5) is None
+
+    memo_drop(key="key")
+
+
 def test__memo_enabled__reads_the_environment(monkeypatch):
     monkeypatch.delenv("AUTOARRAY_NNLS_WARM_START", raising=False)
     assert nnls_memo.memo_enabled() is True