@@ -22,12 +22,16 @@
   - Each experiment's model is chosen per row on the Experiment and Analysis
     pages and shows the stored pairing (the combo used to reset to the first
     model and could change another experiment).
-  - A "Fit" checkbox per experiment chooses what the next fit includes; a
-    parameter that an included model follows stays fitted even when its own
-    model is left out. The results dialog lists each dataset's χ² per point
-    and share of the total; the statistics come from the library's record of
-    the run, so they survive switching the current model.
-  - The Analysis chart has the staggered view too.
+  - A "Fit" checkbox per experiment chooses what the next fit, or Bayesian
+    sampling, includes; a parameter that an included model follows stays
+    fitted even when its own model is left out. The pre-fit bound checks look
+    only at the parameters the fit varies. The results dialog lists each
+    dataset's χ² per point and share of the total; the statistics come from
+    the library's record of the last completed run, so they survive switching
+    the current model and are not replaced by a failed or cancelled run.
+  - The Analysis chart has the staggered view too (not in the R·q⁴ view).
+  - Linking several models links all of them or, when one cannot be linked,
+    none.
   - Removing a model that experiments use asks whether to remove them or fit
     them with another model; experiments are no longer removed by position.
   - A data file that cannot be read is reported in a dialog.
 
@@ -564,11 +564,9 @@ def _on_fit_failed(self, error_message: str) -> None:
         is_user_cancel = self._fitting_logic.fit_cancelled and 'cancel' in error_message.lower()
         if is_user_cancel:
             error_message = 'Fitting cancelled by user'
+        # Not recorded on the project: its record keeps describing the last completed fit,
+        # which the parameters still hold. The dialog shows this error.
         self._fitting_logic.on_fit_failed(error_message)
-        try:
-            self._fitting_logic.record_on_project(None, 'cancelled' if is_user_cancel else 'failed')
-        except Exception:
-            logger.exception('Failed to record the fit on the project')
         self._fitter_thread = None
         self.fittingChanged.emit()
         self._clearCacheAndEmitParametersChanged()
@@ -1048,15 +1046,19 @@ def _prefit_errors(self) -> List[str]:
         return errors
 
     def _free_parameters(self) -> List[dict]:
-        """The parameters a fit varies, each once.
+        """The parameters the next fit varies, each once.
 
         Read from the unfiltered list: the table's name and free/fixed filters
         must not change what the fit-wide checks see. A parameter shared by
-        several models is listed once per model, hence the identity check.
+        several models is listed once per model, hence the identity check. The
+        library says which parameters the included experiments' fit varies
+        (``Project.fit_parameters``), so a model left out does not block it.
         """
+        fit_parameters = getattr(self._project_lib, 'fit_parameters', None)
+        in_fit = None if fit_parameters is None else {id(parameter) for parameter in fit_parameters()}
         unique = {}
         for param in self._parameters_logic.all_parameters():
-            if param['fit'] and param.get('enabled', True):
+            if param['fit'] and param.get('enabled', True) and (in_fit is None or id(param['object']) in in_fit):
                 unique.setdefault(id(param['object']), param)
         return list(unique.values())
 
@@ -1168,12 +1170,7 @@ def removeExperiment(self, index: int) -> None:
         Remove the experiment at the given index.
         """
         if 0 <= index < len(self._experiments_logic.available()):
-            self._experiments_logic.remove_experiment(index)
-            # The selection follows: the removed experiment leaves it, later ones shift down.
-            if self._selection.remove_index(index, len(self._experiments_logic.available())):
-                self._sync_current_experiment_to_selection()
-            self.experimentsChanged.emit()
-            self.externalExperimentChanged.emit()
+            self.follow_rekeyed_experiments(self._experiments_logic.remove_experiment(index))
         else:
             logger.warning('Experiment index %s is out of range.', index)
 
@@ -1211,14 +1208,11 @@ def setSelectedExperimentIndices(self, indices: List[int]) -> None:
             self.experimentsChanged.emit()
             self.externalExperimentChanged.emit()
 
