fix(core): labelling after an apairo resume silently did nothing

AnnotationController cached cloud.labels at construction, but resume_apairo
replaces the array wholesale — every later assign wrote into the orphaned
pre-resume array while the UI (and saves) read the new one. The controller
now reads cloud.labels live, and resume clears the undo history so edits
recorded against the old array can't be spliced into the resumed labels.

tests/test_annotation_history.py

@@ -50,3 +50,14 @@ def test_new_edit_clears_redo():
     ann.undo()
     ann.assign(Selection.from_indices([1], 6), 2)
     assert ann.redo() is None  # redo stack was cleared by the new edit
+
+
+def test_assign_survives_a_wholesale_labels_swap():
+    # Resuming a previous session replaces cloud.labels with a fresh array;
+    # the controller must write into the new one, not a cached reference to
+    # the old (the "labelling silently does nothing after resume" bug).
+    cloud = _cloud()
+    ann = AnnotationController(cloud)
+    cloud.labels = np.array([7, 7, 0, 0, 0, 0], np.int32)
+    ann.assign(Selection.from_indices([2], 6), class_id=5)
+    assert cloud.labels.tolist() == [7, 7, 5, 0, 0, 0]

tests/test_apairo_channel.py

@@ -286,3 +286,26 @@ def test_apairo_info_false_for_loose_cloud(tmp_path):
     svc = AnnotationService()
     svc.open_cloud(str(path))
     assert svc.apairo_info()["is_apairo"] is False
+
+
+def test_assign_after_resume_reaches_the_resumed_labels(tmp_path):
+    # Resume replaces cloud.labels wholesale; a later assign must land in the
+    # resumed array (regression: the controller kept writing into the
+    # pre-resume array, so labelling after a resume silently did nothing).
+    from toaster.api.service import AnnotationService
+
+    seq = _apairo_seq(tmp_path)
+    frame = seq / "ouster_points" / "000000.npy"
+    np.save(frame, np.zeros((4, 4), np.float32))
+    gt = seq / "ground_truth"
+    gt.mkdir()
+    np.save(gt / "000000.npy", np.array([1, 1, 0, 0], np.int32))
+
+    svc = AnnotationService()
+    svc.open_cloud(str(frame))
+    assert svc.apairo_resume_info()["available"] is True
+    svc.resume_apairo()
+    assert not svc._ctl().session.history.can_undo()  # pre-resume edits dropped
+    svc.box([2])
+    svc.assign(class_id=5)
+    assert svc._ctl().label_array().tolist() == [1, 1, 5, 0]

toaster/api/service.py

@@ -368,6 +368,10 @@ class AnnotationService:
                 f"'{channel}' frame {target.stem} has {full.shape[0]} labels, expected {expected}"
             )
         cloud.labels = cloud.from_source_frame(full)
+        # The resume replaced the labels wholesale: edits recorded before it
+        # refer to values from the pre-resume array — undoing across the swap
+        # would splice stale values into the resumed labels.
+        session.history.clear()
         return self.state()
 
     def apairo_nav(self) -> dict[str, Any]:

toaster/core/annotation.py

@@ -94,7 +94,14 @@ class AnnotationController:
     ) -> None:
         self.cloud = cloud
         self.history = history if history is not None else EditHistory()
-        self._labels = cloud.ensure_labels(unlabeled_id)
+        cloud.ensure_labels(unlabeled_id)
+
+    @property
+    def _labels(self) -> np.ndarray:
+        # Always read through the cloud: anything that swaps the array wholesale
+        # (e.g. resuming a previous session's labels) must not leave this
+        # controller writing into the orphaned old array.
+        return self.cloud.labels
 
     def assign(self, selection: Selection, class_id: int) -> np.ndarray:
         """Write ``class_id`` to every selected point; return the touched indices.