-    def follow_removed_experiments(self, removed: list) -> None:
-        """The selection follows experiments removed elsewhere (with their model): the removed
-        ones leave it and the later ones move up, as for :meth:`removeExperiment`."""
-        remaining = len(self._experiments_logic.available())
-        changed = False
-        for index in sorted(removed, reverse=True):
-            changed |= self._selection.remove_index(index, remaining)
-        if changed:
+    def follow_rekeyed_experiments(self, keys: dict) -> None:
+        """The selection follows removed experiments, by the library's old -> new key table
+        (the removed ones are not in it). The experiment list changed, so it is announced
+        whether or not the selection did."""
+        if self._selection.remap(keys, len(self._experiments_logic.available())):
             self._sync_current_experiment_to_selection()
         self.experimentsChanged.emit()
         self.externalExperimentChanged.emit()
 
@@ -33,11 +33,10 @@ def set_indices(self, indices, available_count: int) -> bool:
         self._indices = valid
         return True
 
-    def remove_index(self, removed: int, available_count: int) -> bool:
-        """Follow the removal of experiment `removed`: drop it and shift the later ones down.
-        `available_count` is the number of experiments left."""
-        shifted = [index - 1 if index > removed else index for index in self._indices if index != removed]
-        return self.set_indices(shifted, available_count)
+    def remap(self, keys: dict, available_count: int) -> bool:
+        """Follow removed experiments with the library's old -> new key table (the removed
+        ones are not in it). `available_count` is the number of experiments left."""
+        return self.set_indices([keys[index] for index in self._indices if index in keys], available_count)
 
     def prune(self, available_count: int) -> bool:
         """Drop indices that no longer exist (after experiments were removed elsewhere)."""
 
@@ -166,10 +166,11 @@ def set_included_in_fit(self, index: int, included: bool) -> bool:
         experiment.include_in_fit = included
         return True
 
-    def remove_experiment(self, index: int) -> None:
-        """Remove the experiment at the given (ordered) index; the library re-keys the rest."""
+    def remove_experiment(self, index: int) -> dict:
+        """Remove the experiment at the given (ordered) index; returns the library's old -> new
+        key table of the remaining ones (empty when nothing was removed)."""
         key = self._experiment_key_at_index(index)
         if key is None:
             logger.warning('Experiment index %s is out of range.', index)
-            return
-        self._project_lib.remove_experiment(key)
+            return {}
+        return self._project_lib.remove_experiment(key)
@@ -187,6 +187,7 @@ def on_fit_failed(self, error_message: str) -> None:
         """
         self._result = None
         self._results = []
+        self._prepared = None
         self._fit_error_message = error_message
         self._running = False
         self._finished = True
@@ -248,11 +249,14 @@ def _ordered_experiments(self) -> list:
         'Bayesian sampling of polarized experiments is not supported yet.'
     )
 
-    def _has_polarized_experiments(self) -> bool:
-        """Whether any loaded experiment carries per-channel (polarized) data."""
-        return any(
-            getattr(experiment, 'available_channels', None) is not None for experiment in self._ordered_experiments()
-        )
+    def _has_polarized_experiments(self, experiments: Optional[list] = None) -> bool:
+        """Whether any of `experiments` (by default every loaded one) carries per-channel data."""
+        experiments = self._ordered_experiments() if experiments is None else experiments
+        return any(getattr(experiment, 'available_channels', None) is not None for experiment in experiments)
+
+    def _included_experiments(self) -> list:
+        """The experiments whose Fit box is ticked, in order."""
+        return [experiment for experiment in self._ordered_experiments() if getattr(experiment, 'include_in_fit', True)]
 
     # ------------------------------------------------------------------
     # Inequality constraints (BUMPS penalties)
@@ -377,11 +381,13 @@ def _fail_before_start(self, message: str) -> None:
         self._finished = True
         self._show_results_dialog = True
 
-    def record_on_project(self, results: Optional[list], status: str = 'completed') -> None:
-        """Record the outcome of the worker's run on the project (``Project.last_fit``),
-        which the results dialog and the summary read."""
+    def record_on_project(self, results: list) -> None:
+        """Record the completed run on the project (``Project.last_fit``), which the results
+        dialog and the summary read. The prepared run is used up: a later failure, or a
+        sampling run, cannot be recorded against it."""
         if self._prepared is not None:
-            self._project_lib.record_fit(self._prepared, results, status)
+            prepared, self._prepared = self._prepared, None
+            self._project_lib.record_fit(prepared, results)
 
     @property
     def _run(self):
@@ -399,6 +405,7 @@ def fit_dataset_rows(self) -> list[dict]:
                 {
                     'name': name if channel is None else f'{name} ({channel})',
                     'points': entry['objective_n_points'],
+                    'measuredPoints': entry['classical_n_points'],
                     'chi2': entry['objective_chi2'],
                     'chi2PerPoint': entry['objective_chi2_per_point'],
                     'share': entry['share_of_objective'],
@@ -430,25 +437,23 @@ def fit_classical_reduced_chi2(self) -> float | None:
     # Bayesian sampling helpers
     # ------------------------------------------------------------------
 
-    def collect_all_experiments_datagroup(self) -> 'sc.DataGroup':
+    def collect_all_experiments_datagroup(self, experiments: Optional[list] = None) -> 'sc.DataGroup':
         """Build the scipp DataGroup required by reflectometry-lib ``MultiFitter.mcmc_sample()``.
 
-        Scope decision (see issue #319): Bayesian sampling deliberately runs over
-        **all** experiments, mirroring the classical fit path (``prepare_threaded_fit``)
-        which also fits every experiment. The experiment selection currently affects
-        only plotting, not the fit/sampling scope. If per-selection sampling is ever
-        wanted, filter ``self._ordered_experiments()`` here and rename accordingly.
+        Sampling covers the experiments whose Fit box is ticked, like a classical fit;
+        the selection only affects plotting.
 
+        :param experiments: The experiments to sample, by default the included ones.
         :return: DataGroup with reflectivity coords and data.
         :rtype: sc.DataGroup
         """
         import numpy as np
         import scipp as sc
 
-        if self._has_polarized_experiments():
+        experiments = self._included_experiments() if experiments is None else experiments
+        if self._has_polarized_experiments(experiments):
             raise ValueError(self._POLARIZED_SAMPLE_MESSAGE)
 
-        experiments = self._ordered_experiments()
         coords = {}
         data = {}
         for i, experiment in enumerate(experiments):
@@ -483,17 +488,26 @@ def prepare_threaded_sample(self, minimizers_logic: 'Minimizers') -> tuple:
         try:
             from easyreflectometry.fitting import MultiFitter
 
-            experiments = self._ordered_experiments()
-            if not experiments:
+            if not self._ordered_experiments():
                 self._fail_before_start('No experiments to sample')
                 return None, None
+            experiments = self._included_experiments()
+            if not experiments:
+                self._fail_before_start('No experiment to sample: tick Fit for at least one experiment.')
+                return None, None
+            unbound = [experiment.name for experiment in experiments if experiment.model is None]
+            if unbound:
+                names = ', '.join(f"'{name}'" for name in unbound)
+                self._fail_before_start(f'{names} cannot be sampled: no model is assigned.')
+                return None, None
 
             constraints_error = self.inequality_constraints_error(minimizers_logic)
             if constraints_error:
                 logger.warning('Sampling refused: %s', constraints_error)
                 self._fail_before_start(constraints_error)
                 return None, None
 
+            # The library adds the free parameters of excluded models that these follow.
             models = [experiment.model for experiment in experiments]
             multi_fitter = MultiFitter(*models)
             # Sampled with a snapshot of the project's settings (a BUMPS minimizer
@@ -502,7 +516,7 @@ def prepare_threaded_sample(self, minimizers_logic: 'Minimizers') -> tuple:
             # controls stay editable meanwhile.
             multi_fitter.settings = copy.deepcopy(self._project_lib.fit_settings)
 
-            data_group = self.collect_all_experiments_datagroup()
+            data_group = self.collect_all_experiments_datagroup(experiments)
             return multi_fitter, data_group
         except Exception as e:
             self._fail_before_start(f'Error preparing sampling: {e}')
@@ -511,6 +525,7 @@ def prepare_threaded_sample(self, minimizers_logic: 'Minimizers') -> tuple:
 
     def prepare_for_threaded_sample(self) -> None:
         """Set running flags and sampling progress message before launching the worker."""
+        self._prepared = None  # a sampling run is not recorded as a classical one
         self.reset_stop_flag()
         self._running = True
         self._finished = False
 
@@ -8,6 +8,7 @@
 from easyreflectometry.model import Model
 from easyreflectometry.model import ModelCollection
 from easyreflectometry.model.resolution_functions import PercentageFwhm
+from easyreflectometry.project import ModelRemoval
 
 from .helpers import get_original_name
 
@@ -19,7 +20,7 @@ def _formula_of(target) -> str:
 class Models:
     def __init__(self, project_lib: ProjectLib):
         self._project_lib = project_lib
-        self._contrast_candidates: list = []
+        self._contrast_candidates: tuple = (None, [])
 
     @property
     def _models(self) -> ModelCollection:
@@ -98,7 +99,7 @@ def contrast_candidates(self, index: int) -> list[dict]:
         (``'material'``: replace it by another material; ``'formula'``: give it another
         chemical formula) and, for a formula, the current one."""
         materials, formulas = substitution_candidates(self._project_lib.models[index])
-        self._contrast_candidates = materials + formulas
+        self._contrast_candidates = (self._project_lib.models[index], materials + formulas)
         rows = [{'label': material.name, 'kind': 'material'} for material in materials]
         rows += [{'label': target.name, 'kind': 'formula', 'formula': _formula_of(target)} for target in formulas]
         # Two distinct objects may share a name (each surfactant layer has its own D2O).
@@ -113,10 +114,18 @@ def contrast_candidates(self, index: int) -> list[dict]:
     def add_contrast(self, index: int, name: str, choices: list[dict]) -> int:
         """Add a contrast of the model at `index`; `choices` refer to the rows of the last
         :meth:`contrast_candidates`, each with a palette ``material`` index or a ``formula``.
-        Returns the new model's index."""
+        Returns the new model's index.
+
+        Raises ValueError when the model changed since the candidates were listed: a row
+        would then name another object."""
+        model, candidates = self._contrast_candidates
+        materials, formulas = substitution_candidates(self._project_lib.models[index])
+        current = materials + formulas
+        if model is not self._project_lib.models[index] or [id(c) for c in current] != [id(c) for c in candidates]:
+            raise ValueError('The model changed since the dialog opened; open it again.')
         substitutions = []
         for choice in choices:
-            candidate = self._contrast_candidates[int(choice['candidate'])]
+            candidate = candidates[int(choice['candidate'])]
             if 'material' in choice:
                 material = self._project_lib._materials[int(choice['material'])]
                 if material is not candidate:
@@ -130,14 +139,14 @@ def experiments_using(self, index: int) -> list[str]:
         experiments = self._project_lib.experiments
         return [experiments[key].name for key in self._project_lib.experiments_for_model(index)]
 
-    def remove_at_index(self, index: int, rebind_to: int = -1) -> list[int]:
+    def remove_at_index(self, index: int, rebind_to: int = -1) -> ModelRemoval:
         """Remove the model; its experiments are removed, or bound to `rebind_to` when that is
-        a model index. Returns the keys of the experiments removed with it."""
+        a model index (counted before the removal). Returns the library's account of it: with
+        the experiments removed, ``remap`` keys the remaining ones."""
         experiments = None
         if self._project_lib.experiments_for_model(index):
             experiments = rebind_to if rebind_to >= 0 else 'remove'
-        removal = self._project_lib.remove_model_at_index(index, experiments=experiments)
-        return removal.experiments if experiments == 'remove' else []
+        return self._project_lib.remove_model_at_index(index, experiments=experiments)
 
     def default_model_content(self, model: Model) -> None:
         """Set the default content for a model."""
@@ -189,15 +198,14 @@ def _attach_calculator(self, model: Model) -> None:
         """
         model.interface = self._project_lib._calculator
 
+    # The library keeps the moved model the current one.
     def move_selected_up(self) -> None:
         if self.index > 0:
             self._project_lib.move_model(self.index, self.index - 1)
-            self.index = self.index - 1
 
     def move_selected_down(self) -> None:
         if self.index < len(self._models) - 1:
             self._project_lib.move_model(self.index, self.index + 1)
-            self.index = self.index + 1
 
 
 def _from_models_collection_to_list_of_dicts(models_collection: ModelCollection) -> list[dict[str, str]]:
 
@@ -296,7 +296,7 @@ def _connect_project_page(self) -> None:
     def _connect_sample_page(self) -> None:
         # Removing a model can remove its experiments. Connected first, so that every
         # handler below already sees a selection without them.
-        self._sample.experimentsRemoved.connect(self._analysis.follow_removed_experiments)
+        self._sample.experimentsRekeyed.connect(self._analysis.follow_rekeyed_experiments)
         self._sample.modelsTableChanged.connect(self._analysis.prune_selected_experiments)
         self._sample.externalSampleChanged.connect(self._relay_sample_page_sample_changed)
         # Enabling magnetism can switch the project's calculation engine; the